1 /*-------------------------------------------------------------------------
2 SDCCsymt.c - Code file for Symbols table related structures and MACRO's.
3 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 In other words, you are welcome to use, share and improve this program.
20 You are forbidden to forbid anyone else to use, share and improve
21 what you give them. Help stamp out software-hoarding!
22 -------------------------------------------------------------------------*/
26 #include "dbuf_string.h"
30 value *aggregateToPointer (value *val);
31 void printTypeChainRaw (sym_link * start, FILE * of);
33 void printFromToType(sym_link *from, sym_link *to) {
34 fprintf (stderr, "from type '");
35 printTypeChain (from, stderr);
36 fprintf (stderr, "'\nto type '");
37 printTypeChain (to, stderr);
38 fprintf (stderr, "'\n");
42 char *nounName(sym_link *sl) {
43 switch (SPEC_NOUN(sl))
46 if (SPEC_LONG(sl)) return "long";
47 if (SPEC_SHORT(sl)) return "short";
50 case V_FLOAT: return "float";
51 case V_FIXED16X16: return "fixed16x16";
52 case V_CHAR: return "char";
53 case V_VOID: return "void";
54 case V_STRUCT: return "struct";
55 case V_LABEL: return "label";
56 case V_BITFIELD: return "bitfield";
57 case V_BIT: return "bit";
58 case V_SBIT: return "sbit";
59 case V_DOUBLE: return "double";
64 bucket *SymbolTab[256]; /* the symbol table */
65 bucket *StructTab[256]; /* the structure table */
66 bucket *TypedefTab[256]; /* the typedef table */
67 bucket *LabelTab[256]; /* the Label table */
68 bucket *enumTab[256]; /* enumerated table */
70 /*------------------------------------------------------------------*/
71 /* initSymt () - initialises symbol table related stuff */
72 /*------------------------------------------------------------------*/
78 for (i = 0; i < 256; i++)
79 SymbolTab[i] = StructTab[i] = (void *) NULL;
83 /*-----------------------------------------------------------------*/
84 /* newBucket - allocates & returns a new bucket */
85 /*-----------------------------------------------------------------*/
91 bp = Safe_alloc ( sizeof (bucket));
96 /*-----------------------------------------------------------------*/
97 /* hashKey - computes the hashkey given a symbol name */
98 /*-----------------------------------------------------------------*/
100 hashKey (const char *s)
102 unsigned long key = 0;
109 /*-----------------------------------------------------------------*/
110 /* addSym - adds a symbol to the hash Table */
111 /*-----------------------------------------------------------------*/
113 addSym (bucket ** stab,
120 int i; /* index into the hash Table */
121 bucket *bp; /* temp bucket * */
124 symbol *csym = (symbol *)sym;
126 if (getenv("DEBUG_SANITY")) {
127 fprintf (stderr, "addSym: %s ", sname);
129 /* make sure the type is complete and sane */
130 checkTypeSanity(csym->etype, csym->name);
133 /* prevent overflow of the (r)name buffers */
134 if (strlen(sname)>SDCC_SYMNAME_MAX) {
135 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
136 sname[SDCC_SYMNAME_MAX]='\0';
139 /* the symbols are always added at the head of the list */
141 /* get a free entry */
142 bp = Safe_alloc ( sizeof (bucket));
144 bp->sym = sym; /* update the symbol pointer */
145 bp->level = level; /* update the nest level */
147 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
149 /* if this is the first entry */
152 bp->prev = bp->next = (void *) NULL; /* point to nothing */
155 /* not first entry then add @ head of list */
165 /*-----------------------------------------------------------------*/
166 /* deleteSym - deletes a symbol from the hash Table entry */
167 /*-----------------------------------------------------------------*/
169 deleteSym (bucket ** stab, void *sym, char *sname)
177 /* find the symbol */
180 if (bp->sym == sym) /* found it then break out */
181 break; /* of the loop */
185 if (!bp) /* did not find it */
187 /* if this is the first one in the chain */
191 if (stab[i]) /* if chain ! empty */
192 stab[i]->prev = (void *) NULL;
194 /* middle || end of chain */
197 if (bp->next) /* if not end of chain */
198 bp->next->prev = bp->prev;
200 bp->prev->next = bp->next;
205 /*-----------------------------------------------------------------*/
206 /* findSym - finds a symbol in a table */
207 /*-----------------------------------------------------------------*/
209 findSym (bucket ** stab, void *sym, const char *sname)
213 bp = stab[hashKey (sname)];
216 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
221 return (bp ? bp->sym : (void *) NULL);
224 /*-----------------------------------------------------------------*/
225 /* findSymWithLevel - finds a symbol with a name & level */
226 /*-----------------------------------------------------------------*/
228 findSymWithLevel (bucket ** stab, symbol * sym)
232 bp = stab[hashKey (sym->name)];
235 ** do the search from the head of the list since the
236 ** elements are added at the head it is ensured that
237 ** we will find the deeper definitions before we find
238 ** the global ones. we need to check for symbols with
239 ** level <= to the level given, if levels match then block
240 ** numbers need to match as well
244 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
246 /* if this is parameter then nothing else need to be checked */
247 if (((symbol *) (bp->sym))->_isparm)
249 /* if levels match then block numbers should also match */
250 if (bp->level && bp->level == sym->level && bp->block == sym->block)
252 /* if levels don't match then we are okay */
253 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
255 /* if this is a global variable then we are ok too */
263 return (void *) NULL;
266 /*-----------------------------------------------------------------*/
267 /* findSymWithBlock - finds a symbol with name in with a block */
268 /*-----------------------------------------------------------------*/
270 findSymWithBlock (bucket ** stab, symbol * sym, int block)
274 bp = stab[hashKey (sym->name)];
277 if (strcmp (bp->name, sym->name) == 0 &&
283 return (bp ? bp->sym : (void *) NULL);
286 /*------------------------------------------------------------------*/
287 /* newSymbol () - returns a new pointer to a symbol */
288 /*------------------------------------------------------------------*/
290 newSymbol (char *name, int scope)
294 sym = Safe_alloc ( sizeof (symbol));
296 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
297 sym->level = scope; /* set the level */
298 sym->block = currBlockno;
299 sym->lineDef = lexLineno; /* set the line number */
300 sym->fileDef = lexFilename;
304 /*------------------------------------------------------------------*/
305 /* newLink - creates a new link (declarator,specifier) */
306 /*------------------------------------------------------------------*/
308 newLink (SYM_LINK_CLASS select)
312 p = Safe_alloc ( sizeof (sym_link));
318 /*------------------------------------------------------------------*/
319 /* newStruct - creats a new structdef from the free list */
320 /*------------------------------------------------------------------*/
322 newStruct (char *tag)
326 s = Safe_alloc ( sizeof (structdef));
328 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
332 /*------------------------------------------------------------------*/
333 /* sclsFromPtr - Return the storage class a pointer points into. */
334 /* S_FIXED is returned for generic pointers or other */
335 /* unexpected cases */
336 /*------------------------------------------------------------------*/
338 sclsFromPtr(sym_link *ptr)
340 switch (DCL_TYPE (ptr))
363 /*------------------------------------------------------------------*/
364 /* pointerTypes - do the computation for the pointer types */
365 /*------------------------------------------------------------------*/
367 pointerTypes (sym_link * ptr, sym_link * type)
372 /* find the first pointer type */
373 while (ptr && !IS_PTR (ptr))
376 /* could not find it */
377 if (!ptr || IS_SPEC (ptr))
380 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
381 pointerTypes (ptr->next, type);
385 /* change the pointer type depending on the
386 storage class of the type */
389 switch (SPEC_SCLS (type))
392 DCL_TYPE (ptr) = FPOINTER;
395 DCL_TYPE (ptr) = IPOINTER;
398 DCL_TYPE (ptr) = PPOINTER;
401 DCL_TYPE (ptr) = POINTER;
404 DCL_TYPE (ptr) = CPOINTER;
407 DCL_TYPE (ptr) = EEPPOINTER;
410 DCL_TYPE (ptr) = port->unqualified_pointer;
413 /* the storage class of type ends here */
414 SPEC_SCLS (type) = 0;
417 /* now change all the remaining unknown pointers
418 to generic pointers */
421 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
422 DCL_TYPE (ptr) = port->unqualified_pointer;
426 /* same for the type although it is highly unlikely that
427 type will have a pointer */
430 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
431 DCL_TYPE (type) = port->unqualified_pointer;
436 /*------------------------------------------------------------------*/
437 /* addDecl - adds a declarator @ the end of a chain */
438 /*------------------------------------------------------------------*/
440 addDecl (symbol * sym, int type, sym_link * p)
442 static sym_link *empty = NULL;
447 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
448 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
451 empty = newLink(SPECIFIER);
453 /* if we are passed a link then set head & tail */
462 head = tail = newLink (DECLARATOR);
463 DCL_TYPE (head) = type;
466 /* if this is the first entry */
472 else if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
474 sym->etype = mergeSpec (sym->etype, head, sym->name);
476 else if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
479 while (t->next != sym->etype)
482 tail->next = sym->etype;
484 else if (IS_FUNC (sym->type) && IS_SPEC (sym->type->next) &&
485 !memcmp(sym->type->next, empty, sizeof(sym_link)))
487 sym->type->next = head;
492 sym->etype->next = head;
496 /* if the type is an unknown pointer and has
497 a tspec then take the storage class const & volatile
498 attribute from the tspec & make it those of this
502 //DCL_TYPE (p) == UPOINTER &&
505 if (!IS_SPEC (sym->etype))
507 sym->etype = sym->etype->next = newLink (SPECIFIER);
509 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
510 DCL_TSPEC (p) = NULL;
513 // if there is a function in this type chain
514 if (p && funcInChain(sym->type)) {
515 processFuncArgs (sym);
521 /*------------------------------------------------------------------
522 checkTypeSanity: prevent the user from doing e.g.:
524 ------------------------------------------------------------------*/
525 void checkTypeSanity(sym_link *etype, char *name) {
529 if (getenv("DEBUG_SANITY")) {
530 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
535 if (!IS_SPEC(etype)) {
536 if (getenv("DEBUG_SANITY")) {
537 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
542 noun=nounName(etype);
544 if (getenv("DEBUG_SANITY")) {
545 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
548 if ((SPEC_NOUN(etype)==V_CHAR ||
549 SPEC_NOUN(etype)==V_FLOAT ||
550 SPEC_NOUN(etype)==V_FIXED16X16 ||
551 SPEC_NOUN(etype)==V_DOUBLE ||
552 SPEC_NOUN(etype)==V_VOID) &&
553 (SPEC_SHORT(etype) || SPEC_LONG(etype))) {
554 // long or short for char float double or void
555 werror (E_LONG_OR_SHORT_INVALID, noun, name);
557 if ((SPEC_NOUN(etype)==V_FLOAT ||
558 SPEC_NOUN(etype)==V_FIXED16X16 ||
559 SPEC_NOUN(etype)==V_DOUBLE ||
560 SPEC_NOUN(etype)==V_VOID) &&
561 (etype->select.s.b_signed || SPEC_USIGN(etype))) {
562 // signed or unsigned for float double or void
563 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
566 // special case for "short"
567 if (SPEC_SHORT(etype)) {
568 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
569 SPEC_SHORT(etype) = 0;
573 "const a;" or "data b;" or "signed s" or "long l"
575 if (!SPEC_NOUN(etype)) {
576 SPEC_NOUN(etype)=V_INT;
579 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
580 /* a "plain" int bitfield is unsigned */
581 if (SPEC_NOUN(etype)==V_BIT ||
582 SPEC_NOUN(etype)==V_SBIT) {
583 if (!etype->select.s.b_signed)
584 SPEC_USIGN(etype) = 1;
587 if (etype->select.s.b_signed && SPEC_USIGN(etype)) {
588 // signed AND unsigned
589 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
591 if (SPEC_SHORT(etype) && SPEC_LONG(etype)) {
593 werror (E_LONG_AND_SHORT_INVALID, noun, name);
598 /*------------------------------------------------------------------*/
599 /* mergeSpec - merges two specifiers and returns the new one */
600 /*------------------------------------------------------------------*/
602 mergeSpec (sym_link * dest, sym_link * src, char *name)
604 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
606 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
609 werror (E_SYNTAX_ERROR, yytext);
610 // the show must go on
615 if (SPEC_NOUN(src)) {
616 if (!SPEC_NOUN(dest)) {
617 SPEC_NOUN(dest)=SPEC_NOUN(src);
619 /* we shouldn't redeclare the type */
620 if (getenv("DEBUG_SANITY")) {
621 fprintf (stderr, "mergeSpec: ");
623 werror(E_TWO_OR_MORE_DATA_TYPES, name);
627 if (SPEC_SCLS(src)) {
628 /* if destination has no storage class */
629 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
630 SPEC_SCLS (dest) = SPEC_SCLS (src);
632 if (getenv("DEBUG_SANITY")) {
633 fprintf (stderr, "mergeSpec: ");
635 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
639 /* copy all the specifications */
641 // we really should do:
643 if (SPEC_what(src)) {
644 if (SPEC_what(dest)) {
645 werror(W_DUPLICATE_SPEC, "what");
647 SPEC_what(dst)|=SPEC_what(src);
650 // but there are more important thing right now
652 SPEC_LONG (dest) |= SPEC_LONG (src);
653 SPEC_SHORT(dest) |= SPEC_SHORT(src);
654 SPEC_USIGN (dest) |= SPEC_USIGN (src);
655 dest->select.s.b_signed|=src->select.s.b_signed;
656 SPEC_STAT (dest) |= SPEC_STAT (src);
657 SPEC_EXTR (dest) |= SPEC_EXTR (src);
658 SPEC_INLINE (dest) |= SPEC_INLINE (src);
659 SPEC_CONST(dest) |= SPEC_CONST (src);
660 SPEC_ABSA (dest) |= SPEC_ABSA (src);
661 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
662 SPEC_RESTRICT (dest) |= SPEC_RESTRICT (src);
663 SPEC_ADDR (dest) |= SPEC_ADDR (src);
664 SPEC_OCLS (dest) = SPEC_OCLS (src);
665 SPEC_BLEN (dest) |= SPEC_BLEN (src);
666 SPEC_BSTR (dest) |= SPEC_BSTR (src);
667 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
668 SPEC_ENUM (dest) |= SPEC_ENUM (src);
669 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
670 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
672 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
673 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
675 /* these are the only function attributes that will be set
676 in a specifier while parsing */
677 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
678 FUNC_BANKED(dest) |= FUNC_BANKED(src);
679 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
680 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
681 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
682 FUNC_ISISR(dest) |= FUNC_ISISR(src);
683 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
684 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
685 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
686 FUNC_INTNO(dest) |= FUNC_INTNO(src);
687 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
688 FUNC_ISINLINE (dest) |= FUNC_ISINLINE (src);
693 /*------------------------------------------------------------------*/
694 /* genSymName - generates and returns a name used for anonymous vars */
695 /*------------------------------------------------------------------*/
697 genSymName (int level)
699 static int gCount = 0;
700 static char gname[SDCC_NAME_MAX + 1];
702 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
706 /*------------------------------------------------------------------*/
707 /* getSpec - returns the specifier part from a declaration chain */
708 /*------------------------------------------------------------------*/
710 getSpec (sym_link * p)
715 while (p && !(IS_SPEC (p)))
721 /*------------------------------------------------------------------*/
722 /* newCharLink() - creates an char type */
723 /*------------------------------------------------------------------*/
729 p = newLink (SPECIFIER);
730 SPEC_NOUN (p) = V_CHAR;
735 /*------------------------------------------------------------------*/
736 /* newFloatLink - a new Float type */
737 /*------------------------------------------------------------------*/
743 p = newLink (SPECIFIER);
744 SPEC_NOUN (p) = V_FLOAT;
749 /*------------------------------------------------------------------*/
750 /* newFixed16x16Link - a new Float type */
751 /*------------------------------------------------------------------*/
757 p = newLink (SPECIFIER);
758 SPEC_NOUN (p) = V_FIXED16X16;
763 /*------------------------------------------------------------------*/
764 /* newLongLink() - new long type */
765 /*------------------------------------------------------------------*/
771 p = newLink (SPECIFIER);
772 SPEC_NOUN (p) = V_INT;
778 /*------------------------------------------------------------------*/
779 /* newIntLink() - creates an int type */
780 /*------------------------------------------------------------------*/
786 p = newLink (SPECIFIER);
787 SPEC_NOUN (p) = V_INT;
792 /*------------------------------------------------------------------*/
793 /* newBoolLink() - creates an bool type */
794 /*------------------------------------------------------------------*/
800 p = newLink (SPECIFIER);
801 SPEC_NOUN (p) = V_BIT;
806 /*------------------------------------------------------------------*/
807 /* getSize - returns size of a type chain in bytes */
808 /*------------------------------------------------------------------*/
810 getSize (sym_link * p)
812 /* if nothing return 0 */
816 { /* if this is the specifier then */
817 switch (SPEC_NOUN (p))
818 { /* depending on the specifier type */
820 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
830 return SPEC_STRUCT (p)->size;
837 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
843 /* this is a declarator */
844 switch (DCL_TYPE (p))
848 return DCL_ELEM (p) * getSize (p->next);
850 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
851 // "can not tell the size of an array[]");
862 return (IFFUNC_BANKED (p) ? GPTRSIZE : FPTRSIZE);
871 /*------------------------------------------------------------------*/
872 /* checkStructFlexArray - check tree behind a struct */
873 /*------------------------------------------------------------------*/
875 checkStructFlexArray (symbol *sym, sym_link *p)
877 /* if nothing return FALSE */
883 /* (nested) struct with flexible array member? */
884 if (IS_STRUCT (p) && SPEC_STRUCT (p)->b_flexArrayMember)
886 werror (W_INVALID_FLEXARRAY);
892 /* this is a declarator */
895 /* flexible array member? */
898 if (!options.std_c99)
899 werror (W_C89_NO_FLEXARRAY);
903 return checkStructFlexArray (sym, p->next);
908 /*------------------------------------------------------------------*/
909 /* bitsForType - returns # of bits required to store this type */
910 /*------------------------------------------------------------------*/
912 bitsForType (sym_link * p)
914 /* if nothing return 0 */
919 { /* if this is the specifier then */
921 switch (SPEC_NOUN (p))
922 { /* depending on the specifier type */
924 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
926 return FLOATSIZE * 8;
934 return SPEC_STRUCT (p)->size * 8;
941 return SPEC_BLEN (p);
947 /* this is a specifier */
948 switch (DCL_TYPE (p))
951 return DCL_ELEM (p) * getSize (p->next) * 8;
955 return (PTRSIZE * 8);
960 return (FPTRSIZE * 8);
962 return (GPTRSIZE * 8);
969 /*------------------------------------------------------------------*/
970 /* copySymbolChain - copies a symbol chain */
971 /*------------------------------------------------------------------*/
973 copySymbolChain (symbol * src)
980 dest = copySymbol (src);
981 dest->next = copySymbolChain (src->next);
985 /*------------------------------------------------------------------*/
986 /* copySymbol - makes a copy of a symbol */
987 /*------------------------------------------------------------------*/
989 copySymbol (symbol * src)
996 dest = newSymbol (src->name, src->level);
997 memcpy (dest, src, sizeof (symbol));
998 dest->level = src->level;
999 dest->block = src->block;
1000 dest->ival = copyIlist (src->ival);
1001 dest->type = copyLinkChain (src->type);
1002 dest->etype = getSpec (dest->type);
1004 dest->key = src->key;
1005 dest->allocreq = src->allocreq;
1009 /*------------------------------------------------------------------*/
1010 /* reverseSyms - reverses the links for a symbol chain */
1011 /*------------------------------------------------------------------*/
1013 reverseSyms (symbol * sym)
1015 symbol *prev, *curr, *next;
1030 sym->next = (void *) NULL;
1034 /*------------------------------------------------------------------*/
1035 /* reverseLink - reverses the links for a type chain */
1036 /*------------------------------------------------------------------*/
1038 reverseLink (sym_link * type)
1040 sym_link *prev, *curr, *next;
1055 type->next = (void *) NULL;
1059 /*------------------------------------------------------------------*/
1060 /* addSymChain - adds a symbol chain to the symboltable */
1061 /*------------------------------------------------------------------*/
1063 addSymChain (symbol ** symHead)
1065 symbol *sym = *symHead;
1066 symbol *csym = NULL;
1070 for (; sym != NULL; sym = sym->next)
1072 changePointer(sym->type);
1073 checkTypeSanity(sym->etype, sym->name);
1075 if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1078 /* if already exists in the symbol table then check if
1079 one of them is an extern definition if yes then
1080 then check if the type match, if the types match then
1081 delete the current entry and add the new entry */
1082 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1083 csym->level == sym->level)
1085 /* if not formal parameter and not in file scope
1086 then show symbol redefined error
1087 else check if symbols have conpatible types */
1088 if (!sym->_isparm && sym->level > 0)
1092 /* If the previous definition was for an array with incomplete */
1093 /* type, and the new definition has completed the type, update */
1094 /* the original type to match */
1095 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1096 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1098 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1099 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1103 /* If only one of the definitions used the "at" keyword, copy */
1104 /* the address to the other. */
1105 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1106 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1108 SPEC_ABSA (sym->etype) = 1;
1109 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1111 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1112 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1114 SPEC_ABSA (csym->etype) = 1;
1115 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1120 if (csym->ival && sym->ival)
1122 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1128 /* one definition extern ? */
1129 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1130 werror (E_EXTERN_MISMATCH, sym->name);
1132 werror (E_DUPLICATE, sym->name);
1133 werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1135 fprintf (stderr, "from type '");
1136 printTypeChain (csym->type, stderr);
1137 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1138 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1139 fprintf (stderr, "'\nto type '");
1140 printTypeChain (sym->type, stderr);
1141 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1142 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1143 fprintf (stderr, "'\n");
1148 if (csym->ival && !sym->ival)
1149 sym->ival = csym->ival;
1151 /* delete current entry */
1152 deleteSym (SymbolTab, csym, csym->name);
1153 deleteFromSeg(csym);
1155 symPtrPtr = symHead;
1156 while (*symPtrPtr && *symPtrPtr != csym)
1157 symPtrPtr = &(*symPtrPtr)->next;
1158 if (*symPtrPtr == csym)
1159 *symPtrPtr = csym->next;
1163 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1168 /*------------------------------------------------------------------*/
1169 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1170 /*------------------------------------------------------------------*/
1172 funcInChain (sym_link * lnk)
1183 /*------------------------------------------------------------------*/
1184 /* structElemType - returns the type info of a struct member */
1185 /*------------------------------------------------------------------*/
1187 structElemType (sym_link * stype, value * id)
1189 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1190 sym_link *type, *etype;
1191 sym_link *petype = getSpec (stype);
1195 /* look for the id */
1198 if (strcmp (fields->rname, id->name) == 0)
1200 type = copyLinkChain (fields->type);
1201 etype = getSpec (type);
1202 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1203 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1205 SPEC_CONST (type) |= SPEC_CONST (stype);
1207 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1210 fields = fields->next;
1214 werror (E_NOT_MEMBER, id->name);
1216 // the show must go on
1217 return newIntLink();
1220 /*------------------------------------------------------------------*/
1221 /* getStructElement - returns element of a tructure definition */
1222 /*------------------------------------------------------------------*/
1224 getStructElement (structdef * sdef, symbol * sym)
1228 for (field = sdef->fields; field; field = field->next)
1229 if (strcmp (field->name, sym->name) == 0)
1232 werror (E_NOT_MEMBER, sym->name);
1234 return sdef->fields;
1237 /*------------------------------------------------------------------*/
1238 /* compStructSize - computes the size of a structure */
1239 /*------------------------------------------------------------------*/
1241 compStructSize (int su, structdef * sdef)
1243 int sum = 0, usum = 0;
1247 /* for the identifiers */
1248 loop = sdef->fields;
1251 /* create the internal name for this variable */
1252 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1257 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1259 /* if this is a bit field */
1262 /* change it to a unsigned bit */
1263 SPEC_NOUN (loop->etype) = V_BITFIELD;
1264 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
1265 /* a "plain" int bitfield is unsigned */
1266 if (!loop->etype->select.s.b_signed)
1267 SPEC_USIGN(loop->etype) = 1;
1269 SPEC_BLEN (loop->etype) = loop->bitVar;
1271 if (loop->bitVar == BITVAR_PAD) {
1272 /* A zero length bitfield forces padding */
1273 SPEC_BSTR (loop->etype) = bitOffset;
1274 SPEC_BLEN (loop->etype) = 0;
1279 if (bitOffset == 8) {
1283 /* check if this fit into the remaining */
1284 /* bits of this byte else align it to the */
1285 /* next byte boundary */
1286 if (loop->bitVar <= (8 - bitOffset)) {
1287 /* fits into current byte */
1289 SPEC_BSTR (loop->etype) = bitOffset;
1290 bitOffset += loop->bitVar;
1292 else if (!bitOffset) {
1293 /* does not fit, but is already byte aligned */
1295 SPEC_BSTR (loop->etype) = bitOffset;
1296 bitOffset += loop->bitVar;
1299 if( TARGET_IS_PIC16 && getenv("PIC16_PACKED_BITFIELDS") ) {
1300 /* if PIC16 && enviroment variable is set, then
1301 * tightly pack bitfields, this means that when a
1302 * bitfield goes beyond byte alignment, do not
1303 * automatically start allocatint from next byte,
1304 * but also use the available bits first */
1305 fprintf(stderr, ": packing bitfields in structures\n");
1306 SPEC_BSTR (loop->etype) = bitOffset;
1307 bitOffset += loop->bitVar;
1308 loop->offset = (su == UNION ? sum = 0 : sum);
1310 /* does not fit; need to realign first */
1312 loop->offset = (su == UNION ? sum = 0 : sum);
1314 SPEC_BSTR (loop->etype) = bitOffset;
1315 bitOffset += loop->bitVar;
1318 while (bitOffset>8) {
1325 /* This is a non-bit field. Make sure we are */
1326 /* byte aligned first */
1329 loop->offset = (su == UNION ? sum = 0 : sum);
1333 checkDecl (loop, 1);
1334 sum += getSize (loop->type);
1336 /* search for "flexibel array members" */
1337 /* and do some syntax checks */
1339 && checkStructFlexArray (loop, loop->type))
1341 /* found a "flexible array member" */
1342 sdef->b_flexArrayMember = TRUE;
1343 /* is another struct-member following? */
1345 werror (E_FLEXARRAY_NOTATEND);
1346 /* is it the first struct-member? */
1347 else if (loop == sdef->fields)
1348 werror (E_FLEXARRAY_INEMPTYSTRCT);
1354 /* if union then size = sizeof largest field */
1356 /* For UNION, round up after each field */
1357 sum += ((bitOffset+7)/8);
1358 usum = max (usum, sum);
1363 /* For STRUCT, round up after all fields processed */
1365 sum += ((bitOffset+7)/8);
1367 return (su == UNION ? usum : sum);
1370 /*-------------------------------------------------------------------*/
1371 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1372 /* an enclosing struct/union */
1373 /*-------------------------------------------------------------------*/
1375 promoteAnonStructs (int su, structdef * sdef)
1384 tofield = &sdef->fields;
1385 field = sdef->fields;
1388 nextfield = field->next;
1389 if (!*field->name && IS_STRUCT (field->type))
1391 /* Found an anonymous struct/union. Replace it */
1392 /* with the fields it contains and adjust all */
1395 base = field->offset;
1396 subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1398 continue; /* just in case it's empty */
1400 *tofield = subfield;
1403 /* check for field name conflicts resulting from promotion */
1404 dupfield = sdef->fields;
1405 while (dupfield && dupfield != subfield)
1407 if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1409 werrorfl (subfield->fileDef, subfield->lineDef,
1411 su==STRUCT ? "struct" : "union",
1413 werrorfl (dupfield->fileDef, dupfield->lineDef,
1416 dupfield = dupfield->next;
1419 subfield->offset += base;
1421 subfield = subfield->next;
1425 subfield->next = nextfield;
1426 tofield = &subfield->next;
1429 tofield = &field->next;
1435 /*------------------------------------------------------------------*/
1436 /* checkSClass - check the storage class specification */
1437 /*------------------------------------------------------------------*/
1439 checkSClass (symbol * sym, int isProto)
1443 if (getenv("DEBUG_SANITY")) {
1444 fprintf (stderr, "checkSClass: %s \n", sym->name);
1447 /* type is literal can happen for enums change to auto */
1448 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1449 SPEC_SCLS (sym->etype) = S_AUTO;
1451 /* if sfr or sbit then must also be volatile */
1452 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1453 SPEC_SCLS (sym->etype) == S_SFR)
1455 SPEC_VOLATILE (sym->etype) = 1;
1458 /* make sure restrict is only used with pointers */
1459 if (SPEC_RESTRICT (sym->etype))
1461 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1462 SPEC_RESTRICT (sym->etype) = 0;
1467 if (IS_DECL (t) && DCL_PTR_RESTRICT (t) && !IS_PTR (t))
1469 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1470 DCL_PTR_RESTRICT (t) = 0;
1476 /* if absolute address given then it mark it as
1477 volatile -- except in the PIC port */
1479 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1480 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1481 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1484 if (IS_ABSOLUTE (sym->etype))
1485 SPEC_VOLATILE (sym->etype) = 1;
1487 if (TARGET_IS_MCS51 &&
1488 IS_ABSOLUTE (sym->etype) &&
1489 SPEC_SCLS (sym->etype) == S_SFR)
1494 if (SPEC_NOUN (sym->etype) == V_CHAR)
1496 else if (SPEC_LONG (sym->etype) == 0)
1501 addr = SPEC_ADDR (sym->etype);
1502 for (n=0; n<size; n+=8)
1503 if (((addr >> n) & 0xFF) < 0x80)
1504 werror (W_SFR_ABSRANGE, sym->name);
1507 /* If code memory is read only, then pointers to code memory */
1508 /* implicitly point to constants -- make this explicit */
1510 while (t && t->next) {
1511 if (IS_CODEPTR(t) && port->mem.code_ro) {
1512 if (IS_SPEC(t->next)) {
1513 SPEC_CONST (t->next) = 1;
1515 DCL_PTR_CONST (t->next) = 1;
1521 /* global variables declared const put into code */
1522 /* if no other storage class specified */
1523 if (sym->level == 0 &&
1524 SPEC_SCLS(sym->etype) == S_FIXED &&
1525 !IS_FUNC(sym->type)) {
1526 /* find the first non-array link */
1530 if (IS_CONSTANT (t)) {
1531 SPEC_SCLS (sym->etype) = S_CODE;
1535 /* global variable in code space is a constant */
1536 if (sym->level == 0 &&
1537 SPEC_SCLS (sym->etype) == S_CODE &&
1538 port->mem.code_ro) {
1539 /* find the first non-array link */
1546 DCL_PTR_CONST (t) = 1;
1550 /* if bit variable then no storage class can be */
1551 /* specified since bit is already a storage */
1552 if (IS_BITVAR (sym->etype) &&
1553 (SPEC_SCLS (sym->etype) != S_FIXED &&
1554 SPEC_SCLS (sym->etype) != S_SBIT &&
1555 SPEC_SCLS (sym->etype) != S_BIT)
1558 werror (E_BITVAR_STORAGE, sym->name);
1559 SPEC_SCLS (sym->etype) = S_FIXED;
1562 /* extern variables cannot be initialized */
1563 if (IS_EXTERN (sym->etype) && sym->ival)
1565 werror (E_EXTERN_INIT, sym->name);
1569 /* if this is an automatic symbol */
1570 if (sym->level && (options.stackAuto || reentrant)) {
1571 if (SPEC_SCLS (sym->etype) != S_BIT) {
1572 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1573 SPEC_SCLS (sym->etype) == S_FIXED ||
1574 SPEC_SCLS (sym->etype) == S_REGISTER ||
1575 SPEC_SCLS (sym->etype) == S_STACK ||
1576 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1577 SPEC_SCLS (sym->etype) = S_AUTO;
1579 /* storage class may only be specified for statics */
1580 if (!IS_STATIC(sym->etype)) {
1581 werror (E_AUTO_ASSUMED, sym->name);
1587 /* automatic symbols cannot be given */
1588 /* an absolute address ignore it */
1590 SPEC_ABSA (sym->etype) &&
1591 (options.stackAuto || reentrant))
1593 werror (E_AUTO_ABSA, sym->name);
1594 SPEC_ABSA (sym->etype) = 0;
1597 /* arrays & pointers cannot be defined for bits */
1598 /* SBITS or SFRs or BIT */
1599 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1600 !IS_FUNCPTR (sym->type) &&
1601 (SPEC_NOUN (sym->etype) == V_BIT ||
1602 SPEC_NOUN (sym->etype) == V_SBIT ||
1603 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1604 SPEC_SCLS (sym->etype) == S_SFR))
1605 werror (E_BIT_ARRAY, sym->name);
1607 /* if this is a bit|sbit then set length & start */
1608 if (SPEC_NOUN (sym->etype) == V_BIT ||
1609 SPEC_NOUN (sym->etype) == V_SBIT)
1611 SPEC_BLEN (sym->etype) = 1;
1612 SPEC_BSTR (sym->etype) = 0;
1616 /* variables declared in CODE space must have */
1617 /* initializers if not an extern */
1618 if (SPEC_SCLS (sym->etype) == S_CODE &&
1619 sym->ival == NULL &&
1622 port->mem.code_ro &&
1623 !IS_EXTERN (sym->etype) &&
1624 !SPEC_ABSA (sym->etype) &&
1625 !funcInChain (sym->type))
1626 werror (E_CODE_NO_INIT, sym->name);
1629 /* if parameter or local variable then change */
1630 /* the storage class to reflect where the var will go */
1631 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1632 && !IS_STATIC(sym->etype)
1635 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1637 SPEC_SCLS (sym->etype) = (options.useXstack ?
1638 S_XSTACK : S_STACK);
1642 /* hack-o-matic! I see no reason why the useXstack option should ever
1643 * control this allocation, but the code was originally that way, and
1644 * changing it for non-390 ports breaks the compiler badly.
1646 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1647 1 : options.useXstack;
1648 SPEC_SCLS (sym->etype) = (useXdata ?
1654 /*------------------------------------------------------------------*/
1655 /* changePointer - change pointer to functions */
1656 /*------------------------------------------------------------------*/
1658 changePointer (sym_link * p)
1661 /* go thru the chain of declarations */
1662 /* if we find a pointer to a function */
1663 /* change it to a ptr to code area */
1664 /* unless the function is banked. */
1665 for (; p; p = p->next)
1667 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1668 DCL_TYPE (p) = port->unqualified_pointer;
1669 if (IS_PTR (p) && IS_FUNC (p->next))
1670 if (!IFFUNC_BANKED(p->next))
1671 DCL_TYPE (p) = CPOINTER;
1675 /*------------------------------------------------------------------*/
1676 /* checkDecl - does semantic validation of a declaration */
1677 /*------------------------------------------------------------------*/
1679 checkDecl (symbol * sym, int isProto)
1682 checkSClass (sym, isProto); /* check the storage class */
1683 changePointer (sym->type); /* change pointers if required */
1685 /* if this is an array without any dimension
1686 then update the dimension from the initial value */
1687 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1688 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1693 /*------------------------------------------------------------------*/
1694 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1695 /*------------------------------------------------------------------*/
1697 copyLinkChain (sym_link * p)
1699 sym_link *head, *curr, *loop;
1701 /* note: v_struct and v_struct->fields are not copied! */
1703 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1706 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1707 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1715 /*------------------------------------------------------------------*/
1716 /* cleanUpBlock - cleansup the symbol table specified for all the */
1717 /* symbols in the given block */
1718 /*------------------------------------------------------------------*/
1720 cleanUpBlock (bucket ** table, int block)
1725 /* go thru the entire table */
1726 for (i = 0; i < 256; i++)
1728 for (chain = table[i]; chain; chain = chain->next)
1730 if (chain->block >= block)
1732 deleteSym (table, chain->sym, chain->name);
1738 /*------------------------------------------------------------------*/
1739 /* cleanUpLevel - cleansup the symbol table specified for all the */
1740 /* symbols in the given level */
1741 /*------------------------------------------------------------------*/
1743 cleanUpLevel (bucket ** table, int level)
1748 /* go thru the entire table */
1749 for (i = 0; i < 256; i++)
1751 for (chain = table[i]; chain; chain = chain->next)
1753 if (chain->level >= level)
1755 deleteSym (table, chain->sym, chain->name);
1761 /*------------------------------------------------------------------*/
1762 /* computeTypeOr - computes the resultant type from two types */
1763 /*------------------------------------------------------------------*/
1765 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1768 assert ( (IS_CHAR (etype1) || IS_BIT (etype1))
1769 && (IS_CHAR (etype2) || IS_BIT (etype2)));
1771 if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1773 SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1777 if (SPEC_USIGN (etype1))
1779 if ( IS_LITERAL (etype2)
1780 && floatFromVal (valFromType (etype2)) >= 0)
1781 SPEC_USIGN (reType) = 1;
1784 /* promote to int */
1785 SPEC_USIGN (reType) = 0;
1786 SPEC_NOUN (reType) = V_INT;
1789 else /* etype1 signed */
1791 if ( IS_LITERAL (etype2)
1792 && floatFromVal (valFromType (etype2)) <= 127)
1793 SPEC_USIGN (reType) = 0;
1796 /* promote to int */
1797 SPEC_USIGN (reType) = 0;
1798 SPEC_NOUN (reType) = V_INT;
1802 if (SPEC_USIGN (etype2))
1804 if ( IS_LITERAL (etype1)
1805 && floatFromVal (valFromType (etype1)) >= 0)
1806 SPEC_USIGN (reType) = 1;
1809 /* promote to int */
1810 SPEC_USIGN (reType) = 0;
1811 SPEC_NOUN (reType) = V_INT;
1814 else /* etype2 signed */
1816 if ( IS_LITERAL (etype1)
1817 && floatFromVal (valFromType (etype1)) <= 127)
1818 SPEC_USIGN (reType) = 0;
1821 /* promote to int */
1822 SPEC_USIGN (reType) = 0;
1823 SPEC_NOUN (reType) = V_INT;
1829 /*------------------------------------------------------------------*/
1830 /* computeType - computes the resultant type from two types */
1831 /*------------------------------------------------------------------*/
1833 computeType (sym_link * type1, sym_link * type2,
1834 RESULT_TYPE resultType, int op)
1838 sym_link *etype1 = getSpec (type1);
1841 etype2 = type2 ? getSpec (type2) : type1;
1843 /* if one of them is a float then result is a float */
1844 /* here we assume that the types passed are okay */
1845 /* and can be cast to one another */
1846 /* which ever is greater in size */
1847 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1848 rType = newFloatLink ();
1849 /* if both are fixed16x16 then result is float */
1850 else if (IS_FIXED16X16(etype1) && IS_FIXED16X16(etype2))
1851 rType = newFixed16x16Link();
1852 else if (IS_FIXED16X16(etype1) && IS_FLOAT (etype2))
1853 rType = newFloatLink ();
1854 else if (IS_FLOAT (etype1) && IS_FIXED16X16 (etype2) )
1855 rType = newFloatLink ();
1857 /* if both are bitvars choose the larger one */
1858 else if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1859 rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1860 copyLinkChain (type1) : copyLinkChain (type1);
1862 /* if only one of them is a bit variable then the other one prevails */
1863 else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1865 rType = copyLinkChain (type2);
1866 /* bitfield can have up to 16 bits */
1867 if (getSize (etype1) > 1)
1868 SPEC_NOUN (getSpec (rType)) = V_INT;
1870 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1872 rType = copyLinkChain (type1);
1873 /* bitfield can have up to 16 bits */
1874 if (getSize (etype2) > 1)
1875 SPEC_NOUN (getSpec (rType)) = V_INT;
1877 /* if one of them is a pointer or array then that
1879 else if (IS_PTR (type1) || IS_ARRAY (type1))
1880 rType = copyLinkChain (type1);
1881 else if (IS_PTR (type2) || IS_ARRAY (type2))
1882 rType = copyLinkChain (type2);
1883 else if (getSize (type1) > getSize (type2))
1884 rType = copyLinkChain (type1);
1886 rType = copyLinkChain (type2);
1888 reType = getSpec (rType);
1890 /* avoid conflicting types */
1891 reType->select.s.b_signed = 0;
1893 /* if result is a literal then make not so */
1894 if (IS_LITERAL (reType))
1895 SPEC_SCLS (reType) = S_REGISTER;
1899 case RESULT_TYPE_CHAR:
1900 if (IS_BITVAR (reType))
1902 SPEC_NOUN (reType) = V_CHAR;
1903 SPEC_SCLS (reType) = 0;
1904 SPEC_USIGN (reType) = 0;
1908 case RESULT_TYPE_INT:
1909 case RESULT_TYPE_NONE:
1910 case RESULT_TYPE_OTHER:
1911 if (IS_BIT (reType))
1913 SPEC_NOUN (reType) = V_CHAR;
1914 SPEC_SCLS (reType) = 0;
1915 SPEC_USIGN (reType) = 0;
1918 else if (IS_BITFIELD (reType))
1920 /* could be smarter, but it depends on the op */
1921 /* this is for the worst case: a multiplication of 4 * 4 bit */
1922 SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1923 SPEC_SCLS (reType) = 0;
1924 SPEC_USIGN (reType) = 0;
1927 else if (IS_CHAR (reType))
1929 /* promotion of some special cases */
1934 return computeTypeOr (etype1, etype2, reType);
1936 if (SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1938 SPEC_USIGN (reType) = 1;
1943 SPEC_NOUN (reType) = V_INT;
1944 SPEC_USIGN (reType) = 0;
1947 /* if both are unsigned char then no promotion required */
1948 if (!(SPEC_USIGN (etype1) && SPEC_USIGN (etype2)))
1950 SPEC_NOUN (reType) = V_INT;
1951 SPEC_USIGN (reType) = 0;
1964 /* SDCC's sign promotion:
1965 - if one or both operands are unsigned, the resultant type will be unsigned
1966 (except char, see below)
1967 - if an operand is promoted to a larger type (char -> int, int -> long),
1968 the larger type will be signed
1970 SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1971 much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1972 the standard. The standard demands, that the result has to be the same
1973 "as if" the promotion would have been performed:
1975 - if the result of an operation with two char's is promoted to a
1976 larger type, the result will be signed.
1978 More sophisticated are these:
1979 - if the result of an operation with two char's is a char again,
1980 the result will only then be unsigned, if both operands are
1981 unsigned. In all other cases the result will be signed.
1983 This seems to be contradictionary to the first two rules, but it makes
1984 real sense (all types are char's):
1986 A signed char can be negative; this must be preserved in the result
1989 Only if both operands are unsigned it's safe to make the result
1990 unsigned; this helps to avoid overflow:
1993 - ToDo: document '|', '^' and '&'
1995 Homework: - why is (200 * 200 < 0) true?
1996 - why is { char l = 200, r = 200; (r * l > 0) } true?
1999 if (!IS_FLOAT (reType)
2000 && ( (SPEC_USIGN (etype1)
2001 /* if this operand is promoted to a larger type,
2002 then it will be promoted to a signed type */
2003 && !(bitsForType (etype1) < bitsForType (reType))
2004 /* char require special handling */
2005 && !IS_CHAR (etype1))
2006 || /* same for 2nd operand */
2007 (SPEC_USIGN (etype2)
2008 && !(bitsForType (etype2) < bitsForType (reType))
2009 && !IS_CHAR (etype2))
2010 || /* if both are 'unsigned char' and not promoted
2011 let the result be unsigned too */
2012 ( SPEC_USIGN (etype1)
2013 && SPEC_USIGN (etype2)
2016 && IS_CHAR (reType))))
2017 SPEC_USIGN (reType) = 1;
2019 SPEC_USIGN (reType) = 0;
2024 /*--------------------------------------------------------------------*/
2025 /* compareType - will do type check return 1 if match, -1 if castable */
2026 /*--------------------------------------------------------------------*/
2028 compareType (sym_link * dest, sym_link * src)
2039 /* if dest is a declarator then */
2044 /* banked function pointer */
2045 if (IS_GENPTR (dest) && IS_GENPTR (src))
2047 if (IS_FUNC (src->next) && IS_VOID(dest->next))
2049 if (IS_FUNC (dest->next) && IS_VOID(src->next))
2051 return compareType (dest->next, src->next);
2054 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2056 //checkFunction(src,dest);
2058 return compareType (dest->next, src->next);
2060 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
2064 (IS_GENPTR (dest) ||
2065 ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
2068 if (IS_PTR (dest) && IS_ARRAY (src)) {
2069 value *val=aggregateToPointer (valFromType(src));
2070 int res=compareType (dest, val->type);
2071 Safe_free(val->type);
2075 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
2076 return compareType (dest->next, src);
2079 else if (IS_PTR (dest) && IS_INTEGRAL (src))
2085 /* if one is a specifier and the other is not */
2086 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2087 (IS_SPEC (dest) && !IS_SPEC (src)))
2090 /* if one of them is a void then ok */
2091 if (SPEC_NOUN (dest) == V_VOID &&
2092 SPEC_NOUN (src) != V_VOID)
2095 if (SPEC_NOUN (dest) != V_VOID &&
2096 SPEC_NOUN (src) == V_VOID)
2099 /* if they are both bitfields then if the lengths
2100 and starts don't match */
2101 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2102 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2103 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2106 /* it is a specifier */
2107 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2109 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
2110 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
2112 bitsForType (dest) == bitsForType (src))
2113 instead of the next two lines, but the regression tests fail with
2114 them; I guess it's a problem with replaceCheaperOp */
2115 getSize (dest) == getSize (src) &&
2116 !(!IS_BIT (dest) && IS_BIT (src)))
2118 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
2123 else if (IS_STRUCT (dest))
2125 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2130 if (SPEC_LONG (dest) != SPEC_LONG (src))
2133 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2139 /*--------------------------------------------------------------------*/
2140 /* compareTypeExact - will do type check return 1 if match exactly */
2141 /*--------------------------------------------------------------------*/
2143 compareTypeExact (sym_link * dest, sym_link * src, int level)
2145 STORAGE_CLASS srcScls, destScls;
2156 /* if dest is a declarator then */
2161 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2162 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2164 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2166 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2170 value *exargs, *acargs, *checkValue;
2172 /* verify function return type */
2173 if (!compareTypeExact (dest->next, src->next, -1))
2175 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2177 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2179 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2182 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2186 /* compare expected args with actual args */
2187 exargs = FUNC_ARGS(dest);
2188 acargs = FUNC_ARGS(src);
2190 /* for all the expected args do */
2191 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2193 //checkTypeSanity(acargs->etype, acargs->name);
2195 if (IS_AGGREGATE (acargs->type))
2197 checkValue = copyValue (acargs);
2198 aggregateToPointer (checkValue);
2201 checkValue = acargs;
2204 if (!compareTypeExact (exargs->type, checkValue->type, -1))
2209 /* if one them ended we have a problem */
2210 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2211 (!exargs && acargs && !IS_VOID (acargs->type)))
2215 return compareTypeExact (dest->next, src->next, level);
2222 /* if one is a specifier and the other is not */
2223 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2224 (IS_SPEC (dest) && !IS_SPEC (src)))
2227 /* if one of them is a void then ok */
2228 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2231 /* if they are both bitfields then if the lengths
2232 and starts don't match */
2233 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2234 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2235 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2238 if (IS_INTEGRAL (dest))
2240 /* signedness must match */
2241 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2243 /* size must match */
2244 if (SPEC_LONG (dest) != SPEC_LONG (src))
2246 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2250 if (IS_STRUCT (dest))
2252 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2256 if (SPEC_CONST (dest) != SPEC_CONST (src))
2258 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2260 if (SPEC_STAT (dest) != SPEC_STAT (src))
2262 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2264 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2267 destScls = SPEC_SCLS (dest);
2268 srcScls = SPEC_SCLS (src);
2270 /* Compensate for const to const code change in checkSClass() */
2271 if (!level & port->mem.code_ro && SPEC_CONST (dest))
2273 if (srcScls == S_CODE && destScls == S_FIXED)
2275 if (destScls == S_CODE && srcScls == S_FIXED)
2279 /* compensate for allocGlobal() */
2280 if ((srcScls == S_FIXED || srcScls == S_AUTO)
2281 && port->mem.default_globl_map == xdata
2285 if (level>0 && !SPEC_STAT (dest))
2287 /* Compensate for hack-o-matic in checkSClass() */
2288 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2290 if (destScls == S_FIXED)
2291 destScls = (options.useXstack ? S_XSTACK : S_STACK);
2292 if (srcScls == S_FIXED)
2293 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2295 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2297 if (destScls == S_FIXED)
2299 if (srcScls == S_FIXED)
2304 if (srcScls != destScls)
2307 printf ("level = %d\n", level);
2308 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2309 SPEC_SCLS (src), SPEC_SCLS (dest));
2310 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2318 /*------------------------------------------------------------------*/
2319 /* inCalleeSaveList - return 1 if found in callee save list */
2320 /*------------------------------------------------------------------*/
2322 calleeCmp(void *p1, void *p2)
2324 return (strcmp((char *)p1, (char *)(p2)) == 0);
2328 inCalleeSaveList(char *s)
2330 if (options.all_callee_saves)
2332 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2335 /*-----------------------------------------------------------------*/
2336 /* aggregateToPointer: change an agggregate type function */
2337 /* argument to a pointer to that type. */
2338 /*-----------------------------------------------------------------*/
2340 aggregateToPointer (value * val)
2342 if (IS_AGGREGATE (val->type))
2344 /* if this is a structure */
2345 /* then we need to add a new link */
2346 if (IS_STRUCT (val->type))
2348 /* first lets add DECLARATOR type */
2349 sym_link *p = val->type;
2351 werror (W_STRUCT_AS_ARG, val->name);
2352 val->type = newLink (DECLARATOR);
2353 val->type->next = p;
2356 /* change to a pointer depending on the */
2357 /* storage class specified */
2358 switch (SPEC_SCLS (val->etype))
2361 DCL_TYPE (val->type) = IPOINTER;
2364 DCL_TYPE (val->type) = PPOINTER;
2367 if (SPEC_OCLS(val->etype)) {
2368 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2370 // this happens for (external) function parameters
2371 DCL_TYPE (val->type) = port->unqualified_pointer;
2377 DCL_TYPE (val->type) = POINTER;
2380 DCL_TYPE (val->type) = CPOINTER;
2383 DCL_TYPE (val->type) = FPOINTER;
2386 DCL_TYPE (val->type) = EEPPOINTER;
2389 DCL_TYPE (val->type) = port->unqualified_pointer;
2392 /* is there is a symbol associated then */
2393 /* change the type of the symbol as well */
2396 val->sym->type = copyLinkChain (val->type);
2397 val->sym->etype = getSpec (val->sym->type);
2402 /*------------------------------------------------------------------*/
2403 /* checkFunction - does all kinds of check on a function */
2404 /*------------------------------------------------------------------*/
2406 checkFunction (symbol * sym, symbol *csym)
2408 value *exargs, *acargs;
2412 if (getenv("DEBUG_SANITY")) {
2413 fprintf (stderr, "checkFunction: %s ", sym->name);
2416 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2418 werror(E_SYNTAX_ERROR, sym->name);
2422 /* move inline specifier from return type to function attributes */
2423 if (IS_INLINE (sym->etype))
2425 SPEC_INLINE (sym->etype) = 0;
2426 FUNC_ISINLINE (sym->type) = 1;
2429 /* make sure the type is complete and sane */
2430 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2432 /* if not type then some kind of error */
2436 /* if the function has no type then make it return int */
2437 if (!sym->type->next)
2438 sym->type->next = sym->etype = newIntLink ();
2440 /* function cannot return aggregate */
2441 if (IS_AGGREGATE (sym->type->next))
2443 werror (E_FUNC_AGGR, sym->name);
2447 /* check if this function is defined as calleeSaves
2448 then mark it as such */
2449 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2451 /* if interrupt service routine */
2452 /* then it cannot have arguments */
2453 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2455 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2456 werror (E_INT_ARGS, sym->name);
2457 FUNC_ARGS(sym->type)=NULL;
2461 if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2463 werror (E_SHADOWREGS_NO_ISR, sym->name);
2467 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2469 acargs=acargs->next, argCnt++) {
2471 // this can happen for reentrant functions
2472 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2473 // the show must go on: synthesize a name and symbol
2474 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2475 acargs->sym = newSymbol (acargs->name, 1);
2476 SPEC_OCLS (acargs->etype) = istack;
2477 acargs->sym->type = copyLinkChain (acargs->type);
2478 acargs->sym->etype = getSpec (acargs->sym->type);
2479 acargs->sym->_isparm = 1;
2480 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2481 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2483 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2488 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2489 return 1; /* not defined nothing more to check */
2491 /* check if body already present */
2492 if (csym && IFFUNC_HASBODY(csym->type))
2494 werror (E_FUNC_BODY, sym->name);
2498 /* check the return value type */
2499 if (compareType (csym->type, sym->type) <= 0)
2501 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2502 printFromToType(csym->type, sym->type);
2506 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2508 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2511 /* I don't think this is necessary for interrupts. An isr is a */
2512 /* root in the calling tree. */
2513 if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2514 (!FUNC_ISISR (sym->type)))
2516 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2519 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2521 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2524 /* Really, reentrant should match regardless of argCnt, but */
2525 /* this breaks some existing code (the fp lib functions). If */
2526 /* the first argument is always passed the same way, this */
2527 /* lax checking is ok (but may not be true for in future ports) */
2528 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2531 //printf("argCnt = %d\n",argCnt);
2532 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2535 if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2537 werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2540 if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2542 werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2546 /* compare expected args with actual args */
2547 exargs = FUNC_ARGS(csym->type);
2548 acargs = FUNC_ARGS(sym->type);
2550 /* for all the expected args do */
2553 exargs = exargs->next, acargs = acargs->next, argCnt++)
2555 if (getenv("DEBUG_SANITY")) {
2556 fprintf (stderr, "checkFunction: %s ", exargs->name);
2558 /* make sure the type is complete and sane */
2559 checkTypeSanity(exargs->etype, exargs->name);
2561 /* If the actual argument is an array, any prototype
2562 * will have modified it to a pointer. Duplicate that
2565 if (IS_AGGREGATE (acargs->type))
2567 checkValue = copyValue (acargs);
2568 aggregateToPointer (checkValue);
2572 checkValue = acargs;
2575 if (compareType (exargs->type, checkValue->type) <= 0)
2577 werror (E_ARG_TYPE, argCnt);
2578 printFromToType(exargs->type, checkValue->type);
2583 /* if one them ended we have a problem */
2584 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2585 (!exargs && acargs && !IS_VOID (acargs->type)))
2586 werror (E_ARG_COUNT);
2588 /* replace with this defition */
2589 sym->cdef = csym->cdef;
2590 deleteSym (SymbolTab, csym, csym->name);
2591 deleteFromSeg(csym);
2592 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2593 if (IS_EXTERN (csym->etype) && !
2594 IS_EXTERN (sym->etype))
2596 addSet (&publics, sym);
2601 /*------------------------------------------------------------------*/
2602 /* cdbStructBlock - calls struct printing for a blcks */
2603 /*------------------------------------------------------------------*/
2604 void cdbStructBlock (int block)
2607 bucket **table = StructTab;
2610 /* go thru the entire table */
2611 for (i = 0; i < 256; i++)
2613 for (chain = table[i]; chain; chain = chain->next)
2615 if (chain->block >= block)
2618 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2624 /*-----------------------------------------------------------------*/
2625 /* processFuncPtrArgs - does some processing with args of func ptrs*/
2626 /*-----------------------------------------------------------------*/
2628 processFuncPtrArgs (sym_link * funcType)
2630 value *val = FUNC_ARGS(funcType);
2632 /* if it is void then remove parameters */
2633 if (val && IS_VOID (val->type))
2635 FUNC_ARGS(funcType) = NULL;
2640 /*-----------------------------------------------------------------*/
2641 /* processFuncArgs - does some processing with function args */
2642 /*-----------------------------------------------------------------*/
2644 processFuncArgs (symbol * func)
2648 sym_link *funcType=func->type;
2650 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2651 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2653 /* find the function declaration within the type */
2654 while (funcType && !IS_FUNC(funcType))
2655 funcType=funcType->next;
2657 /* if this function has variable argument list */
2658 /* then make the function a reentrant one */
2659 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2660 FUNC_ISREENT(funcType)=1;
2662 /* check if this function is defined as calleeSaves
2663 then mark it as such */
2664 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2666 /* loop thru all the arguments */
2667 val = FUNC_ARGS(funcType);
2669 /* if it is void then remove parameters */
2670 if (val && IS_VOID (val->type))
2672 FUNC_ARGS(funcType) = NULL;
2676 /* reset regparm for the port */
2677 (*port->reset_regparms) ();
2679 /* if any of the arguments is an aggregate */
2680 /* change it to pointer to the same type */
2684 char buffer[SDCC_NAME_MAX+1];
2686 SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2687 checkTypeSanity (val->etype, buffer);
2689 /* mark it as a register parameter if
2690 the function does not have VA_ARG
2691 and as port dictates */
2692 if (!IFFUNC_HASVARARGS(funcType) &&
2693 (argreg = (*port->reg_parm) (val->type, FUNC_ISREENT(funcType))))
2695 SPEC_REGPARM (val->etype) = 1;
2696 SPEC_ARGREG(val->etype) = argreg;
2697 } else if (IFFUNC_ISREENT(funcType)) {
2698 FUNC_HASSTACKPARM(funcType) = 1;
2701 if (IS_AGGREGATE (val->type))
2703 aggregateToPointer (val);
2710 /* if this is an internal generated function call */
2712 /* ignore --stack-auto for this one, we don't know how it is compiled */
2713 /* simply trust on --int-long-reent or --float-reent */
2714 if (IFFUNC_ISREENT(funcType)) {
2718 /* if this function is reentrant or */
2719 /* automatics r 2b stacked then nothing */
2720 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2724 val = FUNC_ARGS(funcType);
2729 /* if a symbolname is not given */
2730 /* synthesize a variable name */
2733 SNPRINTF (val->name, sizeof(val->name),
2734 "_%s_PARM_%d", func->name, pNum++);
2735 val->sym = newSymbol (val->name, 1);
2736 if (SPEC_SCLS(val->etype) == S_BIT)
2737 SPEC_OCLS (val->etype) = bit;
2739 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2740 val->sym->type = copyLinkChain (val->type);
2741 val->sym->etype = getSpec (val->sym->type);
2742 val->sym->_isparm = 1;
2743 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2745 /* ?? static functions shouldn't imply static parameters - EEP */
2746 if (IS_SPEC(func->etype)) {
2747 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2748 SPEC_STAT (func->etype);
2751 addSymChain (&val->sym);
2754 else /* symbol name given create synth name */
2757 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2758 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2759 val->sym->_isparm = 1;
2760 if (SPEC_SCLS(val->etype) == S_BIT)
2761 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2763 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2764 port->mem.default_local_map;
2767 /* ?? static functions shouldn't imply static parameters - EEP */
2768 if (IS_SPEC(func->etype)) {
2769 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2770 SPEC_STAT (func->etype);
2774 if (SPEC_OCLS (val->sym->etype) == pdata)
2775 val->sym->iaccess = 1;
2776 if (!isinSet(operKeyReset, val->sym)) {
2777 addSet (&operKeyReset, val->sym);
2778 applyToSet (operKeyReset, resetParmKey);
2784 /*-----------------------------------------------------------------*/
2785 /* isSymbolEqual - compares two symbols return 1 if they match */
2786 /*-----------------------------------------------------------------*/
2788 isSymbolEqual (symbol * dest, symbol * src)
2790 /* if pointers match then equal */
2794 /* if one of them is null then don't match */
2798 /* if both of them have rname match on rname */
2799 if (dest->rname[0] && src->rname[0])
2800 return (!strcmp (dest->rname, src->rname));
2802 /* otherwise match on name */
2803 return (!strcmp (dest->name, src->name));
2806 void PT(sym_link *type)
2808 printTypeChain(type,0);
2810 /*-----------------------------------------------------------------*/
2811 /* printTypeChain - prints the type chain in human readable form */
2812 /*-----------------------------------------------------------------*/
2814 printTypeChain (sym_link * start, FILE * of)
2825 dbuf_init (&dbuf, 1024);
2826 dbuf_printTypeChain (start, &dbuf);
2827 dbuf_write_and_destroy (&dbuf, of);
2834 dbuf_printTypeChain (sym_link * start, struct dbuf_s *dbuf)
2837 sym_link * type, * search;
2841 dbuf_append_str (dbuf, "void");
2845 /* Print the chain as it is written in the source: */
2846 /* start with the last entry. */
2847 /* However, the storage class at the end of the */
2848 /* chain reall applies to the first in the chain! */
2850 for (type = start; type && type->next; type = type->next)
2853 scls=SPEC_SCLS(type);
2861 case S_DATA: dbuf_append_str (dbuf, "data-"); break;
2862 case S_XDATA: dbuf_append_str (dbuf, "xdata-"); break;
2863 case S_SFR: dbuf_append_str (dbuf, "sfr-"); break;
2864 case S_SBIT: dbuf_append_str (dbuf, "sbit-"); break;
2865 case S_CODE: dbuf_append_str (dbuf, "code-"); break;
2866 case S_IDATA: dbuf_append_str (dbuf, "idata-"); break;
2867 case S_PDATA: dbuf_append_str (dbuf, "pdata-"); break;
2868 case S_LITERAL: dbuf_append_str (dbuf, "literal-"); break;
2869 case S_STACK: dbuf_append_str (dbuf, "stack-"); break;
2870 case S_XSTACK: dbuf_append_str (dbuf, "xstack-"); break;
2871 case S_BIT: dbuf_append_str (dbuf, "bit-"); break;
2872 case S_EEPROM: dbuf_append_str (dbuf, "eeprom-"); break;
2879 if (!IS_FUNC(type)) {
2880 if (DCL_PTR_VOLATILE (type)) {
2881 dbuf_append_str (dbuf, "volatile-");
2883 if (DCL_PTR_CONST (type)) {
2884 dbuf_append_str (dbuf, "const-");
2886 if (DCL_PTR_RESTRICT (type)) {
2887 dbuf_append_str (dbuf, "restrict-");
2890 switch (DCL_TYPE (type))
2893 dbuf_printf (dbuf, "function %s %s",
2894 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2895 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2896 dbuf_append_str (dbuf, "( ");
2897 for (args = FUNC_ARGS(type);
2900 dbuf_printTypeChain(args->type, dbuf);
2902 dbuf_append_str (dbuf, ", ");
2904 dbuf_append_str (dbuf, ") ");
2907 dbuf_append_str (dbuf, "generic* ");
2910 dbuf_append_str (dbuf, "code* ");
2913 dbuf_append_str (dbuf, "xdata* ");
2916 dbuf_append_str (dbuf, "eeprom* ");
2919 dbuf_append_str (dbuf, "near* ");
2922 dbuf_append_str (dbuf, "idata* ");
2925 dbuf_append_str (dbuf, "pdata* ");
2928 dbuf_append_str (dbuf, "unknown* ");
2931 if (DCL_ELEM(type)) {
2932 dbuf_printf (dbuf, "[%d] ", DCL_ELEM(type));
2934 dbuf_append_str (dbuf, "[] ");
2941 if (SPEC_VOLATILE (type))
2942 dbuf_append_str (dbuf, "volatile-");
2943 if (SPEC_CONST (type))
2944 dbuf_append_str (dbuf, "const-");
2945 if (SPEC_USIGN (type))
2946 dbuf_append_str (dbuf, "unsigned-");
2947 switch (SPEC_NOUN (type))
2951 dbuf_append_str (dbuf, "long-");
2952 dbuf_append_str (dbuf, "int");
2956 dbuf_append_str (dbuf, "char");
2960 dbuf_append_str (dbuf, "void");
2964 dbuf_append_str (dbuf, "float");
2968 dbuf_append_str (dbuf, "fixed16x16");
2972 dbuf_printf (dbuf, "struct %s", SPEC_STRUCT (type)->tag);
2976 dbuf_append_str (dbuf, "sbit");
2980 dbuf_append_str (dbuf, "bit");
2984 dbuf_printf (dbuf, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2988 dbuf_append_str (dbuf, "double");
2992 dbuf_append_str (dbuf, "unknown type");
2996 /* search entry in list before "type" */
2997 for (search = start; search && search->next != type;)
2998 search = search->next;
3001 dbuf_append_char(dbuf, ' ');
3005 /*--------------------------------------------------------------------*/
3006 /* printTypeChainRaw - prints the type chain in human readable form */
3007 /* in the raw data structure ordering */
3008 /*--------------------------------------------------------------------*/
3010 printTypeChainRaw (sym_link * start, FILE * of)
3023 fprintf (of, "void");
3033 if (!IS_FUNC(type)) {
3034 if (DCL_PTR_VOLATILE (type)) {
3035 fprintf (of, "volatile-");
3037 if (DCL_PTR_CONST (type)) {
3038 fprintf (of, "const-");
3040 if (DCL_PTR_RESTRICT (type)) {
3041 fprintf (of, "restrict-");
3044 switch (DCL_TYPE (type))
3047 if (IFFUNC_ISINLINE(type)) {
3048 fprintf (of, "inline-");
3050 fprintf (of, "function %s %s",
3051 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
3052 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
3054 for (args = FUNC_ARGS(type);
3057 printTypeChain(args->type, of);
3064 fprintf (of, "generic* ");
3067 fprintf (of, "code* ");
3070 fprintf (of, "xdata* ");
3073 fprintf (of, "eeprom* ");
3076 fprintf (of, "near* ");
3079 fprintf (of, "idata* ");
3082 fprintf (of, "pdata* ");
3085 fprintf (of, "unknown* ");
3088 if (DCL_ELEM(type)) {
3089 fprintf (of, "[%d] ", DCL_ELEM(type));
3091 fprintf (of, "[] ");
3095 if (DCL_TSPEC(type))
3098 printTypeChainRaw(DCL_TSPEC(type), of);
3102 else if (IS_SPEC (type))
3104 switch (SPEC_SCLS (type))
3106 case S_DATA: fprintf (of, "data-"); break;
3107 case S_XDATA: fprintf (of, "xdata-"); break;
3108 case S_SFR: fprintf (of, "sfr-"); break;
3109 case S_SBIT: fprintf (of, "sbit-"); break;
3110 case S_CODE: fprintf (of, "code-"); break;
3111 case S_IDATA: fprintf (of, "idata-"); break;
3112 case S_PDATA: fprintf (of, "pdata-"); break;
3113 case S_LITERAL: fprintf (of, "literal-"); break;
3114 case S_STACK: fprintf (of, "stack-"); break;
3115 case S_XSTACK: fprintf (of, "xstack-"); break;
3116 case S_BIT: fprintf (of, "bit-"); break;
3117 case S_EEPROM: fprintf (of, "eeprom-"); break;
3120 if (SPEC_VOLATILE (type))
3121 fprintf (of, "volatile-");
3122 if (SPEC_CONST (type))
3123 fprintf (of, "const-");
3124 if (SPEC_USIGN (type))
3125 fprintf (of, "unsigned-");
3126 switch (SPEC_NOUN (type))
3130 fprintf (of, "long-");
3131 fprintf (of, "int");
3135 fprintf (of, "char");
3139 fprintf (of, "void");
3143 fprintf (of, "float");
3147 fprintf (of, "fixed16x16");
3151 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
3155 fprintf (of, "sbit");
3159 fprintf (of, "bit");
3163 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3167 fprintf (of, "double");
3171 fprintf (of, "unknown type");
3176 fprintf (of, "NOT_SPEC_OR_DECL");
3186 /*-----------------------------------------------------------------*/
3187 /* powof2 - returns power of two for the number if number is pow 2 */
3188 /*-----------------------------------------------------------------*/
3190 powof2 (TYPE_TARGET_ULONG num)
3203 if (n1s > 1 || nshifts == 0)
3219 symbol *__fps16x16_add;
3220 symbol *__fps16x16_sub;
3221 symbol *__fps16x16_mul;
3222 symbol *__fps16x16_div;
3223 symbol *__fps16x16_eq;
3224 symbol *__fps16x16_neq;
3225 symbol *__fps16x16_lt;
3226 symbol *__fps16x16_lteq;
3227 symbol *__fps16x16_gt;
3228 symbol *__fps16x16_gteq;
3230 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3231 symbol *__muldiv[3][3][2];
3232 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3233 sym_link *__multypes[3][2];
3234 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3235 symbol *__conv[2][3][2];
3236 /* Dims: to/from fixed16x16, BYTE/WORD/DWORD/FLOAT, SIGNED/USIGNED */
3237 symbol *__fp16x16conv[2][4][2];
3238 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3239 symbol *__rlrr[2][3][2];
3241 sym_link *floatType;
3242 sym_link *fixed16x16Type;
3245 _mangleFunctionName(char *in)
3247 if (port->getMangledFunctionName)
3249 return port->getMangledFunctionName(in);
3257 /*-----------------------------------------------------------------*/
3258 /* typeFromStr - create a typechain from an encoded string */
3259 /* basic types - 'c' - char */
3264 /* 'q' - fixed16x16 */
3266 /* '*' - pointer - default (GPOINTER) */
3267 /* modifiers - 'u' - unsigned */
3268 /* pointer modifiers - 'g' - generic */
3272 /* 'F' - function */
3273 /* examples : "ig*" - generic int * */
3274 /* "cx*" - char xdata * */
3275 /* "ui" - unsigned int */
3276 /*-----------------------------------------------------------------*/
3277 sym_link *typeFromStr (char *s)
3279 sym_link *r = newLink(DECLARATOR);
3291 r->class = SPECIFIER;
3292 SPEC_NOUN(r) = V_CHAR;
3296 r->class = SPECIFIER;
3297 SPEC_NOUN(r) = V_INT;
3300 r->class = SPECIFIER;
3301 SPEC_NOUN(r) = V_INT;
3305 r->class = SPECIFIER;
3306 SPEC_NOUN(r) = V_FLOAT;
3309 r->class = SPECIFIER;
3310 SPEC_NOUN(r) = V_FIXED16X16;
3313 r->class = SPECIFIER;
3314 SPEC_NOUN(r) = V_VOID;
3317 DCL_TYPE(r) = port->unqualified_pointer;
3324 assert(*(s+1)=='*');
3325 nr = newLink(DECLARATOR);
3330 DCL_TYPE(r) = GPOINTER;
3333 DCL_TYPE(r) = FPOINTER;
3336 DCL_TYPE(r) = CPOINTER;
3339 DCL_TYPE(r) = POINTER;
3342 DCL_TYPE(r) = FUNCTION;
3343 nr = newLink(DECLARATOR);
3346 DCL_TYPE(r) = CPOINTER;
3352 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3353 "typeFromStr: unknown type");
3356 if (IS_SPEC(r) && usign) {
3365 /*-----------------------------------------------------------------*/
3366 /* initCSupport - create functions for C support routines */
3367 /*-----------------------------------------------------------------*/
3371 const char *smuldivmod[] =
3375 const char *sbwd[] =
3377 "char", "int", "long", "fixed16x16",
3379 const char *fp16x16sbwd[] =
3381 "char", "int", "long", "float",
3387 const char *srlrr[] =
3392 int bwd, su, muldivmod, tofrom, rlrr;
3394 if (getenv("SDCC_NO_C_SUPPORT")) {
3395 /* for debugging only */
3399 floatType = newFloatLink ();
3400 fixed16x16Type = newFixed16x16Link ();
3402 for (bwd = 0; bwd < 3; bwd++)
3419 __multypes[bwd][0] = l;
3420 __multypes[bwd][1] = copyLinkChain (l);
3421 SPEC_USIGN (__multypes[bwd][1]) = 1;
3424 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3425 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3426 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3427 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3428 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3429 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3430 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3431 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3432 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3433 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3435 __fps16x16_add = funcOfType ("__fps16x16_add", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3436 __fps16x16_sub = funcOfType ("__fps16x16_sub", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3437 __fps16x16_mul = funcOfType ("__fps16x16_mul", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3438 __fps16x16_div = funcOfType ("__fps16x16_div", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3439 __fps16x16_eq = funcOfType ("__fps16x16_eq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3440 __fps16x16_neq = funcOfType ("__fps16x16_neq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3441 __fps16x16_lt = funcOfType ("__fps16x16_lt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3442 __fps16x16_lteq = funcOfType ("__fps16x16_lteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3443 __fps16x16_gt = funcOfType ("__fps16x16_gt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3444 __fps16x16_gteq = funcOfType ("__fps16x16_gteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3447 for (tofrom = 0; tofrom < 2; tofrom++)
3449 for (bwd = 0; bwd < 3; bwd++)
3451 for (su = 0; su < 2; su++)
3455 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3456 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3460 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3461 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3467 for (tofrom = 0; tofrom < 2; tofrom++)
3469 for (bwd = 0; bwd < 4; bwd++)
3471 for (su = 0; su < 2; su++)
3475 SNPRINTF (buffer, sizeof(buffer), "__fps16x162%s%s", ssu[su], fp16x16sbwd[bwd]);
3477 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, floatType, fixed16x16Type, 1, options.float_rent);
3479 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], fixed16x16Type, 1, options.float_rent);
3483 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fps16x16", ssu[su], fp16x16sbwd[bwd]);
3485 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, floatType, 1, options.float_rent);
3487 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, __multypes[bwd][su], 1, options.float_rent);
3494 for (muldivmod = 0; muldivmod < 3; muldivmod++)
3496 for (bwd = 0; bwd < 3; bwd++)
3498 for (su = 0; su < 2; su++)
3500 SNPRINTF (buffer, sizeof(buffer),
3502 smuldivmod[muldivmod],
3505 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3506 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3511 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3512 Therefore they've been merged into mulint() and mullong().
3515 for (bwd = 0; bwd < 3; bwd++)
3517 for (su = 0; su < 2; su++)
3519 for (muldivmod = 1; muldivmod < 3; muldivmod++)
3521 /* div and mod : s8_t x s8_t -> s8_t should be s8_t x s8_t -> s16_t, see below */
3522 if (!TARGET_IS_PIC16 || muldivmod != 1 || bwd != 0 || su != 0)
3524 SNPRINTF (buffer, sizeof(buffer),
3526 smuldivmod[muldivmod],
3529 __muldiv[muldivmod][bwd][su] = funcOfType (
3530 _mangleFunctionName(buffer),
3531 __multypes[bwd][su],
3532 __multypes[bwd][su],
3534 options.intlong_rent);
3535 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3541 if (TARGET_IS_PIC16)
3543 /* PIC16 port wants __divschar/__modschar to return an int, so that both
3544 * 100 / -4 = -25 and -128 / -1 = 128 can be handled correctly
3545 * (first one would have to be sign extended, second one must not be).
3546 * Similarly, modschar should be handled, but the iCode introduces cast
3547 * here and forces '% : s8 x s8 -> s8' ... */
3549 for (muldivmod = 1; muldivmod < 2; muldivmod++) {
3550 SNPRINTF (buffer, sizeof(buffer),
3552 smuldivmod[muldivmod],
3555 __muldiv[muldivmod][bwd][su] = funcOfType (
3556 _mangleFunctionName(buffer),
3558 __multypes[bwd][su],
3560 options.intlong_rent);
3561 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3569 for (su = 0; su < 2; su++)
3571 /* muluchar and mulschar are still separate functions, because e.g. the z80
3572 port is sign/zero-extending to int before calling mulint() */
3573 SNPRINTF (buffer, sizeof(buffer),
3575 smuldivmod[muldivmod],
3578 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3579 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3583 /* word and doubleword */
3584 for (bwd = 1; bwd < 3; bwd++)
3587 SNPRINTF (buffer, sizeof(buffer),
3589 smuldivmod[muldivmod],
3591 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3592 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3593 /* signed = unsigned */
3594 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3597 for (rlrr = 0; rlrr < 2; rlrr++)
3599 for (bwd = 0; bwd < 3; bwd++)
3601 for (su = 0; su < 2; su++)
3603 SNPRINTF (buffer, sizeof(buffer),
3608 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3609 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3615 /*-----------------------------------------------------------------*/
3616 /* initBuiltIns - create prototypes for builtin functions */
3617 /*-----------------------------------------------------------------*/
3623 if (!port->builtintable) return ;
3625 for (i = 0 ; port->builtintable[i].name ; i++) {
3626 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3627 port->builtintable[i].nParms,port->builtintable[i].parm_types);
3628 FUNC_ISBUILTIN(sym->type) = 1;
3629 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
3633 sym_link *validateLink(sym_link *l,
3640 if (l && l->class==select)
3645 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3646 " expected %s, got %s\n",
3647 macro, args, file, line,
3648 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3650 return l; // never reached, makes compiler happy.
3653 /*--------------------------------------------------------------------*/
3654 /* newEnumType - create an integer type compatible with enumerations */
3655 /*--------------------------------------------------------------------*/
3657 newEnumType (symbol *enumlist)
3665 type = newLink (SPECIFIER);
3666 SPEC_NOUN (type) = V_INT;
3670 /* Determine the range of the enumerated values */
3672 min = max = (int) floatFromVal (valFromType (sym->type));
3673 for (sym = sym->next; sym; sym = sym->next)
3675 v = (int) floatFromVal (valFromType (sym->type));
3682 /* Determine the smallest integer type that is compatible with this range */
3683 type = newLink (SPECIFIER);
3684 if (min>=0 && max<=255)
3686 SPEC_NOUN (type) = V_CHAR;
3687 SPEC_USIGN (type) = 1;
3689 else if (min>=-128 && max<=127)
3691 SPEC_NOUN (type) = V_CHAR;
3693 else if (min>=0 && max<=65535)
3695 SPEC_NOUN (type) = V_INT;
3696 SPEC_USIGN (type) = 1;
3698 else if (min>=-32768 && max<=32767)
3700 SPEC_NOUN (type) = V_INT;
3704 SPEC_NOUN (type) = V_INT;
3705 SPEC_LONG (type) = 1;
3707 SPEC_USIGN (type) = 1;