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)))
1079 /* if this is an array without any dimension
1080 then update the dimension from the initial value */
1081 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1082 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1085 /* if already exists in the symbol table then check if
1086 one of them is an extern definition;
1087 if yes then then check if the type match;
1088 if the types match then delete the current entry and
1089 add the new entry */
1090 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1091 csym->level == sym->level)
1093 /* if not formal parameter and not in file scope
1094 then show symbol redefined error
1095 else check if symbols have conpatible types */
1096 if (!sym->_isparm && sym->level > 0)
1100 /* If the previous definition was for an array with incomplete */
1101 /* type, and the new definition has completed the type, update */
1102 /* the original type to match */
1103 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1104 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1106 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1107 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1111 /* If only one of the definitions used the "at" keyword, copy */
1112 /* the address to the other. */
1113 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1114 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1116 SPEC_ABSA (sym->etype) = 1;
1117 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1119 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1120 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1122 SPEC_ABSA (csym->etype) = 1;
1123 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1128 if (csym->ival && sym->ival)
1130 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1136 /* one definition extern ? */
1137 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1138 werror (E_EXTERN_MISMATCH, sym->name);
1140 werror (E_DUPLICATE, sym->name);
1141 werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1143 fprintf (stderr, "from type '");
1144 printTypeChain (csym->type, stderr);
1145 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1146 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1147 fprintf (stderr, "'\nto type '");
1148 printTypeChain (sym->type, stderr);
1149 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1150 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1151 fprintf (stderr, "'\n");
1156 if (csym->ival && !sym->ival)
1157 sym->ival = csym->ival;
1159 /* delete current entry */
1160 deleteSym (SymbolTab, csym, csym->name);
1161 deleteFromSeg(csym);
1163 symPtrPtr = symHead;
1164 while (*symPtrPtr && *symPtrPtr != csym)
1165 symPtrPtr = &(*symPtrPtr)->next;
1166 if (*symPtrPtr == csym)
1167 *symPtrPtr = csym->next;
1171 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1176 /*------------------------------------------------------------------*/
1177 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1178 /*------------------------------------------------------------------*/
1180 funcInChain (sym_link * lnk)
1191 /*------------------------------------------------------------------*/
1192 /* structElemType - returns the type info of a struct member */
1193 /*------------------------------------------------------------------*/
1195 structElemType (sym_link * stype, value * id)
1197 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1198 sym_link *type, *etype;
1199 sym_link *petype = getSpec (stype);
1203 /* look for the id */
1206 if (strcmp (fields->rname, id->name) == 0)
1208 type = copyLinkChain (fields->type);
1209 etype = getSpec (type);
1210 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1211 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1213 SPEC_CONST (type) |= SPEC_CONST (stype);
1215 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1218 fields = fields->next;
1222 werror (E_NOT_MEMBER, id->name);
1224 // the show must go on
1225 return newIntLink();
1228 /*------------------------------------------------------------------*/
1229 /* getStructElement - returns element of a tructure definition */
1230 /*------------------------------------------------------------------*/
1232 getStructElement (structdef * sdef, symbol * sym)
1236 for (field = sdef->fields; field; field = field->next)
1237 if (strcmp (field->name, sym->name) == 0)
1240 werror (E_NOT_MEMBER, sym->name);
1242 return sdef->fields;
1245 /*------------------------------------------------------------------*/
1246 /* compStructSize - computes the size of a structure */
1247 /*------------------------------------------------------------------*/
1249 compStructSize (int su, structdef * sdef)
1251 int sum = 0, usum = 0;
1255 /* for the identifiers */
1256 loop = sdef->fields;
1259 /* create the internal name for this variable */
1260 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1265 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1267 /* if this is a bit field */
1270 /* change it to a unsigned bit */
1271 SPEC_NOUN (loop->etype) = V_BITFIELD;
1272 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
1273 /* a "plain" int bitfield is unsigned */
1274 if (!loop->etype->select.s.b_signed)
1275 SPEC_USIGN(loop->etype) = 1;
1277 SPEC_BLEN (loop->etype) = loop->bitVar;
1279 if (loop->bitVar == BITVAR_PAD) {
1280 /* A zero length bitfield forces padding */
1281 SPEC_BSTR (loop->etype) = bitOffset;
1282 SPEC_BLEN (loop->etype) = 0;
1287 if (bitOffset == 8) {
1291 /* check if this fit into the remaining */
1292 /* bits of this byte else align it to the */
1293 /* next byte boundary */
1294 if (loop->bitVar <= (8 - bitOffset)) {
1295 /* fits into current byte */
1297 SPEC_BSTR (loop->etype) = bitOffset;
1298 bitOffset += loop->bitVar;
1300 else if (!bitOffset) {
1301 /* does not fit, but is already byte aligned */
1303 SPEC_BSTR (loop->etype) = bitOffset;
1304 bitOffset += loop->bitVar;
1307 if( TARGET_IS_PIC16 && getenv("PIC16_PACKED_BITFIELDS") ) {
1308 /* if PIC16 && enviroment variable is set, then
1309 * tightly pack bitfields, this means that when a
1310 * bitfield goes beyond byte alignment, do not
1311 * automatically start allocatint from next byte,
1312 * but also use the available bits first */
1313 fprintf(stderr, ": packing bitfields in structures\n");
1314 SPEC_BSTR (loop->etype) = bitOffset;
1315 bitOffset += loop->bitVar;
1316 loop->offset = (su == UNION ? sum = 0 : sum);
1318 /* does not fit; need to realign first */
1320 loop->offset = (su == UNION ? sum = 0 : sum);
1322 SPEC_BSTR (loop->etype) = bitOffset;
1323 bitOffset += loop->bitVar;
1326 while (bitOffset>8) {
1333 /* This is a non-bit field. Make sure we are */
1334 /* byte aligned first */
1337 loop->offset = (su == UNION ? sum = 0 : sum);
1341 checkDecl (loop, 1);
1342 sum += getSize (loop->type);
1344 /* search for "flexibel array members" */
1345 /* and do some syntax checks */
1347 && checkStructFlexArray (loop, loop->type))
1349 /* found a "flexible array member" */
1350 sdef->b_flexArrayMember = TRUE;
1351 /* is another struct-member following? */
1353 werror (E_FLEXARRAY_NOTATEND);
1354 /* is it the first struct-member? */
1355 else if (loop == sdef->fields)
1356 werror (E_FLEXARRAY_INEMPTYSTRCT);
1362 /* if union then size = sizeof largest field */
1364 /* For UNION, round up after each field */
1365 sum += ((bitOffset+7)/8);
1366 usum = max (usum, sum);
1371 /* For STRUCT, round up after all fields processed */
1373 sum += ((bitOffset+7)/8);
1375 return (su == UNION ? usum : sum);
1378 /*-------------------------------------------------------------------*/
1379 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1380 /* an enclosing struct/union */
1381 /*-------------------------------------------------------------------*/
1383 promoteAnonStructs (int su, structdef * sdef)
1392 tofield = &sdef->fields;
1393 field = sdef->fields;
1396 nextfield = field->next;
1397 if (!*field->name && IS_STRUCT (field->type))
1399 /* Found an anonymous struct/union. Replace it */
1400 /* with the fields it contains and adjust all */
1403 base = field->offset;
1404 subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1406 continue; /* just in case it's empty */
1408 *tofield = subfield;
1411 /* check for field name conflicts resulting from promotion */
1412 dupfield = sdef->fields;
1413 while (dupfield && dupfield != subfield)
1415 if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1417 werrorfl (subfield->fileDef, subfield->lineDef,
1419 su==STRUCT ? "struct" : "union",
1421 werrorfl (dupfield->fileDef, dupfield->lineDef,
1424 dupfield = dupfield->next;
1427 subfield->offset += base;
1429 subfield = subfield->next;
1433 subfield->next = nextfield;
1434 tofield = &subfield->next;
1437 tofield = &field->next;
1443 /*------------------------------------------------------------------*/
1444 /* checkSClass - check the storage class specification */
1445 /*------------------------------------------------------------------*/
1447 checkSClass (symbol * sym, int isProto)
1451 if (getenv("DEBUG_SANITY")) {
1452 fprintf (stderr, "checkSClass: %s \n", sym->name);
1455 /* type is literal can happen for enums change to auto */
1456 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1457 SPEC_SCLS (sym->etype) = S_AUTO;
1459 /* if sfr or sbit then must also be volatile */
1460 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1461 SPEC_SCLS (sym->etype) == S_SFR)
1463 SPEC_VOLATILE (sym->etype) = 1;
1466 /* make sure restrict is only used with pointers */
1467 if (SPEC_RESTRICT (sym->etype))
1469 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1470 SPEC_RESTRICT (sym->etype) = 0;
1475 if (IS_DECL (t) && DCL_PTR_RESTRICT (t) && !IS_PTR (t))
1477 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1478 DCL_PTR_RESTRICT (t) = 0;
1484 /* if absolute address given then it mark it as
1485 volatile -- except in the PIC port */
1487 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1488 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1489 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1492 if (IS_ABSOLUTE (sym->etype))
1493 SPEC_VOLATILE (sym->etype) = 1;
1495 if (TARGET_IS_MCS51 &&
1496 IS_ABSOLUTE (sym->etype) &&
1497 SPEC_SCLS (sym->etype) == S_SFR)
1502 if (SPEC_NOUN (sym->etype) == V_CHAR)
1504 else if (SPEC_LONG (sym->etype) == 0)
1509 addr = SPEC_ADDR (sym->etype);
1510 for (n=0; n<size; n+=8)
1511 if (((addr >> n) & 0xFF) < 0x80)
1512 werror (W_SFR_ABSRANGE, sym->name);
1515 /* If code memory is read only, then pointers to code memory */
1516 /* implicitly point to constants -- make this explicit */
1518 while (t && t->next) {
1519 if (IS_CODEPTR(t) && port->mem.code_ro) {
1520 if (IS_SPEC(t->next)) {
1521 SPEC_CONST (t->next) = 1;
1523 DCL_PTR_CONST (t->next) = 1;
1529 /* global variables declared const put into code */
1530 /* if no other storage class specified */
1531 if (sym->level == 0 &&
1532 SPEC_SCLS(sym->etype) == S_FIXED &&
1533 !IS_FUNC(sym->type)) {
1534 /* find the first non-array link */
1538 if (IS_CONSTANT (t)) {
1539 SPEC_SCLS (sym->etype) = S_CODE;
1543 /* global variable in code space is a constant */
1544 if (sym->level == 0 &&
1545 SPEC_SCLS (sym->etype) == S_CODE &&
1546 port->mem.code_ro) {
1547 /* find the first non-array link */
1554 DCL_PTR_CONST (t) = 1;
1558 /* if bit variable then no storage class can be */
1559 /* specified since bit is already a storage */
1560 if (IS_BITVAR (sym->etype) &&
1561 (SPEC_SCLS (sym->etype) != S_FIXED &&
1562 SPEC_SCLS (sym->etype) != S_SBIT &&
1563 SPEC_SCLS (sym->etype) != S_BIT)
1566 werror (E_BITVAR_STORAGE, sym->name);
1567 SPEC_SCLS (sym->etype) = S_FIXED;
1570 /* extern variables cannot be initialized */
1571 if (IS_EXTERN (sym->etype) && sym->ival)
1573 werror (E_EXTERN_INIT, sym->name);
1577 /* if this is an automatic symbol */
1578 if (sym->level && (options.stackAuto || reentrant)) {
1579 if (SPEC_SCLS (sym->etype) != S_BIT) {
1580 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1581 SPEC_SCLS (sym->etype) == S_FIXED ||
1582 SPEC_SCLS (sym->etype) == S_REGISTER ||
1583 SPEC_SCLS (sym->etype) == S_STACK ||
1584 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1585 SPEC_SCLS (sym->etype) = S_AUTO;
1587 /* storage class may only be specified for statics */
1588 if (!IS_STATIC(sym->etype)) {
1589 werror (E_AUTO_ASSUMED, sym->name);
1595 /* automatic symbols cannot be given */
1596 /* an absolute address ignore it */
1598 SPEC_ABSA (sym->etype) &&
1599 (options.stackAuto || reentrant))
1601 werror (E_AUTO_ABSA, sym->name);
1602 SPEC_ABSA (sym->etype) = 0;
1605 /* arrays & pointers cannot be defined for bits */
1606 /* SBITS or SFRs or BIT */
1607 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1608 !IS_FUNCPTR (sym->type) &&
1609 (SPEC_NOUN (sym->etype) == V_BIT ||
1610 SPEC_NOUN (sym->etype) == V_SBIT ||
1611 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1612 SPEC_SCLS (sym->etype) == S_SFR))
1613 werror (E_BIT_ARRAY, sym->name);
1615 /* if this is a bit|sbit then set length & start */
1616 if (SPEC_NOUN (sym->etype) == V_BIT ||
1617 SPEC_NOUN (sym->etype) == V_SBIT)
1619 SPEC_BLEN (sym->etype) = 1;
1620 SPEC_BSTR (sym->etype) = 0;
1624 /* variables declared in CODE space must have */
1625 /* initializers if not an extern */
1626 if (SPEC_SCLS (sym->etype) == S_CODE &&
1627 sym->ival == NULL &&
1630 port->mem.code_ro &&
1631 !IS_EXTERN (sym->etype) &&
1632 !SPEC_ABSA (sym->etype) &&
1633 !funcInChain (sym->type))
1634 werror (E_CODE_NO_INIT, sym->name);
1637 /* if parameter or local variable then change */
1638 /* the storage class to reflect where the var will go */
1639 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1640 && !IS_STATIC(sym->etype)
1643 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1645 SPEC_SCLS (sym->etype) = (options.useXstack ?
1646 S_XSTACK : S_STACK);
1650 /* hack-o-matic! I see no reason why the useXstack option should ever
1651 * control this allocation, but the code was originally that way, and
1652 * changing it for non-390 ports breaks the compiler badly.
1654 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1655 1 : options.useXstack;
1656 SPEC_SCLS (sym->etype) = (useXdata ?
1662 /*------------------------------------------------------------------*/
1663 /* changePointer - change pointer to functions */
1664 /*------------------------------------------------------------------*/
1666 changePointer (sym_link * p)
1669 /* go thru the chain of declarations */
1670 /* if we find a pointer to a function */
1671 /* change it to a ptr to code area */
1672 /* unless the function is banked. */
1673 for (; p; p = p->next)
1675 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1676 DCL_TYPE (p) = port->unqualified_pointer;
1677 if (IS_PTR (p) && IS_FUNC (p->next))
1678 if (!IFFUNC_BANKED(p->next))
1679 DCL_TYPE (p) = CPOINTER;
1683 /*------------------------------------------------------------------*/
1684 /* checkDecl - does semantic validation of a declaration */
1685 /*------------------------------------------------------------------*/
1687 checkDecl (symbol * sym, int isProto)
1690 checkSClass (sym, isProto); /* check the storage class */
1691 changePointer (sym->type); /* change pointers if required */
1693 /* if this is an array without any dimension
1694 then update the dimension from the initial value */
1695 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1696 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1701 /*------------------------------------------------------------------*/
1702 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1703 /*------------------------------------------------------------------*/
1705 copyLinkChain (sym_link * p)
1707 sym_link *head, *curr, *loop;
1709 /* note: v_struct and v_struct->fields are not copied! */
1711 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1714 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1715 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1723 /*------------------------------------------------------------------*/
1724 /* cleanUpBlock - cleansup the symbol table specified for all the */
1725 /* symbols in the given block */
1726 /*------------------------------------------------------------------*/
1728 cleanUpBlock (bucket ** table, int block)
1733 /* go thru the entire table */
1734 for (i = 0; i < 256; i++)
1736 for (chain = table[i]; chain; chain = chain->next)
1738 if (chain->block >= block)
1740 deleteSym (table, chain->sym, chain->name);
1746 /*------------------------------------------------------------------*/
1747 /* cleanUpLevel - cleansup the symbol table specified for all the */
1748 /* symbols in the given level */
1749 /*------------------------------------------------------------------*/
1751 cleanUpLevel (bucket ** table, int level)
1756 /* go thru the entire table */
1757 for (i = 0; i < 256; i++)
1759 for (chain = table[i]; chain; chain = chain->next)
1761 if (chain->level >= level)
1763 deleteSym (table, chain->sym, chain->name);
1769 /*------------------------------------------------------------------*/
1770 /* computeTypeOr - computes the resultant type from two types */
1771 /*------------------------------------------------------------------*/
1773 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1776 assert ( (IS_CHAR (etype1) || IS_BIT (etype1))
1777 && (IS_CHAR (etype2) || IS_BIT (etype2)));
1779 if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1781 SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1785 if (SPEC_USIGN (etype1))
1787 if ( IS_LITERAL (etype2)
1788 && floatFromVal (valFromType (etype2)) >= 0)
1789 SPEC_USIGN (reType) = 1;
1792 /* promote to int */
1793 SPEC_USIGN (reType) = 0;
1794 SPEC_NOUN (reType) = V_INT;
1797 else /* etype1 signed */
1799 if ( IS_LITERAL (etype2)
1800 && floatFromVal (valFromType (etype2)) <= 127)
1801 SPEC_USIGN (reType) = 0;
1804 /* promote to int */
1805 SPEC_USIGN (reType) = 0;
1806 SPEC_NOUN (reType) = V_INT;
1810 if (SPEC_USIGN (etype2))
1812 if ( IS_LITERAL (etype1)
1813 && floatFromVal (valFromType (etype1)) >= 0)
1814 SPEC_USIGN (reType) = 1;
1817 /* promote to int */
1818 SPEC_USIGN (reType) = 0;
1819 SPEC_NOUN (reType) = V_INT;
1822 else /* etype2 signed */
1824 if ( IS_LITERAL (etype1)
1825 && floatFromVal (valFromType (etype1)) <= 127)
1826 SPEC_USIGN (reType) = 0;
1829 /* promote to int */
1830 SPEC_USIGN (reType) = 0;
1831 SPEC_NOUN (reType) = V_INT;
1837 /*------------------------------------------------------------------*/
1838 /* computeType - computes the resultant type from two types */
1839 /*------------------------------------------------------------------*/
1841 computeType (sym_link * type1, sym_link * type2,
1842 RESULT_TYPE resultType, int op)
1846 sym_link *etype1 = getSpec (type1);
1849 etype2 = type2 ? getSpec (type2) : type1;
1851 /* if one of them is a float then result is a float */
1852 /* here we assume that the types passed are okay */
1853 /* and can be cast to one another */
1854 /* which ever is greater in size */
1855 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1856 rType = newFloatLink ();
1857 /* if both are fixed16x16 then result is float */
1858 else if (IS_FIXED16X16(etype1) && IS_FIXED16X16(etype2))
1859 rType = newFixed16x16Link();
1860 else if (IS_FIXED16X16(etype1) && IS_FLOAT (etype2))
1861 rType = newFloatLink ();
1862 else if (IS_FLOAT (etype1) && IS_FIXED16X16 (etype2) )
1863 rType = newFloatLink ();
1865 /* if both are bitvars choose the larger one */
1866 else if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1867 rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1868 copyLinkChain (type1) : copyLinkChain (type1);
1870 /* if only one of them is a bit variable then the other one prevails */
1871 else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1873 rType = copyLinkChain (type2);
1874 /* bitfield can have up to 16 bits */
1875 if (getSize (etype1) > 1)
1876 SPEC_NOUN (getSpec (rType)) = V_INT;
1878 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1880 rType = copyLinkChain (type1);
1881 /* bitfield can have up to 16 bits */
1882 if (getSize (etype2) > 1)
1883 SPEC_NOUN (getSpec (rType)) = V_INT;
1885 /* if one of them is a pointer or array then that
1887 else if (IS_PTR (type1) || IS_ARRAY (type1))
1888 rType = copyLinkChain (type1);
1889 else if (IS_PTR (type2) || IS_ARRAY (type2))
1890 rType = copyLinkChain (type2);
1891 else if (getSize (type1) > getSize (type2))
1892 rType = copyLinkChain (type1);
1894 rType = copyLinkChain (type2);
1896 reType = getSpec (rType);
1898 /* avoid conflicting types */
1899 reType->select.s.b_signed = 0;
1901 /* if result is a literal then make not so */
1902 if (IS_LITERAL (reType))
1903 SPEC_SCLS (reType) = S_REGISTER;
1907 case RESULT_TYPE_CHAR:
1908 if (IS_BITVAR (reType))
1910 SPEC_NOUN (reType) = V_CHAR;
1911 SPEC_SCLS (reType) = 0;
1912 SPEC_USIGN (reType) = 0;
1916 case RESULT_TYPE_INT:
1917 case RESULT_TYPE_NONE:
1918 case RESULT_TYPE_OTHER:
1919 if (IS_BIT (reType))
1921 SPEC_NOUN (reType) = V_CHAR;
1922 SPEC_SCLS (reType) = 0;
1923 SPEC_USIGN (reType) = 0;
1926 else if (IS_BITFIELD (reType))
1928 /* could be smarter, but it depends on the op */
1929 /* this is for the worst case: a multiplication of 4 * 4 bit */
1930 SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1931 SPEC_SCLS (reType) = 0;
1932 SPEC_USIGN (reType) = 0;
1935 else if (IS_CHAR (reType))
1937 /* promotion of some special cases */
1942 return computeTypeOr (etype1, etype2, reType);
1944 if (SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1946 SPEC_USIGN (reType) = 1;
1951 SPEC_NOUN (reType) = V_INT;
1952 SPEC_USIGN (reType) = 0;
1955 /* if both are unsigned char then no promotion required */
1956 if (!(SPEC_USIGN (etype1) && SPEC_USIGN (etype2)))
1958 SPEC_NOUN (reType) = V_INT;
1959 SPEC_USIGN (reType) = 0;
1972 /* SDCC's sign promotion:
1973 - if one or both operands are unsigned, the resultant type will be unsigned
1974 (except char, see below)
1975 - if an operand is promoted to a larger type (char -> int, int -> long),
1976 the larger type will be signed
1978 SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1979 much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1980 the standard. The standard demands, that the result has to be the same
1981 "as if" the promotion would have been performed:
1983 - if the result of an operation with two char's is promoted to a
1984 larger type, the result will be signed.
1986 More sophisticated are these:
1987 - if the result of an operation with two char's is a char again,
1988 the result will only then be unsigned, if both operands are
1989 unsigned. In all other cases the result will be signed.
1991 This seems to be contradictionary to the first two rules, but it makes
1992 real sense (all types are char's):
1994 A signed char can be negative; this must be preserved in the result
1997 Only if both operands are unsigned it's safe to make the result
1998 unsigned; this helps to avoid overflow:
2001 - ToDo: document '|', '^' and '&'
2003 Homework: - why is (200 * 200 < 0) true?
2004 - why is { char l = 200, r = 200; (r * l > 0) } true?
2007 if (!IS_FLOAT (reType)
2008 && ( (SPEC_USIGN (etype1)
2009 /* if this operand is promoted to a larger type,
2010 then it will be promoted to a signed type */
2011 && !(bitsForType (etype1) < bitsForType (reType))
2012 /* char require special handling */
2013 && !IS_CHAR (etype1))
2014 || /* same for 2nd operand */
2015 (SPEC_USIGN (etype2)
2016 && !(bitsForType (etype2) < bitsForType (reType))
2017 && !IS_CHAR (etype2))
2018 || /* if both are 'unsigned char' and not promoted
2019 let the result be unsigned too */
2020 ( SPEC_USIGN (etype1)
2021 && SPEC_USIGN (etype2)
2024 && IS_CHAR (reType))))
2025 SPEC_USIGN (reType) = 1;
2027 SPEC_USIGN (reType) = 0;
2032 /*--------------------------------------------------------------------*/
2033 /* compareType - will do type check return 1 if match, -1 if castable */
2034 /*--------------------------------------------------------------------*/
2036 compareType (sym_link * dest, sym_link * src)
2047 /* if dest is a declarator then */
2052 /* banked function pointer */
2053 if (IS_GENPTR (dest) && IS_GENPTR (src))
2055 if (IS_FUNC (src->next) && IS_VOID(dest->next))
2057 if (IS_FUNC (dest->next) && IS_VOID(src->next))
2059 return compareType (dest->next, src->next);
2062 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2064 //checkFunction(src,dest);
2066 return compareType (dest->next, src->next);
2068 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
2072 (IS_GENPTR (dest) ||
2073 ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
2076 if (IS_PTR (dest) && IS_ARRAY (src)) {
2077 value *val=aggregateToPointer (valFromType(src));
2078 int res=compareType (dest, val->type);
2079 Safe_free(val->type);
2083 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
2084 return compareType (dest->next, src);
2087 else if (IS_PTR (dest) && IS_INTEGRAL (src))
2093 /* if one is a specifier and the other is not */
2094 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2095 (IS_SPEC (dest) && !IS_SPEC (src)))
2098 /* if one of them is a void then ok */
2099 if (SPEC_NOUN (dest) == V_VOID &&
2100 SPEC_NOUN (src) != V_VOID)
2103 if (SPEC_NOUN (dest) != V_VOID &&
2104 SPEC_NOUN (src) == V_VOID)
2107 /* if they are both bitfields then if the lengths
2108 and starts don't match */
2109 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2110 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2111 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2114 /* it is a specifier */
2115 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2117 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
2118 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
2120 bitsForType (dest) == bitsForType (src))
2121 instead of the next two lines, but the regression tests fail with
2122 them; I guess it's a problem with replaceCheaperOp */
2123 getSize (dest) == getSize (src) &&
2124 !(!IS_BIT (dest) && IS_BIT (src)))
2126 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
2131 else if (IS_STRUCT (dest))
2133 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2138 if (SPEC_LONG (dest) != SPEC_LONG (src))
2141 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2147 /*--------------------------------------------------------------------*/
2148 /* compareTypeExact - will do type check return 1 if match exactly */
2149 /*--------------------------------------------------------------------*/
2151 compareTypeExact (sym_link * dest, sym_link * src, int level)
2153 STORAGE_CLASS srcScls, destScls;
2164 /* if dest is a declarator then */
2169 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2170 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2172 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2174 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2178 value *exargs, *acargs, *checkValue;
2180 /* verify function return type */
2181 if (!compareTypeExact (dest->next, src->next, -1))
2183 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2185 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2187 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2190 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2194 /* compare expected args with actual args */
2195 exargs = FUNC_ARGS(dest);
2196 acargs = FUNC_ARGS(src);
2198 /* for all the expected args do */
2199 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2201 //checkTypeSanity(acargs->etype, acargs->name);
2203 if (IS_AGGREGATE (acargs->type))
2205 checkValue = copyValue (acargs);
2206 aggregateToPointer (checkValue);
2209 checkValue = acargs;
2212 if (!compareTypeExact (exargs->type, checkValue->type, -1))
2217 /* if one them ended we have a problem */
2218 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2219 (!exargs && acargs && !IS_VOID (acargs->type)))
2223 return compareTypeExact (dest->next, src->next, level);
2230 /* if one is a specifier and the other is not */
2231 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2232 (IS_SPEC (dest) && !IS_SPEC (src)))
2235 /* if one of them is a void then ok */
2236 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2239 /* if they are both bitfields then if the lengths
2240 and starts don't match */
2241 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2242 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2243 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2246 if (IS_INTEGRAL (dest))
2248 /* signedness must match */
2249 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2251 /* size must match */
2252 if (SPEC_LONG (dest) != SPEC_LONG (src))
2254 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2258 if (IS_STRUCT (dest))
2260 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2264 if (SPEC_CONST (dest) != SPEC_CONST (src))
2266 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2268 if (SPEC_STAT (dest) != SPEC_STAT (src))
2270 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2272 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2275 destScls = SPEC_SCLS (dest);
2276 srcScls = SPEC_SCLS (src);
2278 /* Compensate for const to const code change in checkSClass() */
2279 if (!level & port->mem.code_ro && SPEC_CONST (dest))
2281 if (srcScls == S_CODE && destScls == S_FIXED)
2283 if (destScls == S_CODE && srcScls == S_FIXED)
2287 /* compensate for allocGlobal() */
2288 if ((srcScls == S_FIXED || srcScls == S_AUTO)
2289 && port->mem.default_globl_map == xdata
2293 if (level>0 && !SPEC_STAT (dest))
2295 /* Compensate for hack-o-matic in checkSClass() */
2296 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2298 if (destScls == S_FIXED)
2299 destScls = (options.useXstack ? S_XSTACK : S_STACK);
2300 if (srcScls == S_FIXED)
2301 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2303 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2305 if (destScls == S_FIXED)
2307 if (srcScls == S_FIXED)
2312 if (srcScls != destScls)
2315 printf ("level = %d\n", level);
2316 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2317 SPEC_SCLS (src), SPEC_SCLS (dest));
2318 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2326 /*------------------------------------------------------------------*/
2327 /* inCalleeSaveList - return 1 if found in callee save list */
2328 /*------------------------------------------------------------------*/
2330 calleeCmp(void *p1, void *p2)
2332 return (strcmp((char *)p1, (char *)(p2)) == 0);
2336 inCalleeSaveList(char *s)
2338 if (options.all_callee_saves)
2340 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2343 /*-----------------------------------------------------------------*/
2344 /* aggregateToPointer: change an agggregate type function */
2345 /* argument to a pointer to that type. */
2346 /*-----------------------------------------------------------------*/
2348 aggregateToPointer (value * val)
2350 if (IS_AGGREGATE (val->type))
2352 /* if this is a structure */
2353 /* then we need to add a new link */
2354 if (IS_STRUCT (val->type))
2356 /* first lets add DECLARATOR type */
2357 sym_link *p = val->type;
2359 werror (W_STRUCT_AS_ARG, val->name);
2360 val->type = newLink (DECLARATOR);
2361 val->type->next = p;
2364 /* change to a pointer depending on the */
2365 /* storage class specified */
2366 switch (SPEC_SCLS (val->etype))
2369 DCL_TYPE (val->type) = IPOINTER;
2372 DCL_TYPE (val->type) = PPOINTER;
2375 if (SPEC_OCLS(val->etype)) {
2376 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2378 // this happens for (external) function parameters
2379 DCL_TYPE (val->type) = port->unqualified_pointer;
2385 DCL_TYPE (val->type) = POINTER;
2388 DCL_TYPE (val->type) = CPOINTER;
2391 DCL_TYPE (val->type) = FPOINTER;
2394 DCL_TYPE (val->type) = EEPPOINTER;
2397 DCL_TYPE (val->type) = port->unqualified_pointer;
2400 /* is there is a symbol associated then */
2401 /* change the type of the symbol as well */
2404 val->sym->type = copyLinkChain (val->type);
2405 val->sym->etype = getSpec (val->sym->type);
2410 /*------------------------------------------------------------------*/
2411 /* checkFunction - does all kinds of check on a function */
2412 /*------------------------------------------------------------------*/
2414 checkFunction (symbol * sym, symbol *csym)
2416 value *exargs, *acargs;
2420 if (getenv("DEBUG_SANITY")) {
2421 fprintf (stderr, "checkFunction: %s ", sym->name);
2424 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2426 werror(E_SYNTAX_ERROR, sym->name);
2430 /* move inline specifier from return type to function attributes */
2431 if (IS_INLINE (sym->etype))
2433 SPEC_INLINE (sym->etype) = 0;
2434 FUNC_ISINLINE (sym->type) = 1;
2437 /* make sure the type is complete and sane */
2438 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2440 /* if not type then some kind of error */
2444 /* if the function has no type then make it return int */
2445 if (!sym->type->next)
2446 sym->type->next = sym->etype = newIntLink ();
2448 /* function cannot return aggregate */
2449 if (IS_AGGREGATE (sym->type->next))
2451 werror (E_FUNC_AGGR, sym->name);
2455 /* check if this function is defined as calleeSaves
2456 then mark it as such */
2457 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2459 /* if interrupt service routine */
2460 /* then it cannot have arguments */
2461 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2463 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2464 werror (E_INT_ARGS, sym->name);
2465 FUNC_ARGS(sym->type)=NULL;
2469 if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2471 werror (E_SHADOWREGS_NO_ISR, sym->name);
2475 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2477 acargs=acargs->next, argCnt++) {
2479 // this can happen for reentrant functions
2480 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2481 // the show must go on: synthesize a name and symbol
2482 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2483 acargs->sym = newSymbol (acargs->name, 1);
2484 SPEC_OCLS (acargs->etype) = istack;
2485 acargs->sym->type = copyLinkChain (acargs->type);
2486 acargs->sym->etype = getSpec (acargs->sym->type);
2487 acargs->sym->_isparm = 1;
2488 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2489 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2491 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2496 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2497 return 1; /* not defined nothing more to check */
2499 /* check if body already present */
2500 if (csym && IFFUNC_HASBODY(csym->type))
2502 werror (E_FUNC_BODY, sym->name);
2506 /* check the return value type */
2507 if (compareType (csym->type, sym->type) <= 0)
2509 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2510 printFromToType(csym->type, sym->type);
2514 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2516 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2519 /* I don't think this is necessary for interrupts. An isr is a */
2520 /* root in the calling tree. */
2521 if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2522 (!FUNC_ISISR (sym->type)))
2524 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2527 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2529 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2532 /* Really, reentrant should match regardless of argCnt, but */
2533 /* this breaks some existing code (the fp lib functions). If */
2534 /* the first argument is always passed the same way, this */
2535 /* lax checking is ok (but may not be true for in future ports) */
2536 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2539 //printf("argCnt = %d\n",argCnt);
2540 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2543 if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2545 werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2548 if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2550 werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2554 /* compare expected args with actual args */
2555 exargs = FUNC_ARGS(csym->type);
2556 acargs = FUNC_ARGS(sym->type);
2558 /* for all the expected args do */
2561 exargs = exargs->next, acargs = acargs->next, argCnt++)
2563 if (getenv("DEBUG_SANITY")) {
2564 fprintf (stderr, "checkFunction: %s ", exargs->name);
2566 /* make sure the type is complete and sane */
2567 checkTypeSanity(exargs->etype, exargs->name);
2569 /* If the actual argument is an array, any prototype
2570 * will have modified it to a pointer. Duplicate that
2573 if (IS_AGGREGATE (acargs->type))
2575 checkValue = copyValue (acargs);
2576 aggregateToPointer (checkValue);
2580 checkValue = acargs;
2583 if (compareType (exargs->type, checkValue->type) <= 0)
2585 werror (E_ARG_TYPE, argCnt);
2586 printFromToType(exargs->type, checkValue->type);
2591 /* if one them ended we have a problem */
2592 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2593 (!exargs && acargs && !IS_VOID (acargs->type)))
2594 werror (E_ARG_COUNT);
2596 /* replace with this defition */
2597 sym->cdef = csym->cdef;
2598 deleteSym (SymbolTab, csym, csym->name);
2599 deleteFromSeg(csym);
2600 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2601 if (IS_EXTERN (csym->etype) && !
2602 IS_EXTERN (sym->etype))
2604 addSet (&publics, sym);
2609 /*------------------------------------------------------------------*/
2610 /* cdbStructBlock - calls struct printing for a blcks */
2611 /*------------------------------------------------------------------*/
2612 void cdbStructBlock (int block)
2615 bucket **table = StructTab;
2618 /* go thru the entire table */
2619 for (i = 0; i < 256; i++)
2621 for (chain = table[i]; chain; chain = chain->next)
2623 if (chain->block >= block)
2626 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2632 /*-----------------------------------------------------------------*/
2633 /* processFuncPtrArgs - does some processing with args of func ptrs*/
2634 /*-----------------------------------------------------------------*/
2636 processFuncPtrArgs (sym_link * funcType)
2638 value *val = FUNC_ARGS(funcType);
2640 /* if it is void then remove parameters */
2641 if (val && IS_VOID (val->type))
2643 FUNC_ARGS(funcType) = NULL;
2648 /*-----------------------------------------------------------------*/
2649 /* processFuncArgs - does some processing with function args */
2650 /*-----------------------------------------------------------------*/
2652 processFuncArgs (symbol * func)
2656 sym_link *funcType=func->type;
2658 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2659 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2661 /* find the function declaration within the type */
2662 while (funcType && !IS_FUNC(funcType))
2663 funcType=funcType->next;
2665 /* if this function has variable argument list */
2666 /* then make the function a reentrant one */
2667 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2668 FUNC_ISREENT(funcType)=1;
2670 /* check if this function is defined as calleeSaves
2671 then mark it as such */
2672 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2674 /* loop thru all the arguments */
2675 val = FUNC_ARGS(funcType);
2677 /* if it is void then remove parameters */
2678 if (val && IS_VOID (val->type))
2680 FUNC_ARGS(funcType) = NULL;
2684 /* reset regparm for the port */
2685 (*port->reset_regparms) ();
2687 /* if any of the arguments is an aggregate */
2688 /* change it to pointer to the same type */
2692 char buffer[SDCC_NAME_MAX+1];
2694 SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2695 checkTypeSanity (val->etype, buffer);
2697 /* mark it as a register parameter if
2698 the function does not have VA_ARG
2699 and as port dictates */
2700 if (!IFFUNC_HASVARARGS(funcType) &&
2701 (argreg = (*port->reg_parm) (val->type, FUNC_ISREENT(funcType))))
2703 SPEC_REGPARM (val->etype) = 1;
2704 SPEC_ARGREG(val->etype) = argreg;
2705 } else if (IFFUNC_ISREENT(funcType)) {
2706 FUNC_HASSTACKPARM(funcType) = 1;
2709 if (IS_AGGREGATE (val->type))
2711 aggregateToPointer (val);
2718 /* if this is an internal generated function call */
2720 /* ignore --stack-auto for this one, we don't know how it is compiled */
2721 /* simply trust on --int-long-reent or --float-reent */
2722 if (IFFUNC_ISREENT(funcType)) {
2726 /* if this function is reentrant or */
2727 /* automatics r 2b stacked then nothing */
2728 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2732 val = FUNC_ARGS(funcType);
2737 /* if a symbolname is not given */
2738 /* synthesize a variable name */
2741 SNPRINTF (val->name, sizeof(val->name),
2742 "_%s_PARM_%d", func->name, pNum++);
2743 val->sym = newSymbol (val->name, 1);
2744 if (SPEC_SCLS(val->etype) == S_BIT)
2745 SPEC_OCLS (val->etype) = bit;
2747 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2748 val->sym->type = copyLinkChain (val->type);
2749 val->sym->etype = getSpec (val->sym->type);
2750 val->sym->_isparm = 1;
2751 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2753 /* ?? static functions shouldn't imply static parameters - EEP */
2754 if (IS_SPEC(func->etype)) {
2755 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2756 SPEC_STAT (func->etype);
2759 addSymChain (&val->sym);
2762 else /* symbol name given create synth name */
2765 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2766 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2767 val->sym->_isparm = 1;
2768 if (SPEC_SCLS(val->etype) == S_BIT)
2769 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2771 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2772 port->mem.default_local_map;
2775 /* ?? static functions shouldn't imply static parameters - EEP */
2776 if (IS_SPEC(func->etype)) {
2777 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2778 SPEC_STAT (func->etype);
2782 if (SPEC_OCLS (val->sym->etype) == pdata)
2783 val->sym->iaccess = 1;
2784 if (!isinSet(operKeyReset, val->sym)) {
2785 addSet (&operKeyReset, val->sym);
2786 applyToSet (operKeyReset, resetParmKey);
2792 /*-----------------------------------------------------------------*/
2793 /* isSymbolEqual - compares two symbols return 1 if they match */
2794 /*-----------------------------------------------------------------*/
2796 isSymbolEqual (symbol * dest, symbol * src)
2798 /* if pointers match then equal */
2802 /* if one of them is null then don't match */
2806 /* if both of them have rname match on rname */
2807 if (dest->rname[0] && src->rname[0])
2808 return (!strcmp (dest->rname, src->rname));
2810 /* otherwise match on name */
2811 return (!strcmp (dest->name, src->name));
2814 void PT(sym_link *type)
2816 printTypeChain(type,0);
2818 /*-----------------------------------------------------------------*/
2819 /* printTypeChain - prints the type chain in human readable form */
2820 /*-----------------------------------------------------------------*/
2822 printTypeChain (sym_link * start, FILE * of)
2833 dbuf_init (&dbuf, 1024);
2834 dbuf_printTypeChain (start, &dbuf);
2835 dbuf_write_and_destroy (&dbuf, of);
2842 dbuf_printTypeChain (sym_link * start, struct dbuf_s *dbuf)
2845 sym_link * type, * search;
2849 dbuf_append_str (dbuf, "void");
2853 /* Print the chain as it is written in the source: */
2854 /* start with the last entry. */
2855 /* However, the storage class at the end of the */
2856 /* chain reall applies to the first in the chain! */
2858 for (type = start; type && type->next; type = type->next)
2861 scls=SPEC_SCLS(type);
2869 case S_DATA: dbuf_append_str (dbuf, "data-"); break;
2870 case S_XDATA: dbuf_append_str (dbuf, "xdata-"); break;
2871 case S_SFR: dbuf_append_str (dbuf, "sfr-"); break;
2872 case S_SBIT: dbuf_append_str (dbuf, "sbit-"); break;
2873 case S_CODE: dbuf_append_str (dbuf, "code-"); break;
2874 case S_IDATA: dbuf_append_str (dbuf, "idata-"); break;
2875 case S_PDATA: dbuf_append_str (dbuf, "pdata-"); break;
2876 case S_LITERAL: dbuf_append_str (dbuf, "literal-"); break;
2877 case S_STACK: dbuf_append_str (dbuf, "stack-"); break;
2878 case S_XSTACK: dbuf_append_str (dbuf, "xstack-"); break;
2879 case S_BIT: dbuf_append_str (dbuf, "bit-"); break;
2880 case S_EEPROM: dbuf_append_str (dbuf, "eeprom-"); break;
2887 if (!IS_FUNC(type)) {
2888 if (DCL_PTR_VOLATILE (type)) {
2889 dbuf_append_str (dbuf, "volatile-");
2891 if (DCL_PTR_CONST (type)) {
2892 dbuf_append_str (dbuf, "const-");
2894 if (DCL_PTR_RESTRICT (type)) {
2895 dbuf_append_str (dbuf, "restrict-");
2898 switch (DCL_TYPE (type))
2901 dbuf_printf (dbuf, "function %s %s",
2902 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2903 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2904 dbuf_append_str (dbuf, "( ");
2905 for (args = FUNC_ARGS(type);
2908 dbuf_printTypeChain(args->type, dbuf);
2910 dbuf_append_str (dbuf, ", ");
2912 dbuf_append_str (dbuf, ") ");
2915 dbuf_append_str (dbuf, "generic* ");
2918 dbuf_append_str (dbuf, "code* ");
2921 dbuf_append_str (dbuf, "xdata* ");
2924 dbuf_append_str (dbuf, "eeprom* ");
2927 dbuf_append_str (dbuf, "near* ");
2930 dbuf_append_str (dbuf, "idata* ");
2933 dbuf_append_str (dbuf, "pdata* ");
2936 dbuf_append_str (dbuf, "unknown* ");
2939 if (DCL_ELEM(type)) {
2940 dbuf_printf (dbuf, "[%d] ", DCL_ELEM(type));
2942 dbuf_append_str (dbuf, "[] ");
2949 if (SPEC_VOLATILE (type))
2950 dbuf_append_str (dbuf, "volatile-");
2951 if (SPEC_CONST (type))
2952 dbuf_append_str (dbuf, "const-");
2953 if (SPEC_USIGN (type))
2954 dbuf_append_str (dbuf, "unsigned-");
2955 switch (SPEC_NOUN (type))
2959 dbuf_append_str (dbuf, "long-");
2960 dbuf_append_str (dbuf, "int");
2964 dbuf_append_str (dbuf, "char");
2968 dbuf_append_str (dbuf, "void");
2972 dbuf_append_str (dbuf, "float");
2976 dbuf_append_str (dbuf, "fixed16x16");
2980 dbuf_printf (dbuf, "struct %s", SPEC_STRUCT (type)->tag);
2984 dbuf_append_str (dbuf, "sbit");
2988 dbuf_append_str (dbuf, "bit");
2992 dbuf_printf (dbuf, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2996 dbuf_append_str (dbuf, "double");
3000 dbuf_append_str (dbuf, "unknown type");
3004 /* search entry in list before "type" */
3005 for (search = start; search && search->next != type;)
3006 search = search->next;
3009 dbuf_append_char(dbuf, ' ');
3013 /*--------------------------------------------------------------------*/
3014 /* printTypeChainRaw - prints the type chain in human readable form */
3015 /* in the raw data structure ordering */
3016 /*--------------------------------------------------------------------*/
3018 printTypeChainRaw (sym_link * start, FILE * of)
3031 fprintf (of, "void");
3041 if (!IS_FUNC(type)) {
3042 if (DCL_PTR_VOLATILE (type)) {
3043 fprintf (of, "volatile-");
3045 if (DCL_PTR_CONST (type)) {
3046 fprintf (of, "const-");
3048 if (DCL_PTR_RESTRICT (type)) {
3049 fprintf (of, "restrict-");
3052 switch (DCL_TYPE (type))
3055 if (IFFUNC_ISINLINE(type)) {
3056 fprintf (of, "inline-");
3058 fprintf (of, "function %s %s",
3059 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
3060 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
3062 for (args = FUNC_ARGS(type);
3065 printTypeChain(args->type, of);
3072 fprintf (of, "generic* ");
3075 fprintf (of, "code* ");
3078 fprintf (of, "xdata* ");
3081 fprintf (of, "eeprom* ");
3084 fprintf (of, "near* ");
3087 fprintf (of, "idata* ");
3090 fprintf (of, "pdata* ");
3093 fprintf (of, "unknown* ");
3096 if (DCL_ELEM(type)) {
3097 fprintf (of, "[%d] ", DCL_ELEM(type));
3099 fprintf (of, "[] ");
3103 if (DCL_TSPEC(type))
3106 printTypeChainRaw(DCL_TSPEC(type), of);
3110 else if (IS_SPEC (type))
3112 switch (SPEC_SCLS (type))
3114 case S_DATA: fprintf (of, "data-"); break;
3115 case S_XDATA: fprintf (of, "xdata-"); break;
3116 case S_SFR: fprintf (of, "sfr-"); break;
3117 case S_SBIT: fprintf (of, "sbit-"); break;
3118 case S_CODE: fprintf (of, "code-"); break;
3119 case S_IDATA: fprintf (of, "idata-"); break;
3120 case S_PDATA: fprintf (of, "pdata-"); break;
3121 case S_LITERAL: fprintf (of, "literal-"); break;
3122 case S_STACK: fprintf (of, "stack-"); break;
3123 case S_XSTACK: fprintf (of, "xstack-"); break;
3124 case S_BIT: fprintf (of, "bit-"); break;
3125 case S_EEPROM: fprintf (of, "eeprom-"); break;
3128 if (SPEC_VOLATILE (type))
3129 fprintf (of, "volatile-");
3130 if (SPEC_CONST (type))
3131 fprintf (of, "const-");
3132 if (SPEC_USIGN (type))
3133 fprintf (of, "unsigned-");
3134 switch (SPEC_NOUN (type))
3138 fprintf (of, "long-");
3139 fprintf (of, "int");
3143 fprintf (of, "char");
3147 fprintf (of, "void");
3151 fprintf (of, "float");
3155 fprintf (of, "fixed16x16");
3159 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
3163 fprintf (of, "sbit");
3167 fprintf (of, "bit");
3171 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3175 fprintf (of, "double");
3179 fprintf (of, "unknown type");
3184 fprintf (of, "NOT_SPEC_OR_DECL");
3194 /*-----------------------------------------------------------------*/
3195 /* powof2 - returns power of two for the number if number is pow 2 */
3196 /*-----------------------------------------------------------------*/
3198 powof2 (TYPE_TARGET_ULONG num)
3211 if (n1s > 1 || nshifts == 0)
3227 symbol *__fps16x16_add;
3228 symbol *__fps16x16_sub;
3229 symbol *__fps16x16_mul;
3230 symbol *__fps16x16_div;
3231 symbol *__fps16x16_eq;
3232 symbol *__fps16x16_neq;
3233 symbol *__fps16x16_lt;
3234 symbol *__fps16x16_lteq;
3235 symbol *__fps16x16_gt;
3236 symbol *__fps16x16_gteq;
3238 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3239 symbol *__muldiv[3][3][2];
3240 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3241 sym_link *__multypes[3][2];
3242 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3243 symbol *__conv[2][3][2];
3244 /* Dims: to/from fixed16x16, BYTE/WORD/DWORD/FLOAT, SIGNED/USIGNED */
3245 symbol *__fp16x16conv[2][4][2];
3246 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3247 symbol *__rlrr[2][3][2];
3249 sym_link *floatType;
3250 sym_link *fixed16x16Type;
3253 _mangleFunctionName(char *in)
3255 if (port->getMangledFunctionName)
3257 return port->getMangledFunctionName(in);
3265 /*-----------------------------------------------------------------*/
3266 /* typeFromStr - create a typechain from an encoded string */
3267 /* basic types - 'c' - char */
3272 /* 'q' - fixed16x16 */
3274 /* '*' - pointer - default (GPOINTER) */
3275 /* modifiers - 'u' - unsigned */
3276 /* pointer modifiers - 'g' - generic */
3280 /* 'F' - function */
3281 /* examples : "ig*" - generic int * */
3282 /* "cx*" - char xdata * */
3283 /* "ui" - unsigned int */
3284 /*-----------------------------------------------------------------*/
3285 sym_link *typeFromStr (char *s)
3287 sym_link *r = newLink(DECLARATOR);
3299 r->class = SPECIFIER;
3300 SPEC_NOUN(r) = V_CHAR;
3304 r->class = SPECIFIER;
3305 SPEC_NOUN(r) = V_INT;
3308 r->class = SPECIFIER;
3309 SPEC_NOUN(r) = V_INT;
3313 r->class = SPECIFIER;
3314 SPEC_NOUN(r) = V_FLOAT;
3317 r->class = SPECIFIER;
3318 SPEC_NOUN(r) = V_FIXED16X16;
3321 r->class = SPECIFIER;
3322 SPEC_NOUN(r) = V_VOID;
3325 DCL_TYPE(r) = port->unqualified_pointer;
3332 assert(*(s+1)=='*');
3333 nr = newLink(DECLARATOR);
3338 DCL_TYPE(r) = GPOINTER;
3341 DCL_TYPE(r) = FPOINTER;
3344 DCL_TYPE(r) = CPOINTER;
3347 DCL_TYPE(r) = POINTER;
3350 DCL_TYPE(r) = FUNCTION;
3351 nr = newLink(DECLARATOR);
3354 DCL_TYPE(r) = CPOINTER;
3360 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3361 "typeFromStr: unknown type");
3364 if (IS_SPEC(r) && usign) {
3373 /*-----------------------------------------------------------------*/
3374 /* initCSupport - create functions for C support routines */
3375 /*-----------------------------------------------------------------*/
3379 const char *smuldivmod[] =
3383 const char *sbwd[] =
3385 "char", "int", "long", "fixed16x16",
3387 const char *fp16x16sbwd[] =
3389 "char", "int", "long", "float",
3395 const char *srlrr[] =
3400 int bwd, su, muldivmod, tofrom, rlrr;
3402 if (getenv("SDCC_NO_C_SUPPORT")) {
3403 /* for debugging only */
3407 floatType = newFloatLink ();
3408 fixed16x16Type = newFixed16x16Link ();
3410 for (bwd = 0; bwd < 3; bwd++)
3427 __multypes[bwd][0] = l;
3428 __multypes[bwd][1] = copyLinkChain (l);
3429 SPEC_USIGN (__multypes[bwd][1]) = 1;
3432 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3433 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3434 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3435 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3436 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3437 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3438 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3439 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3440 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3441 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3443 __fps16x16_add = funcOfType ("__fps16x16_add", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3444 __fps16x16_sub = funcOfType ("__fps16x16_sub", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3445 __fps16x16_mul = funcOfType ("__fps16x16_mul", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3446 __fps16x16_div = funcOfType ("__fps16x16_div", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3447 __fps16x16_eq = funcOfType ("__fps16x16_eq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3448 __fps16x16_neq = funcOfType ("__fps16x16_neq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3449 __fps16x16_lt = funcOfType ("__fps16x16_lt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3450 __fps16x16_lteq = funcOfType ("__fps16x16_lteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3451 __fps16x16_gt = funcOfType ("__fps16x16_gt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3452 __fps16x16_gteq = funcOfType ("__fps16x16_gteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3455 for (tofrom = 0; tofrom < 2; tofrom++)
3457 for (bwd = 0; bwd < 3; bwd++)
3459 for (su = 0; su < 2; su++)
3463 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3464 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3468 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3469 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3475 for (tofrom = 0; tofrom < 2; tofrom++)
3477 for (bwd = 0; bwd < 4; bwd++)
3479 for (su = 0; su < 2; su++)
3483 SNPRINTF (buffer, sizeof(buffer), "__fps16x162%s%s", ssu[su], fp16x16sbwd[bwd]);
3485 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, floatType, fixed16x16Type, 1, options.float_rent);
3487 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], fixed16x16Type, 1, options.float_rent);
3491 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fps16x16", ssu[su], fp16x16sbwd[bwd]);
3493 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, floatType, 1, options.float_rent);
3495 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, __multypes[bwd][su], 1, options.float_rent);
3502 for (muldivmod = 0; muldivmod < 3; muldivmod++)
3504 for (bwd = 0; bwd < 3; bwd++)
3506 for (su = 0; su < 2; su++)
3508 SNPRINTF (buffer, sizeof(buffer),
3510 smuldivmod[muldivmod],
3513 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3514 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3519 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3520 Therefore they've been merged into mulint() and mullong().
3523 for (bwd = 0; bwd < 3; bwd++)
3525 for (su = 0; su < 2; su++)
3527 for (muldivmod = 1; muldivmod < 3; muldivmod++)
3529 /* div and mod : s8_t x s8_t -> s8_t should be s8_t x s8_t -> s16_t, see below */
3530 if (!TARGET_IS_PIC16 || muldivmod != 1 || bwd != 0 || su != 0)
3532 SNPRINTF (buffer, sizeof(buffer),
3534 smuldivmod[muldivmod],
3537 __muldiv[muldivmod][bwd][su] = funcOfType (
3538 _mangleFunctionName(buffer),
3539 __multypes[bwd][su],
3540 __multypes[bwd][su],
3542 options.intlong_rent);
3543 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3549 if (TARGET_IS_PIC16)
3551 /* PIC16 port wants __divschar/__modschar to return an int, so that both
3552 * 100 / -4 = -25 and -128 / -1 = 128 can be handled correctly
3553 * (first one would have to be sign extended, second one must not be).
3554 * Similarly, modschar should be handled, but the iCode introduces cast
3555 * here and forces '% : s8 x s8 -> s8' ... */
3557 for (muldivmod = 1; muldivmod < 2; muldivmod++) {
3558 SNPRINTF (buffer, sizeof(buffer),
3560 smuldivmod[muldivmod],
3563 __muldiv[muldivmod][bwd][su] = funcOfType (
3564 _mangleFunctionName(buffer),
3566 __multypes[bwd][su],
3568 options.intlong_rent);
3569 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3577 for (su = 0; su < 2; su++)
3579 /* muluchar and mulschar are still separate functions, because e.g. the z80
3580 port is sign/zero-extending to int before calling mulint() */
3581 SNPRINTF (buffer, sizeof(buffer),
3583 smuldivmod[muldivmod],
3586 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3587 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3591 /* word and doubleword */
3592 for (bwd = 1; bwd < 3; bwd++)
3595 SNPRINTF (buffer, sizeof(buffer),
3597 smuldivmod[muldivmod],
3599 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3600 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3601 /* signed = unsigned */
3602 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3605 for (rlrr = 0; rlrr < 2; rlrr++)
3607 for (bwd = 0; bwd < 3; bwd++)
3609 for (su = 0; su < 2; su++)
3611 SNPRINTF (buffer, sizeof(buffer),
3616 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3617 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3623 /*-----------------------------------------------------------------*/
3624 /* initBuiltIns - create prototypes for builtin functions */
3625 /*-----------------------------------------------------------------*/
3631 if (!port->builtintable) return ;
3633 for (i = 0 ; port->builtintable[i].name ; i++) {
3634 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3635 port->builtintable[i].nParms,port->builtintable[i].parm_types);
3636 FUNC_ISBUILTIN(sym->type) = 1;
3637 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
3641 sym_link *validateLink(sym_link *l,
3648 if (l && l->class==select)
3653 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3654 " expected %s, got %s\n",
3655 macro, args, file, line,
3656 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3658 return l; // never reached, makes compiler happy.
3661 /*--------------------------------------------------------------------*/
3662 /* newEnumType - create an integer type compatible with enumerations */
3663 /*--------------------------------------------------------------------*/
3665 newEnumType (symbol *enumlist)
3673 type = newLink (SPECIFIER);
3674 SPEC_NOUN (type) = V_INT;
3678 /* Determine the range of the enumerated values */
3680 min = max = (int) floatFromVal (valFromType (sym->type));
3681 for (sym = sym->next; sym; sym = sym->next)
3683 v = (int) floatFromVal (valFromType (sym->type));
3690 /* Determine the smallest integer type that is compatible with this range */
3691 type = newLink (SPECIFIER);
3692 if (min>=0 && max<=255)
3694 SPEC_NOUN (type) = V_CHAR;
3695 SPEC_USIGN (type) = 1;
3697 else if (min>=-128 && max<=127)
3699 SPEC_NOUN (type) = V_CHAR;
3701 else if (min>=0 && max<=65535)
3703 SPEC_NOUN (type) = V_INT;
3704 SPEC_USIGN (type) = 1;
3706 else if (min>=-32768 && max<=32767)
3708 SPEC_NOUN (type) = V_INT;
3712 SPEC_NOUN (type) = V_INT;
3713 SPEC_LONG (type) = 1;
3715 SPEC_USIGN (type) = 1;