git.gag.com Git - fw/sdcc/blob - src/SDCCsymt.c

   1 /*-------------------------------------------------------------------------
   2   SDCCsymt.c - Code file for Symbols table related structures and MACRO's.
   3         Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   4
   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
   8    later version.
   9
  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.
  14
  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.
  18
  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 -------------------------------------------------------------------------*/
  23
  24 #include "common.h"
  25 #include "newalloc.h"
  26
  27 #include "SDCCsymt.h"
  28
  29 value *aggregateToPointer (value *val);
  30 void printTypeChainRaw (sym_link * start, FILE * of);
  31
  32 void printFromToType(sym_link *from, sym_link *to) {
  33   fprintf (stderr, "from type '");
  34   printTypeChain (from, stderr);
  35   fprintf (stderr, "'\nto type '");
  36   printTypeChain (to, stderr);
  37   fprintf (stderr, "'\n");
  38 }
  39
  40 /* noun strings */
  41 char *nounName(sym_link *sl) {
  42   switch (SPEC_NOUN(sl))
  43     {
  44     case V_INT: {
  45       if (SPEC_LONG(sl)) return "long";
  46       if (sl->select.s._short) return "short";
  47       return "int";
  48     }
  49     case V_FLOAT: return "float";
  50     case V_CHAR: return "char";
  51     case V_VOID: return "void";
  52     case V_STRUCT: return "struct";
  53     case V_LABEL: return "label";
  54     case V_BITFIELD: return "bitfield";
  55     case V_BIT: return "bit";
  56     case V_SBIT: return "sbit";
  57     case V_DOUBLE: return "double";
  58     }
  59   return "unknown";
  60 };
  61
  62 bucket *SymbolTab[256];         /* the symbol    table  */
  63 bucket *StructTab[256];         /* the structure table  */
  64 bucket *TypedefTab[256];        /* the typedef   table  */
  65 bucket *LabelTab[256];          /* the Label     table  */
  66 bucket *enumTab[256];           /* enumerated    table  */
  67
  68 /*------------------------------------------------------------------*/
  69 /* initSymt () - initialises symbol table related stuff             */
  70 /*------------------------------------------------------------------*/
  71 void
  72 initSymt ()
  73 {
  74   int i = 0;
  75
  76   for (i = 0; i < 256; i++)
  77     SymbolTab[i] = StructTab[i] = (void *) NULL;
  78
  79
  80 }
  81 /*-----------------------------------------------------------------*/
  82 /* newBucket - allocates & returns a new bucket        */
  83 /*-----------------------------------------------------------------*/
  84 bucket *
  85 newBucket ()
  86 {
  87   bucket *bp;
  88
  89   bp = Safe_alloc ( sizeof (bucket));
  90
  91   return bp;
  92 }
  93
  94 /*-----------------------------------------------------------------*/
  95 /* hashKey - computes the hashkey given a symbol name              */
  96 /*-----------------------------------------------------------------*/
  97 int
  98 hashKey (const char *s)
  99 {
 100   unsigned long key = 0;
 101
 102   while (*s)
 103     key += *s++;
 104   return key % 256;
 105 }
 106
 107 /*-----------------------------------------------------------------*/
 108 /* addSym - adds a symbol to the hash Table                        */
 109 /*-----------------------------------------------------------------*/
 110 void
 111 addSym (bucket ** stab,
 112         void *sym,
 113         char *sname,
 114         int level,
 115         int block,
 116         int checkType)
 117 {
 118   int i;                        /* index into the hash Table */
 119   bucket *bp;                   /* temp bucket    *         */
 120
 121   if (checkType) {
 122     symbol *csym = (symbol *)sym;
 123
 124     if (getenv("DEBUG_SANITY")) {
 125       fprintf (stderr, "addSym: %s ", sname);
 126     }
 127     /* make sure the type is complete and sane */
 128     checkTypeSanity(csym->etype, csym->name);
 129   }
 130
 131   /* prevent overflow of the (r)name buffers */
 132   if (strlen(sname)>SDCC_SYMNAME_MAX) {
 133     werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
 134     sname[SDCC_SYMNAME_MAX]='\0';
 135   }
 136
 137   /* the symbols are always added at the head of the list  */
 138   i = hashKey (sname);
 139   /* get a free entry */
 140   bp = Safe_alloc ( sizeof (bucket));
 141
 142   bp->sym = sym;                /* update the symbol pointer  */
 143   bp->level = level;            /* update the nest level      */
 144   bp->block = block;
 145   strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
 146
 147   /* if this is the first entry */
 148   if (stab[i] == NULL)
 149     {
 150       bp->prev = bp->next = (void *) NULL;      /* point to nothing */
 151       stab[i] = bp;
 152     }
 153   /* not first entry then add @ head of list */
 154   else
 155     {
 156       bp->prev = NULL;
 157       stab[i]->prev = bp;
 158       bp->next = stab[i];
 159       stab[i] = bp;
 160     }
 161 }
 162
 163 /*-----------------------------------------------------------------*/
 164 /* deleteSym - deletes a symbol from the hash Table  entry     */
 165 /*-----------------------------------------------------------------*/
 166 void
 167 deleteSym (bucket ** stab, void *sym, char *sname)
 168 {
 169   int i = 0;
 170   bucket *bp;
 171
 172   i = hashKey (sname);
 173
 174   bp = stab[i];
 175   /* find the symbol */
 176   while (bp)
 177     {
 178       if (bp->sym == sym)       /* found it then break out */
 179         break;                  /* of the loop       */
 180       bp = bp->next;
 181     }
 182
 183   if (!bp)                      /* did not find it */
 184     return;
 185   /* if this is the first one in the chain */
 186   if (!bp->prev)
 187     {
 188       stab[i] = bp->next;
 189       if (stab[i])              /* if chain ! empty */
 190         stab[i]->prev = (void *) NULL;
 191     }
 192   /* middle || end of chain */
 193   else
 194     {
 195       if (bp->next)             /* if not end of chain */
 196         bp->next->prev = bp->prev;
 197
 198       bp->prev->next = bp->next;
 199     }
 200
 201 }
 202
 203 /*-----------------------------------------------------------------*/
 204 /* findSym - finds a symbol in a table           */
 205 /*-----------------------------------------------------------------*/
 206 void *
 207 findSym (bucket ** stab, void *sym, const char *sname)
 208 {
 209   bucket *bp;
 210
 211   bp = stab[hashKey (sname)];
 212   while (bp)
 213     {
 214       if (bp->sym == sym || strcmp (bp->name, sname) == 0)
 215         break;
 216       bp = bp->next;
 217     }
 218
 219   return (bp ? bp->sym : (void *) NULL);
 220 }
 221
 222 /*-----------------------------------------------------------------*/
 223 /* findSymWithLevel - finds a symbol with a name & level           */
 224 /*-----------------------------------------------------------------*/
 225 void *
 226 findSymWithLevel (bucket ** stab, symbol * sym)
 227 {
 228   bucket *bp;
 229
 230   bp = stab[hashKey (sym->name)];
 231
 232   /**
 233    **  do the search from the head of the list since the
 234    **  elements are added at the head it is ensured that
 235    ** we will find the deeper definitions before we find
 236    ** the global ones. we need to check for symbols with
 237    ** level <= to the level given, if levels match then block
 238    ** numbers need to match as well
 239    **/
 240   while (bp)
 241     {
 242       if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
 243         {
 244           /* if this is parameter then nothing else need to be checked */
 245           if (((symbol *) (bp->sym))->_isparm)
 246             return (bp->sym);
 247           /* if levels match then block numbers should also match */
 248           if (bp->level && bp->level == sym->level && bp->block == sym->block)
 249             return (bp->sym);
 250           /* if levels don't match then we are okay */
 251           if (bp->level && bp->level != sym->level && bp->block <= sym->block)
 252             return (bp->sym);
 253           /* if this is a global variable then we are ok too */
 254           if (bp->level == 0)
 255             return (bp->sym);
 256         }
 257
 258       bp = bp->next;
 259     }
 260
 261   return (void *) NULL;
 262 }
 263
 264 /*-----------------------------------------------------------------*/
 265 /* findSymWithBlock - finds a symbol with name in with a block     */
 266 /*-----------------------------------------------------------------*/
 267 void *
 268 findSymWithBlock (bucket ** stab, symbol * sym, int block)
 269 {
 270   bucket *bp;
 271
 272   bp = stab[hashKey (sym->name)];
 273   while (bp)
 274     {
 275       if (strcmp (bp->name, sym->name) == 0 &&
 276           bp->block <= block)
 277         break;
 278       bp = bp->next;
 279     }
 280
 281   return (bp ? bp->sym : (void *) NULL);
 282 }
 283
 284 /*------------------------------------------------------------------*/
 285 /* newSymbol () - returns a new pointer to a symbol                 */
 286 /*------------------------------------------------------------------*/
 287 symbol *
 288 newSymbol (char *name, int scope)
 289 {
 290   symbol *sym;
 291
 292   sym = Safe_alloc ( sizeof (symbol));
 293
 294   strncpyz (sym->name, name, sizeof(sym->name));        /* copy the name */
 295   sym->level = scope;           /* set the level    */
 296   sym->block = currBlockno;
 297   sym->lineDef = mylineno;      /* set the line number */
 298   sym->fileDef = currFname;
 299   return sym;
 300 }
 301
 302 /*------------------------------------------------------------------*/
 303 /* newLink - creates a new link (declarator,specifier)              */
 304 /*------------------------------------------------------------------*/
 305 sym_link *
 306 newLink (SYM_LINK_CLASS select)
 307 {
 308   sym_link *p;
 309
 310   p = Safe_alloc ( sizeof (sym_link));
 311   p->class=select;
 312
 313   return p;
 314 }
 315
 316 /*------------------------------------------------------------------*/
 317 /* newStruct - creats a new structdef from the free list            */
 318 /*------------------------------------------------------------------*/
 319 structdef *
 320 newStruct (char *tag)
 321 {
 322   structdef *s;
 323
 324   s = Safe_alloc ( sizeof (structdef));
 325
 326   strncpyz (s->tag, tag, sizeof(s->tag));               /* copy the tag */
 327   return s;
 328 }
 329
 330 /*------------------------------------------------------------------*/
 331 /* sclsFromPtr - Return the storage class a pointer points into.    */
 332 /*               S_FIXED is returned for generic pointers or other  */
 333 /*               unexpected cases                                   */
 334 /*------------------------------------------------------------------*/
 335 STORAGE_CLASS
 336 sclsFromPtr(sym_link *ptr)
 337 {
 338   switch (DCL_TYPE (ptr))
 339     {
 340     case POINTER:
 341       return S_DATA;
 342     case GPOINTER:
 343       return S_FIXED;
 344     case FPOINTER:
 345       return S_XDATA;
 346     case CPOINTER:
 347       return S_CODE;
 348     case IPOINTER:
 349       return S_IDATA;
 350     case PPOINTER:
 351       return S_PDATA;
 352     case EEPPOINTER:
 353       return S_EEPROM;
 354     case FUNCTION:
 355       return S_CODE;
 356     default:
 357       return S_FIXED;
 358     }
 359 }
 360
 361 /*------------------------------------------------------------------*/
 362 /* pointerTypes - do the computation for the pointer types          */
 363 /*------------------------------------------------------------------*/
 364 void
 365 pointerTypes (sym_link * ptr, sym_link * type)
 366 {
 367   if (IS_SPEC (ptr))
 368     return;
 369
 370   /* find the first pointer type */
 371   while (ptr && !IS_PTR (ptr))
 372     ptr = ptr->next;
 373
 374   /* could not find it */
 375   if (!ptr || IS_SPEC (ptr))
 376     return;
 377
 378   if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
 379     pointerTypes (ptr->next, type);
 380     return;
 381   }
 382
 383   /* change the pointer type depending on the
 384      storage class of the type */
 385   if (IS_SPEC (type))
 386     {
 387       switch (SPEC_SCLS (type))
 388         {
 389         case S_XDATA:
 390           DCL_TYPE (ptr) = FPOINTER;
 391           break;
 392         case S_IDATA:
 393           DCL_TYPE (ptr) = IPOINTER;
 394           break;
 395         case S_PDATA:
 396           DCL_TYPE (ptr) = PPOINTER;
 397           break;
 398         case S_DATA:
 399           DCL_TYPE (ptr) = POINTER;
 400           break;
 401         case S_CODE:
 402           DCL_TYPE (ptr) = CPOINTER;
 403           break;
 404         case S_EEPROM:
 405           DCL_TYPE (ptr) = EEPPOINTER;
 406           break;
 407         default:
 408           DCL_TYPE (ptr) = port->unqualified_pointer;
 409           break;
 410         }
 411       /* the storage class of type ends here */
 412       SPEC_SCLS (type) = 0;
 413     }
 414
 415   /* now change all the remaining unknown pointers
 416      to generic pointers */
 417   while (ptr)
 418     {
 419       if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
 420         DCL_TYPE (ptr) = port->unqualified_pointer;
 421       ptr = ptr->next;
 422     }
 423
 424   /* same for the type although it is highly unlikely that
 425      type will have a pointer */
 426   while (type)
 427     {
 428       if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
 429         DCL_TYPE (type) = port->unqualified_pointer;
 430       type = type->next;
 431     }
 432 }
 433
 434 /*------------------------------------------------------------------*/
 435 /* addDecl - adds a declarator @ the end of a chain                 */
 436 /*------------------------------------------------------------------*/
 437 void
 438 addDecl (symbol * sym, int type, sym_link * p)
 439 {
 440   sym_link *head;
 441   sym_link *tail;
 442   sym_link *t;
 443
 444   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
 445     fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
 446
 447   /* if we are passed a link then set head & tail */
 448   if (p)
 449     {
 450       tail = head = p;
 451       while (tail->next)
 452         tail = tail->next;
 453     }
 454   else
 455     {
 456       head = tail = newLink (DECLARATOR);
 457       DCL_TYPE (head) = type;
 458     }
 459
 460   /* if this is the first entry   */
 461   if (!sym->type)
 462     {
 463       sym->type = head;
 464       sym->etype = tail;
 465     }
 466   else
 467     {
 468       if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
 469         {
 470           sym->etype = mergeSpec (sym->etype, head, sym->name);
 471         }
 472       else
 473         {
 474           if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
 475             {
 476               t = sym->type;
 477               while (t->next != sym->etype)
 478                 t = t->next;
 479               t->next = head;
 480               tail->next = sym->etype;
 481             }
 482           else
 483             {
 484               sym->etype->next = head;
 485               sym->etype = tail;
 486             }
 487         }
 488     }
 489
 490   /* if the type is an unknown pointer and has
 491      a tspec then take the storage class const & volatile
 492      attribute from the tspec & make it those of this
 493      symbol */
 494   if (p &&
 495       !IS_SPEC (p) &&
 496       //DCL_TYPE (p) == UPOINTER &&
 497       DCL_TSPEC (p))
 498     {
 499       if (!IS_SPEC (sym->etype))
 500         {
 501           sym->etype = sym->etype->next = newLink (SPECIFIER);
 502         }
 503       SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
 504       DCL_TSPEC (p) = NULL;
 505     }
 506
 507   // if there is a function in this type chain
 508   if (p && funcInChain(sym->type)) {
 509     processFuncArgs (sym);
 510   }
 511
 512   return;
 513 }
 514
 515 /*------------------------------------------------------------------
 516   checkTypeSanity: prevent the user from doing e.g.:
 517   unsigned float uf;
 518   ------------------------------------------------------------------*/
 519 void checkTypeSanity(sym_link *etype, char *name) {
 520   char *noun;
 521
 522   if (!etype) {
 523     if (getenv("DEBUG_SANITY")) {
 524       fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
 525     }
 526     return;
 527   }
 528
 529   if (!IS_SPEC(etype)) {
 530     if (getenv("DEBUG_SANITY")) {
 531       fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
 532     }
 533     return;
 534   }
 535
 536   noun=nounName(etype);
 537
 538   if (getenv("DEBUG_SANITY")) {
 539     fprintf (stderr, "checking sanity for %s %p\n", name, etype);
 540   }
 541
 542   if ((SPEC_NOUN(etype)==V_CHAR ||
 543        SPEC_NOUN(etype)==V_FLOAT ||
 544        SPEC_NOUN(etype)==V_DOUBLE ||
 545        SPEC_NOUN(etype)==V_VOID) &&
 546       (etype->select.s._short || SPEC_LONG(etype))) {
 547     // long or short for char float double or void
 548     werror (E_LONG_OR_SHORT_INVALID, noun, name);
 549   }
 550   if ((SPEC_NOUN(etype)==V_FLOAT ||
 551        SPEC_NOUN(etype)==V_DOUBLE ||
 552        SPEC_NOUN(etype)==V_VOID) &&
 553       (etype->select.s._signed || SPEC_USIGN(etype))) {
 554     // signed or unsigned for float double or void
 555     werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
 556   }
 557
 558   // special case for "short"
 559   if (etype->select.s._short) {
 560     SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
 561     etype->select.s._short = 0;
 562   }
 563
 564   /* if no noun e.g.
 565      "const a;" or "data b;" or "signed s" or "long l"
 566      assume an int */
 567   if (!SPEC_NOUN(etype)) {
 568     SPEC_NOUN(etype)=V_INT;
 569   }
 570
 571   /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
 572   /* a "plain" int bitfield is unsigned */
 573   if (SPEC_NOUN(etype)==V_BIT ||
 574       SPEC_NOUN(etype)==V_SBIT) {
 575     if (!etype->select.s._signed)
 576       SPEC_USIGN(etype) = 1;
 577   }
 578
 579   if (etype->select.s._signed && SPEC_USIGN(etype)) {
 580     // signed AND unsigned
 581     werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
 582   }
 583   if (etype->select.s._short && SPEC_LONG(etype)) {
 584     // short AND long
 585     werror (E_LONG_AND_SHORT_INVALID, noun, name);
 586   }
 587
 588 }
 589
 590 /*------------------------------------------------------------------*/
 591 /* mergeSpec - merges two specifiers and returns the new one        */
 592 /*------------------------------------------------------------------*/
 593 sym_link *
 594 mergeSpec (sym_link * dest, sym_link * src, char *name)
 595 {
 596   if (!IS_SPEC(dest) || !IS_SPEC(src)) {
 597 #if 0
 598     werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
 599     exit (1);
 600 #else
 601     werror (E_SYNTAX_ERROR, yytext);
 602     // the show must go on
 603     return newIntLink();
 604 #endif
 605   }
 606
 607   if (SPEC_NOUN(src)) {
 608     if (!SPEC_NOUN(dest)) {
 609       SPEC_NOUN(dest)=SPEC_NOUN(src);
 610     } else {
 611       /* we shouldn't redeclare the type */
 612       if (getenv("DEBUG_SANITY")) {
 613         fprintf (stderr, "mergeSpec: ");
 614       }
 615       werror(E_TWO_OR_MORE_DATA_TYPES, name);
 616     }
 617   }
 618
 619   if (SPEC_SCLS(src)) {
 620     /* if destination has no storage class */
 621     if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
 622       SPEC_SCLS (dest) = SPEC_SCLS (src);
 623     } else {
 624       if (getenv("DEBUG_SANITY")) {
 625         fprintf (stderr, "mergeSpec: ");
 626       }
 627       werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
 628     }
 629   }
 630
 631   /* copy all the specifications  */
 632
 633   // we really should do:
 634 #if 0
 635   if (SPEC_what(src)) {
 636     if (SPEC_what(dest)) {
 637       werror(W_DUPLICATE_SPEC, "what");
 638     }
 639     SPEC_what(dst)|=SPEC_what(src);
 640   }
 641 #endif
 642   // but there are more important thing right now
 643
 644   SPEC_LONG (dest) |= SPEC_LONG (src);
 645   dest->select.s._short|=src->select.s._short;
 646   SPEC_USIGN (dest) |= SPEC_USIGN (src);
 647   dest->select.s._signed|=src->select.s._signed;
 648   SPEC_STAT (dest) |= SPEC_STAT (src);
 649   SPEC_EXTR (dest) |= SPEC_EXTR (src);
 650   SPEC_CONST(dest) |= SPEC_CONST (src);
 651   SPEC_ABSA (dest) |= SPEC_ABSA (src);
 652   SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
 653   SPEC_ADDR (dest) |= SPEC_ADDR (src);
 654   SPEC_OCLS (dest) = SPEC_OCLS (src);
 655   SPEC_BLEN (dest) |= SPEC_BLEN (src);
 656   SPEC_BSTR (dest) |= SPEC_BSTR (src);
 657   SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
 658   SPEC_ENUM (dest) |= SPEC_ENUM (src);
 659   if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
 660       SPEC_ARGREG(dest) = SPEC_ARGREG(src);
 661
 662   if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
 663     SPEC_STRUCT (dest) = SPEC_STRUCT (src);
 664
 665   /* these are the only function attributes that will be set
 666      in a specifier while parsing */
 667   FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
 668   FUNC_BANKED(dest) |= FUNC_BANKED(src);
 669   FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
 670   FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
 671   FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
 672   FUNC_ISISR(dest) |= FUNC_ISISR(src);
 673   FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
 674   FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
 675   FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
 676   FUNC_INTNO(dest) |= FUNC_INTNO(src);
 677   FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
 678
 679   return dest;
 680 }
 681
 682 /*------------------------------------------------------------------*/
 683 /* genSymName - generates and returns a name used for anonymous vars */
 684 /*------------------------------------------------------------------*/
 685 char *
 686 genSymName (int level)
 687 {
 688   static int gCount = 0;
 689   static char gname[SDCC_NAME_MAX + 1];
 690
 691   SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
 692   return gname;
 693 }
 694
 695 /*------------------------------------------------------------------*/
 696 /* getSpec - returns the specifier part from a declaration chain    */
 697 /*------------------------------------------------------------------*/
 698 sym_link *
 699 getSpec (sym_link * p)
 700 {
 701   sym_link *loop;
 702
 703   loop = p;
 704   while (p && !(IS_SPEC (p)))
 705     p = p->next;
 706
 707   return p;
 708 }
 709
 710 /*------------------------------------------------------------------*/
 711 /* newCharLink() - creates an char type                             */
 712 /*------------------------------------------------------------------*/
 713 sym_link *
 714 newCharLink ()
 715 {
 716   sym_link *p;
 717
 718   p = newLink (SPECIFIER);
 719   SPEC_NOUN (p) = V_CHAR;
 720
 721   return p;
 722 }
 723
 724 /*------------------------------------------------------------------*/
 725 /* newFloatLink - a new Float type                                  */
 726 /*------------------------------------------------------------------*/
 727 sym_link *
 728 newFloatLink ()
 729 {
 730   sym_link *p;
 731
 732   p = newLink (SPECIFIER);
 733   SPEC_NOUN (p) = V_FLOAT;
 734
 735   return p;
 736 }
 737
 738 /*------------------------------------------------------------------*/
 739 /* newLongLink() - new long type                                    */
 740 /*------------------------------------------------------------------*/
 741 sym_link *
 742 newLongLink ()
 743 {
 744   sym_link *p;
 745
 746   p = newLink (SPECIFIER);
 747   SPEC_NOUN (p) = V_INT;
 748   SPEC_LONG (p) = 1;
 749
 750   return p;
 751 }
 752
 753 /*------------------------------------------------------------------*/
 754 /* newIntLink() - creates an int type                               */
 755 /*------------------------------------------------------------------*/
 756 sym_link *
 757 newIntLink ()
 758 {
 759   sym_link *p;
 760
 761   p = newLink (SPECIFIER);
 762   SPEC_NOUN (p) = V_INT;
 763
 764   return p;
 765 }
 766
 767 /*------------------------------------------------------------------*/
 768 /* getSize - returns size of a type chain in bits                   */
 769 /*------------------------------------------------------------------*/
 770 unsigned int
 771 getSize (sym_link * p)
 772 {
 773   /* if nothing return 0 */
 774   if (!p)
 775     return 0;
 776   if (IS_SPEC (p))
 777     {                           /* if this is the specifier then */
 778       switch (SPEC_NOUN (p))
 779         {                       /* depending on the specifier type */
 780         case V_INT:
 781           return (IS_LONG (p) ? LONGSIZE : INTSIZE);
 782         case V_FLOAT:
 783           return FLOATSIZE;
 784         case V_CHAR:
 785           return CHARSIZE;
 786         case V_VOID:
 787           return 0;
 788         case V_STRUCT:
 789           return SPEC_STRUCT (p)->size;
 790         case V_LABEL:
 791           return 0;
 792         case V_SBIT:
 793         case V_BIT:
 794           return BITSIZE;
 795         case V_BITFIELD:
 796           return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
 797         default:
 798           return 0;
 799         }
 800     }
 801
 802   /* this is a declarator */
 803   switch (DCL_TYPE (p))
 804     {
 805     case ARRAY:
 806       if (DCL_ELEM(p)) {
 807         return DCL_ELEM (p) * getSize (p->next);
 808       } else {
 809           //    werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 810           //    "can not tell the size of an array[]");
 811         return 0;
 812       }
 813     case IPOINTER:
 814     case PPOINTER:
 815     case POINTER:
 816       return (PTRSIZE);
 817     case EEPPOINTER:
 818     case FPOINTER:
 819     case CPOINTER:
 820     case FUNCTION:
 821       return (FPTRSIZE);
 822     case GPOINTER:
 823       return (GPTRSIZE);
 824
 825     default:
 826       return 0;
 827     }
 828 }
 829
 830 /*---------------------------------------------------------------------*/
 831 /* getAllocSize - returns size of a type chain in bytes for allocation */
 832 /*---------------------------------------------------------------------*/
 833 unsigned int
 834 getAllocSize (sym_link *p)
 835 {
 836   if (IS_STRUCT (p) && SPEC_STRUCT (p)->type == STRUCT)
 837     {
 838       /* if this is a struct specifier then  */
 839       /* calculate the size as it could end  */
 840       /* with an array of unspecified length */
 841       symbol *sflds = SPEC_STRUCT (p)->fields;
 842
 843       while (sflds && sflds->next)
 844         sflds = sflds->next;
 845
 846       if (sflds && !IS_BITFIELD (sflds->type))
 847         return sflds->offset + getAllocSize (sflds->type);
 848       else
 849         return SPEC_STRUCT (p)->size;
 850     }
 851   else
 852     return getSize (p);
 853 }
 854
 855 /*------------------------------------------------------------------*/
 856 /* bitsForType - returns # of bits required to store this type      */
 857 /*------------------------------------------------------------------*/
 858 unsigned int
 859 bitsForType (sym_link * p)
 860 {
 861   /* if nothing return 0 */
 862   if (!p)
 863     return 0;
 864
 865   if (IS_SPEC (p))
 866     {                           /* if this is the specifier then */
 867
 868       switch (SPEC_NOUN (p))
 869         {                       /* depending on the specifier type */
 870         case V_INT:
 871           return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
 872         case V_FLOAT:
 873           return FLOATSIZE * 8;
 874         case V_CHAR:
 875           return CHARSIZE * 8;
 876         case V_VOID:
 877           return 0;
 878         case V_STRUCT:
 879           return SPEC_STRUCT (p)->size * 8;
 880         case V_LABEL:
 881           return 0;
 882         case V_SBIT:
 883         case V_BIT:
 884           return 1;
 885         case V_BITFIELD:
 886           return SPEC_BLEN (p);
 887         default:
 888           return 0;
 889         }
 890     }
 891
 892   /* this is a specifier  */
 893   switch (DCL_TYPE (p))
 894     {
 895     case ARRAY:
 896       return DCL_ELEM (p) * getSize (p->next) * 8;
 897     case IPOINTER:
 898     case PPOINTER:
 899     case POINTER:
 900       return (PTRSIZE * 8);
 901     case EEPPOINTER:
 902     case FPOINTER:
 903     case CPOINTER:
 904     case FUNCTION:
 905       return (FPTRSIZE * 8);
 906     case GPOINTER:
 907       return (GPTRSIZE * 8);
 908
 909     default:
 910       return 0;
 911     }
 912 }
 913
 914 /*------------------------------------------------------------------*/
 915 /* copySymbolChain - copies a symbol chain                          */
 916 /*------------------------------------------------------------------*/
 917 symbol *
 918 copySymbolChain (symbol * src)
 919 {
 920   symbol *dest;
 921
 922   if (!src)
 923     return NULL;
 924
 925   dest = copySymbol (src);
 926   dest->next = copySymbolChain (src->next);
 927   return dest;
 928 }
 929
 930 /*------------------------------------------------------------------*/
 931 /* copySymbol - makes a copy of a symbol                            */
 932 /*------------------------------------------------------------------*/
 933 symbol *
 934 copySymbol (symbol * src)
 935 {
 936   symbol *dest;
 937
 938   if (!src)
 939     return NULL;
 940
 941   dest = newSymbol (src->name, src->level);
 942   memcpy (dest, src, sizeof (symbol));
 943   dest->level = src->level;
 944   dest->block = src->block;
 945   dest->ival = copyIlist (src->ival);
 946   dest->type = copyLinkChain (src->type);
 947   dest->etype = getSpec (dest->type);
 948   dest->next = NULL;
 949   dest->key = src->key;
 950   dest->allocreq = src->allocreq;
 951   return dest;
 952 }
 953
 954 /*------------------------------------------------------------------*/
 955 /* reverseSyms - reverses the links for a symbol chain      */
 956 /*------------------------------------------------------------------*/
 957 symbol *
 958 reverseSyms (symbol * sym)
 959 {
 960   symbol *prev, *curr, *next;
 961
 962   if (!sym)
 963     return NULL;
 964
 965   prev = sym;
 966   curr = sym->next;
 967
 968   while (curr)
 969     {
 970       next = curr->next;
 971       curr->next = prev;
 972       prev = curr;
 973       curr = next;
 974     }
 975   sym->next = (void *) NULL;
 976   return prev;
 977 }
 978
 979 /*------------------------------------------------------------------*/
 980 /* reverseLink - reverses the links for a type chain        */
 981 /*------------------------------------------------------------------*/
 982 sym_link *
 983 reverseLink (sym_link * type)
 984 {
 985   sym_link *prev, *curr, *next;
 986
 987   if (!type)
 988     return NULL;
 989
 990   prev = type;
 991   curr = type->next;
 992
 993   while (curr)
 994     {
 995       next = curr->next;
 996       curr->next = prev;
 997       prev = curr;
 998       curr = next;
 999     }
1000   type->next = (void *) NULL;
1001   return prev;
1002 }
1003
1004 /*------------------------------------------------------------------*/
1005 /* addSymChain - adds a symbol chain to the symboltable             */
1006 /*------------------------------------------------------------------*/
1007 void
1008 addSymChain (symbol * symHead)
1009 {
1010   symbol *sym = symHead;
1011   symbol *csym = NULL;
1012   int error = 0;
1013
1014   for (; sym != NULL; sym = sym->next)
1015     {
1016       changePointer(sym);
1017       checkTypeSanity(sym->etype, sym->name);
1018
1019       if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1020         checkDecl (sym, 0);
1021
1022       /* if already exists in the symbol table then check if
1023          one of them is an extern definition if yes then
1024          then check if the type match, if the types match then
1025          delete the current entry and add the new entry      */
1026       if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1027           csym->level == sym->level) {
1028
1029         /* If the previous definition was for an array with incomplete */
1030         /* type, and the new definition has completed the type, update */
1031         /* the original type to match */
1032         if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1033             && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1034           {
1035             if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1036               DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1037           }
1038
1039         #if 0
1040         /* If only one of the definitions used the "at" keyword, copy */
1041         /* the address to the other. */
1042         if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1043             && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1044           {
1045             SPEC_ABSA (sym->etype) = 1;
1046             SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1047           }
1048         if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1049             && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1050           {
1051             SPEC_ABSA (csym->etype) = 1;
1052             SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1053           }
1054         #endif
1055
1056         error = 0;
1057         if (csym->ival && sym->ival)
1058           error = 1;
1059         if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1060           error = 1;
1061
1062         if (error) {
1063           /* one definition extern ? */
1064           if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1065             werror (E_EXTERN_MISMATCH, sym->name);
1066           else
1067             werror (E_DUPLICATE, sym->name);
1068           werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1069           #if 0
1070           fprintf (stderr, "from type '");
1071           printTypeChain (csym->type, stderr);
1072           if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1073             fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1074           fprintf (stderr, "'\nto type '");
1075           printTypeChain (sym->type, stderr);
1076           if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1077             fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1078           fprintf (stderr, "'\n");
1079           #endif
1080           continue;
1081         }
1082
1083         if (csym->ival && !sym->ival)
1084           sym->ival = csym->ival;
1085
1086         /* delete current entry */
1087         deleteSym (SymbolTab, csym, csym->name);
1088         deleteFromSeg(csym);
1089       }
1090
1091       /* add new entry */
1092       addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1093     }
1094 }
1095
1096
1097 /*------------------------------------------------------------------*/
1098 /* funcInChain - DCL Type 'FUNCTION' found in type chain            */
1099 /*------------------------------------------------------------------*/
1100 int
1101 funcInChain (sym_link * lnk)
1102 {
1103   while (lnk)
1104     {
1105       if (IS_FUNC (lnk))
1106         return 1;
1107       lnk = lnk->next;
1108     }
1109   return 0;
1110 }
1111
1112 /*------------------------------------------------------------------*/
1113 /* structElemType - returns the type info of a struct member        */
1114 /*------------------------------------------------------------------*/
1115 sym_link *
1116 structElemType (sym_link * stype, value * id)
1117 {
1118   symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1119   sym_link *type, *etype;
1120   sym_link *petype = getSpec (stype);
1121
1122   if (fields && id) {
1123
1124     /* look for the id */
1125     while (fields)
1126       {
1127         if (strcmp (fields->rname, id->name) == 0)
1128           {
1129             type = copyLinkChain (fields->type);
1130             etype = getSpec (type);
1131             SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1132                                  SPEC_SCLS (etype) : SPEC_SCLS (petype));
1133             if (IS_SPEC (type))
1134               SPEC_CONST (type) |= SPEC_CONST (stype);
1135             else
1136               DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1137             return type;
1138           }
1139         fields = fields->next;
1140       }
1141   }
1142
1143   werror (E_NOT_MEMBER, id->name);
1144
1145   // the show must go on
1146   return newIntLink();
1147 }
1148
1149 /*------------------------------------------------------------------*/
1150 /* getStructElement - returns element of a tructure definition      */
1151 /*------------------------------------------------------------------*/
1152 symbol *
1153 getStructElement (structdef * sdef, symbol * sym)
1154 {
1155   symbol *field;
1156
1157   for (field = sdef->fields; field; field = field->next)
1158     if (strcmp (field->name, sym->name) == 0)
1159       return field;
1160
1161   werror (E_NOT_MEMBER, sym->name);
1162
1163   return sdef->fields;
1164 }
1165
1166 /*------------------------------------------------------------------*/
1167 /* compStructSize - computes the size of a structure                */
1168 /*------------------------------------------------------------------*/
1169 int
1170 compStructSize (int su, structdef * sdef)
1171 {
1172     int sum = 0, usum = 0;
1173     int bitOffset = 0;
1174     symbol *loop;
1175
1176     /* for the identifiers  */
1177     loop = sdef->fields;
1178     while (loop) {
1179
1180         /* create the internal name for this variable */
1181         SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1182         if (su == UNION) {
1183             sum = 0;
1184             bitOffset = 0;
1185         }
1186         SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1187
1188         /* if this is a bit field  */
1189         if (loop->bitVar) {
1190
1191             /* change it to a unsigned bit */
1192             SPEC_NOUN (loop->etype) = V_BITFIELD;
1193             SPEC_USIGN (loop->etype) = 1;
1194             SPEC_BLEN (loop->etype) = loop->bitVar;
1195
1196             if (loop->bitVar == BITVAR_PAD) {
1197                 /* A zero length bitfield forces padding */
1198                 SPEC_BSTR (loop->etype) = bitOffset;
1199                 SPEC_BLEN (loop->etype) = 0;
1200                 bitOffset = 8;
1201                 loop->offset = sum;
1202             }
1203             else {
1204                 if (bitOffset == 8) {
1205                     bitOffset = 0;
1206                     sum++;
1207                 }
1208                 /* check if this fit into the remaining   */
1209                 /* bits of this byte else align it to the */
1210                 /* next byte boundary                     */
1211                 if (loop->bitVar <= (8 - bitOffset)) {
1212                     /* fits into current byte */
1213                     loop->offset = sum;
1214                     SPEC_BSTR (loop->etype) = bitOffset;
1215                     bitOffset += loop->bitVar;
1216                 }
1217                 else if (!bitOffset) {
1218                     /* does not fit, but is already byte aligned */
1219                     loop->offset = sum;
1220                     SPEC_BSTR (loop->etype) = bitOffset;
1221                     bitOffset += loop->bitVar;
1222                 }
1223                 else {
1224                     /* does not fit; need to realign first */
1225                     sum++;
1226                     loop->offset = (su == UNION ? sum = 0 : sum);
1227                     bitOffset = 0;
1228                     SPEC_BSTR (loop->etype) = bitOffset;
1229                     bitOffset += loop->bitVar;
1230                 }
1231                 while (bitOffset>8) {
1232                     bitOffset -= 8;
1233                     sum++;
1234                 }
1235             }
1236         }
1237         else {
1238             /* This is a non-bit field. Make sure we are */
1239             /* byte aligned first */
1240             if (bitOffset) {
1241                 sum++;
1242                 loop->offset = (su == UNION ? sum = 0 : sum);
1243                 bitOffset = 0;
1244             }
1245             loop->offset = sum;
1246             checkDecl (loop, 1);
1247             sum += getSize (loop->type);
1248         }
1249
1250         loop = loop->next;
1251
1252         /* if union then size = sizeof larget field */
1253         if (su == UNION) {
1254             /* For UNION, round up after each field */
1255             sum += ((bitOffset+7)/8);
1256             usum = max (usum, sum);
1257         }
1258
1259     }
1260
1261     /* For STRUCT, round up after all fields processed */
1262     if (su != UNION)
1263         sum += ((bitOffset+7)/8);
1264
1265     return (su == UNION ? usum : sum);
1266 }
1267
1268 /*-------------------------------------------------------------------*/
1269 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1270 /*                      an enclosing struct/union                    */
1271 /*-------------------------------------------------------------------*/
1272 void
1273 promoteAnonStructs (int su, structdef * sdef)
1274 {
1275   symbol *field;
1276   symbol *subfield;
1277   symbol **tofield;
1278   symbol *nextfield;
1279   symbol *dupfield;
1280   int base;
1281
1282   tofield = &sdef->fields;
1283   field = sdef->fields;
1284   while (field)
1285     {
1286       nextfield = field->next;
1287       if (!*field->name && IS_STRUCT (field->type))
1288         {
1289           /* Found an anonymous struct/union. Replace it */
1290           /* with the fields it contains and adjust all  */
1291           /* the offsets */
1292
1293           base = field->offset;
1294           subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1295           if (!subfield)
1296             continue;           /* just in case it's empty */
1297
1298           *tofield = subfield;
1299           for (;;)
1300             {
1301               /* check for field name conflicts resulting from promotion */
1302               dupfield = sdef->fields;
1303               while (dupfield && dupfield != subfield)
1304                 {
1305                   if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1306                     {
1307                       werrorfl (subfield->fileDef, subfield->lineDef,
1308                                 E_DUPLICATE_MEMBER,
1309                                 su==STRUCT ? "struct" : "union",
1310                                 subfield->name);
1311                       werrorfl (dupfield->fileDef, dupfield->lineDef,
1312                                 E_PREVIOUS_DEF);
1313                     }
1314                   dupfield = dupfield->next;
1315                 }
1316
1317               subfield->offset += base;
1318               if (subfield->next)
1319                 subfield = subfield->next;
1320               else
1321                 break;
1322             }
1323           subfield->next = nextfield;
1324           tofield = &subfield->next;
1325         }
1326       else
1327         tofield = &field->next;
1328       field = nextfield;
1329     }
1330 }
1331
1332
1333 /*------------------------------------------------------------------*/
1334 /* checkSClass - check the storage class specification              */
1335 /*------------------------------------------------------------------*/
1336 static void
1337 checkSClass (symbol * sym, int isProto)
1338 {
1339   sym_link *t;
1340
1341   if (getenv("DEBUG_SANITY")) {
1342     fprintf (stderr, "checkSClass: %s \n", sym->name);
1343   }
1344
1345   /* type is literal can happen for enums change
1346      to auto */
1347   if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1348     SPEC_SCLS (sym->etype) = S_AUTO;
1349
1350   /* if sfr or sbit then must also be volatile */
1351   if (SPEC_SCLS (sym->etype) == S_SBIT ||
1352       SPEC_SCLS (sym->etype) == S_SFR)
1353     {
1354       SPEC_VOLATILE (sym->etype) = 1;
1355     }
1356
1357   /* if absolute address given then it mark it as
1358      volatile -- except in the PIC port */
1359
1360 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1361   /* The PIC port uses a different peep hole optimizer based on "pCode" */
1362   if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1363 #endif
1364
1365     if (IS_ABSOLUTE (sym->etype))
1366       SPEC_VOLATILE (sym->etype) = 1;
1367
1368   /* If code memory is read only, then pointers to code memory */
1369   /* implicitly point to constants -- make this explicit       */
1370   t = sym->type;
1371   while (t && t->next) {
1372     if (IS_CODEPTR(t) && port->mem.code_ro) {
1373       if (IS_SPEC(t->next)) {
1374         SPEC_CONST (t->next) = 1;
1375       } else {
1376         DCL_PTR_CONST (t->next) = 1;
1377       }
1378     }
1379     t = t->next;
1380   }
1381
1382   /* global variables declared const put into code */
1383   /* if no other storage class specified */
1384   if (sym->level == 0 &&
1385       SPEC_SCLS(sym->etype) == S_FIXED &&
1386       !IS_FUNC(sym->type)) {
1387     /* find the first non-array link */
1388     t = sym->type;
1389     while (IS_ARRAY(t))
1390       t = t->next;
1391     if (IS_CONSTANT (t)) {
1392       SPEC_SCLS (sym->etype) = S_CODE;
1393     }
1394   }
1395
1396   /* global variable in code space is a constant */
1397   if (sym->level == 0 &&
1398       SPEC_SCLS (sym->etype) == S_CODE &&
1399       port->mem.code_ro) {
1400     /* find the first non-array link */
1401     t = sym->type;
1402     while (IS_ARRAY(t))
1403       t = t->next;
1404     if (IS_SPEC(t)) {
1405       SPEC_CONST (t) = 1;
1406     } else {
1407       DCL_PTR_CONST (t) = 1;
1408     }
1409   }
1410
1411   /* if bit variable then no storage class can be */
1412   /* specified since bit is already a storage */
1413   if (IS_BITVAR (sym->etype) &&
1414       (SPEC_SCLS (sym->etype) != S_FIXED &&
1415        SPEC_SCLS (sym->etype) != S_SBIT &&
1416        SPEC_SCLS (sym->etype) != S_BIT)
1417     )
1418     {
1419       werror (E_BITVAR_STORAGE, sym->name);
1420       SPEC_SCLS (sym->etype) = S_FIXED;
1421     }
1422
1423   /* extern variables cannot be initialized */
1424   if (IS_EXTERN (sym->etype) && sym->ival)
1425     {
1426       werror (E_EXTERN_INIT, sym->name);
1427       sym->ival = NULL;
1428     }
1429
1430   /* if this is an automatic symbol */
1431   if (sym->level && (options.stackAuto || reentrant)) {
1432     if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1433          SPEC_SCLS (sym->etype) == S_FIXED ||
1434          SPEC_SCLS (sym->etype) == S_REGISTER ||
1435          SPEC_SCLS (sym->etype) == S_STACK ||
1436          SPEC_SCLS (sym->etype) == S_XSTACK)) {
1437       SPEC_SCLS (sym->etype) = S_AUTO;
1438     } else {
1439       /* storage class may only be specified for statics */
1440       if (!IS_STATIC(sym->etype)) {
1441         werror (E_AUTO_ASSUMED, sym->name);
1442       }
1443     }
1444   }
1445
1446   /* automatic symbols cannot be given   */
1447   /* an absolute address ignore it      */
1448   if (sym->level &&
1449       SPEC_ABSA (sym->etype) &&
1450       (options.stackAuto || reentrant))
1451     {
1452       werror (E_AUTO_ABSA, sym->name);
1453       SPEC_ABSA (sym->etype) = 0;
1454     }
1455
1456   /* arrays & pointers cannot be defined for bits   */
1457   /* SBITS or SFRs or BIT                           */
1458   if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1459       (SPEC_NOUN (sym->etype) == V_BIT ||
1460        SPEC_NOUN (sym->etype) == V_SBIT ||
1461        SPEC_NOUN (sym->etype) == V_BITFIELD ||
1462        SPEC_SCLS (sym->etype) == S_SFR))
1463     werror (E_BIT_ARRAY, sym->name);
1464
1465   /* if this is a bit|sbit then set length & start  */
1466   if (SPEC_NOUN (sym->etype) == V_BIT ||
1467       SPEC_NOUN (sym->etype) == V_SBIT)
1468     {
1469       SPEC_BLEN (sym->etype) = 1;
1470       SPEC_BSTR (sym->etype) = 0;
1471     }
1472
1473   if (!isProto) {
1474     /* variables declared in CODE space must have */
1475     /* initializers if not an extern */
1476     if (SPEC_SCLS (sym->etype) == S_CODE &&
1477         sym->ival == NULL &&
1478         !sym->_isparm &&
1479         //!sym->level &&
1480         port->mem.code_ro &&
1481         !IS_EXTERN (sym->etype) &&
1482         !funcInChain (sym->type))
1483       werror (E_CODE_NO_INIT, sym->name);
1484   }
1485
1486   /* if parameter or local variable then change */
1487   /* the storage class to reflect where the var will go */
1488   if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1489       !IS_STATIC(sym->etype))
1490     {
1491       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1492         {
1493           SPEC_SCLS (sym->etype) = (options.useXstack ?
1494                                     S_XSTACK : S_STACK);
1495         }
1496       else
1497         {
1498           /* hack-o-matic! I see no reason why the useXstack option should ever
1499            * control this allcoation, but the code was originally that way, and
1500            * changing it for non-390 ports breaks the compiler badly.
1501            */
1502           bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1503                 1 : options.useXstack;
1504           SPEC_SCLS (sym->etype) = (useXdata ?
1505                                     S_XDATA : S_FIXED);
1506         }
1507     }
1508 }
1509
1510 /*------------------------------------------------------------------*/
1511 /* changePointer - change pointer to functions                      */
1512 /*------------------------------------------------------------------*/
1513 void
1514 changePointer (symbol * sym)
1515 {
1516   sym_link *p;
1517
1518   /* go thru the chain of declarations   */
1519   /* if we find a pointer to a function  */
1520   /* unconditionally change it to a ptr  */
1521   /* to code area                        */
1522   for (p = sym->type; p; p = p->next)
1523     {
1524       if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1525         DCL_TYPE (p) = port->unqualified_pointer;
1526       if (IS_PTR (p) && IS_FUNC (p->next))
1527         DCL_TYPE (p) = CPOINTER;
1528     }
1529 }
1530
1531 /*------------------------------------------------------------------*/
1532 /* checkDecl - does semantic validation of a declaration                   */
1533 /*------------------------------------------------------------------*/
1534 int
1535 checkDecl (symbol * sym, int isProto)
1536 {
1537
1538   checkSClass (sym, isProto);           /* check the storage class      */
1539   changePointer (sym);          /* change pointers if required */
1540
1541   /* if this is an array without any dimension
1542      then update the dimension from the initial value */
1543   if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1544     DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1545
1546   return 0;
1547 }
1548
1549 /*------------------------------------------------------------------*/
1550 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1551 /*------------------------------------------------------------------*/
1552 sym_link *
1553 copyLinkChain (sym_link * p)
1554 {
1555   sym_link *head, *curr, *loop;
1556
1557   curr = p;
1558   head = loop = (curr ? newLink (p->class) : (void *) NULL);
1559   while (curr)
1560     {
1561       memcpy (loop, curr, sizeof (sym_link));   /* copy it */
1562       loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1563       loop = loop->next;
1564       curr = curr->next;
1565     }
1566
1567   return head;
1568 }
1569
1570
1571 /*------------------------------------------------------------------*/
1572 /* cleanUpBlock - cleansup the symbol table specified for all the   */
1573 /*                symbols in the given block                        */
1574 /*------------------------------------------------------------------*/
1575 void
1576 cleanUpBlock (bucket ** table, int block)
1577 {
1578   int i;
1579   bucket *chain;
1580
1581   /* go thru the entire  table  */
1582   for (i = 0; i < 256; i++)
1583     {
1584       for (chain = table[i]; chain; chain = chain->next)
1585         {
1586           if (chain->block >= block)
1587             {
1588               deleteSym (table, chain->sym, chain->name);
1589             }
1590         }
1591     }
1592 }
1593
1594 /*------------------------------------------------------------------*/
1595 /* cleanUpLevel - cleansup the symbol table specified for all the   */
1596 /*                symbols in the given level                        */
1597 /*------------------------------------------------------------------*/
1598 void
1599 cleanUpLevel (bucket ** table, int level)
1600 {
1601   int i;
1602   bucket *chain;
1603
1604   /* go thru the entire  table  */
1605   for (i = 0; i < 256; i++)
1606     {
1607       for (chain = table[i]; chain; chain = chain->next)
1608         {
1609           if (chain->level >= level)
1610             {
1611               deleteSym (table, chain->sym, chain->name);
1612             }
1613         }
1614     }
1615 }
1616
1617 /*------------------------------------------------------------------*/
1618 /* computeTypeOr - computes the resultant type from two types       */
1619 /*------------------------------------------------------------------*/
1620 static sym_link *
1621 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1622 {
1623   /* sanity check */
1624   assert (   (IS_CHAR (etype1) || IS_BIT (etype1))
1625           && (IS_CHAR (etype2) || IS_BIT (etype2)));
1626
1627   if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1628     {
1629       SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1630       return reType;
1631     }
1632
1633   if (SPEC_USIGN (etype1))
1634     {
1635       if (   IS_LITERAL (etype2)
1636           && floatFromVal (valFromType (etype2)) >= 0)
1637         SPEC_USIGN (reType) = 1;
1638       else
1639         {
1640           /* promote to int */
1641           SPEC_USIGN (reType) = 0;
1642           SPEC_NOUN (reType) = V_INT;
1643         }
1644     }
1645   else /* etype1 signed */
1646     {
1647       if (   IS_LITERAL (etype2)
1648           && floatFromVal (valFromType (etype2)) <= 127)
1649         SPEC_USIGN (reType) = 0;
1650       else
1651         {
1652           /* promote to int */
1653           SPEC_USIGN (reType) = 0;
1654           SPEC_NOUN (reType) = V_INT;
1655         }
1656     }
1657
1658   if (SPEC_USIGN (etype2))
1659     {
1660       if (   IS_LITERAL (etype1)
1661           && floatFromVal (valFromType (etype1)) >= 0)
1662         SPEC_USIGN (reType) = 1;
1663       else
1664         {
1665           /* promote to int */
1666           SPEC_USIGN (reType) = 0;
1667           SPEC_NOUN (reType) = V_INT;
1668         }
1669     }
1670   else /* etype2 signed */
1671     {
1672       if (   IS_LITERAL (etype1)
1673           && floatFromVal (valFromType (etype1)) <= 127)
1674         SPEC_USIGN (reType) = 0;
1675       else
1676         {
1677           /* promote to int */
1678           SPEC_USIGN (reType) = 0;
1679           SPEC_NOUN (reType) = V_INT;
1680         }
1681     }
1682   return reType;
1683 }
1684
1685 /*------------------------------------------------------------------*/
1686 /* computeType - computes the resultant type from two types         */
1687 /*------------------------------------------------------------------*/
1688 sym_link *
1689 computeType (sym_link * type1, sym_link * type2,
1690              RESULT_TYPE resultType, int op)
1691 {
1692   sym_link *rType;
1693   sym_link *reType;
1694   sym_link *etype1 = getSpec (type1);
1695   sym_link *etype2;
1696
1697   etype2 = type2 ? getSpec (type2) : type1;
1698
1699   /* if one of them is a float then result is a float */
1700   /* here we assume that the types passed are okay */
1701   /* and can be cast to one another                */
1702   /* which ever is greater in size */
1703   if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1704     rType = newFloatLink ();
1705   else
1706     /* if both are bitvars choose the larger one */
1707   if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1708     {
1709       rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1710                 copyLinkChain (type1) : copyLinkChain (type1);
1711     }
1712     /* if only one of them is a bit variable
1713        then the other one prevails */
1714   else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1715     {
1716       rType = copyLinkChain (type2);
1717       /* bitfield can have up to 16 bits */
1718       if (getSize (etype1) > 1)
1719         SPEC_NOUN (getSpec (rType)) = V_INT;
1720     }
1721   else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1722     {
1723       rType = copyLinkChain (type1);
1724       /* bitfield can have up to 16 bits */
1725       if (getSize (etype2) > 1)
1726         SPEC_NOUN (getSpec (rType)) = V_INT;
1727     }
1728   else
1729     /* if one of them is a pointer or array then that
1730        prevails */
1731   if (IS_PTR (type1) || IS_ARRAY (type1))
1732     rType = copyLinkChain (type1);
1733   else if (IS_PTR (type2) || IS_ARRAY (type2))
1734     rType = copyLinkChain (type2);
1735   else if (getSize (type1) > getSize (type2))
1736     rType = copyLinkChain (type1);
1737   else
1738     rType = copyLinkChain (type2);
1739
1740   reType = getSpec (rType);
1741
1742   /* avoid conflicting types */
1743   reType->select.s._signed = 0;
1744
1745   /* if result is a literal then make not so */
1746   if (IS_LITERAL (reType))
1747     SPEC_SCLS (reType) = S_REGISTER;
1748
1749   switch (resultType)
1750     {
1751       case RESULT_TYPE_CHAR:
1752         if (IS_BITVAR (reType))
1753           {
1754             SPEC_NOUN (reType) = V_CHAR;
1755             SPEC_SCLS (reType) = 0;
1756             SPEC_USIGN (reType) = 0;
1757             return rType;
1758           }
1759         break;
1760       case RESULT_TYPE_INT:
1761       case RESULT_TYPE_NONE:
1762       case RESULT_TYPE_OTHER:
1763         if (IS_BIT (reType))
1764           {
1765             SPEC_NOUN (reType) = V_CHAR;
1766             SPEC_SCLS (reType) = 0;
1767             SPEC_USIGN (reType) = 0;
1768             return rType;
1769           }
1770         else if (IS_BITFIELD (reType))
1771           {
1772             /* could be smarter, but it depends on the op */
1773             /* this is for the worst case: a multiplication of 4 * 4 bit */
1774             SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1775             SPEC_SCLS (reType) = 0;
1776             SPEC_USIGN (reType) = 0;
1777             return rType;
1778           }
1779         else if (IS_CHAR (reType))
1780           {
1781             if (op == '|' || op == '^')
1782               return computeTypeOr (etype1, etype2, reType);
1783             else if (   op == '&'
1784                      && SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1785               {
1786                 SPEC_USIGN (reType) = 1;
1787                 return rType;
1788               }
1789             else if (op == '*')
1790               {
1791                 SPEC_NOUN (reType) = V_INT;
1792                 SPEC_USIGN (reType) = 0;
1793                 return rType;
1794               }
1795             /* TODO: should be in SDCCast.c */
1796             else if (   op == '/'
1797                      && (   !SPEC_USIGN (etype1)
1798                          || !SPEC_USIGN (etype2)))
1799               {
1800                 SPEC_NOUN (reType) = V_INT;
1801                 SPEC_USIGN (reType) = 0;
1802                 return rType;
1803               }
1804           }
1805         break;
1806       default:
1807         break;
1808     }
1809
1810   /* SDCC's sign promotion:
1811      - if one or both operands are unsigned, the resultant type will be unsigned
1812        (except char, see below)
1813      - if an operand is promoted to a larger type (char -> int, int -> long),
1814        the larger type will be signed
1815
1816      SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1817      much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1818      the standard. The standard demands, that the result has to be the same
1819      "as if" the promotion would have been performed:
1820
1821      - if the result of an operation with two char's is promoted to a
1822        larger type, the result will be signed.
1823
1824      More sophisticated are these:
1825      - if the result of an operation with two char's is a char again,
1826        the result will only then be unsigned, if both operands are
1827        unsigned. In all other cases the result will be signed.
1828
1829        This seems to be contradictionary to the first two rules, but it makes
1830        real sense (all types are char's):
1831
1832         A signed char can be negative; this must be preserved in the result
1833                 -1 * 100 = -100;
1834
1835         Only if both operands are unsigned it's safe to make the result
1836         unsigned; this helps to avoid overflow:
1837                 2 * 100 =  200;
1838
1839      - ToDo: document '|', '^' and '&'
1840
1841      Homework: - why is (200 * 200 < 0) true?
1842                - why is { char l = 200, r = 200; (r * l > 0) } true?
1843   */
1844
1845   if (!IS_FLOAT (reType)
1846       && (   (SPEC_USIGN (etype1)
1847               /* if this operand is promoted to a larger type,
1848                  then it will be promoted to a signed type */
1849               && !(getSize (etype1) < getSize (reType))
1850               /* char require special handling */
1851               && !IS_CHAR (etype1))
1852           || /* same for 2nd operand */
1853              (SPEC_USIGN (etype2)
1854               && !(getSize (etype2) < getSize (reType))
1855               && !IS_CHAR (etype2))
1856           || /* if both are 'unsigned char' and not promoted
1857                 let the result be unsigned too */
1858              (   SPEC_USIGN (etype1)
1859               && SPEC_USIGN (etype2)
1860               && IS_CHAR (etype1)
1861               && IS_CHAR (etype2)
1862               && IS_CHAR (reType))))
1863     SPEC_USIGN (reType) = 1;
1864   else
1865     SPEC_USIGN (reType) = 0;
1866
1867   return rType;
1868 }
1869
1870 /*--------------------------------------------------------------------*/
1871 /* compareType - will do type check return 1 if match, -1 if castable */
1872 /*--------------------------------------------------------------------*/
1873 int
1874 compareType (sym_link * dest, sym_link * src)
1875 {
1876   if (!dest && !src)
1877     return 1;
1878
1879   if (dest && !src)
1880     return 0;
1881
1882   if (src && !dest)
1883     return 0;
1884
1885   /* if dest is a declarator then */
1886   if (IS_DECL (dest))
1887     {
1888       if (IS_DECL (src))
1889         {
1890           if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1891             if (IS_FUNC(src)) {
1892               //checkFunction(src,dest);
1893             }
1894             return compareType (dest->next, src->next);
1895           }
1896           if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1897             return 1;
1898           }
1899           if (IS_PTR (src) && IS_GENPTR (dest))
1900             return -1;
1901           if (IS_PTR (dest) && IS_ARRAY (src)) {
1902             value *val=aggregateToPointer (valFromType(src));
1903             int res=compareType (dest, val->type);
1904             Safe_free(val->type);
1905             Safe_free(val);
1906             return res;
1907           }
1908           if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1909             return compareType (dest->next, src);
1910           return 0;
1911         }
1912       else if (IS_PTR (dest) && IS_INTEGRAL (src))
1913         return -1;
1914       else
1915         return 0;
1916     }
1917
1918   /* if one is a specifier and the other is not */
1919   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1920       (IS_SPEC (dest) && !IS_SPEC (src)))
1921     return 0;
1922
1923   /* if one of them is a void then ok */
1924   if (SPEC_NOUN (dest) == V_VOID &&
1925       SPEC_NOUN (src) != V_VOID)
1926     return -1;
1927
1928   if (SPEC_NOUN (dest) != V_VOID &&
1929       SPEC_NOUN (src) == V_VOID)
1930     return -1;
1931
1932   /* if they are both bitfields then if the lengths
1933      and starts don't match */
1934   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1935       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1936        SPEC_BSTR (dest) != SPEC_BSTR (src)))
1937     return -1;
1938
1939   /* it is a specifier */
1940   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1941     {
1942       if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1943           IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1944           /* I would prefer
1945           bitsForType (dest) == bitsForType (src))
1946              instead of the next two lines, but the regression tests fail with
1947              them; I guess it's a problem with replaceCheaperOp  */
1948           getSize (dest) == getSize (src) &&
1949           !(!IS_BIT (dest) && IS_BIT (src)))
1950         return 1;
1951       else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1952         return -1;
1953       else
1954         return 0;
1955     }
1956   else if (IS_STRUCT (dest))
1957     {
1958       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1959         return 0;
1960       else
1961         return 1;
1962     }
1963   if (SPEC_LONG (dest) != SPEC_LONG (src))
1964     return -1;
1965
1966   if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1967     return -1;
1968
1969   return 1;
1970 }
1971
1972 /*--------------------------------------------------------------------*/
1973 /* compareTypeExact - will do type check return 1 if match exactly    */
1974 /*--------------------------------------------------------------------*/
1975 int
1976 compareTypeExact (sym_link * dest, sym_link * src, int level)
1977 {
1978   STORAGE_CLASS srcScls, destScls;
1979
1980   if (!dest && !src)
1981     return 1;
1982
1983   if (dest && !src)
1984     return 0;
1985
1986   if (src && !dest)
1987     return 0;
1988
1989   /* if dest is a declarator then */
1990   if (IS_DECL (dest))
1991     {
1992       if (IS_DECL (src))
1993         {
1994           if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1995             if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
1996               return 0;
1997             if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
1998               return 0;
1999             if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2000               return 0;
2001             if (IS_FUNC(src))
2002               {
2003                 value *exargs, *acargs, *checkValue;
2004
2005                 /* verify function return type */
2006                 if (!compareTypeExact (dest->next, src->next, -1))
2007                   return 0;
2008                 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2009                   return 0;
2010                 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2011                   return 0;
2012                 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2013                   return 0;
2014                 #if 0
2015                 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2016                   return 0;
2017                 #endif
2018
2019                 /* compare expected args with actual args */
2020                 exargs = FUNC_ARGS(dest);
2021                 acargs = FUNC_ARGS(src);
2022
2023                 /* for all the expected args do */
2024                 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2025                   {
2026                     //checkTypeSanity(acargs->etype, acargs->name);
2027
2028                     if (IS_AGGREGATE (acargs->type))
2029                       {
2030                         checkValue = copyValue (acargs);
2031                         aggregateToPointer (checkValue);
2032                       }
2033                     else
2034                       checkValue = acargs;
2035
2036                     #if 0
2037                     if (!compareTypeExact (exargs->type, checkValue->type, -1))
2038                       return 0;
2039                     #endif
2040                   }
2041
2042                   /* if one them ended we have a problem */
2043                   if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2044                       (!exargs && acargs && !IS_VOID (acargs->type)))
2045                     return 0;
2046                   return 1;
2047               }
2048             return compareTypeExact (dest->next, src->next, level);
2049           }
2050           return 0;
2051         }
2052       return 0;
2053     }
2054
2055   /* if one is a specifier and the other is not */
2056   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2057       (IS_SPEC (dest) && !IS_SPEC (src)))
2058     return 0;
2059
2060   /* if one of them is a void then ok */
2061   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2062     return 0;
2063
2064   /* if they are both bitfields then if the lengths
2065      and starts don't match */
2066   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2067       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2068        SPEC_BSTR (dest) != SPEC_BSTR (src)))
2069     return 0;
2070
2071   if (IS_INTEGRAL (dest))
2072     {
2073       /* signedness must match */
2074       if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2075         return 0;
2076       /* size must match */
2077       if (SPEC_LONG (dest) != SPEC_LONG (src))
2078         return 0;
2079       if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2080         return 0;
2081     }
2082
2083   if (IS_STRUCT (dest))
2084     {
2085       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2086         return 0;
2087     }
2088
2089   if (SPEC_CONST (dest) != SPEC_CONST (src))
2090     return 0;
2091   if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2092     return 0;
2093   if (SPEC_STAT (dest) != SPEC_STAT (src))
2094     return 0;
2095   if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2096     return 0;
2097   if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2098     return 0;
2099
2100   destScls = SPEC_SCLS (dest);
2101   srcScls = SPEC_SCLS (src);
2102
2103   /* Compensate for const to const code change in checkSClass() */
2104   if (!level & port->mem.code_ro && SPEC_CONST (dest))
2105     {
2106       if (srcScls == S_CODE && destScls == S_FIXED)
2107         destScls = S_CODE;
2108       if (destScls == S_CODE && srcScls == S_FIXED)
2109         srcScls = S_CODE;
2110     }
2111
2112   /* compensate for allocGlobal() */
2113   if ((srcScls == S_FIXED || srcScls == S_AUTO)
2114       && port->mem.default_globl_map == xdata
2115       && !level)
2116     srcScls = S_XDATA;
2117
2118   if (level>0 && !SPEC_STAT (dest))
2119     {
2120       /* Compensate for hack-o-matic in checkSClass() */
2121       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2122         {
2123           if (destScls == S_FIXED)
2124             destScls = (options.useXstack ? S_XSTACK : S_STACK);
2125           if (srcScls == S_FIXED)
2126             srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2127         }
2128       else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2129         {
2130           if (destScls == S_FIXED)
2131             destScls = S_XDATA;
2132           if (srcScls == S_FIXED)
2133             srcScls = S_XDATA;
2134         }
2135     }
2136
2137   if (srcScls != destScls)
2138     {
2139       #if 0
2140       printf ("level = %d\n", level);
2141       printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2142                 SPEC_SCLS (src), SPEC_SCLS (dest));
2143       printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2144       #endif
2145       return 0;
2146     }
2147
2148   return 1;
2149 }
2150
2151 /*------------------------------------------------------------------*/
2152 /* inCalleeSaveList - return 1 if found in callee save list          */
2153 /*------------------------------------------------------------------*/
2154 static int
2155 calleeCmp(void *p1, void *p2)
2156 {
2157   return (strcmp((char *)p1, (char *)(p2)) == 0);
2158 }
2159
2160 bool
2161 inCalleeSaveList(char *s)
2162 {
2163   if (options.all_callee_saves)
2164     return 1;
2165   return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2166 }
2167
2168 /*-----------------------------------------------------------------*/
2169 /* aggregateToPointer:  change an agggregate type function      */
2170 /*         argument to a pointer to that type.     */
2171 /*-----------------------------------------------------------------*/
2172 value *
2173 aggregateToPointer (value * val)
2174 {
2175   if (IS_AGGREGATE (val->type))
2176     {
2177       /* if this is a structure */
2178       /* then we need to add a new link */
2179       if (IS_STRUCT (val->type))
2180         {
2181           /* first lets add DECLARATOR type */
2182           sym_link *p = val->type;
2183
2184           werror (W_STRUCT_AS_ARG, val->name);
2185           val->type = newLink (DECLARATOR);
2186           val->type->next = p;
2187         }
2188
2189       /* change to a pointer depending on the */
2190       /* storage class specified        */
2191       switch (SPEC_SCLS (val->etype))
2192         {
2193         case S_IDATA:
2194           DCL_TYPE (val->type) = IPOINTER;
2195           break;
2196         case S_PDATA:
2197           DCL_TYPE (val->type) = PPOINTER;
2198           break;
2199         case S_FIXED:
2200           if (SPEC_OCLS(val->etype)) {
2201             DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2202           } else {
2203             // this happens for (external) function parameters
2204             DCL_TYPE (val->type) = port->unqualified_pointer;
2205           }
2206           break;
2207         case S_AUTO:
2208         case S_DATA:
2209         case S_REGISTER:
2210           DCL_TYPE (val->type) = POINTER;
2211           break;
2212         case S_CODE:
2213           DCL_TYPE (val->type) = CPOINTER;
2214           break;
2215         case S_XDATA:
2216           DCL_TYPE (val->type) = FPOINTER;
2217           break;
2218         case S_EEPROM:
2219           DCL_TYPE (val->type) = EEPPOINTER;
2220           break;
2221         default:
2222           DCL_TYPE (val->type) = port->unqualified_pointer;
2223         }
2224
2225       /* is there is a symbol associated then */
2226       /* change the type of the symbol as well */
2227       if (val->sym)
2228         {
2229           val->sym->type = copyLinkChain (val->type);
2230           val->sym->etype = getSpec (val->sym->type);
2231         }
2232     }
2233   return val;
2234 }
2235 /*------------------------------------------------------------------*/
2236 /* checkFunction - does all kinds of check on a function            */
2237 /*------------------------------------------------------------------*/
2238 int
2239 checkFunction (symbol * sym, symbol *csym)
2240 {
2241   value *exargs, *acargs;
2242   value *checkValue;
2243   int argCnt = 0;
2244
2245   if (getenv("DEBUG_SANITY")) {
2246     fprintf (stderr, "checkFunction: %s ", sym->name);
2247   }
2248
2249   if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2250     {
2251       werror(E_SYNTAX_ERROR, sym->name);
2252       return 0;
2253     }
2254
2255   /* make sure the type is complete and sane */
2256   checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2257
2258   /* if not type then some kind of error */
2259   if (!sym->type)
2260     return 0;
2261
2262   /* if the function has no type then make it return int */
2263   if (!sym->type->next)
2264     sym->type->next = sym->etype = newIntLink ();
2265
2266   /* function cannot return aggregate */
2267   if (IS_AGGREGATE (sym->type->next))
2268     {
2269       werror (E_FUNC_AGGR, sym->name);
2270       return 0;
2271     }
2272
2273   /* function cannot return bit */
2274   if (IS_BITVAR (sym->type->next))
2275     {
2276       werror (E_FUNC_BIT, sym->name);
2277       return 0;
2278     }
2279
2280   /* check if this function is defined as calleeSaves
2281      then mark it as such */
2282   FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2283
2284   /* if interrupt service routine  */
2285   /* then it cannot have arguments */
2286   if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2287     {
2288       if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2289         werror (E_INT_ARGS, sym->name);
2290         FUNC_ARGS(sym->type)=NULL;
2291       }
2292     }
2293
2294   for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2295        acargs;
2296        acargs=acargs->next, argCnt++) {
2297     if (!acargs->sym) {
2298       // this can happen for reentrant functions
2299       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2300       // the show must go on: synthesize a name and symbol
2301       SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2302       acargs->sym = newSymbol (acargs->name, 1);
2303       SPEC_OCLS (acargs->etype) = istack;
2304       acargs->sym->type = copyLinkChain (acargs->type);
2305       acargs->sym->etype = getSpec (acargs->sym->type);
2306       acargs->sym->_isparm = 1;
2307       strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2308     } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2309       // synthesized name
2310       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2311     }
2312   }
2313   argCnt--;
2314
2315   if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2316     return 1;                   /* not defined nothing more to check  */
2317
2318   /* check if body already present */
2319   if (csym && IFFUNC_HASBODY(csym->type))
2320     {
2321       werror (E_FUNC_BODY, sym->name);
2322       return 0;
2323     }
2324
2325   /* check the return value type   */
2326   if (compareType (csym->type, sym->type) <= 0)
2327     {
2328       werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2329       printFromToType(csym->type, sym->type);
2330       return 0;
2331     }
2332
2333   if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2334     {
2335       werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2336     }
2337
2338   if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
2339     {
2340       werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2341     }
2342
2343   if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2344     {
2345       werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2346     }
2347
2348   /* Really, reentrant should match regardless of argCnt, but     */
2349   /* this breaks some existing code (the fp lib functions). If    */
2350   /* the first argument is always passed the same way, this       */
2351   /* lax checking is ok (but may not be true for in future ports) */
2352   if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2353       && argCnt>1)
2354     {
2355       //printf("argCnt = %d\n",argCnt);
2356       werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2357     }
2358
2359   /* compare expected args with actual args */
2360   exargs = FUNC_ARGS(csym->type);
2361   acargs = FUNC_ARGS(sym->type);
2362
2363   /* for all the expected args do */
2364   for (argCnt = 1;
2365        exargs && acargs;
2366        exargs = exargs->next, acargs = acargs->next, argCnt++)
2367     {
2368       if (getenv("DEBUG_SANITY")) {
2369         fprintf (stderr, "checkFunction: %s ", exargs->name);
2370       }
2371       /* make sure the type is complete and sane */
2372       checkTypeSanity(exargs->etype, exargs->name);
2373
2374       /* If the actual argument is an array, any prototype
2375        * will have modified it to a pointer. Duplicate that
2376        * change here.
2377        */
2378       if (IS_AGGREGATE (acargs->type))
2379         {
2380           checkValue = copyValue (acargs);
2381           aggregateToPointer (checkValue);
2382         }
2383       else
2384         {
2385           checkValue = acargs;
2386         }
2387
2388       if (compareType (exargs->type, checkValue->type) <= 0)
2389         {
2390           werror (E_ARG_TYPE, argCnt);
2391           printFromToType(exargs->type, checkValue->type);
2392           return 0;
2393         }
2394     }
2395
2396   /* if one them ended we have a problem */
2397   if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2398       (!exargs && acargs && !IS_VOID (acargs->type)))
2399     werror (E_ARG_COUNT);
2400
2401   /* replace with this defition */
2402   sym->cdef = csym->cdef;
2403   deleteSym (SymbolTab, csym, csym->name);
2404   deleteFromSeg(csym);
2405   addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2406   if (IS_EXTERN (csym->etype) && !
2407       IS_EXTERN (sym->etype))
2408     {
2409       addSet (&publics, sym);
2410     }
2411   return 1;
2412 }
2413
2414 /*------------------------------------------------------------------*/
2415 /* cdbStructBlock - calls struct printing for a blcks               */
2416 /*------------------------------------------------------------------*/
2417 void cdbStructBlock (int block)
2418 {
2419   int i;
2420   bucket **table = StructTab;
2421   bucket *chain;
2422
2423   /* go thru the entire  table  */
2424   for (i = 0; i < 256; i++)
2425     {
2426       for (chain = table[i]; chain; chain = chain->next)
2427         {
2428           if (chain->block >= block)
2429             {
2430               if(debugFile)
2431                 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2432             }
2433         }
2434     }
2435 }
2436
2437 /*-----------------------------------------------------------------*/
2438 /* processFuncArgs - does some processing with function args       */
2439 /*-----------------------------------------------------------------*/
2440 void
2441 processFuncArgs (symbol * func)
2442 {
2443   value *val;
2444   int pNum = 1;
2445   sym_link *funcType=func->type;
2446
2447   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2448     fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2449
2450   /* find the function declaration within the type */
2451   while (funcType && !IS_FUNC(funcType))
2452     funcType=funcType->next;
2453
2454   /* if this function has variable argument list */
2455   /* then make the function a reentrant one    */
2456   if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2457     FUNC_ISREENT(funcType)=1;
2458
2459   /* check if this function is defined as calleeSaves
2460      then mark it as such */
2461   FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2462
2463   /* loop thru all the arguments   */
2464   val = FUNC_ARGS(funcType);
2465
2466   /* if it is void then remove parameters */
2467   if (val && IS_VOID (val->type))
2468     {
2469       FUNC_ARGS(funcType) = NULL;
2470       return;
2471     }
2472
2473   /* reset regparm for the port */
2474   (*port->reset_regparms) ();
2475   /* if any of the arguments is an aggregate */
2476   /* change it to pointer to the same type */
2477   while (val)
2478     {
2479         int argreg = 0;
2480       /* mark it as a register parameter if
2481          the function does not have VA_ARG
2482          and as port dictates */
2483       if (!IFFUNC_HASVARARGS(funcType) &&
2484           (argreg = (*port->reg_parm) (val->type)))
2485         {
2486           SPEC_REGPARM (val->etype) = 1;
2487           SPEC_ARGREG(val->etype) = argreg;
2488         } else if (IFFUNC_ISREENT(funcType)) {
2489             FUNC_HASSTACKPARM(funcType) = 1;
2490         }
2491
2492       if (IS_AGGREGATE (val->type))
2493         {
2494           aggregateToPointer (val);
2495         }
2496
2497       val = val->next;
2498       pNum++;
2499     }
2500
2501   /* if this is an internal generated function call */
2502   if (func->cdef) {
2503     /* ignore --stack-auto for this one, we don't know how it is compiled */
2504     /* simply trust on --int-long-reent or --float-reent */
2505     if (IFFUNC_ISREENT(funcType)) {
2506       return;
2507     }
2508   } else {
2509     /* if this function is reentrant or */
2510     /* automatics r 2b stacked then nothing */
2511     if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2512       return;
2513   }
2514
2515   val = FUNC_ARGS(funcType);
2516   pNum = 1;
2517   while (val)
2518     {
2519
2520       /* if a symbolname is not given  */
2521       /* synthesize a variable name */
2522       if (!val->sym)
2523         {
2524           SNPRINTF (val->name, sizeof(val->name),
2525                     "_%s_PARM_%d", func->name, pNum++);
2526           val->sym = newSymbol (val->name, 1);
2527           SPEC_OCLS (val->etype) = port->mem.default_local_map;
2528           val->sym->type = copyLinkChain (val->type);
2529           val->sym->etype = getSpec (val->sym->type);
2530           val->sym->_isparm = 1;
2531           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2532           #if 0
2533           /* ?? static functions shouldn't imply static parameters - EEP */
2534           if (IS_SPEC(func->etype)) {
2535             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2536               SPEC_STAT (func->etype);
2537           }
2538           #endif
2539           addSymChain (val->sym);
2540
2541         }
2542       else                      /* symbol name given create synth name */
2543         {
2544
2545           SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2546           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2547           val->sym->_isparm = 1;
2548           SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2549             (options.model != MODEL_SMALL ? xdata : data);
2550
2551           #if 0
2552           /* ?? static functions shouldn't imply static parameters - EEP */
2553           if (IS_SPEC(func->etype)) {
2554             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2555               SPEC_STAT (func->etype);
2556           }
2557           #endif
2558         }
2559       if (!isinSet(operKeyReset, val->sym)) {
2560         addSet (&operKeyReset, val->sym);
2561         applyToSet (operKeyReset, resetParmKey);
2562       }
2563       val = val->next;
2564     }
2565 }
2566
2567 /*-----------------------------------------------------------------*/
2568 /* isSymbolEqual - compares two symbols return 1 if they match     */
2569 /*-----------------------------------------------------------------*/
2570 int
2571 isSymbolEqual (symbol * dest, symbol * src)
2572 {
2573   /* if pointers match then equal */
2574   if (dest == src)
2575     return 1;
2576
2577   /* if one of them is null then don't match */
2578   if (!dest || !src)
2579     return 0;
2580
2581   /* if both of them have rname match on rname */
2582   if (dest->rname[0] && src->rname[0])
2583     return (!strcmp (dest->rname, src->rname));
2584
2585   /* otherwise match on name */
2586   return (!strcmp (dest->name, src->name));
2587 }
2588
2589 void PT(sym_link *type)
2590 {
2591         printTypeChain(type,0);
2592 }
2593 /*-----------------------------------------------------------------*/
2594 /* printTypeChain - prints the type chain in human readable form   */
2595 /*-----------------------------------------------------------------*/
2596 void
2597 printTypeChain (sym_link * start, FILE * of)
2598 {
2599   int nlr = 0;
2600   value *args;
2601   sym_link * type, * search;
2602   STORAGE_CLASS scls;
2603
2604   if (!of)
2605     {
2606       of = stdout;
2607       nlr = 1;
2608     }
2609
2610   if (start==NULL) {
2611     fprintf (of, "void");
2612     return;
2613   }
2614
2615   /* Print the chain as it is written in the source: */
2616   /* start with the last entry.                      */
2617   /* However, the storage class at the end of the    */
2618   /* chain reall applies to the first in the chain!  */
2619
2620   for (type = start; type && type->next; type = type->next)
2621     ;
2622   if (IS_SPEC (type))
2623     scls=SPEC_SCLS(type);
2624   else
2625     scls=0;
2626   while (type)
2627     {
2628       if (type==start) {
2629         switch (scls)
2630           {
2631           case S_DATA: fprintf (of, "data-"); break;
2632           case S_XDATA: fprintf (of, "xdata-"); break;
2633           case S_SFR: fprintf (of, "sfr-"); break;
2634           case S_SBIT: fprintf (of, "sbit-"); break;
2635           case S_CODE: fprintf (of, "code-"); break;
2636           case S_IDATA: fprintf (of, "idata-"); break;
2637           case S_PDATA: fprintf (of, "pdata-"); break;
2638           case S_LITERAL: fprintf (of, "literal-"); break;
2639           case S_STACK: fprintf (of, "stack-"); break;
2640           case S_XSTACK: fprintf (of, "xstack-"); break;
2641           case S_BIT: fprintf (of, "bit-"); break;
2642           case S_EEPROM: fprintf (of, "eeprom-"); break;
2643           default: break;
2644           }
2645       }
2646
2647       if (IS_DECL (type))
2648         {
2649           if (!IS_FUNC(type)) {
2650             if (DCL_PTR_VOLATILE (type)) {
2651               fprintf (of, "volatile-");
2652             }
2653             if (DCL_PTR_CONST (type)) {
2654               fprintf (of, "const-");
2655             }
2656           }
2657           switch (DCL_TYPE (type))
2658             {
2659             case FUNCTION:
2660               fprintf (of, "function %s %s",
2661                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2662                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2663               fprintf (of, "( ");
2664               for (args = FUNC_ARGS(type);
2665                    args;
2666                    args=args->next) {
2667                 printTypeChain(args->type, of);
2668                 if (args->next)
2669                   fprintf(of, ", ");
2670               }
2671               fprintf (of, ") ");
2672               break;
2673             case GPOINTER:
2674               fprintf (of, "generic* ");
2675               break;
2676             case CPOINTER:
2677               fprintf (of, "code* ");
2678               break;
2679             case FPOINTER:
2680               fprintf (of, "xdata* ");
2681               break;
2682             case EEPPOINTER:
2683               fprintf (of, "eeprom* ");
2684               break;
2685             case POINTER:
2686               fprintf (of, "near* ");
2687               break;
2688             case IPOINTER:
2689               fprintf (of, "idata* ");
2690               break;
2691             case PPOINTER:
2692               fprintf (of, "pdata* ");
2693               break;
2694             case UPOINTER:
2695               fprintf (of, "unknown* ");
2696               break;
2697             case ARRAY:
2698               if (DCL_ELEM(type)) {
2699                 fprintf (of, "[%d] ", DCL_ELEM(type));
2700               } else {
2701                 fprintf (of, "[] ");
2702               }
2703               break;
2704             }
2705         }
2706       else
2707         {
2708           if (SPEC_VOLATILE (type))
2709             fprintf (of, "volatile-");
2710           if (SPEC_CONST (type))
2711             fprintf (of, "const-");
2712           if (SPEC_USIGN (type))
2713             fprintf (of, "unsigned-");
2714           switch (SPEC_NOUN (type))
2715             {
2716             case V_INT:
2717               if (IS_LONG (type))
2718                 fprintf (of, "long-");
2719               fprintf (of, "int");
2720               break;
2721
2722             case V_CHAR:
2723               fprintf (of, "char");
2724               break;
2725
2726             case V_VOID:
2727               fprintf (of, "void");
2728               break;
2729
2730             case V_FLOAT:
2731               fprintf (of, "float");
2732               break;
2733
2734             case V_STRUCT:
2735               fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2736               break;
2737
2738             case V_SBIT:
2739               fprintf (of, "sbit");
2740               break;
2741
2742             case V_BIT:
2743               fprintf (of, "bit");
2744               break;
2745
2746             case V_BITFIELD:
2747               fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2748               break;
2749
2750             case V_DOUBLE:
2751               fprintf (of, "double");
2752               break;
2753
2754             default:
2755               fprintf (of, "unknown type");
2756               break;
2757             }
2758         }
2759       /* search entry in list before "type" */
2760       for (search = start; search && search->next != type;)
2761         search = search->next;
2762       type = search;
2763       if (type)
2764         fputc (' ', of);
2765     }
2766   if (nlr)
2767     fprintf (of, "\n");
2768 }
2769
2770 /*--------------------------------------------------------------------*/
2771 /* printTypeChainRaw - prints the type chain in human readable form   */
2772 /*                     in the raw data structure ordering             */
2773 /*--------------------------------------------------------------------*/
2774 void
2775 printTypeChainRaw (sym_link * start, FILE * of)
2776 {
2777   int nlr = 0;
2778   value *args;
2779   sym_link * type;
2780
2781   if (!of)
2782     {
2783       of = stdout;
2784       nlr = 1;
2785     }
2786
2787   if (start==NULL) {
2788     fprintf (of, "void");
2789     return;
2790   }
2791
2792   type = start;
2793
2794   while (type)
2795     {
2796       if (IS_DECL (type))
2797         {
2798           if (!IS_FUNC(type)) {
2799             if (DCL_PTR_VOLATILE (type)) {
2800               fprintf (of, "volatile-");
2801             }
2802             if (DCL_PTR_CONST (type)) {
2803               fprintf (of, "const-");
2804             }
2805           }
2806           switch (DCL_TYPE (type))
2807             {
2808             case FUNCTION:
2809               fprintf (of, "function %s %s",
2810                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2811                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2812               fprintf (of, "( ");
2813               for (args = FUNC_ARGS(type);
2814                    args;
2815                    args=args->next) {
2816                 printTypeChain(args->type, of);
2817                 if (args->next)
2818                   fprintf(of, ", ");
2819               }
2820               fprintf (of, ") ");
2821               break;
2822             case GPOINTER:
2823               fprintf (of, "generic* ");
2824               break;
2825             case CPOINTER:
2826               fprintf (of, "code* ");
2827               break;
2828             case FPOINTER:
2829               fprintf (of, "xdata* ");
2830               break;
2831             case EEPPOINTER:
2832               fprintf (of, "eeprom* ");
2833               break;
2834             case POINTER:
2835               fprintf (of, "near* ");
2836               break;
2837             case IPOINTER:
2838               fprintf (of, "idata* ");
2839               break;
2840             case PPOINTER:
2841               fprintf (of, "pdata* ");
2842               break;
2843             case UPOINTER:
2844               fprintf (of, "unknown* ");
2845               break;
2846             case ARRAY:
2847               if (DCL_ELEM(type)) {
2848                 fprintf (of, "[%d] ", DCL_ELEM(type));
2849               } else {
2850                 fprintf (of, "[] ");
2851               }
2852               break;
2853             }
2854           if (DCL_TSPEC(type))
2855             {
2856               fprintf (of, "{");
2857               printTypeChainRaw(DCL_TSPEC(type), of);
2858               fprintf (of, "}");
2859             }
2860         }
2861       else if (IS_SPEC (type))
2862         {
2863         switch (SPEC_SCLS (type))
2864           {
2865           case S_DATA: fprintf (of, "data-"); break;
2866           case S_XDATA: fprintf (of, "xdata-"); break;
2867           case S_SFR: fprintf (of, "sfr-"); break;
2868           case S_SBIT: fprintf (of, "sbit-"); break;
2869           case S_CODE: fprintf (of, "code-"); break;
2870           case S_IDATA: fprintf (of, "idata-"); break;
2871           case S_PDATA: fprintf (of, "pdata-"); break;
2872           case S_LITERAL: fprintf (of, "literal-"); break;
2873           case S_STACK: fprintf (of, "stack-"); break;
2874           case S_XSTACK: fprintf (of, "xstack-"); break;
2875           case S_BIT: fprintf (of, "bit-"); break;
2876           case S_EEPROM: fprintf (of, "eeprom-"); break;
2877           default: break;
2878           }
2879           if (SPEC_VOLATILE (type))
2880             fprintf (of, "volatile-");
2881           if (SPEC_CONST (type))
2882             fprintf (of, "const-");
2883           if (SPEC_USIGN (type))
2884             fprintf (of, "unsigned-");
2885           switch (SPEC_NOUN (type))
2886             {
2887             case V_INT:
2888               if (IS_LONG (type))
2889                 fprintf (of, "long-");
2890               fprintf (of, "int");
2891               break;
2892
2893             case V_CHAR:
2894               fprintf (of, "char");
2895               break;
2896
2897             case V_VOID:
2898               fprintf (of, "void");
2899               break;
2900
2901             case V_FLOAT:
2902               fprintf (of, "float");
2903               break;
2904
2905             case V_STRUCT:
2906               fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2907               break;
2908
2909             case V_SBIT:
2910               fprintf (of, "sbit");
2911               break;
2912
2913             case V_BIT:
2914               fprintf (of, "bit");
2915               break;
2916
2917             case V_BITFIELD:
2918               fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2919               break;
2920
2921             case V_DOUBLE:
2922               fprintf (of, "double");
2923               break;
2924
2925             default:
2926               fprintf (of, "unknown type");
2927               break;
2928             }
2929         }
2930       else
2931         fprintf (of, "NOT_SPEC_OR_DECL");
2932       type = type->next;
2933       if (type)
2934         fputc (' ', of);
2935     }
2936   if (nlr)
2937     fprintf (of, "\n");
2938 }
2939
2940
2941 /*-----------------------------------------------------------------*/
2942 /* powof2 - returns power of two for the number if number is pow 2 */
2943 /*-----------------------------------------------------------------*/
2944 int
2945 powof2 (TYPE_UDWORD num)
2946 {
2947   int nshifts = 0;
2948   int n1s = 0;
2949
2950   while (num)
2951     {
2952       if (num & 1)
2953         n1s++;
2954       num >>= 1;
2955       nshifts++;
2956     }
2957
2958   if (n1s > 1 || nshifts == 0)
2959     return 0;
2960   return nshifts - 1;
2961 }
2962
2963 symbol *__fsadd;
2964 symbol *__fssub;
2965 symbol *__fsmul;
2966 symbol *__fsdiv;
2967 symbol *__fseq;
2968 symbol *__fsneq;
2969 symbol *__fslt;
2970 symbol *__fslteq;
2971 symbol *__fsgt;
2972 symbol *__fsgteq;
2973
2974 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2975 symbol *__muldiv[3][3][2];
2976 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2977 sym_link *__multypes[3][2];
2978 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2979 symbol *__conv[2][3][2];
2980 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2981 symbol *__rlrr[2][3][2];
2982
2983 sym_link *floatType;
2984
2985 static char *
2986 _mangleFunctionName(char *in)
2987 {
2988   if (port->getMangledFunctionName)
2989     {
2990       return port->getMangledFunctionName(in);
2991     }
2992   else
2993     {
2994       return in;
2995     }
2996 }
2997
2998 /*-----------------------------------------------------------------*/
2999 /* typeFromStr - create a typechain from an encoded string         */
3000 /* basic types -        'c' - char                                 */
3001 /*                      's' - short                                */
3002 /*                      'i' - int                                  */
3003 /*                      'l' - long                                 */
3004 /*                      'f' - float                                */
3005 /*                      'v' - void                                 */
3006 /*                      '*' - pointer - default (GPOINTER)         */
3007 /* modifiers -          'u' - unsigned                             */
3008 /* pointer modifiers -  'g' - generic                              */
3009 /*                      'x' - xdata                                */
3010 /*                      'p' - code                                 */
3011 /*                      'd' - data                                 */
3012 /*                      'F' - function                             */
3013 /* examples : "ig*" - generic int *                                */
3014 /*            "cx*" - char xdata *                                 */
3015 /*            "ui" -  unsigned int                                 */
3016 /*-----------------------------------------------------------------*/
3017 sym_link *typeFromStr (char *s)
3018 {
3019     sym_link *r = newLink(DECLARATOR);
3020     int usign = 0;
3021
3022     do {
3023         sym_link *nr;
3024         switch (*s) {
3025         case 'u' :
3026             usign = 1;
3027             s++;
3028             continue ;
3029             break ;
3030         case 'c':
3031             r->class = SPECIFIER;
3032             SPEC_NOUN(r) = V_CHAR;
3033             break;
3034         case 's':
3035         case 'i':
3036             r->class = SPECIFIER;
3037             SPEC_NOUN(r) = V_INT;
3038             break;
3039         case 'l':
3040             r->class = SPECIFIER;
3041             SPEC_NOUN(r) = V_INT;
3042             SPEC_LONG(r) = 1;
3043             break;
3044         case 'f':
3045             r->class = SPECIFIER;
3046             SPEC_NOUN(r) = V_FLOAT;
3047             break;
3048         case 'v':
3049             r->class = SPECIFIER;
3050             SPEC_NOUN(r) = V_VOID;
3051             break;
3052         case '*':
3053             DCL_TYPE(r) = port->unqualified_pointer;
3054             break;
3055         case 'g':
3056         case 'x':
3057         case 'p':
3058         case 'd':
3059         case 'F':
3060             assert(*(s+1)=='*');
3061             nr = newLink(DECLARATOR);
3062             nr->next = r;
3063             r = nr;
3064             switch (*s) {
3065             case 'g':
3066                 DCL_TYPE(r) = GPOINTER;
3067                 break;
3068             case 'x':
3069                 DCL_TYPE(r) = FPOINTER;
3070                 break;
3071             case 'p':
3072                 DCL_TYPE(r) = CPOINTER;
3073                 break;
3074             case 'd':
3075                 DCL_TYPE(r) = POINTER;
3076                 break;
3077             case 'F':
3078                 DCL_TYPE(r) = FUNCTION;
3079                 nr = newLink(DECLARATOR);
3080                 nr->next = r;
3081                 r = nr;
3082                 DCL_TYPE(r) = CPOINTER;
3083                 break;
3084             }
3085             s++;
3086             break;
3087         default:
3088             werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3089                    "typeFromStr: unknown type");
3090             break;
3091         }
3092         if (IS_SPEC(r) && usign) {
3093             SPEC_USIGN(r) = 1;
3094             usign = 0;
3095         }
3096         s++;
3097     } while (*s);
3098     return r;
3099 }
3100
3101 /*-----------------------------------------------------------------*/
3102 /* initCSupport - create functions for C support routines          */
3103 /*-----------------------------------------------------------------*/
3104 void
3105 initCSupport ()
3106 {
3107   const char *smuldivmod[] =
3108   {
3109     "mul", "div", "mod"
3110   };
3111   const char *sbwd[] =
3112   {
3113     "char", "int", "long"
3114   };
3115   const char *ssu[] =
3116   {
3117     "s", "u"
3118   };
3119   const char *srlrr[] =
3120   {
3121     "rl", "rr"
3122   };
3123
3124   int bwd, su, muldivmod, tofrom, rlrr;
3125
3126   if (getenv("SDCC_NO_C_SUPPORT")) {
3127     /* for debugging only */
3128     return;
3129   }
3130
3131   floatType = newFloatLink ();
3132
3133   for (bwd = 0; bwd < 3; bwd++)
3134     {
3135       sym_link *l = NULL;
3136       switch (bwd)
3137         {
3138         case 0:
3139           l = newCharLink ();
3140           break;
3141         case 1:
3142           l = newIntLink ();
3143           break;
3144         case 2:
3145           l = newLongLink ();
3146           break;
3147         default:
3148           assert (0);
3149         }
3150       __multypes[bwd][0] = l;
3151       __multypes[bwd][1] = copyLinkChain (l);
3152       SPEC_USIGN (__multypes[bwd][1]) = 1;
3153     }
3154
3155   __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3156   __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3157   __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3158   __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3159   __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3160   __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3161   __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3162   __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3163   __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3164   __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3165
3166   for (tofrom = 0; tofrom < 2; tofrom++)
3167     {
3168       for (bwd = 0; bwd < 3; bwd++)
3169         {
3170           for (su = 0; su < 2; su++)
3171             {
3172               if (tofrom)
3173                 {
3174                   SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3175                   __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3176                 }
3177               else
3178                 {
3179                   SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3180                   __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3181                 }
3182             }
3183         }
3184     }
3185
3186 /*
3187   for (muldivmod = 0; muldivmod < 3; muldivmod++)
3188     {
3189       for (bwd = 0; bwd < 3; bwd++)
3190         {
3191           for (su = 0; su < 2; su++)
3192             {
3193               SNPRINTF (buffer, sizeof(buffer),
3194                         "_%s%s%s",
3195                        smuldivmod[muldivmod],
3196                        ssu[su],
3197                        sbwd[bwd]);
3198               __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3199               FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3200             }
3201         }
3202     }
3203
3204   muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3205   Therefore they've been merged into mulint() and mullong().
3206 */
3207
3208   for (bwd = 0; bwd < 3; bwd++)
3209     {
3210       for (su = 0; su < 2; su++)
3211         {
3212           for (muldivmod = 1; muldivmod < 3; muldivmod++)
3213             {
3214               /* div and mod */
3215               SNPRINTF (buffer, sizeof(buffer),
3216                         "_%s%s%s",
3217                        smuldivmod[muldivmod],
3218                        ssu[su],
3219                        sbwd[bwd]);
3220               __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3221               FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3222             }
3223         }
3224     }
3225   /* mul only */
3226   muldivmod = 0;
3227   /* byte */
3228   bwd = 0;
3229   for (su = 0; su < 2; su++)
3230     {
3231       /* muluchar and mulschar are still separate functions, because e.g. the z80
3232          port is sign/zero-extending to int before calling mulint() */
3233       SNPRINTF (buffer, sizeof(buffer),
3234                 "_%s%s%s",
3235                 smuldivmod[muldivmod],
3236                 ssu[su],
3237                 sbwd[bwd]);
3238       __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3239       FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3240     }
3241   /* signed only */
3242   su = 0;
3243   /* word and doubleword */
3244   for (bwd = 1; bwd < 3; bwd++)
3245     {
3246       /* mul, int/long */
3247       SNPRINTF (buffer, sizeof(buffer),
3248                 "_%s%s",
3249                 smuldivmod[muldivmod],
3250                 sbwd[bwd]);
3251       __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3252       FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3253       /* signed = unsigned */
3254       __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3255     }
3256
3257   for (rlrr = 0; rlrr < 2; rlrr++)
3258     {
3259       for (bwd = 0; bwd < 3; bwd++)
3260         {
3261           for (su = 0; su < 2; su++)
3262             {
3263               SNPRINTF (buffer, sizeof(buffer),
3264                         "_%s%s%s",
3265                        srlrr[rlrr],
3266                        ssu[su],
3267                        sbwd[bwd]);
3268               __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3269               FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3270             }
3271         }
3272     }
3273 }
3274
3275 /*-----------------------------------------------------------------*/
3276 /* initBuiltIns - create prototypes for builtin functions          */
3277 /*-----------------------------------------------------------------*/
3278 void initBuiltIns()
3279 {
3280     int i;
3281     symbol *sym;
3282
3283     if (!port->builtintable) return ;
3284
3285     for (i = 0 ; port->builtintable[i].name ; i++) {
3286         sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3287                              port->builtintable[i].nParms,port->builtintable[i].parm_types);
3288         FUNC_ISBUILTIN(sym->type) = 1;
3289         FUNC_ISREENT(sym->type) = 0;    /* can never be reentrant */
3290     }
3291 }
3292
3293 sym_link *validateLink(sym_link         *l,
3294                         const char      *macro,
3295                         const char      *args,
3296                         const char      select,
3297                         const char      *file,
3298                         unsigned        line)
3299 {
3300   if (l && l->class==select)
3301     {
3302         return l;
3303     }
3304     fprintf(stderr,
3305             "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3306             " expected %s, got %s\n",
3307             macro, args, file, line,
3308             DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3309     exit(-1);
3310     return l; // never reached, makes compiler happy.
3311 }
3312
3313 /*--------------------------------------------------------------------*/
3314 /* newEnumType - create an integer type compatible with enumerations  */
3315 /*--------------------------------------------------------------------*/
3316 sym_link *
3317 newEnumType (symbol *enumlist)
3318 {
3319   int min, max, v;
3320   symbol *sym;
3321   sym_link *type;
3322
3323   if (!enumlist)
3324     {
3325       type = newLink (SPECIFIER);
3326       SPEC_NOUN (type) = V_INT;
3327       return type;
3328     }
3329
3330   /* Determine the range of the enumerated values */
3331   sym = enumlist;
3332   min = max = (int) floatFromVal (valFromType (sym->type));
3333   for (sym = sym->next; sym; sym = sym->next)
3334     {
3335       v = (int) floatFromVal (valFromType (sym->type));
3336       if (v<min)
3337         min = v;
3338       if (v>max)
3339         max = v;
3340     }
3341
3342   /* Determine the smallest integer type that is compatible with this range */
3343   type = newLink (SPECIFIER);
3344   if (min>=0 && max<=255)
3345     {
3346       SPEC_NOUN (type) = V_CHAR;
3347       SPEC_USIGN (type) = 1;
3348     }
3349   else if (min>=-128 && max<=127)
3350     {
3351       SPEC_NOUN (type) = V_CHAR;
3352     }
3353   else if (min>=0 && max<=65535)
3354     {
3355       SPEC_NOUN (type) = V_INT;
3356       SPEC_USIGN (type) = 1;
3357     }
3358   else if (min>=-32768 && max<=32767)
3359     {
3360       SPEC_NOUN (type) = V_INT;
3361     }
3362   else
3363     {
3364       SPEC_NOUN (type) = V_INT;
3365       SPEC_LONG (type) = 1;
3366       if (min>=0)
3367         SPEC_USIGN (type) = 1;
3368     }
3369
3370   return type;
3371 }