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 bucket   *SymbolTab [256]  ;  /* the symbol    table  */
  28 bucket   *StructTab [256]  ;  /* the structure table  */
  29 bucket   *TypedefTab[256]  ;  /* the typedef   table  */
  30 bucket   *LabelTab  [256]  ;  /* the Label     table  */
  31 bucket   *enumTab   [256]  ;  /* enumerated    table  */
  32
  33 /*------------------------------------------------------------------*/
  34 /* initSymt () - initialises symbol table related stuff             */
  35 /*------------------------------------------------------------------*/
  36 void  initSymt ()
  37 {
  38    int i = 0 ;
  39
  40    for ( i = 0 ; i < 256 ; i++ )
  41       SymbolTab[i] = StructTab[i] = (void *) NULL ;
  42
  43
  44 }
  45 /*-----------------------------------------------------------------*/
  46 /* newBucket - allocates & returns a new bucket        */
  47 /*-----------------------------------------------------------------*/
  48 bucket   *newBucket ()
  49 {
  50   bucket *bp ;
  51
  52   bp = Safe_calloc(1,sizeof(bucket));
  53
  54   return bp ;
  55 }
  56
  57 /*-----------------------------------------------------------------*/
  58 /* hashKey - computes the hashkey given a symbol name              */
  59 /*-----------------------------------------------------------------*/
  60 int hashKey (const char *s)
  61 {
  62     unsigned long key = 0;
  63
  64     while (*s)
  65   key += *s++ ;
  66     return key % 256 ;
  67 }
  68
  69 /*-----------------------------------------------------------------*/
  70 /* addSym - adds a symbol to the hash Table                        */
  71 /*-----------------------------------------------------------------*/
  72 void  addSym ( bucket **stab ,
  73          void *sym     ,
  74          char *sname   ,
  75          int level     ,
  76          int block)
  77 {
  78     int i ;   /* index into the hash Table */
  79     bucket   *bp ; /* temp bucket    *         */
  80
  81     /* the symbols are always added at the head of the list  */
  82     i = hashKey(sname) ;
  83     /* get a free entry */
  84     bp = Safe_calloc(1,sizeof(bucket));
  85
  86     bp->sym = sym ; /* update the symbol pointer  */
  87     bp->level = level;   /* update the nest level      */
  88     bp->block = block;
  89     strcpy(bp->name,sname); /* copy the name into place */
  90
  91     /* if this is the first entry */
  92     if (stab[i] == NULL) {
  93   bp->prev = bp->next = (void *) NULL ;  /* point to nothing */
  94   stab[i] = bp ;
  95     }
  96     /* not first entry then add @ head of list */
  97     else {
  98   bp->prev      = NULL ;
  99   stab[i]->prev = bp ;
 100   bp->next      = stab[i] ;
 101   stab[i]       = bp ;
 102     }
 103 }
 104
 105 /*-----------------------------------------------------------------*/
 106 /* deleteSym - deletes a symbol from the hash Table  entry     */
 107 /*-----------------------------------------------------------------*/
 108 void  deleteSym ( bucket **stab, void *sym, char *sname)
 109 {
 110     int i = 0 ;
 111     bucket *bp ;
 112
 113     i = hashKey(sname) ;
 114
 115     bp = stab[i] ;
 116     /* find the symbol */
 117     while (bp) {
 118   if (bp->sym == sym)  /* found it then break out */
 119       break ;    /* of the loop       */
 120   bp = bp->next ;
 121     }
 122
 123     if (!bp)   /* did not find it */
 124   return ;
 125     /* if this is the first one in the chain */
 126     if ( ! bp->prev ) {
 127   stab[i] = bp->next ;
 128   if ( stab[i] ) /* if chain ! empty */
 129       stab[i]->prev = (void *) NULL ;
 130     }
 131     /* middle || end of chain */
 132     else {
 133   if ( bp->next ) /* if not end of chain */
 134       bp->next->prev = bp->prev ;
 135
 136   bp->prev->next = bp->next ;
 137     }
 138
 139 }
 140
 141 /*-----------------------------------------------------------------*/
 142 /* findSym - finds a symbol in a table           */
 143 /*-----------------------------------------------------------------*/
 144 void  *findSym ( bucket **stab, void *sym, const char *sname)
 145 {
 146    bucket *bp ;
 147
 148    bp = stab[hashKey(sname)] ;
 149    while (bp)
 150    {
 151       if ( bp->sym == sym || strcmp (bp->name,sname) == 0 )
 152         break ;
 153       bp = bp->next ;
 154    }
 155
 156    return ( bp ? bp->sym : (void *) NULL ) ;
 157 }
 158
 159 /*-----------------------------------------------------------------*/
 160 /* findSymWithLevel - finds a symbol with a name & level           */
 161 /*-----------------------------------------------------------------*/
 162 void *findSymWithLevel ( bucket **stab, symbol *sym)
 163 {
 164   bucket *bp ;
 165
 166   bp = stab[hashKey(sym->name)];
 167
 168   /**
 169    **  do the search from the head of the list since the
 170    **  elements are added at the head it is ensured that
 171    ** we will find the deeper definitions before we find
 172    ** the global ones. we need to check for symbols with
 173    ** level <= to the level given, if levels match then block
 174    ** numbers need to match as well
 175    **/
 176   while (bp) {
 177
 178     if ( strcmp(bp->name,sym->name) == 0 && bp->level <= sym->level) {
 179       /* if this is parameter then nothing else need to be checked */
 180       if (((symbol *)(bp->sym))->_isparm)
 181   return (bp->sym) ;
 182       /* if levels match then block numbers hsould also match */
 183       if (bp->level && bp->level == sym->level && bp->block == sym->block )
 184         return ( bp->sym );
 185       /* if levels don't match then we are okay */
 186       if (bp->level && bp->level != sym->level)
 187         return ( bp->sym );
 188       /* if this is a global variable then we are ok too */
 189       if (bp->level == 0 )
 190         return (bp->sym);
 191     }
 192
 193     bp = bp->next;
 194   }
 195
 196   return (void *) NULL ;
 197 }
 198
 199 /*-----------------------------------------------------------------*/
 200 /* findSymWithBlock - finds a symbol with name in with a block     */
 201 /*-----------------------------------------------------------------*/
 202 void  *findSymWithBlock ( bucket **stab, symbol *sym, int block)
 203 {
 204    bucket *bp ;
 205
 206    bp = stab[hashKey(sym->name)] ;
 207    while (bp)
 208    {
 209       if ( strcmp (bp->name,sym->name) == 0 &&
 210      bp->block <= block )
 211         break ;
 212       bp = bp->next ;
 213    }
 214
 215    return ( bp ? bp->sym : (void *) NULL ) ;
 216 }
 217
 218 /*------------------------------------------------------------------*/
 219 /* newSymbol () - returns a new pointer to a symbol                 */
 220 /*------------------------------------------------------------------*/
 221 symbol *newSymbol (char *name, int scope )
 222 {
 223    symbol *sym ;
 224
 225    sym = Safe_calloc(1,sizeof(symbol));
 226
 227    strcpy(sym->name,name);             /* copy the name    */
 228    sym->level = scope ;                /* set the level    */
 229    sym->block = currBlockno ;
 230    sym->lineDef = yylineno ;    /* set the line number */
 231    return sym ;
 232 }
 233
 234 /*------------------------------------------------------------------*/
 235 /* newLink - creates a new link (declarator,specifier)              */
 236 /*------------------------------------------------------------------*/
 237 sym_link  *newLink ()
 238 {
 239    sym_link *p ;
 240
 241    p = Safe_calloc(1,sizeof(sym_link));
 242
 243    return p;
 244 }
 245
 246 /*------------------------------------------------------------------*/
 247 /* newStruct - creats a new structdef from the free list            */
 248 /*------------------------------------------------------------------*/
 249 structdef   *newStruct  ( char   *tag   )
 250 {
 251    structdef  *s;
 252
 253    s = Safe_calloc(1,sizeof(structdef));
 254
 255    strcpy(s->tag,tag) ;                     /* copy the tag            */
 256    return s ;
 257 }
 258
 259 /*------------------------------------------------------------------*/
 260 /* pointerTypes - do the computation for the pointer types          */
 261 /*------------------------------------------------------------------*/
 262 void pointerTypes (sym_link *ptr, sym_link *type)
 263 {
 264     if (IS_SPEC(ptr))
 265   return ;
 266
 267     /* find the first pointer type */
 268     while (ptr && !IS_PTR(ptr))
 269   ptr = ptr->next;
 270
 271     /* could not find it */
 272     if (!ptr || IS_SPEC(ptr) ||
 273   DCL_TYPE(ptr) != UPOINTER)
 274   return ;
 275
 276     /* change the pointer type depending on the
 277        storage class of the type */
 278     if (IS_SPEC(type)) {
 279   DCL_PTR_CONST(ptr) = SPEC_CONST(type);
 280   DCL_PTR_VOLATILE(ptr) = SPEC_VOLATILE(type);
 281   switch (SPEC_SCLS(type)) {
 282   case S_XDATA:
 283       DCL_TYPE(ptr) = FPOINTER;
 284       break;
 285   case S_IDATA:
 286       DCL_TYPE(ptr) = IPOINTER ;
 287       break;
 288   case S_PDATA:
 289       DCL_TYPE(ptr) = PPOINTER ;
 290       break;
 291   case S_DATA:
 292       DCL_TYPE(ptr) = POINTER ;
 293       break;
 294   case S_CODE:
 295       DCL_PTR_CONST(ptr) = port->mem.code_ro;
 296       DCL_TYPE(ptr) = CPOINTER ;
 297       break;
 298   case S_EEPROM:
 299       DCL_TYPE(ptr) = EEPPOINTER;
 300       break;
 301   default:
 302       DCL_TYPE(ptr) = GPOINTER;
 303       break;
 304   }
 305   /* the storage class of type ends here */
 306   SPEC_SCLS(type) =
 307       SPEC_CONST(type) =
 308       SPEC_VOLATILE(type) = 0;
 309     }
 310
 311     /* now change all the remaining unknown pointers
 312        to generic pointers */
 313     while (ptr) {
 314   if (!IS_SPEC(ptr) && DCL_TYPE(ptr) == UPOINTER)
 315       DCL_TYPE(ptr) = GPOINTER;
 316   ptr = ptr->next;
 317     }
 318
 319     /* same for the type although it is highly unlikely that
 320        type will have a pointer */
 321     while (type) {
 322   if (!IS_SPEC(type) && DCL_TYPE(type) == UPOINTER)
 323       DCL_TYPE(type) = GPOINTER;
 324   type = type->next;
 325     }
 326
 327 }
 328
 329 /*------------------------------------------------------------------*/
 330 /* addDecl - adds a declarator @ the end of a chain                 */
 331 /*------------------------------------------------------------------*/
 332 void  addDecl ( symbol *sym, int type , sym_link *p )
 333 {
 334     sym_link    *head;
 335     sym_link    *tail;
 336     sym_link        *t ;
 337
 338     /* if we are passed a link then set head & tail */
 339     if ( p )  {
 340   tail = head = p ;
 341   while ( tail->next )
 342       tail = tail->next ;
 343     }
 344     else {
 345   head = tail = newLink() ;
 346   DCL_TYPE(head) = type   ;
 347     }
 348
 349     /* if this is the first entry   */
 350     if ( !sym->type )  {
 351   sym->type = head ;
 352   sym->etype = tail ;
 353     }
 354     else   {
 355   if ( IS_SPEC(sym->etype) && IS_SPEC(head) && head == tail ) {
 356       sym->etype = mergeSpec(sym->etype,head);
 357   }
 358   else {
 359       if ( IS_SPEC(sym->etype) && !IS_SPEC(head) && head == tail ) {
 360     t = sym->type ;
 361     while (t->next != sym->etype) t = t->next ;
 362     t->next = head ;
 363     tail->next = sym->etype;
 364       } else {
 365     sym->etype->next = head;
 366     sym->etype   = tail;
 367       }
 368   }
 369     }
 370
 371     /* if the type is a unknown pointer and has
 372        a tspec then take the storage class const & volatile
 373        attribute from the tspec & make it those of this
 374        symbol */
 375     if (p &&
 376   !IS_SPEC(p) &&
 377   DCL_TYPE(p) == UPOINTER &&
 378   DCL_TSPEC(p)) {
 379   if (!IS_SPEC(sym->etype)) {
 380       sym->etype = sym->etype->next = newLink();
 381       sym->etype->class = SPECIFIER;
 382   }
 383   SPEC_SCLS(sym->etype) = SPEC_SCLS(DCL_TSPEC(p));
 384   SPEC_CONST(sym->etype) = SPEC_CONST(DCL_TSPEC(p));
 385   SPEC_VOLATILE(sym->etype) = SPEC_VOLATILE(DCL_TSPEC(p));
 386   DCL_TSPEC(p) = NULL;
 387     }
 388     return  ;
 389 }
 390
 391 /*------------------------------------------------------------------*/
 392 /* mergeSpec - merges two specifiers and returns the new one       */
 393 /*------------------------------------------------------------------*/
 394 sym_link  *mergeSpec ( sym_link *dest, sym_link *src )
 395 {
 396     /* if noun different then src overrides */
 397     if ( SPEC_NOUN(dest) != SPEC_NOUN(src) && !SPEC_NOUN(dest))
 398   SPEC_NOUN(dest) = SPEC_NOUN(src) ;
 399
 400     if (! SPEC_SCLS(dest))  /* if destination has no storage class */
 401   SPEC_SCLS(dest) = SPEC_SCLS(src) ;
 402
 403     /* copy all the specifications  */
 404     SPEC_LONG(dest) |= SPEC_LONG(src);
 405     SPEC_SHORT(dest) |= SPEC_SHORT(src);
 406     SPEC_USIGN(dest) |= SPEC_USIGN(src);
 407     SPEC_STAT(dest) |= SPEC_STAT(src);
 408     SPEC_EXTR(dest) |= SPEC_EXTR(src);
 409     SPEC_ABSA(dest) |= SPEC_ABSA(src);
 410     SPEC_RENT(dest) |= SPEC_RENT(src);
 411     SPEC_INTN(dest) |= SPEC_INTN(src);
 412     SPEC_BANK(dest) |= SPEC_BANK(src);
 413     SPEC_VOLATILE(dest) |= SPEC_VOLATILE(src);
 414     SPEC_CRTCL(dest) |= SPEC_CRTCL(src);
 415     SPEC_ADDR(dest) |= SPEC_ADDR(src);
 416     SPEC_OCLS(dest)  = SPEC_OCLS(src);
 417     SPEC_BLEN(dest) |= SPEC_BLEN(src);
 418     SPEC_BSTR(dest) |= SPEC_BSTR(src);
 419     SPEC_TYPEDEF(dest) |= SPEC_TYPEDEF(src);
 420     SPEC_NONBANKED(dest) |= SPEC_NONBANKED(src);
 421
 422     if ( IS_STRUCT(dest) && SPEC_STRUCT(dest) == NULL )
 423   SPEC_STRUCT(dest) = SPEC_STRUCT(src);
 424
 425     return dest ;
 426 }
 427
 428 /*------------------------------------------------------------------*/
 429 /* cloneSpec - copies the entire spec and returns a new spec        */
 430 /*------------------------------------------------------------------*/
 431 sym_link  *cloneSpec ( sym_link *src )
 432 {
 433     sym_link  *spec ;
 434
 435     /* go thru chain till we find the specifier */
 436     while ( src && src->class != SPECIFIER )
 437   src = src->next ;
 438
 439     spec = newLink() ;
 440     memcpy (spec,src,sizeof(sym_link));
 441     return spec ;
 442 }
 443
 444 /*------------------------------------------------------------------*/
 445 /* genSymName - generates and returns a name used for anonymous vars*/
 446 /*------------------------------------------------------------------*/
 447 char  *genSymName ( int level )
 448 {
 449     static   int gCount = 0 ;
 450     static   char gname[SDCC_NAME_MAX+1] ;
 451
 452     sprintf (gname,"__%04d%04d",level,gCount++);
 453     return gname ;
 454 }
 455
 456 /*------------------------------------------------------------------*/
 457 /* getSpec - returns the specifier part from a declaration chain    */
 458 /*------------------------------------------------------------------*/
 459 sym_link  *getSpec ( sym_link *p )
 460 {
 461     sym_link *loop ;
 462
 463     loop = p ;
 464     while ( p && ! (IS_SPEC(p)))
 465   p = p->next ;
 466
 467     return p ;
 468 }
 469
 470 /*------------------------------------------------------------------*/
 471 /* newCharLink() - creates an int type                              */
 472 /*------------------------------------------------------------------*/
 473 sym_link  *newCharLink()
 474 {
 475     sym_link *p;
 476
 477     p = newLink();
 478     p->class = SPECIFIER ;
 479     SPEC_NOUN(p) = V_CHAR ;
 480
 481     return p;
 482 }
 483
 484 /*------------------------------------------------------------------*/
 485 /* newFloatLink - a new Float type                                  */
 486 /*------------------------------------------------------------------*/
 487 sym_link *newFloatLink()
 488 {
 489     sym_link *p;
 490
 491     p = newLink();
 492     p->class = SPECIFIER ;
 493     SPEC_NOUN(p) = V_FLOAT ;
 494
 495     return p;
 496 }
 497
 498 /*------------------------------------------------------------------*/
 499 /* newLongLink() - new long type                                    */
 500 /*------------------------------------------------------------------*/
 501 sym_link *newLongLink()
 502 {
 503     sym_link *p;
 504
 505     p = newLink();
 506     p->class = SPECIFIER ;
 507     SPEC_NOUN(p) = V_INT ;
 508     SPEC_LONG(p) = 1;
 509
 510     return p;
 511 }
 512
 513 /*------------------------------------------------------------------*/
 514 /* newIntLink() - creates an int type                               */
 515 /*------------------------------------------------------------------*/
 516 sym_link  *newIntLink()
 517 {
 518     sym_link *p;
 519
 520     p = newLink();
 521     p->class = SPECIFIER ;
 522     SPEC_NOUN(p) = V_INT ;
 523
 524     return p;
 525 }
 526
 527 /*------------------------------------------------------------------*/
 528 /* getSize - returns size of a type chain in bits                   */
 529 /*------------------------------------------------------------------*/
 530 unsigned int   getSize ( sym_link *p )
 531 {
 532     /* if nothing return 0 */
 533     if ( ! p )
 534   return 0 ;
 535     if ( IS_SPEC(p) ) { /* if this is the specifier then */
 536   switch (SPEC_NOUN(p)) { /* depending on the specifier type */
 537   case V_INT:
 538       return (IS_LONG(p) ? LONGSIZE : ( IS_SHORT(p) ? SHORTSIZE: INTSIZE)) ;
 539   case V_FLOAT:
 540       return FLOATSIZE ;
 541   case V_CHAR:
 542       return CHARSIZE ;
 543   case V_VOID:
 544       return   0 ;
 545   case V_STRUCT:
 546       return SPEC_STRUCT(p)->size ;
 547   case V_LABEL:
 548       return 0 ;
 549   case V_SBIT:
 550       return BITSIZE ;
 551   case V_BIT:
 552       return ((SPEC_BLEN(p) / 8) + (SPEC_BLEN(p) % 8 ? 1 : 0)) ;
 553   default  :
 554       return 0 ;
 555   }
 556     }
 557
 558     /* this is a specifier  */
 559     switch (DCL_TYPE(p))  {
 560     case FUNCTION:
 561   return 2;
 562     case ARRAY:
 563   return DCL_ELEM(p) * getSize (p->next) ;
 564     case IPOINTER:
 565     case PPOINTER:
 566     case POINTER:
 567   return ( PTRSIZE ) ;
 568     case EEPPOINTER:
 569     case FPOINTER:
 570     case CPOINTER:
 571   return ( FPTRSIZE );
 572     case GPOINTER:
 573   return ( GPTRSIZE );
 574
 575     default     :
 576   return  0 ;
 577     }
 578 }
 579
 580 /*------------------------------------------------------------------*/
 581 /* bitsForType - returns # of bits required to store this type      */
 582 /*------------------------------------------------------------------*/
 583 unsigned int   bitsForType ( sym_link *p )
 584 {
 585     /* if nothing return 0 */
 586     if ( ! p )
 587   return 0 ;
 588
 589     if ( IS_SPEC(p) ) { /* if this is the specifier then */
 590
 591   switch (SPEC_NOUN(p)) { /* depending on the specifier type */
 592   case V_INT:
 593       return (IS_LONG(p) ? LONGSIZE*8 : ( IS_SHORT(p) ? SHORTSIZE*8: INTSIZE*8)) ;
 594   case V_FLOAT:
 595       return FLOATSIZE*8 ;
 596   case V_CHAR:
 597       return   CHARSIZE*8 ;
 598   case V_VOID:
 599       return   0 ;
 600   case V_STRUCT:
 601       return   SPEC_STRUCT(p)->size*8 ;
 602   case V_LABEL:
 603       return 0 ;
 604   case V_SBIT:
 605       return 1 ;
 606   case V_BIT:
 607       return SPEC_BLEN(p);
 608   default  :
 609       return 0 ;
 610   }
 611     }
 612
 613     /* this is a specifier  */
 614     switch (DCL_TYPE(p))  {
 615     case FUNCTION:
 616   return 2;
 617     case ARRAY:
 618   return DCL_ELEM(p) * getSize (p->next) *8 ;
 619     case IPOINTER:
 620     case PPOINTER:
 621     case POINTER:
 622   return ( PTRSIZE * 8) ;
 623     case EEPPOINTER:
 624     case FPOINTER:
 625     case CPOINTER:
 626   return ( FPTRSIZE * 8);
 627     case GPOINTER:
 628   return ( GPTRSIZE * 8);
 629
 630     default     :
 631   return  0 ;
 632     }
 633 }
 634
 635 /*------------------------------------------------------------------*/
 636 /* copySymbolChain - copies a symbol chain                          */
 637 /*------------------------------------------------------------------*/
 638 symbol *copySymbolChain (symbol *src)
 639 {
 640   symbol *dest ;
 641
 642   if (!src)
 643     return NULL ;
 644
 645   dest = copySymbol(src);
 646   dest->next = copySymbolChain(src->next);
 647   return dest ;
 648 }
 649
 650 /*------------------------------------------------------------------*/
 651 /* copySymbol - makes a copy of a symbol                            */
 652 /*------------------------------------------------------------------*/
 653 symbol  *copySymbol     (symbol *src)
 654 {
 655   symbol *dest;
 656
 657   if (!src )
 658     return NULL ;
 659
 660   dest = newSymbol( src->name, src->level );
 661   memcpy(dest,src,sizeof(symbol));
 662   dest->level = src->level ;
 663   dest->block = src->block ;
 664   dest->ival = copyIlist(src->ival);
 665   dest->type = copyLinkChain(src->type);
 666   dest->etype= getSpec(dest->type);
 667   dest->next = NULL ;
 668   dest->args = copyValueChain (src->args);
 669   dest->key = src->key;
 670   dest->calleeSave = src->calleeSave;
 671   dest->allocreq = src->allocreq;
 672   return dest;
 673 }
 674
 675 /*------------------------------------------------------------------*/
 676 /* reverseSyms - reverses the links for a symbol chain      */
 677 /*------------------------------------------------------------------*/
 678 symbol   *reverseSyms ( symbol *sym)
 679 {
 680    symbol *prev  , *curr, *next ;
 681
 682    if (!sym)
 683       return NULL ;
 684
 685    prev = sym ;
 686    curr = sym->next ;
 687
 688    while (curr)
 689    {
 690       next = curr->next ;
 691       curr->next = prev   ;
 692       prev = curr ;
 693       curr = next ;
 694    }
 695    sym->next = (void *) NULL ;
 696    return prev ;
 697 }
 698
 699 /*------------------------------------------------------------------*/
 700 /* reverseLink - reverses the links for a type chain        */
 701 /*------------------------------------------------------------------*/
 702 sym_link     *reverseLink ( sym_link *type)
 703 {
 704    sym_link *prev  , *curr, *next ;
 705
 706    if (!type)
 707       return NULL ;
 708
 709    prev = type ;
 710    curr = type->next ;
 711
 712    while (curr)
 713    {
 714       next = curr->next ;
 715       curr->next = prev   ;
 716       prev = curr ;
 717       curr = next ;
 718    }
 719    type->next = (void *) NULL ;
 720    return prev ;
 721 }
 722
 723 /*------------------------------------------------------------------*/
 724 /* addSymChain - adds a symbol chain to the symboltable             */
 725 /*------------------------------------------------------------------*/
 726 void addSymChain ( symbol *symHead )
 727 {
 728   symbol *sym  = symHead ;
 729   symbol *csym = NULL ;
 730
 731   for (;sym != NULL ; sym = sym->next ) {
 732
 733     /* if already exists in the symbol table then check if
 734        the previous was an extern definition if yes then
 735        then check if the type match, if the types match then
 736        delete the current entry and add the new entry      */
 737       if ((csym = findSymWithLevel (SymbolTab,sym)) &&
 738   csym->level == sym->level) {
 739
 740       /* previous definition extern ? */
 741       if ( IS_EXTERN(csym->etype) ) {
 742   /* do types match ? */
 743   if (checkType ( csym->type,sym->type) != 1)
 744     /* no then error */
 745     werror (E_DUPLICATE,csym->name);
 746
 747   /* delete current entry */
 748   deleteSym (SymbolTab, csym, csym->name );
 749   /* add new entry */
 750   addSym (SymbolTab, sym, sym->name, sym->level,sym->block);
 751       } else /* not extern */
 752     werror(E_DUPLICATE,sym->name) ;
 753       continue ;
 754     }
 755
 756     /* check if previously defined */
 757     if (csym  && csym->level == sym->level  ) {
 758       /* if the previous one was declared as extern */
 759       /* then check the type with the current one         */
 760       if ( IS_EXTERN(csym->etype) ) {
 761   if ( checkType (csym->type, sym->type ) <= 0 )
 762     werror (W_EXTERN_MISMATCH,csym->name);
 763       }
 764     }
 765
 766     addSym (SymbolTab,sym,sym->name,sym->level,sym->block) ;
 767   }
 768 }
 769
 770
 771 /*------------------------------------------------------------------*/
 772 /* funcInChain - DCL Type 'FUNCTION' found in type chain            */
 773 /*------------------------------------------------------------------*/
 774 int funcInChain (sym_link *lnk)
 775 {
 776     while (lnk) {
 777   if (IS_FUNC(lnk))
 778       return 1;
 779   lnk = lnk->next;
 780     }
 781     return 0;
 782 }
 783
 784 /*------------------------------------------------------------------*/
 785 /* structElemType - returns the type info of a sturct member        */
 786 /*------------------------------------------------------------------*/
 787 sym_link *structElemType (sym_link *stype, value *id ,value **argsp)
 788 {
 789     symbol *fields = (SPEC_STRUCT(stype) ? SPEC_STRUCT(stype)->fields : NULL);
 790     sym_link *type, *etype;
 791     sym_link *petype = getSpec(stype);
 792
 793     if ( ! fields || ! id)
 794   return NULL ;
 795
 796     /* look for the id */
 797     while (fields) {
 798   if (strcmp(fields->rname,id->name) == 0) {
 799       if (argsp) {
 800     *argsp = fields->args;
 801       }
 802       type = copyLinkChain (fields->type) ;
 803       etype=getSpec(type);
 804       SPEC_SCLS(etype) = (SPEC_SCLS(petype) == S_REGISTER ?
 805         SPEC_SCLS(etype) : SPEC_SCLS(petype));
 806       return type;
 807   }
 808   fields = fields->next ;
 809     }
 810     werror(E_NOT_MEMBER,id->name);
 811
 812     return NULL ;
 813 }
 814
 815 /*------------------------------------------------------------------*/
 816 /* getStructElement - returns element of a tructure definition      */
 817 /*------------------------------------------------------------------*/
 818 symbol *getStructElement ( structdef *sdef, symbol *sym)
 819 {
 820     symbol *field ;
 821
 822     for ( field = sdef->fields ; field ; field = field->next )
 823   if ( strcmp(field->name,sym->name) == 0)
 824       return field ;
 825
 826     werror(E_NOT_MEMBER,sym->name);
 827
 828     return sdef->fields ;
 829 }
 830
 831 /*------------------------------------------------------------------*/
 832 /* compStructSize - computes the size of a structure                */
 833 /*------------------------------------------------------------------*/
 834 int   compStructSize (int su, structdef  *sdef )
 835 {
 836     int sum = 0 , usum =0;
 837     int bitOffset = 0 ;
 838     symbol   *loop ;
 839
 840     /* for the identifiers  */
 841     loop = sdef->fields ;
 842     while ( loop ) {
 843
 844   /* create the internal name for this variable */
 845   sprintf (loop->rname,"_%s",loop->name);
 846   loop->offset = ( su == UNION ? sum = 0 : sum ) ;
 847   SPEC_VOLATILE(loop->etype) |= (su == UNION ? 1 : 0);
 848
 849   /* if this is a bit field  */
 850   if (loop->bitVar)       {
 851
 852       /* change it to a unsigned bit */
 853       SPEC_NOUN(loop->etype) = V_BIT ;
 854       SPEC_USIGN(loop->etype) = 1     ;
 855       /* check if this fit into the remaining   */
 856       /* bits of this byte else align it to the */
 857       /* next byte boundary                     */
 858       if ((SPEC_BLEN(loop->etype)=loop->bitVar) <= (8 - bitOffset))  {
 859     SPEC_BSTR(loop->etype) = bitOffset   ;
 860     if ((bitOffset += (loop->bitVar % 8)) == 8) sum++;
 861       }
 862       else  /* does not fit */
 863     {
 864         bitOffset = 0 ;
 865         SPEC_BSTR(loop->etype) = bitOffset   ;
 866         sum += (loop->bitVar / 8)  ;
 867         bitOffset += (loop->bitVar % 8);
 868     }
 869       /* if this is the last field then pad */
 870       if (!loop->next && bitOffset && bitOffset != 8) {
 871     bitOffset = 0 ;
 872     sum++ ;
 873       }
 874   }
 875   else {
 876       checkDecl (loop);
 877       sum += getSize (loop->type) ;
 878   }
 879
 880   /* if function then do the arguments for it */
 881   if (funcInChain(loop->type)) {
 882       processFuncArgs (loop, 1);
 883   }
 884
 885   loop = loop->next ;
 886
 887   /* if this is not a bitfield but the */
 888   /* previous one was and did not take */
 889   /* the whole byte then pad the rest  */
 890   if ((loop && !loop->bitVar) && bitOffset) {
 891       bitOffset = 0 ;
 892       sum++ ;
 893   }
 894
 895   /* if union then size = sizeof larget field */
 896     if (su == UNION)
 897       usum = max(usum,sum);
 898
 899     }
 900
 901     return (su == UNION ? usum : sum);
 902 }
 903
 904 /*------------------------------------------------------------------*/
 905 /* checkSClass - check the storage class specification              */
 906 /*------------------------------------------------------------------*/
 907 static void  checkSClass ( symbol *sym )
 908 {
 909     /* type is literal can happen foe enums change
 910        to auto */
 911     if (SPEC_SCLS(sym->etype) == S_LITERAL && !SPEC_ENUM(sym->etype))
 912   SPEC_SCLS(sym->etype) = S_AUTO;
 913
 914     /* if sfr or sbit then must also be */
 915     /* volatile the initial value will be xlated */
 916     /* to an absolute address */
 917     if (SPEC_SCLS(sym->etype) == S_SBIT ||
 918   SPEC_SCLS(sym->etype) == S_SFR ) {
 919   SPEC_VOLATILE(sym->etype) = 1;
 920   /* if initial value given */
 921   if (sym->ival) {
 922       SPEC_ABSA(sym->etype) = 1;
 923       SPEC_ADDR(sym->etype) =
 924     (int) list2int(sym->ival);
 925       sym->ival = NULL;
 926   }
 927     }
 928
 929     /* if absolute address given then it mark it as
 930        volatile */
 931     if (IS_ABSOLUTE(sym->etype))
 932   SPEC_VOLATILE(sym->etype) = 1;
 933
 934     /* global variables declared const put into code */
 935     if (sym->level == 0 &&
 936   SPEC_SCLS(sym->etype) == S_CONSTANT) {
 937   SPEC_SCLS(sym->etype) = S_CODE ;
 938   SPEC_CONST(sym->etype) = 1;
 939     }
 940
 941     /* global variable in code space is a constant */
 942     if (sym->level == 0 &&
 943   SPEC_SCLS(sym->etype) == S_CODE &&
 944   port->mem.code_ro )
 945   SPEC_CONST(sym->etype) = 1;
 946
 947
 948     /* if bit variable then no storage class can be */
 949     /* specified since bit is already a storage */
 950     if ( IS_BITVAR(sym->etype)              &&
 951    ( SPEC_SCLS(sym->etype) != S_FIXED &&
 952      SPEC_SCLS(sym->etype) != S_SBIT  &&
 953      SPEC_SCLS(sym->etype) != S_BIT )
 954    ) {
 955   werror (E_BITVAR_STORAGE,sym->name);
 956   SPEC_SCLS(sym->etype) = S_FIXED ;
 957     }
 958
 959     /* extern variables cannot be initialized */
 960     if (IS_EXTERN(sym->etype) && sym->ival)     {
 961   werror(E_EXTERN_INIT,sym->name);
 962   sym->ival = NULL;
 963     }
 964
 965     /* if this is an automatic symbol then */
 966     /* storage class will be ignored and   */
 967     /* symbol will be allocated on stack/  */
 968     /* data depending on flag             */
 969     if ( sym->level                             &&
 970    (options.stackAuto || reentrant )      &&
 971    ( SPEC_SCLS(sym->etype) != S_AUTO      &&
 972      SPEC_SCLS(sym->etype) != S_FIXED     &&
 973      SPEC_SCLS(sym->etype) != S_REGISTER  &&
 974      SPEC_SCLS(sym->etype) != S_STACK     &&
 975      SPEC_SCLS(sym->etype) != S_XSTACK    &&
 976      SPEC_SCLS(sym->etype) != S_CONSTANT  )) {
 977
 978   werror(E_AUTO_ASSUMED,sym->name) ;
 979   SPEC_SCLS(sym->etype) = S_AUTO   ;
 980     }
 981
 982     /* automatic symbols cannot be given   */
 983     /* an absolute address ignore it      */
 984     if ( sym->level  &&
 985    SPEC_ABSA(sym->etype) &&
 986    (options.stackAuto || reentrant) )  {
 987   werror(E_AUTO_ABSA,sym->name);
 988   SPEC_ABSA(sym->etype) = 0 ;
 989     }
 990
 991     /* arrays & pointers cannot be defined for bits   */
 992     /* SBITS or SFRs or BIT                           */
 993     if ((IS_ARRAY(sym->type) || IS_PTR(sym->type))  &&
 994   ( SPEC_NOUN(sym->etype) == V_BIT          ||
 995    SPEC_NOUN(sym->etype) == V_SBIT             ||
 996    SPEC_SCLS(sym->etype) == S_SFR              ))
 997   werror(E_BIT_ARRAY,sym->name);
 998
 999     /* if this is a bit|sbit then set length & start  */
1000     if (SPEC_NOUN(sym->etype) == V_BIT              ||
1001   SPEC_NOUN(sym->etype) == V_SBIT             )  {
1002   SPEC_BLEN(sym->etype) = 1 ;
1003   SPEC_BSTR(sym->etype) = 0 ;
1004     }
1005
1006     /* variables declared in CODE space must have */
1007     /* initializers if not an extern */
1008     if (SPEC_SCLS(sym->etype) == S_CODE &&
1009   sym->ival == NULL               &&
1010   !sym->level                     &&
1011   port->mem.code_ro               &&
1012   !IS_EXTERN(sym->etype)    &&
1013   !funcInChain(sym->type))
1014   werror(E_CODE_NO_INIT,sym->name);
1015
1016     /* if parameter or local variable then change */
1017     /* the storage class to reflect where the var will go */
1018     if ( sym->level && SPEC_SCLS(sym->etype) == S_FIXED) {
1019   if ( options.stackAuto || (currFunc && IS_RENT(currFunc->etype)))
1020   {
1021       SPEC_SCLS(sym->etype) = (options.useXstack  ?
1022              S_XSTACK : S_STACK ) ;
1023   }
1024   else
1025   {
1026       /* hack-o-matic! I see no reason why the useXstack option should ever
1027        * control this allcoation, but the code was originally that way, and
1028        * changing it for non-390 ports breaks the compiler badly.
1029        */
1030       bool useXdata = IS_DS390_PORT ? options.model : options.useXstack;
1031       SPEC_SCLS(sym->etype) = (useXdata  ?
1032              S_XDATA : S_FIXED ) ;
1033   }
1034     }
1035 }
1036
1037 /*------------------------------------------------------------------*/
1038 /* changePointer - change pointer to functions                      */
1039 /*------------------------------------------------------------------*/
1040 void  changePointer  (symbol  *sym)
1041 {
1042     sym_link *p ;
1043
1044     /* go thru the chain of declarations   */
1045     /* if we find a pointer to a function  */
1046     /* unconditionally change it to a ptr  */
1047     /* to code area                        */
1048     for ( p = sym->type ; p ; p = p->next) {
1049   if ( !IS_SPEC(p) && DCL_TYPE(p) == UPOINTER)
1050       DCL_TYPE(p) = GPOINTER ;
1051   if ( IS_PTR(p) && IS_FUNC(p->next))
1052       DCL_TYPE(p) = CPOINTER ;
1053     }
1054 }
1055
1056 /*------------------------------------------------------------------*/
1057 /* checkDecl - does semantic validation of a declaration                   */
1058 /*------------------------------------------------------------------*/
1059 int checkDecl ( symbol *sym )
1060 {
1061
1062     checkSClass  (sym); /* check the storage class      */
1063     changePointer(sym);  /* change pointers if required */
1064
1065     /* if this is an array without any dimension
1066        then update the dimension from the initial value */
1067     if (IS_ARRAY(sym->type) && !DCL_ELEM(sym->type))
1068   DCL_ELEM(sym->type) = getNelements (sym->type,sym->ival);
1069
1070     return 0 ;
1071 }
1072
1073 /*------------------------------------------------------------------*/
1074 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1075 /*------------------------------------------------------------------*/
1076 sym_link  *copyLinkChain ( sym_link *p)
1077 {
1078     sym_link  *head, *curr , *loop;
1079
1080     curr = p ;
1081     head = loop = ( curr ? newLink() : (void *) NULL) ;
1082     while (curr)   {
1083   memcpy(loop,curr,sizeof(sym_link)) ; /* copy it */
1084   loop->next = (curr->next ? newLink() : (void *) NULL) ;
1085   loop = loop->next ;
1086   curr = curr->next ;
1087     }
1088
1089     return head ;
1090 }
1091
1092
1093 /*------------------------------------------------------------------*/
1094 /* cleanUpBlock - cleansup the symbol table specified for all the   */
1095 /*                symbols in the given block                        */
1096 /*------------------------------------------------------------------*/
1097 void cleanUpBlock ( bucket **table, int block)
1098 {
1099     int i ;
1100     bucket  *chain;
1101
1102     /* go thru the entire  table  */
1103     for ( i = 0 ; i < 256; i++ ) {
1104   for ( chain = table[i]; chain ; chain = chain->next ) {
1105       if (chain->block >= block) {
1106     deleteSym (table,chain->sym,chain->name);
1107       }
1108   }
1109     }
1110 }
1111
1112 /*------------------------------------------------------------------*/
1113 /* cleanUpLevel - cleansup the symbol table specified for all the   */
1114 /*                symbols in the given level                        */
1115 /*------------------------------------------------------------------*/
1116 void  cleanUpLevel   (bucket  **table, int level )
1117 {
1118     int i ;
1119     bucket  *chain;
1120
1121     /* go thru the entire  table  */
1122     for ( i = 0 ; i < 256; i++ ) {
1123   for ( chain = table[i]; chain ; chain = chain->next ) {
1124       if (chain->level >= level) {
1125     deleteSym (table,chain->sym,chain->name);
1126       }
1127   }
1128     }
1129 }
1130
1131 /*------------------------------------------------------------------*/
1132 /* computeType - computes the resultant type from two types         */
1133 /*------------------------------------------------------------------*/
1134 sym_link *computeType ( sym_link *type1, sym_link *type2)
1135 {
1136     sym_link *rType ;
1137     sym_link *reType;
1138     sym_link *etype1 = getSpec(type1);
1139     sym_link *etype2 = getSpec(type2);
1140
1141     /* if one of them is a float then result is a float */
1142     /* here we assume that the types passed are okay */
1143     /* and can be cast to one another                */
1144     /* which ever is greater in size */
1145     if (IS_FLOAT(etype1) || IS_FLOAT(etype2))
1146   rType = newFloatLink();
1147     else
1148   /* if only one of them is a bit variable
1149      then the other one prevails */
1150   if (IS_BITVAR(etype1) && !IS_BITVAR(etype2))
1151       rType = copyLinkChain(type2);
1152   else
1153       if (IS_BITVAR(etype2) && !IS_BITVAR(etype1))
1154     rType = copyLinkChain(type1);
1155       else
1156     /* if one of them is a pointer then that
1157        prevails */
1158     if (IS_PTR(type1))
1159         rType = copyLinkChain(type1);
1160     else
1161         if (IS_PTR(type2))
1162       rType = copyLinkChain(type2);
1163         else
1164       if (getSize (type1) > getSize(type2) )
1165           rType = copyLinkChain(type1);
1166       else
1167           rType = copyLinkChain(type2);
1168
1169     reType = getSpec(rType);
1170
1171     /* if either of them unsigned then make this unsigned */
1172     if ((SPEC_USIGN(etype1) || SPEC_USIGN(etype2)) && !IS_FLOAT(reType))
1173   SPEC_USIGN(reType) = 1;
1174
1175     /* if result is a literal then make not so */
1176     if (IS_LITERAL(reType))
1177   SPEC_SCLS(reType) = S_REGISTER ;
1178
1179     return rType;
1180 }
1181
1182 /*------------------------------------------------------------------*/
1183 /* checkType - will do type check return 1 if match                 */
1184 /*------------------------------------------------------------------*/
1185 int checkType ( sym_link *dest, sym_link *src )
1186 {
1187     if ( !dest && !src)
1188   return 1;
1189
1190     if (dest && !src)
1191   return 0;
1192
1193     if (src && !dest)
1194   return 0;
1195
1196     /* if dest is a declarator then */
1197     if (IS_DECL(dest)) {
1198   if (IS_DECL(src)) {
1199       if (DCL_TYPE(src) == DCL_TYPE(dest))
1200     return checkType(dest->next,src->next);
1201       else
1202     if (IS_PTR(src) && IS_PTR(dest))
1203         return -1;
1204     else
1205         if (IS_PTR(dest) && IS_ARRAY(src))
1206       return -1;
1207         else
1208       if (IS_PTR(dest) && IS_FUNC(dest->next) && IS_FUNC(src))
1209           return -1 * checkType (dest->next,src) ;
1210       else
1211           return 0;
1212   }
1213   else
1214       if (IS_PTR(dest) && IS_INTEGRAL(src))
1215     return -1;
1216       else
1217     return 0;
1218     }
1219
1220     /* if one is a specifier and the other is not */
1221     if ((IS_SPEC(src) && !IS_SPEC(dest)) ||
1222   (IS_SPEC(dest) && !IS_SPEC(src))) return 0;
1223
1224     /* if one of them is a void then ok */
1225     if (SPEC_NOUN(dest) == V_VOID    &&
1226   SPEC_NOUN(src)  != V_VOID    )
1227   return -1 ;
1228
1229     if (SPEC_NOUN(dest) != V_VOID &&
1230   SPEC_NOUN(src) == V_VOID )
1231   return -1;
1232
1233     /* char === to short */
1234     if (SPEC_NOUN(dest) == V_CHAR &&
1235   SPEC_NOUN(src)  == V_INT  &&
1236   SPEC_SHORT(src)           )
1237   return (SPEC_USIGN(src) == SPEC_USIGN(dest) ? 1 : -2);
1238
1239     if (SPEC_NOUN(src) == V_CHAR &&
1240   SPEC_NOUN(dest)  == V_INT  &&
1241   SPEC_SHORT(dest)           )
1242   return (SPEC_USIGN(src) == SPEC_USIGN(dest) ? 1 : -2);
1243
1244     /* if they are both bitfields then if the lengths
1245        and starts don't match */
1246     if (IS_BITFIELD(dest) && IS_BITFIELD(src) &&
1247   (SPEC_BLEN(dest) != SPEC_BLEN(src) ||
1248    SPEC_BSTR(dest) != SPEC_BSTR(src)))
1249       return -1;
1250
1251     /* it is a specifier */
1252     if (SPEC_NOUN(dest) != SPEC_NOUN(src))      {
1253   if (SPEC_USIGN(dest) == SPEC_USIGN(src) &&
1254       IS_INTEGRAL(dest) && IS_INTEGRAL(src) &&
1255       getSize(dest) == getSize(src))
1256       return 1;
1257   else
1258       if (IS_ARITHMETIC(dest) && IS_ARITHMETIC(src))
1259     return -1;
1260   else
1261       return 0;
1262     }
1263     else
1264   if (IS_STRUCT(dest)) {
1265       if (SPEC_STRUCT(dest) != SPEC_STRUCT(src))
1266     return 0 ;
1267       else
1268     return 1 ;
1269   }
1270     if (SPEC_LONG(dest) != SPEC_LONG(src))
1271   return -1;
1272
1273     if (SPEC_SHORT(dest) != SPEC_SHORT(src))
1274   return -1;
1275
1276     if (SPEC_USIGN(dest) != SPEC_USIGN(src))
1277   return -2;
1278
1279     return 1;
1280 }
1281
1282 /*------------------------------------------------------------------*/
1283 /* inCalleeSaveList - return 1 if found in calle save list          */
1284 /*------------------------------------------------------------------*/
1285 bool inCalleeSaveList ( char *s)
1286 {
1287     int i;
1288
1289     for (i = 0 ; options.calleeSaves[i] ; i++ )
1290   if (strcmp(options.calleeSaves[i],s) == 0)
1291       return 1;
1292
1293     return 0;
1294 }
1295
1296 /*-----------------------------------------------------------------*/
1297 /* aggregateArgToPointer:  change an agggregate type function      */
1298 /*         argument to a pointer to that type.     */
1299 /*-----------------------------------------------------------------*/
1300 void aggregateArgToPointer(value *val)
1301 {
1302   if ( IS_AGGREGATE(val->type)) {
1303       /* if this is a structure */
1304       /* then we need to add a new link */
1305       if (IS_STRUCT(val->type)) {
1306         /* first lets add DECLARATOR type */
1307     sym_link *p = val->type ;
1308
1309     werror(W_STRUCT_AS_ARG,val->name);
1310     val->type = newLink();
1311     val->type->next = p ;
1312       }
1313
1314       /* change to a pointer depending on the */
1315       /* storage class specified        */
1316       switch (SPEC_SCLS(val->etype)) {
1317       case S_IDATA:
1318     DCL_TYPE(val->type) = IPOINTER;
1319     break;
1320       case S_PDATA:
1321     DCL_TYPE(val->type) = PPOINTER;
1322     break;
1323       case S_FIXED:
1324         if (IS_DS390_PORT)
1325         {
1326             /* The AUTO and REGISTER classes should probably
1327              * also become generic pointers, but I haven't yet
1328              * devised a test case for that.
1329              */
1330             DCL_TYPE(val->type) = GPOINTER;
1331             break;
1332         }
1333         /* fall through! */
1334       case S_AUTO:
1335       case S_DATA:
1336       case S_REGISTER:
1337     DCL_TYPE(val->type) = POINTER ;
1338     break;
1339       case S_CODE:
1340     DCL_TYPE(val->type) = CPOINTER;
1341     break;
1342       case S_XDATA:
1343     DCL_TYPE(val->type) = FPOINTER;
1344     break;
1345       case S_EEPROM:
1346     DCL_TYPE(val->type) = EEPPOINTER;
1347     break;
1348       default :
1349     DCL_TYPE(val->type) = GPOINTER;
1350       }
1351
1352       /* is there is a symbol associated then */
1353       /* change the type of the symbol as well*/
1354       if ( val->sym ) {
1355     val->sym->type = copyLinkChain(val->type);
1356     val->sym->etype = getSpec(val->sym->type);
1357       }
1358   }
1359 }
1360 /*------------------------------------------------------------------*/
1361 /* checkFunction - does all kinds of check on a function            */
1362 /*------------------------------------------------------------------*/
1363 int   checkFunction (symbol   *sym)
1364 {
1365     symbol *csym ;
1366     value  *exargs, *acargs ;
1367     int argCnt = 0 ;
1368
1369     /* if not type then some kind of error */
1370     if ( !sym->type )
1371   return 0;
1372
1373     /* if the function has no type then make it return int */
1374     if ( !sym->type->next )
1375   sym->type->next = sym->etype = newIntLink();
1376
1377     /* function cannot return aggregate */
1378     if (IS_AGGREGATE(sym->type->next))   {
1379   werror(E_FUNC_AGGR,sym->name);
1380   return 0;
1381     }
1382
1383     /* function cannot return bit */
1384     if (IS_BITVAR(sym->type->next)) {
1385   werror(E_FUNC_BIT,sym->name);
1386   return 0;
1387     }
1388
1389     /* check if this function is defined as calleeSaves
1390        then mark it as such */
1391     sym->calleeSave = inCalleeSaveList(sym->name);
1392
1393     /* if interrupt service routine  */
1394     /* then it cannot have arguments */
1395     if ( sym->args  && IS_ISR(sym->etype) && !IS_VOID(sym->args->type))   {
1396   werror(E_INT_ARGS,sym->name);
1397   sym->args = NULL ;
1398     }
1399
1400     if (!(csym = findSym (SymbolTab, sym, sym->name )))
1401   return 1 ;  /* not defined nothing more to check  */
1402
1403     /* check if body already present */
1404     if ( csym && csym->fbody )   {
1405   werror(E_FUNC_BODY,sym->name);
1406   return 0;
1407     }
1408
1409     /* check the return value type   */
1410     if (checkType (csym->type,sym->type) <= 0) {
1411   werror(E_PREV_DEF_CONFLICT,csym->name,"type") ;
1412   werror (E_CONTINUE,"previous defintion type ");
1413   printTypeChain(csym->type,stderr);fprintf(stderr,"\n");
1414   werror (E_CONTINUE,"current definition type ");
1415   printTypeChain(sym->type,stderr);fprintf(stderr,"\n");
1416   return 0;
1417     }
1418
1419     if ( SPEC_INTRTN(csym->etype) != SPEC_INTRTN(sym->etype)) {
1420   werror (E_PREV_DEF_CONFLICT,csym->name,"interrupt");
1421   return 0;
1422     }
1423
1424     if (SPEC_BANK(csym->etype) != SPEC_BANK(sym->etype)) {
1425   werror (E_PREV_DEF_CONFLICT,csym->name,"using");
1426   return 0;
1427     }
1428
1429     /* compare expected agrs with actual args */
1430     exargs = csym->args ;
1431     acargs = sym->args  ;
1432
1433     /* for all the expected args do */
1434     for (argCnt =  1    ;
1435    exargs && acargs ;
1436          exargs = exargs->next, acargs = acargs->next, argCnt++ )
1437     {
1438         value *checkValue;
1439         /* If the actual argument is an array, any prototype
1440          * will have modified it to a pointer. Duplicate that
1441          * change here.
1442          */
1443         if ( IS_AGGREGATE(acargs->type))
1444         {
1445             checkValue = copyValue(acargs);
1446       aggregateArgToPointer(checkValue);
1447   }
1448   else
1449   {
1450       checkValue = acargs;
1451   }
1452
1453   if ( checkType(exargs->type,checkValue->type) <= 0)
1454   {
1455       werror(E_ARG_TYPE,argCnt);
1456       return 0;
1457   }
1458     }
1459
1460     /* if one them ended we have a problem */
1461     if ((exargs && !acargs && !IS_VOID(exargs->type)) ||
1462   (!exargs && acargs && !IS_VOID(acargs->type)))
1463   werror(E_ARG_COUNT);
1464
1465     /* replace with this defition */
1466     sym->cdef = csym->cdef;
1467     deleteSym (SymbolTab,csym,csym->name);
1468     addSym    (SymbolTab,sym,sym->name,sym->level,sym->block);
1469     if (IS_EXTERN(csym->etype) && !
1470   IS_EXTERN(sym->etype)) {
1471   addSet(&publics,sym);
1472     }
1473     return 1 ;
1474 }
1475
1476 /*-----------------------------------------------------------------*/
1477 /* processFuncArgs - does some processing with function args       */
1478 /*-----------------------------------------------------------------*/
1479 void  processFuncArgs   (symbol *func, int ignoreName)
1480 {
1481     value *val ;
1482     int pNum = 1;
1483
1484
1485     /* if this function has variable argument list */
1486     /* then make the function a reentrant one    */
1487     if (func->hasVargs)
1488   SPEC_RENT(func->etype) = 1;
1489
1490     /* check if this function is defined as calleeSaves
1491        then mark it as such */
1492     func->calleeSave = inCalleeSaveList(func->name);
1493
1494     val = func->args; /* loop thru all the arguments   */
1495
1496     /* if it is void then remove parameters */
1497     if (val && IS_VOID(val->type)) {
1498   func->args = NULL ;
1499   return ;
1500     }
1501
1502     /* reset regparm for the port */
1503     (*port->reset_regparms)();
1504     /* if any of the arguments is an aggregate */
1505     /* change it to pointer to the same type */
1506     while (val) {
1507   /* mark it as a register parameter if
1508      the function does not have VA_ARG
1509      and as port dictates
1510      not inhibited by command line option or #pragma */
1511   if (!func->hasVargs       &&
1512       !options.noregparms   &&
1513       !IS_RENT(func->etype) &&
1514       (*port->reg_parm)(val->type)) {
1515       SPEC_REGPARM(val->etype) = 1;
1516   }
1517
1518   if ( IS_AGGREGATE(val->type)) {
1519       aggregateArgToPointer(val);
1520   }
1521   val = val->next ;
1522   pNum++;
1523     }
1524
1525     /* if this function is reentrant or */
1526     /* automatics r 2b stacked then nothing */
1527     if (IS_RENT(func->etype) || options.stackAuto )
1528   return ;
1529
1530     val = func->args;
1531     pNum = 1;
1532     while (val) {
1533
1534   /* if a symbolname is not given  */
1535   /* synthesize a variable name */
1536   if (!val->sym) {
1537
1538       sprintf(val->name,"_%s_PARM_%d",func->name,pNum++);
1539       val->sym = newSymbol(val->name,1);
1540       SPEC_OCLS(val->etype) = port->mem.default_local_map;
1541       val->sym->type = copyLinkChain (val->type);
1542       val->sym->etype = getSpec (val->sym->type);
1543       val->sym->_isparm = 1;
1544       strcpy (val->sym->rname,val->name);
1545       SPEC_STAT(val->etype) = SPEC_STAT(val->sym->etype) =
1546     SPEC_STAT(func->etype);
1547       addSymChain(val->sym);
1548
1549   }
1550   else  /* symbol name given create synth name */      {
1551
1552       sprintf(val->name,"_%s_PARM_%d",func->name,pNum++);
1553       strcpy (val->sym->rname,val->name);
1554       val->sym->_isparm = 1;
1555       SPEC_OCLS(val->etype) = SPEC_OCLS(val->sym->etype) =
1556     (options.model != MODEL_SMALL ? xdata : data);
1557       SPEC_STAT(val->etype) = SPEC_STAT(val->sym->etype) =
1558     SPEC_STAT(func->etype);
1559   }
1560   val = val->next ;
1561     }
1562 }
1563
1564 /*-----------------------------------------------------------------*/
1565 /* isSymbolEqual - compares two symbols return 1 if they match     */
1566 /*-----------------------------------------------------------------*/
1567 int isSymbolEqual (symbol *dest, symbol *src)
1568 {
1569     /* if pointers match then equal */
1570     if (dest == src)
1571   return 1;
1572
1573     /* if one of them is null then don't match */
1574     if (!dest || !src)
1575   return 0;
1576
1577     /* if both of them have rname match on rname */
1578     if (dest->rname[0] && src->rname[0])
1579   return (!strcmp(dest->rname,src->rname));
1580
1581     /* otherwise match on name */
1582     return (!strcmp(dest->name,src->name));
1583 }
1584
1585 /*-----------------------------------------------------------------*/
1586 /* printTypeChain - prints the type chain in human readable form   */
1587 /*-----------------------------------------------------------------*/
1588 void printTypeChain (sym_link *type, FILE *of)
1589 {
1590     int nlr = 0;
1591
1592     if (!of) {
1593   of = stdout;
1594   nlr = 1;
1595     }
1596
1597     while (type) {
1598   if (IS_DECL(type)) {
1599       switch (DCL_TYPE(type)) {
1600       case FUNCTION:
1601     fprintf (of,"function ");
1602     break;
1603       case GPOINTER:
1604     fprintf (of,"_generic * ");
1605     if (DCL_PTR_CONST(type))
1606         fprintf(of,"const ");
1607     break;
1608       case CPOINTER:
1609     fprintf (of,"_code * ");
1610     if (DCL_PTR_CONST(type))
1611         fprintf(of,"const ");
1612     break;
1613       case FPOINTER:
1614     fprintf (of,"_far * ");
1615     if (DCL_PTR_CONST(type))
1616         fprintf(of,"const ");
1617     break;
1618       case EEPPOINTER:
1619     fprintf (of,"_eeprom * ");
1620     if (DCL_PTR_CONST(type))
1621         fprintf(of,"const ");
1622     break;
1623
1624       case POINTER:
1625     fprintf (of,"_near * ");
1626     if (DCL_PTR_CONST(type))
1627         fprintf(of,"const ");
1628     break;
1629       case IPOINTER:
1630     fprintf (of,"_idata *");
1631     if (DCL_PTR_CONST(type))
1632         fprintf(of,"const ");
1633     break;
1634       case PPOINTER:
1635     fprintf (of,"_pdata *");
1636     if (DCL_PTR_CONST(type))
1637         fprintf(of,"const ");
1638     break;
1639       case UPOINTER:
1640     fprintf (of," _unkown *");
1641     if (DCL_PTR_CONST(type))
1642         fprintf(of,"const ");
1643     break;
1644
1645       case ARRAY :
1646     fprintf (of,"array of ");
1647     break;
1648       }
1649   } else {
1650       if (SPEC_VOLATILE(type))
1651     fprintf (of,"volatile ");
1652       if (SPEC_USIGN(type))
1653     fprintf (of,"unsigned ");
1654
1655       switch (SPEC_NOUN(type)) {
1656       case V_INT:
1657     if (IS_LONG(type))
1658         fprintf (of,"long ");
1659     else
1660         if (IS_SHORT(type))
1661       fprintf (of,"short ");
1662         else
1663       fprintf (of,"int ");
1664     break;
1665
1666       case V_CHAR:
1667     fprintf(of,"char ");
1668     break;
1669
1670       case V_VOID:
1671     fprintf(of,"void ");
1672     break;
1673
1674             case V_FLOAT:
1675           fprintf(of,"float ");
1676     break;
1677
1678       case V_STRUCT:
1679     fprintf(of,"struct %s",SPEC_STRUCT(type)->tag);
1680     break;
1681
1682       case V_SBIT:
1683     fprintf(of,"sbit ");
1684     break;
1685
1686       case V_BIT:
1687     fprintf(of,"bit {%d,%d}",SPEC_BSTR(type),SPEC_BLEN(type));
1688     break;
1689
1690       default:
1691     break;
1692       }
1693   }
1694   type = type->next;
1695     }
1696     if (nlr)
1697   fprintf(of,"\n");
1698 }
1699
1700 /*-----------------------------------------------------------------*/
1701 /* cdbTypeInfo - print the type information for debugger           */
1702 /*-----------------------------------------------------------------*/
1703 void cdbTypeInfo (sym_link *type,FILE *of)
1704 {
1705     fprintf(of,"{%d}",getSize(type));
1706     while (type) {
1707   if (IS_DECL(type)) {
1708       switch (DCL_TYPE(type)) {
1709       case FUNCTION:
1710     fprintf (of,"DF,");
1711     break;
1712       case GPOINTER:
1713     fprintf (of,"DG,");
1714     break;
1715       case CPOINTER:
1716     fprintf (of,"DC,");
1717     break;
1718       case FPOINTER:
1719     fprintf (of,"DX,");
1720     break;
1721       case POINTER:
1722     fprintf (of,"DD,");
1723     break;
1724       case IPOINTER:
1725     fprintf (of,"DI,");
1726     break;
1727       case PPOINTER:
1728     fprintf (of,"DP,");
1729     break;
1730       case EEPPOINTER:
1731     fprintf (of,"DA,");
1732     break;
1733       case ARRAY :
1734     fprintf (of,"DA%d,",DCL_ELEM(type));
1735     break;
1736       default:
1737     break;
1738       }
1739   } else {
1740       switch (SPEC_NOUN(type)) {
1741       case V_INT:
1742     if (IS_LONG(type))
1743         fprintf (of,"SL");
1744     else
1745         if (IS_SHORT(type))
1746       fprintf (of,"SS");
1747         else
1748       fprintf (of,"SI");
1749     break;
1750
1751       case V_CHAR:
1752     fprintf(of,"SC");
1753     break;
1754
1755       case V_VOID:
1756     fprintf(of,"SV");
1757     break;
1758
1759             case V_FLOAT:
1760           fprintf(of,"SF");
1761     break;
1762
1763       case V_STRUCT:
1764     fprintf(of,"ST%s",SPEC_STRUCT(type)->tag);
1765     break;
1766
1767       case V_SBIT:
1768     fprintf(of,"SX");
1769     break;
1770
1771       case V_BIT:
1772     fprintf(of,"SB%d$%d",SPEC_BSTR(type),SPEC_BLEN(type));
1773     break;
1774
1775       default:
1776     break;
1777       }
1778       fputs(":",of);
1779       if (SPEC_USIGN(type))
1780     fputs("U",of);
1781       else
1782     fputs("S",of);
1783   }
1784   type = type->next;
1785     }
1786 }
1787 /*-----------------------------------------------------------------*/
1788 /* cdbSymbol - prints a symbol & its type information for debugger */
1789 /*-----------------------------------------------------------------*/
1790 void cdbSymbol ( symbol *sym, FILE *of, int isStructSym, int isFunc)
1791 {
1792     memmap *map;
1793
1794     if (!sym)
1795   return ;
1796     if (!of)
1797   of = stdout;
1798
1799     if (isFunc)
1800   fprintf(of,"F:");
1801     else
1802   fprintf(of,"S:"); /* symbol record */
1803     /* if this is not a structure symbol then
1804        we need to figure out the scope information */
1805     if (!isStructSym) {
1806   if (!sym->level) {
1807       /* global */
1808       if (IS_STATIC(sym->etype))
1809     fprintf(of,"F%s$",moduleName); /* scope is file */
1810       else
1811     fprintf(of,"G$"); /* scope is global */
1812   }
1813   else
1814       /* symbol is local */
1815       fprintf(of,"L%s$",(sym->localof ? sym->localof->name : "-null-"));
1816     } else
1817   fprintf(of,"S$"); /* scope is structure */
1818
1819     /* print the name, & mangled name */
1820     fprintf(of,"%s$%d$%d(",sym->name,
1821       sym->level,sym->block);
1822
1823     cdbTypeInfo(sym->type,of);
1824     fprintf(of,"),");
1825
1826     /* print the address space */
1827     map = SPEC_OCLS(sym->etype);
1828     fprintf(of,"%c,%d,%d",
1829       (map ? map->dbName : 'Z') ,sym->onStack,SPEC_STAK(sym->etype));
1830
1831     /* if assigned to registers then output register names */
1832     /* if this is a function then print
1833        if is it an interrupt routine & interrupt number
1834        and the register bank it is using */
1835     if (isFunc)
1836   fprintf(of,",%d,%d,%d",SPEC_INTRTN(sym->etype),
1837     SPEC_INTN(sym->etype),SPEC_BANK(sym->etype));
1838     /* alternate location to find this symbol @ : eg registers
1839        or spillication */
1840
1841     if (!isStructSym)
1842   fprintf(of,"\n");
1843 }
1844
1845 /*-----------------------------------------------------------------*/
1846 /* cdbStruct - print a structure for debugger                      */
1847 /*-----------------------------------------------------------------*/
1848 void cdbStruct ( structdef *sdef,int block,FILE *of,
1849      int inStruct, char *tag)
1850 {
1851     symbol *sym;
1852
1853     fprintf(of,"T:");
1854     /* if block # then must have function scope */
1855     fprintf(of,"F%s$",moduleName);
1856     fprintf(of,"%s[",(tag ? tag : sdef->tag));
1857     for (sym=sdef->fields ; sym ; sym = sym->next) {
1858   fprintf(of,"({%d}",sym->offset);
1859       cdbSymbol(sym,of,TRUE,FALSE);
1860   fprintf(of,")");
1861     }
1862     fprintf(of,"]");
1863     if (!inStruct)
1864   fprintf(of,"\n");
1865 }
1866
1867 /*------------------------------------------------------------------*/
1868 /* cdbStructBlock - calls struct printing for a blcks               */
1869 /*------------------------------------------------------------------*/
1870 void cdbStructBlock (int block , FILE *of)
1871 {
1872     int i ;
1873     bucket **table = StructTab;
1874     bucket  *chain;
1875     wassert(of);
1876
1877     /* go thru the entire  table  */
1878     for ( i = 0 ; i < 256; i++ ) {
1879   for ( chain = table[i]; chain ; chain = chain->next ) {
1880       if (chain->block >= block) {
1881     cdbStruct((structdef *)chain->sym, chain->block ,of,0,NULL);
1882       }
1883   }
1884     }
1885 }
1886
1887 /*-----------------------------------------------------------------*/
1888 /* powof2 - returns power of two for the number if number is pow 2 */
1889 /*-----------------------------------------------------------------*/
1890 int powof2 (unsigned long num)
1891 {
1892     int nshifts = 0;
1893     int n1s = 0 ;
1894
1895     while (num) {
1896   if (num & 1) n1s++ ;
1897   num >>= 1 ;
1898   nshifts++ ;
1899     }
1900
1901     if (n1s > 1 || nshifts == 0) return 0;
1902     return nshifts - 1 ;
1903 }
1904
1905 symbol *__fsadd ;
1906 symbol *__fssub ;
1907 symbol *__fsmul ;
1908 symbol *__fsdiv ;
1909 symbol *__fseq  ;
1910 symbol *__fsneq ;
1911 symbol *__fslt  ;
1912 symbol *__fslteq;
1913 symbol *__fsgt  ;
1914 symbol *__fsgteq;
1915
1916 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
1917 symbol *__muldiv[3][3][2];
1918 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
1919 sym_link *__multypes[3][2];
1920 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
1921 symbol *__conv[2][3][2];
1922
1923 sym_link *floatType;
1924
1925 static void _makeRegParam(symbol *sym)
1926 {
1927     value *val ;
1928
1929     val = sym->args; /* loop thru all the arguments   */
1930
1931     /* reset regparm for the port */
1932     (*port->reset_regparms)();
1933     while (val) {
1934   SPEC_REGPARM(val->etype) = 1;
1935   sym->argStack -= getSize(val->type);
1936   val = val->next ;
1937     }
1938 }
1939
1940 /*-----------------------------------------------------------------*/
1941 /* initCSupport - create functions for C support routines          */
1942 /*-----------------------------------------------------------------*/
1943 void initCSupport ()
1944 {
1945     const char *smuldivmod[] = {
1946   "mul", "div", "mod"
1947     };
1948     const char *sbwd[] = {
1949   "char", "int", "long"
1950     };
1951     const char *ssu[] = {
1952   "s", "u"
1953     };
1954
1955     int bwd, su, muldivmod, tofrom;
1956
1957     floatType= newFloatLink();
1958
1959     for (bwd = 0; bwd < 3; bwd++) {
1960   sym_link *l;
1961   switch (bwd) {
1962   case 0:
1963       l = newCharLink();
1964       break;
1965   case 1:
1966       l = newIntLink();
1967       break;
1968   case 2:
1969       l = newLongLink();
1970       break;
1971   default:
1972       assert(0);
1973   }
1974   __multypes[bwd][0] = l;
1975   __multypes[bwd][1] = copyLinkChain(l);
1976   SPEC_USIGN(__multypes[bwd][1]) = 1;
1977     }
1978
1979     __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
1980     __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
1981     __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
1982     __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
1983     __fseq  = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
1984     __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
1985     __fslt  = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
1986     __fslteq= funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
1987     __fsgt  = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
1988     __fsgteq= funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
1989
1990     for (tofrom = 0; tofrom < 2; tofrom++) {
1991   for (bwd = 0; bwd < 3; bwd++) {
1992       for (su = 0; su < 2; su++) {
1993     if (tofrom) {
1994         sprintf(buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
1995         __conv[tofrom][bwd][su] = funcOfType(buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
1996     }
1997     else {
1998         sprintf(buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
1999         __conv[tofrom][bwd][su] = funcOfType(buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2000     }
2001       }
2002   }
2003     }
2004
2005     for (muldivmod = 0; muldivmod < 3; muldivmod++) {
2006   for (bwd = 0; bwd < 3; bwd++) {
2007       for (su = 0; su < 2; su++) {
2008     sprintf(buffer, "_%s%s%s",
2009       smuldivmod[muldivmod],
2010       ssu[su],
2011       sbwd[bwd]);
2012     __muldiv[muldivmod][bwd][su] = funcOfType(buffer, __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2013     SPEC_NONBANKED(__muldiv[muldivmod][bwd][su]->etype) = 1;
2014     if (bwd < port->muldiv.force_reg_param_below)
2015         _makeRegParam(__muldiv[muldivmod][bwd][su]);
2016       }
2017   }
2018     }
2019 }