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

   1 /*-------------------------------------------------------------------------
   2   SDCCast.c - source file for parser support & all ast related routines
   3
   4              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #include "common.h"
  26 #include "newalloc.h"
  27
  28 int currLineno = 0;
  29 set *astList = NULL;
  30 set *operKeyReset = NULL;
  31 ast *staticAutos = NULL;
  32 int labelKey = 1;
  33
  34 #define LRVAL(x) x->left->rvalue
  35 #define RRVAL(x) x->right->rvalue
  36 #define TRVAL(x) x->rvalue
  37 #define LLVAL(x) x->left->lvalue
  38 #define RLVAL(x) x->right->lvalue
  39 #define TLVAL(x) x->lvalue
  40 #define RTYPE(x) x->right->ftype
  41 #define RETYPE(x) x->right->etype
  42 #define LTYPE(x) x->left->ftype
  43 #define LETYPE(x) x->left->etype
  44 #define TTYPE(x) x->ftype
  45 #define TETYPE(x) x->etype
  46 #define ALLOCATE 1
  47 #define DEALLOCATE 2
  48
  49 char buffer[1024];
  50 int noLineno = 0;
  51 int noAlloc = 0;
  52 symbol *currFunc;
  53 ast *createIval (ast *, sym_link *, initList *, ast *);
  54 ast *createIvalCharPtr (ast *, sym_link *, ast *);
  55 ast *optimizeRRCRLC (ast *);
  56 ast *optimizeGetHbit (ast *);
  57 ast *backPatchLabels (ast *, symbol *, symbol *);
  58 int inInitMode = 0;
  59 memmap *GcurMemmap=NULL;  /* points to the memmap that's currently active */
  60 FILE *codeOutFile;
  61 int
  62 ptt (ast * tree)
  63 {
  64   printTypeChain (tree->ftype, stdout);
  65   return 0;
  66 }
  67
  68
  69 /*-----------------------------------------------------------------*/
  70 /* newAst - creates a fresh node for an expression tree           */
  71 /*-----------------------------------------------------------------*/
  72 #if 0
  73 ast *
  74 newAst (int type, void *op)
  75 {
  76   ast *ex;
  77   static int oldLineno = 0;
  78
  79   Safe_calloc (1, ex, sizeof (ast));
  80
  81   ex->type = type;
  82   ex->lineno = (noLineno ? oldLineno : yylineno);
  83   ex->filename = currFname;
  84   ex->level = NestLevel;
  85   ex->block = currBlockno;
  86   ex->initMode = inInitMode;
  87
  88   /* depending on the type */
  89   switch (type)
  90     {
  91     case EX_VALUE:
  92       ex->opval.val = (value *) op;
  93       break;
  94     case EX_OP:
  95       ex->opval.op = (long) op;
  96       break;
  97     case EX_LINK:
  98       ex->opval.lnk = (sym_link *) op;
  99       break;
 100     case EX_STMNT:
 101       ex->opval.stmnt = (unsigned) op;
 102     }
 103
 104   return ex;
 105 }
 106 #endif
 107
 108 static ast *
 109 newAst_ (unsigned type)
 110 {
 111   ast *ex;
 112   static int oldLineno = 0;
 113
 114   ex = Safe_calloc (1, sizeof (ast));
 115
 116   ex->type = type;
 117   ex->lineno = (noLineno ? oldLineno : yylineno);
 118   ex->filename = currFname;
 119   ex->level = NestLevel;
 120   ex->block = currBlockno;
 121   ex->initMode = inInitMode;
 122   return ex;
 123 }
 124
 125 ast *
 126 newAst_VALUE (value * val)
 127 {
 128   ast *ex = newAst_ (EX_VALUE);
 129   ex->opval.val = val;
 130   return ex;
 131 }
 132
 133 ast *
 134 newAst_OP (unsigned op)
 135 {
 136   ast *ex = newAst_ (EX_OP);
 137   ex->opval.op = op;
 138   return ex;
 139 }
 140
 141 ast *
 142 newAst_LINK (sym_link * val)
 143 {
 144   ast *ex = newAst_ (EX_LINK);
 145   ex->opval.lnk = val;
 146   return ex;
 147 }
 148
 149 ast *
 150 newAst_STMNT (unsigned val)
 151 {
 152   ast *ex = newAst_ (EX_STMNT);
 153   ex->opval.stmnt = val;
 154   return ex;
 155 }
 156
 157 /*-----------------------------------------------------------------*/
 158 /* newNode - creates a new node                                    */
 159 /*-----------------------------------------------------------------*/
 160 ast *
 161 newNode (long op, ast * left, ast * right)
 162 {
 163   ast *ex;
 164
 165   ex = newAst_OP (op);
 166   ex->left = left;
 167   ex->right = right;
 168
 169   return ex;
 170 }
 171
 172 /*-----------------------------------------------------------------*/
 173 /* newIfxNode - creates a new Ifx Node                             */
 174 /*-----------------------------------------------------------------*/
 175 ast *
 176 newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel)
 177 {
 178   ast *ifxNode;
 179
 180   /* if this is a literal then we already know the result */
 181   if (condAst->etype && IS_LITERAL (condAst->etype))
 182     {
 183       /* then depending on the expression value */
 184       if (floatFromVal (condAst->opval.val))
 185         ifxNode = newNode (GOTO,
 186                            newAst_VALUE (symbolVal (trueLabel)),
 187                            NULL);
 188       else
 189         ifxNode = newNode (GOTO,
 190                            newAst_VALUE (symbolVal (falseLabel)),
 191                            NULL);
 192     }
 193   else
 194     {
 195       ifxNode = newNode (IFX, condAst, NULL);
 196       ifxNode->trueLabel = trueLabel;
 197       ifxNode->falseLabel = falseLabel;
 198     }
 199
 200   return ifxNode;
 201 }
 202
 203 /*-----------------------------------------------------------------*/
 204 /* copyAstValues - copies value portion of ast if needed     */
 205 /*-----------------------------------------------------------------*/
 206 void
 207 copyAstValues (ast * dest, ast * src)
 208 {
 209   switch (src->opval.op)
 210     {
 211     case BLOCK:
 212       dest->values.sym = copySymbolChain (src->values.sym);
 213       break;
 214
 215     case SWITCH:
 216       dest->values.switchVals.swVals =
 217         copyValue (src->values.switchVals.swVals);
 218       dest->values.switchVals.swDefault =
 219         src->values.switchVals.swDefault;
 220       dest->values.switchVals.swNum =
 221         src->values.switchVals.swNum;
 222       break;
 223
 224     case INLINEASM:
 225       dest->values.inlineasm = Safe_calloc (1, strlen (src->values.inlineasm) + 1);
 226       strcpy (dest->values.inlineasm, src->values.inlineasm);
 227       break;
 228
 229     case ARRAYINIT:
 230         dest->values.constlist = copyLiteralList(src->values.constlist);
 231         break;
 232
 233     case FOR:
 234       AST_FOR (dest, trueLabel) = copySymbol (AST_FOR (src, trueLabel));
 235       AST_FOR (dest, continueLabel) = copySymbol (AST_FOR (src, continueLabel));
 236       AST_FOR (dest, falseLabel) = copySymbol (AST_FOR (src, falseLabel));
 237       AST_FOR (dest, condLabel) = copySymbol (AST_FOR (src, condLabel));
 238       AST_FOR (dest, initExpr) = copyAst (AST_FOR (src, initExpr));
 239       AST_FOR (dest, condExpr) = copyAst (AST_FOR (src, condExpr));
 240       AST_FOR (dest, loopExpr) = copyAst (AST_FOR (src, loopExpr));
 241     }
 242
 243 }
 244
 245 /*-----------------------------------------------------------------*/
 246 /* copyAst - makes a copy of a given astession                     */
 247 /*-----------------------------------------------------------------*/
 248 ast *
 249 copyAst (ast * src)
 250 {
 251   ast *dest;
 252
 253   if (!src)
 254     return NULL;
 255
 256   dest = Safe_calloc (1, sizeof (ast));
 257
 258   dest->type = src->type;
 259   dest->lineno = src->lineno;
 260   dest->level = src->level;
 261   dest->funcName = src->funcName;
 262   dest->argSym = src->argSym;
 263
 264   /* if this is a leaf */
 265   /* if value */
 266   if (src->type == EX_VALUE)
 267     {
 268       dest->opval.val = copyValue (src->opval.val);
 269       goto exit;
 270     }
 271
 272   /* if link */
 273   if (src->type == EX_LINK)
 274     {
 275       dest->opval.lnk = copyLinkChain (src->opval.lnk);
 276       goto exit;
 277     }
 278
 279   dest->opval.op = src->opval.op;
 280
 281   /* if this is a node that has special values */
 282   copyAstValues (dest, src);
 283
 284   if (src->ftype)
 285     dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
 286
 287   dest->trueLabel = copySymbol (src->trueLabel);
 288   dest->falseLabel = copySymbol (src->falseLabel);
 289   dest->left = copyAst (src->left);
 290   dest->right = copyAst (src->right);
 291 exit:
 292   return dest;
 293
 294 }
 295
 296 /*-----------------------------------------------------------------*/
 297 /* hasSEFcalls - returns TRUE if tree has a function call          */
 298 /*-----------------------------------------------------------------*/
 299 bool
 300 hasSEFcalls (ast * tree)
 301 {
 302   if (!tree)
 303     return FALSE;
 304
 305   if (tree->type == EX_OP &&
 306       (tree->opval.op == CALL ||
 307        tree->opval.op == PCALL ||
 308        tree->opval.op == '=' ||
 309        tree->opval.op == INC_OP ||
 310        tree->opval.op == DEC_OP))
 311     return TRUE;
 312
 313   return (hasSEFcalls (tree->left) |
 314           hasSEFcalls (tree->right));
 315 }
 316
 317 /*-----------------------------------------------------------------*/
 318 /* isAstEqual - compares two asts & returns 1 if they are equal    */
 319 /*-----------------------------------------------------------------*/
 320 int
 321 isAstEqual (ast * t1, ast * t2)
 322 {
 323   if (!t1 && !t2)
 324     return 1;
 325
 326   if (!t1 || !t2)
 327     return 0;
 328
 329   /* match type */
 330   if (t1->type != t2->type)
 331     return 0;
 332
 333   switch (t1->type)
 334     {
 335     case EX_OP:
 336       if (t1->opval.op != t2->opval.op)
 337         return 0;
 338       return (isAstEqual (t1->left, t2->left) &&
 339               isAstEqual (t1->right, t2->right));
 340       break;
 341
 342     case EX_VALUE:
 343       if (t1->opval.val->sym)
 344         {
 345           if (!t2->opval.val->sym)
 346             return 0;
 347           else
 348             return isSymbolEqual (t1->opval.val->sym,
 349                                   t2->opval.val->sym);
 350         }
 351       else
 352         {
 353           if (t2->opval.val->sym)
 354             return 0;
 355           else
 356             return (floatFromVal (t1->opval.val) ==
 357                     floatFromVal (t2->opval.val));
 358         }
 359       break;
 360
 361       /* only compare these two types */
 362     default:
 363       return 0;
 364     }
 365
 366   return 0;
 367 }
 368
 369 /*-----------------------------------------------------------------*/
 370 /* resolveSymbols - resolve symbols from the symbol table          */
 371 /*-----------------------------------------------------------------*/
 372 ast *
 373 resolveSymbols (ast * tree)
 374 {
 375   /* walk the entire tree and check for values */
 376   /* with symbols if we find one then replace  */
 377   /* symbol with that from the symbol table    */
 378
 379   if (tree == NULL)
 380     return tree;
 381
 382   /* print the line          */
 383   /* if not block & function */
 384   if (tree->type == EX_OP &&
 385       (tree->opval.op != FUNCTION &&
 386        tree->opval.op != BLOCK &&
 387        tree->opval.op != NULLOP))
 388     {
 389       filename = tree->filename;
 390       lineno = tree->lineno;
 391     }
 392
 393   /* make sure we resolve the true & false labels for ifx */
 394   if (tree->type == EX_OP && tree->opval.op == IFX)
 395     {
 396       symbol *csym;
 397
 398       if (tree->trueLabel)
 399         {
 400           if ((csym = findSym (LabelTab, tree->trueLabel,
 401                                tree->trueLabel->name)))
 402             tree->trueLabel = csym;
 403           else
 404             werror (E_LABEL_UNDEF, tree->trueLabel->name);
 405         }
 406
 407       if (tree->falseLabel)
 408         {
 409           if ((csym = findSym (LabelTab,
 410                                tree->falseLabel,
 411                                tree->falseLabel->name)))
 412             tree->falseLabel = csym;
 413           else
 414             werror (E_LABEL_UNDEF, tree->falseLabel->name);
 415         }
 416
 417     }
 418
 419   /* if this is a label resolve it from the labelTab */
 420   if (IS_AST_VALUE (tree) &&
 421       tree->opval.val->sym &&
 422       tree->opval.val->sym->islbl)
 423     {
 424
 425       symbol *csym = findSym (LabelTab, tree->opval.val->sym,
 426                               tree->opval.val->sym->name);
 427
 428       if (!csym)
 429         werror (E_LABEL_UNDEF, tree->opval.val->sym->name);
 430       else
 431         tree->opval.val->sym = csym;
 432
 433       goto resolveChildren;
 434     }
 435
 436   /* do only for leafs */
 437   if (IS_AST_VALUE (tree) &&
 438       tree->opval.val->sym &&
 439       !tree->opval.val->sym->implicit)
 440     {
 441
 442       symbol *csym = findSymWithLevel (SymbolTab, tree->opval.val->sym);
 443
 444       /* if found in the symbol table & they r not the same */
 445       if (csym && tree->opval.val->sym != csym)
 446         {
 447           tree->opval.val->sym = csym;
 448           tree->opval.val->type = csym->type;
 449           tree->opval.val->etype = csym->etype;
 450         }
 451
 452       /* if not found in the symbol table */
 453       /* mark it as undefined assume it is */
 454       /* an integer in data space         */
 455       if (!csym && !tree->opval.val->sym->implicit)
 456         {
 457
 458           /* if this is a function name then */
 459           /* mark it as returning an int     */
 460           if (tree->funcName)
 461             {
 462               tree->opval.val->sym->type = newLink ();
 463               DCL_TYPE (tree->opval.val->sym->type) = FUNCTION;
 464               tree->opval.val->sym->type->next =
 465                 tree->opval.val->sym->etype = newIntLink ();
 466               tree->opval.val->etype = tree->opval.val->etype;
 467               tree->opval.val->type = tree->opval.val->sym->type;
 468               werror (W_IMPLICIT_FUNC, tree->opval.val->sym->name);
 469               allocVariables (tree->opval.val->sym);
 470             }
 471           else
 472             {
 473               tree->opval.val->sym->undefined = 1;
 474               tree->opval.val->type =
 475                 tree->opval.val->etype = newIntLink ();
 476               tree->opval.val->sym->type =
 477                 tree->opval.val->sym->etype = newIntLink ();
 478             }
 479         }
 480     }
 481
 482 resolveChildren:
 483   resolveSymbols (tree->left);
 484   resolveSymbols (tree->right);
 485
 486   return tree;
 487 }
 488
 489 /*-----------------------------------------------------------------*/
 490 /* setAstLineno - walks a ast tree & sets the line number          */
 491 /*-----------------------------------------------------------------*/
 492 int
 493 setAstLineno (ast * tree, int lineno)
 494 {
 495   if (!tree)
 496     return 0;
 497
 498   tree->lineno = lineno;
 499   setAstLineno (tree->left, lineno);
 500   setAstLineno (tree->right, lineno);
 501   return 0;
 502 }
 503
 504 #if 0
 505 /* this functions seems to be superfluous?! kmh */
 506
 507 /*-----------------------------------------------------------------*/
 508 /* resolveFromTable - will return the symbal table value           */
 509 /*-----------------------------------------------------------------*/
 510 value *
 511 resolveFromTable (value * val)
 512 {
 513   symbol *csym;
 514
 515   if (!val->sym)
 516     return val;
 517
 518   csym = findSymWithLevel (SymbolTab, val->sym);
 519
 520   /* if found in the symbol table & they r not the same */
 521   if (csym && val->sym != csym &&
 522       csym->level == val->sym->level &&
 523       csym->_isparm &&
 524       !csym->ismyparm)
 525     {
 526
 527       val->sym = csym;
 528       val->type = csym->type;
 529       val->etype = csym->etype;
 530     }
 531
 532   return val;
 533 }
 534 #endif
 535
 536 /*-----------------------------------------------------------------*/
 537 /* funcOfType :- function of type with name                        */
 538 /*-----------------------------------------------------------------*/
 539 symbol *
 540 funcOfType (char *name, sym_link * type, sym_link * argType,
 541             int nArgs, int rent)
 542 {
 543   symbol *sym;
 544   /* create the symbol */
 545   sym = newSymbol (name, 0);
 546
 547   /* if arguments required */
 548   if (nArgs)
 549     {
 550
 551       value *args;
 552       args = sym->args = newValue ();
 553
 554       while (nArgs--)
 555         {
 556           args->type = copyLinkChain (argType);
 557           args->etype = getSpec (args->type);
 558           if (!nArgs)
 559             break;
 560           args = args->next = newValue ();
 561         }
 562     }
 563
 564   /* setup return value */
 565   sym->type = newLink ();
 566   DCL_TYPE (sym->type) = FUNCTION;
 567   sym->type->next = copyLinkChain (type);
 568   sym->etype = getSpec (sym->type);
 569   SPEC_RENT (sym->etype) = rent;
 570
 571   /* save it */
 572   addSymChain (sym);
 573   sym->cdef = 1;
 574   allocVariables (sym);
 575   return sym;
 576
 577 }
 578
 579 /*-----------------------------------------------------------------*/
 580 /* reverseParms - will reverse a parameter tree                    */
 581 /*-----------------------------------------------------------------*/
 582 void
 583 reverseParms (ast * ptree)
 584 {
 585   ast *ttree;
 586   if (!ptree)
 587     return;
 588
 589   /* top down if we find a nonParm tree then quit */
 590   if (ptree->type == EX_OP && ptree->opval.op == PARAM)
 591     {
 592       ttree = ptree->left;
 593       ptree->left = ptree->right;
 594       ptree->right = ttree;
 595       reverseParms (ptree->left);
 596       reverseParms (ptree->right);
 597     }
 598
 599   return;
 600 }
 601
 602 /*-----------------------------------------------------------------*/
 603 /* processParms  - makes sure the parameters are okay and do some  */
 604 /*                 processing with them                            */
 605 /*-----------------------------------------------------------------*/
 606 int
 607 processParms (ast * func,
 608               value * defParm,
 609               ast * actParm,
 610               int *parmNumber,
 611               bool rightmost)
 612 {
 613   int castError=0;
 614   sym_link *fetype = func->etype;
 615
 616   /* if none of them exist */
 617   if (!defParm && !actParm)
 618     return 0;
 619
 620   if (defParm) {
 621     if (getenv("DEBUG_SANITY")) {
 622       fprintf (stderr, "addSym: %s ", defParm->name);
 623     }
 624     /* make sure the type is complete and sane */
 625     checkTypeSanity(defParm->etype, defParm->name);
 626   }
 627
 628   /* if the function is being called via a pointer &   */
 629   /* it has not been defined a reentrant then we cannot */
 630   /* have parameters                                   */
 631   if (func->type != EX_VALUE && !IS_RENT (fetype) && !options.stackAuto)
 632     {
 633       werror (W_NONRENT_ARGS);
 634       return 1;
 635     }
 636
 637   /* if defined parameters ended but actual parameters */
 638   /* exist and this is not defined as a variable arg   */
 639   /* also check if statckAuto option is specified      */
 640   if ((!defParm) && actParm && (!func->hasVargs) &&
 641       !options.stackAuto && !IS_RENT (fetype))
 642     {
 643       werror (E_TOO_MANY_PARMS);
 644       return 1;
 645     }
 646
 647   /* if defined parameters present but no actual parameters */
 648   if (defParm && !actParm)
 649     {
 650       werror (E_TOO_FEW_PARMS);
 651       return 1;
 652     }
 653
 654   /* If this is a varargs function... */
 655   if (!defParm && actParm && func->hasVargs)
 656     {
 657       ast *newType = NULL;
 658       sym_link *ftype;
 659
 660       if (IS_CAST_OP (actParm)
 661           || (IS_AST_LIT_VALUE (actParm) && actParm->values.literalFromCast))
 662         {
 663           /* Parameter was explicitly typecast; don't touch it. */
 664           return 0;
 665         }
 666
 667       /* The ternary ('?') operator is weird: the ftype of the
 668        * operator is the type of the condition, but it will return a
 669        * (possibly) different type.
 670        */
 671       if (IS_TERNARY_OP(actParm))
 672       {
 673           assert(IS_COLON_OP(actParm->right));
 674           assert(actParm->right->left);
 675           ftype = actParm->right->left->ftype;
 676       }
 677       else
 678       {
 679           ftype = actParm->ftype;
 680       }
 681
 682       /* If it's a small integer, upcast to int. */
 683       if (IS_INTEGRAL (ftype)
 684           && (getSize (ftype) < (unsigned) INTSIZE))
 685         {
 686           newType = newAst_LINK(INTTYPE);
 687         }
 688
 689       if (IS_PTR(ftype) && !IS_GENPTR(ftype))
 690         {
 691           newType = newAst_LINK (copyLinkChain(ftype));
 692           DCL_TYPE (newType->opval.lnk) = GPOINTER;
 693         }
 694
 695       if (IS_AGGREGATE (ftype))
 696         {
 697           newType = newAst_LINK (copyLinkChain (ftype));
 698           DCL_TYPE (newType->opval.lnk) = GPOINTER;
 699         }
 700       if (newType)
 701         {
 702           /* cast required; change this op to a cast. */
 703           ast *parmCopy = resolveSymbols (copyAst (actParm));
 704
 705           actParm->type = EX_OP;
 706           actParm->opval.op = CAST;
 707           actParm->left = newType;
 708           actParm->right = parmCopy;
 709           decorateType (actParm);
 710         }
 711       else if (actParm->type == EX_OP && actParm->opval.op == PARAM)
 712         {
 713           return (processParms (func, NULL, actParm->left, parmNumber, FALSE) ||
 714           processParms (func, NULL, actParm->right, parmNumber, rightmost));
 715         }
 716       return 0;
 717     }
 718
 719   /* if defined parameters ended but actual has not & */
 720   /* stackAuto                */
 721   if (!defParm && actParm &&
 722       (options.stackAuto || IS_RENT (fetype)))
 723     return 0;
 724
 725   resolveSymbols (actParm);
 726   /* if this is a PARAM node then match left & right */
 727   if (actParm->type == EX_OP && actParm->opval.op == PARAM)
 728     {
 729       return (processParms (func, defParm, actParm->left, parmNumber, FALSE) ||
 730               processParms (func, defParm->next, actParm->right, parmNumber, rightmost));
 731     }
 732   else
 733     {
 734       /* If we have found a value node by following only right-hand links,
 735        * then we know that there are no more values after us.
 736        *
 737        * Therefore, if there are more defined parameters, the caller didn't
 738        * supply enough.
 739        */
 740       if (rightmost && defParm->next)
 741         {
 742           werror (E_TOO_FEW_PARMS);
 743           return 1;
 744         }
 745     }
 746
 747
 748   /* the parameter type must be at least castable */
 749   if (compareType (defParm->type, actParm->ftype) == 0)
 750     {
 751       castError++;
 752     }
 753
 754 #ifdef JWK20010916
 755   if (!IS_SPEC(defParm->type) && !IS_SPEC(actParm->ftype)) {
 756     // now we have two pointers, check if they point to the same
 757     sym_link *dtype=defParm->type, *atype=actParm->ftype;
 758     do {
 759       dtype=dtype->next;
 760       atype=atype->next;
 761       if (
 762           (dtype->next && !atype->next) ||
 763           (!dtype->next && atype->next) ||
 764           compareType (dtype, atype)!=1) {
 765         castError++;
 766       }
 767     } while (dtype->next && atype->next);
 768     if (IS_SPEC(dtype) && IS_SPEC(atype)) {
 769       // ok so far, we have two etypes, they must have the same SCLASS
 770       if (SPEC_SCLS(dtype)!=SPEC_SCLS(atype)) {
 771         castError++;
 772       }
 773     }
 774   }
 775 #endif
 776
 777   if (castError) {
 778     werror (W_INCOMPAT_CAST);
 779     fprintf (stderr, "type --> '");
 780     printTypeChain (actParm->ftype, stderr);
 781     fprintf (stderr, "' ");
 782     fprintf (stderr, "assigned to type --> '");
 783     printTypeChain (defParm->type, stderr);
 784     fprintf (stderr, "'\n");
 785   }
 786
 787   /* if the parameter is castable then add the cast */
 788   if (compareType (defParm->type, actParm->ftype) < 0)
 789     {
 790       ast *pTree = resolveSymbols (copyAst (actParm));
 791
 792       /* now change the current one to a cast */
 793       actParm->type = EX_OP;
 794       actParm->opval.op = CAST;
 795       actParm->left = newAst_LINK (defParm->type);
 796       actParm->right = pTree;
 797       actParm->etype = defParm->etype;
 798       actParm->ftype = defParm->type;
 799     }
 800
 801 /*    actParm->argSym = resolveFromTable(defParm)->sym ; */
 802
 803   actParm->argSym = defParm->sym;
 804   /* make a copy and change the regparm type to the defined parm */
 805   actParm->etype = getSpec (actParm->ftype = copyLinkChain (actParm->ftype));
 806   SPEC_REGPARM (actParm->etype) = SPEC_REGPARM (defParm->etype);
 807   (*parmNumber)++;
 808   return 0;
 809 }
 810 /*-----------------------------------------------------------------*/
 811 /* createIvalType - generates ival for basic types                 */
 812 /*-----------------------------------------------------------------*/
 813 ast *
 814 createIvalType (ast * sym, sym_link * type, initList * ilist)
 815 {
 816   ast *iExpr;
 817
 818   /* if initList is deep */
 819   if (ilist->type == INIT_DEEP)
 820     ilist = ilist->init.deep;
 821
 822   iExpr = decorateType (resolveSymbols (list2expr (ilist)));
 823   return decorateType (newNode ('=', sym, iExpr));
 824 }
 825
 826 /*-----------------------------------------------------------------*/
 827 /* createIvalStruct - generates initial value for structures       */
 828 /*-----------------------------------------------------------------*/
 829 ast *
 830 createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 831 {
 832   ast *rast = NULL;
 833   symbol *sflds;
 834   initList *iloop;
 835
 836   sflds = SPEC_STRUCT (type)->fields;
 837   if (ilist->type != INIT_DEEP)
 838     {
 839       werror (E_INIT_STRUCT, "");
 840       return NULL;
 841     }
 842
 843   iloop = ilist->init.deep;
 844
 845   for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
 846     {
 847       ast *lAst;
 848
 849       /* if we have come to end */
 850       if (!iloop)
 851         break;
 852       sflds->implicit = 1;
 853       lAst = newNode (PTR_OP, newNode ('&', sym, NULL), newAst_VALUE (symbolVal (sflds)));
 854       lAst = decorateType (resolveSymbols (lAst));
 855       rast = decorateType (resolveSymbols (createIval (lAst, sflds->type, iloop, rast)));
 856     }
 857   return rast;
 858 }
 859
 860
 861 /*-----------------------------------------------------------------*/
 862 /* createIvalArray - generates code for array initialization       */
 863 /*-----------------------------------------------------------------*/
 864 ast *
 865 createIvalArray (ast * sym, sym_link * type, initList * ilist)
 866 {
 867   ast *rast = NULL;
 868   initList *iloop;
 869   int lcnt = 0, size = 0;
 870   literalList *literalL;
 871
 872   /* take care of the special   case  */
 873   /* array of characters can be init  */
 874   /* by a string                      */
 875   if (IS_CHAR (type->next))
 876     if ((rast = createIvalCharPtr (sym,
 877                                    type,
 878                         decorateType (resolveSymbols (list2expr (ilist))))))
 879
 880       return decorateType (resolveSymbols (rast));
 881
 882     /* not the special case             */
 883     if (ilist->type != INIT_DEEP)
 884     {
 885         werror (E_INIT_STRUCT, "");
 886         return NULL;
 887     }
 888
 889     iloop = ilist->init.deep;
 890     lcnt = DCL_ELEM (type);
 891
 892     if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL))
 893     {
 894         ast *aSym;
 895
 896         aSym = decorateType (resolveSymbols(sym));
 897
 898         rast = newNode(ARRAYINIT, aSym, NULL);
 899         rast->values.constlist = literalL;
 900
 901         // Make sure size is set to length of initializer list.
 902         while (iloop)
 903         {
 904             size++;
 905             iloop = iloop->next;
 906         }
 907
 908         if (lcnt && size > lcnt)
 909         {
 910             // Array size was specified, and we have more initializers than needed.
 911             char *name=sym->opval.val->sym->name;
 912             int lineno=sym->opval.val->sym->lineDef;
 913
 914             werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
 915         }
 916     }
 917     else
 918     {
 919         for (;;)
 920         {
 921             ast *aSym;
 922
 923             aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++))));
 924             aSym = decorateType (resolveSymbols (aSym));
 925             rast = createIval (aSym, type->next, iloop, rast);
 926             iloop = (iloop ? iloop->next : NULL);
 927             if (!iloop)
 928             {
 929                 break;
 930             }
 931
 932             /* no of elements given and we    */
 933             /* have generated for all of them */
 934             if (!--lcnt)
 935             {
 936                 // there has to be a better way
 937                 char *name=sym->opval.val->sym->name;
 938                 int lineno=sym->opval.val->sym->lineDef;
 939                 werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
 940
 941                 break;
 942             }
 943         }
 944     }
 945
 946     /* if we have not been given a size  */
 947     if (!DCL_ELEM (type))
 948     {
 949         DCL_ELEM (type) = size;
 950     }
 951
 952     return decorateType (resolveSymbols (rast));
 953 }
 954
 955
 956 /*-----------------------------------------------------------------*/
 957 /* createIvalCharPtr - generates initial values for char pointers  */
 958 /*-----------------------------------------------------------------*/
 959 ast *
 960 createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 961 {
 962   ast *rast = NULL;
 963
 964   /* if this is a pointer & right is a literal array then */
 965   /* just assignment will do                              */
 966   if (IS_PTR (type) && ((IS_LITERAL (iexpr->etype) ||
 967                          SPEC_SCLS (iexpr->etype) == S_CODE)
 968                         && IS_ARRAY (iexpr->ftype)))
 969     return newNode ('=', sym, iexpr);
 970
 971   /* left side is an array so we have to assign each */
 972   /* element                                         */
 973   if ((IS_LITERAL (iexpr->etype) ||
 974        SPEC_SCLS (iexpr->etype) == S_CODE)
 975       && IS_ARRAY (iexpr->ftype))
 976     {
 977       /* for each character generate an assignment */
 978       /* to the array element */
 979       char *s = SPEC_CVAL (iexpr->etype).v_char;
 980       int i = 0;
 981
 982       while (*s)
 983         {
 984           rast = newNode (NULLOP,
 985                           rast,
 986                           newNode ('=',
 987                                    newNode ('[', sym,
 988                                    newAst_VALUE (valueFromLit ((float) i))),
 989                                    newAst_VALUE (valueFromLit (*s))));
 990           i++;
 991           s++;
 992         }
 993       rast = newNode (NULLOP,
 994                       rast,
 995                       newNode ('=',
 996                                newNode ('[', sym,
 997                                    newAst_VALUE (valueFromLit ((float) i))),
 998                                newAst_VALUE (valueFromLit (*s))));
 999       return decorateType (resolveSymbols (rast));
1000     }
1001
1002   return NULL;
1003 }
1004
1005 /*-----------------------------------------------------------------*/
1006 /* createIvalPtr - generates initial value for pointers            */
1007 /*-----------------------------------------------------------------*/
1008 ast *
1009 createIvalPtr (ast * sym, sym_link * type, initList * ilist)
1010 {
1011   ast *rast;
1012   ast *iexpr;
1013
1014   /* if deep then   */
1015   if (ilist->type == INIT_DEEP)
1016     ilist = ilist->init.deep;
1017
1018   iexpr = decorateType (resolveSymbols (list2expr (ilist)));
1019
1020   /* if character pointer */
1021   if (IS_CHAR (type->next))
1022     if ((rast = createIvalCharPtr (sym, type, iexpr)))
1023       return rast;
1024
1025   return newNode ('=', sym, iexpr);
1026 }
1027
1028 /*-----------------------------------------------------------------*/
1029 /* createIval - generates code for initial value                   */
1030 /*-----------------------------------------------------------------*/
1031 ast *
1032 createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
1033 {
1034   ast *rast = NULL;
1035
1036   if (!ilist)
1037     return NULL;
1038
1039   /* if structure then    */
1040   if (IS_STRUCT (type))
1041     rast = createIvalStruct (sym, type, ilist);
1042   else
1043     /* if this is a pointer */
1044   if (IS_PTR (type))
1045     rast = createIvalPtr (sym, type, ilist);
1046   else
1047     /* if this is an array   */
1048   if (IS_ARRAY (type))
1049     rast = createIvalArray (sym, type, ilist);
1050   else
1051     /* if type is SPECIFIER */
1052   if (IS_SPEC (type))
1053     rast = createIvalType (sym, type, ilist);
1054
1055   if (wid)
1056     return decorateType (resolveSymbols (newNode (NULLOP, wid, rast)));
1057   else
1058     return decorateType (resolveSymbols (rast));
1059 }
1060
1061 /*-----------------------------------------------------------------*/
1062 /* initAggregates - initialises aggregate variables with initv     */
1063 /*-----------------------------------------------------------------*/
1064
1065 /* this has to go */ void printIval (symbol *, sym_link *, initList *, FILE *);
1066
1067 ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
1068   ast *ast;
1069   symbol *newSym;
1070
1071   if (getenv("TRY_THE_NEW_INITIALIZER")) {
1072
1073     if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
1074       fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
1075                "with -mmcs51 and --model-large");
1076       exit(404);
1077     }
1078
1079     if (SPEC_OCLS(sym->etype)==xdata &&
1080         getSize(sym->type) > 16) { // else it isn't worth it: do it the old way
1081
1082       // copy this symbol
1083       newSym=copySymbol (sym);
1084       SPEC_OCLS(newSym->etype)=code;
1085       sprintf (newSym->name, "%s_init__", sym->name);
1086       sprintf (newSym->rname,"%s_init__", sym->rname);
1087       addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
1088
1089       // emit it in the static segment
1090       addSet(&statsg->syms, newSym);
1091
1092       // now memcpy() the entire array from cseg
1093       ast=newNode (ARRAYINIT, // ASSIGN_AGGREGATE
1094                    newAst_VALUE (symbolVal (sym)),
1095                    newAst_VALUE (symbolVal (newSym)));
1096       return decorateType(resolveSymbols(ast));
1097     }
1098   }
1099
1100   return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
1101 }
1102
1103 /*-----------------------------------------------------------------*/
1104 /* gatherAutoInit - creates assignment expressions for initial     */
1105 /*    values                 */
1106 /*-----------------------------------------------------------------*/
1107 ast *
1108 gatherAutoInit (symbol * autoChain)
1109 {
1110   ast *init = NULL;
1111   ast *work;
1112   symbol *sym;
1113
1114   inInitMode = 1;
1115   for (sym = autoChain; sym; sym = sym->next)
1116     {
1117
1118       /* resolve the symbols in the ival */
1119       if (sym->ival)
1120         resolveIvalSym (sym->ival);
1121
1122       /* if this is a static variable & has an */
1123       /* initial value the code needs to be lifted */
1124       /* here to the main portion since they can be */
1125       /* initialised only once at the start    */
1126       if (IS_STATIC (sym->etype) && sym->ival &&
1127           SPEC_SCLS (sym->etype) != S_CODE)
1128         {
1129           symbol *newSym;
1130
1131           // this can only be a constant
1132           if (!inInitMode && !IS_LITERAL(sym->ival->init.node->etype)) {
1133             werror (E_CONST_EXPECTED);
1134           }
1135
1136           /* insert the symbol into the symbol table */
1137           /* with level = 0 & name = rname       */
1138           newSym = copySymbol (sym);
1139           addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
1140
1141           /* now lift the code to main */
1142           if (IS_AGGREGATE (sym->type))
1143             work = initAggregates (sym, sym->ival, NULL);
1144           else
1145             work = newNode ('=', newAst_VALUE (symbolVal (newSym)),
1146                             list2expr (sym->ival));
1147
1148           setAstLineno (work, sym->lineDef);
1149
1150           sym->ival = NULL;
1151           if (staticAutos)
1152             staticAutos = newNode (NULLOP, staticAutos, work);
1153           else
1154             staticAutos = work;
1155
1156           continue;
1157         }
1158
1159       /* if there is an initial value */
1160       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
1161         {
1162           if (IS_AGGREGATE (sym->type))
1163             work = initAggregates (sym, sym->ival, NULL);
1164           else
1165             work = newNode ('=', newAst_VALUE (symbolVal (sym)),
1166                             list2expr (sym->ival));
1167
1168           setAstLineno (work, sym->lineDef);
1169           sym->ival = NULL;
1170           if (init)
1171             init = newNode (NULLOP, init, work);
1172           else
1173             init = work;
1174         }
1175     }
1176   inInitMode = 0;
1177   return init;
1178 }
1179
1180 /*-----------------------------------------------------------------*/
1181 /* stringToSymbol - creates a symbol from a literal string         */
1182 /*-----------------------------------------------------------------*/
1183 static value *
1184 stringToSymbol (value * val)
1185 {
1186   char name[SDCC_NAME_MAX + 1];
1187   static int charLbl = 0;
1188   symbol *sym;
1189
1190   sprintf (name, "_str_%d", charLbl++);
1191   sym = newSymbol (name, 0);    /* make it @ level 0 */
1192   strcpy (sym->rname, name);
1193
1194   /* copy the type from the value passed */
1195   sym->type = copyLinkChain (val->type);
1196   sym->etype = getSpec (sym->type);
1197   /* change to storage class & output class */
1198   SPEC_SCLS (sym->etype) = S_CODE;
1199   SPEC_CVAL (sym->etype).v_char = SPEC_CVAL (val->etype).v_char;
1200   SPEC_STAT (sym->etype) = 1;
1201   /* make the level & block = 0 */
1202   sym->block = sym->level = 0;
1203   sym->isstrlit = 1;
1204   /* create an ival */
1205   sym->ival = newiList (INIT_NODE, newAst_VALUE (val));
1206   if (noAlloc == 0)
1207     {
1208       /* allocate it */
1209       addSymChain (sym);
1210       allocVariables (sym);
1211     }
1212   sym->ival = NULL;
1213   return symbolVal (sym);
1214
1215 }
1216
1217 /*-----------------------------------------------------------------*/
1218 /* processBlockVars - will go thru the ast looking for block if    */
1219 /*                    a block is found then will allocate the syms */
1220 /*                    will also gather the auto inits present      */
1221 /*-----------------------------------------------------------------*/
1222 ast *
1223 processBlockVars (ast * tree, int *stack, int action)
1224 {
1225   if (!tree)
1226     return NULL;
1227
1228   /* if this is a block */
1229   if (tree->type == EX_OP && tree->opval.op == BLOCK)
1230     {
1231       ast *autoInit;
1232
1233       if (action == ALLOCATE)
1234         {
1235           *stack += allocVariables (tree->values.sym);
1236           autoInit = gatherAutoInit (tree->values.sym);
1237
1238           /* if there are auto inits then do them */
1239           if (autoInit)
1240             tree->left = newNode (NULLOP, autoInit, tree->left);
1241         }
1242       else                      /* action is deallocate */
1243         deallocLocal (tree->values.sym);
1244     }
1245
1246   processBlockVars (tree->left, stack, action);
1247   processBlockVars (tree->right, stack, action);
1248   return tree;
1249 }
1250
1251 /*-----------------------------------------------------------------*/
1252 /* constExprValue - returns the value of a constant expression     */
1253 /*-----------------------------------------------------------------*/
1254 value *
1255 constExprValue (ast * cexpr, int check)
1256 {
1257   cexpr = decorateType (resolveSymbols (cexpr));
1258
1259   /* if this is not a constant then */
1260   if (!IS_LITERAL (cexpr->ftype))
1261     {
1262       /* then check if this is a literal array
1263          in code segment */
1264       if (SPEC_SCLS (cexpr->etype) == S_CODE &&
1265           SPEC_CVAL (cexpr->etype).v_char &&
1266           IS_ARRAY (cexpr->ftype))
1267         {
1268           value *val = valFromType (cexpr->ftype);
1269           SPEC_SCLS (val->etype) = S_LITERAL;
1270           val->sym = cexpr->opval.val->sym;
1271           val->sym->type = copyLinkChain (cexpr->ftype);
1272           val->sym->etype = getSpec (val->sym->type);
1273           strcpy (val->name, cexpr->opval.val->sym->rname);
1274           return val;
1275         }
1276
1277       /* if we are casting a literal value then */
1278       if (IS_AST_OP (cexpr) &&
1279           cexpr->opval.op == CAST &&
1280           IS_LITERAL (cexpr->left->ftype))
1281         return valCastLiteral (cexpr->ftype,
1282                                floatFromVal (cexpr->left->opval.val));
1283
1284       if (IS_AST_VALUE (cexpr))
1285         return cexpr->opval.val;
1286
1287       if (check)
1288         werror (E_CONST_EXPECTED, "found expression");
1289
1290       return NULL;
1291     }
1292
1293   /* return the value */
1294   return cexpr->opval.val;
1295
1296 }
1297
1298 /*-----------------------------------------------------------------*/
1299 /* isLabelInAst - will return true if a given label is found       */
1300 /*-----------------------------------------------------------------*/
1301 bool
1302 isLabelInAst (symbol * label, ast * tree)
1303 {
1304   if (!tree || IS_AST_VALUE (tree) || IS_AST_LINK (tree))
1305     return FALSE;
1306
1307   if (IS_AST_OP (tree) &&
1308       tree->opval.op == LABEL &&
1309       isSymbolEqual (AST_SYMBOL (tree->left), label))
1310     return TRUE;
1311
1312   return isLabelInAst (label, tree->right) &&
1313     isLabelInAst (label, tree->left);
1314
1315 }
1316
1317 /*-----------------------------------------------------------------*/
1318 /* isLoopCountable - return true if the loop count can be determi- */
1319 /* -ned at compile time .                                          */
1320 /*-----------------------------------------------------------------*/
1321 bool
1322 isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr,
1323                  symbol ** sym, ast ** init, ast ** end)
1324 {
1325
1326   /* the loop is considered countable if the following
1327      conditions are true :-
1328
1329      a) initExpr :- <sym> = <const>
1330      b) condExpr :- <sym> < <const1>
1331      c) loopExpr :- <sym> ++
1332    */
1333
1334   /* first check the initExpr */
1335   if (IS_AST_OP (initExpr) &&
1336       initExpr->opval.op == '=' &&      /* is assignment */
1337       IS_AST_SYM_VALUE (initExpr->left))
1338     {                           /* left is a symbol */
1339
1340       *sym = AST_SYMBOL (initExpr->left);
1341       *init = initExpr->right;
1342     }
1343   else
1344     return FALSE;
1345
1346   /* for now the symbol has to be of
1347      integral type */
1348   if (!IS_INTEGRAL ((*sym)->type))
1349     return FALSE;
1350
1351   /* now check condExpr */
1352   if (IS_AST_OP (condExpr))
1353     {
1354
1355       switch (condExpr->opval.op)
1356         {
1357         case '<':
1358           if (IS_AST_SYM_VALUE (condExpr->left) &&
1359               isSymbolEqual (*sym, AST_SYMBOL (condExpr->left)) &&
1360               IS_AST_LIT_VALUE (condExpr->right))
1361             {
1362               *end = condExpr->right;
1363               break;
1364             }
1365           return FALSE;
1366
1367         case '!':
1368           if (IS_AST_OP (condExpr->left) &&
1369               condExpr->left->opval.op == '>' &&
1370               IS_AST_LIT_VALUE (condExpr->left->right) &&
1371               IS_AST_SYM_VALUE (condExpr->left->left) &&
1372               isSymbolEqual (*sym, AST_SYMBOL (condExpr->left->left)))
1373             {
1374
1375               *end = newNode ('+', condExpr->left->right,
1376                               newAst_VALUE (constVal ("1")));
1377               break;
1378             }
1379           return FALSE;
1380
1381         default:
1382           return FALSE;
1383         }
1384
1385     }
1386
1387   /* check loop expression is of the form <sym>++ */
1388   if (!IS_AST_OP (loopExpr))
1389     return FALSE;
1390
1391   /* check if <sym> ++ */
1392   if (loopExpr->opval.op == INC_OP)
1393     {
1394
1395       if (loopExpr->left)
1396         {
1397           /* pre */
1398           if (IS_AST_SYM_VALUE (loopExpr->left) &&
1399               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)))
1400             return TRUE;
1401
1402         }
1403       else
1404         {
1405           /* post */
1406           if (IS_AST_SYM_VALUE (loopExpr->right) &&
1407               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->right)))
1408             return TRUE;
1409         }
1410
1411     }
1412   else
1413     {
1414       /* check for += */
1415       if (loopExpr->opval.op == ADD_ASSIGN)
1416         {
1417
1418           if (IS_AST_SYM_VALUE (loopExpr->left) &&
1419               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) &&
1420               IS_AST_LIT_VALUE (loopExpr->right) &&
1421               (int) AST_LIT_VALUE (loopExpr->right) != 1)
1422             return TRUE;
1423         }
1424     }
1425
1426   return FALSE;
1427 }
1428
1429 /*-----------------------------------------------------------------*/
1430 /* astHasVolatile - returns true if ast contains any volatile      */
1431 /*-----------------------------------------------------------------*/
1432 bool
1433 astHasVolatile (ast * tree)
1434 {
1435   if (!tree)
1436     return FALSE;
1437
1438   if (TETYPE (tree) && IS_VOLATILE (TETYPE (tree)))
1439     return TRUE;
1440
1441   if (IS_AST_OP (tree))
1442     return astHasVolatile (tree->left) ||
1443       astHasVolatile (tree->right);
1444   else
1445     return FALSE;
1446 }
1447
1448 /*-----------------------------------------------------------------*/
1449 /* astHasPointer - return true if the ast contains any ptr variable */
1450 /*-----------------------------------------------------------------*/
1451 bool
1452 astHasPointer (ast * tree)
1453 {
1454   if (!tree)
1455     return FALSE;
1456
1457   if (IS_AST_LINK (tree))
1458     return TRUE;
1459
1460   /* if we hit an array expression then check
1461      only the left side */
1462   if (IS_AST_OP (tree) && tree->opval.op == '[')
1463     return astHasPointer (tree->left);
1464
1465   if (IS_AST_VALUE (tree))
1466     return IS_PTR (tree->ftype) || IS_ARRAY (tree->ftype);
1467
1468   return astHasPointer (tree->left) ||
1469     astHasPointer (tree->right);
1470
1471 }
1472
1473 /*-----------------------------------------------------------------*/
1474 /* astHasSymbol - return true if the ast has the given symbol      */
1475 /*-----------------------------------------------------------------*/
1476 bool
1477 astHasSymbol (ast * tree, symbol * sym)
1478 {
1479   if (!tree || IS_AST_LINK (tree))
1480     return FALSE;
1481
1482   if (IS_AST_VALUE (tree))
1483     {
1484       if (IS_AST_SYM_VALUE (tree))
1485         return isSymbolEqual (AST_SYMBOL (tree), sym);
1486       else
1487         return FALSE;
1488     }
1489
1490   return astHasSymbol (tree->left, sym) ||
1491     astHasSymbol (tree->right, sym);
1492 }
1493
1494 /*-----------------------------------------------------------------*/
1495 /* astHasDeref - return true if the ast has an indirect access     */
1496 /*-----------------------------------------------------------------*/
1497 static bool
1498 astHasDeref (ast * tree)
1499 {
1500   if (!tree || IS_AST_LINK (tree) || IS_AST_VALUE(tree))
1501     return FALSE;
1502
1503   if (tree->opval.op == '*' && tree->right == NULL) return TRUE;
1504
1505   return astHasDeref (tree->left) || astHasDeref (tree->right);
1506 }
1507
1508 /*-----------------------------------------------------------------*/
1509 /* isConformingBody - the loop body has to conform to a set of rules */
1510 /* for the loop to be considered reversible read on for rules      */
1511 /*-----------------------------------------------------------------*/
1512 bool
1513 isConformingBody (ast * pbody, symbol * sym, ast * body)
1514 {
1515
1516   /* we are going to do a pre-order traversal of the
1517      tree && check for the following conditions. (essentially
1518      a set of very shallow tests )
1519      a) the sym passed does not participate in
1520      any arithmetic operation
1521      b) There are no function calls
1522      c) all jumps are within the body
1523      d) address of loop control variable not taken
1524      e) if an assignment has a pointer on the
1525      left hand side make sure right does not have
1526      loop control variable */
1527
1528   /* if we reach the end or a leaf then true */
1529   if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody))
1530     return TRUE;
1531
1532
1533   /* if anything else is "volatile" */
1534   if (IS_VOLATILE (TETYPE (pbody)))
1535     return FALSE;
1536
1537   /* we will walk the body in a pre-order traversal for
1538      efficiency sake */
1539   switch (pbody->opval.op)
1540     {
1541 /*------------------------------------------------------------------*/
1542     case '[':
1543       return isConformingBody (pbody->right, sym, body);
1544
1545 /*------------------------------------------------------------------*/
1546     case PTR_OP:
1547     case '.':
1548       return TRUE;
1549
1550 /*------------------------------------------------------------------*/
1551     case INC_OP:                /* incerement operator unary so left only */
1552     case DEC_OP:
1553
1554       /* sure we are not sym is not modified */
1555       if (pbody->left &&
1556           IS_AST_SYM_VALUE (pbody->left) &&
1557           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1558         return FALSE;
1559
1560       if (pbody->right &&
1561           IS_AST_SYM_VALUE (pbody->right) &&
1562           isSymbolEqual (AST_SYMBOL (pbody->right), sym))
1563         return FALSE;
1564
1565       return TRUE;
1566
1567 /*------------------------------------------------------------------*/
1568
1569     case '*':                   /* can be unary  : if right is null then unary operation */
1570     case '+':
1571     case '-':
1572     case '&':
1573
1574       /* if right is NULL then unary operation  */
1575 /*------------------------------------------------------------------*/
1576 /*----------------------------*/
1577       /*  address of                */
1578 /*----------------------------*/
1579       if (!pbody->right)
1580         {
1581           if (IS_AST_SYM_VALUE (pbody->left) &&
1582               isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1583             return FALSE;
1584           else
1585             return isConformingBody (pbody->left, sym, body);
1586         }
1587       else
1588         {
1589           if (astHasSymbol (pbody->left, sym) ||
1590               astHasSymbol (pbody->right, sym))
1591             return FALSE;
1592         }
1593
1594
1595 /*------------------------------------------------------------------*/
1596     case '|':
1597     case '^':
1598     case '/':
1599     case '%':
1600     case LEFT_OP:
1601     case RIGHT_OP:
1602
1603       if (IS_AST_SYM_VALUE (pbody->left) &&
1604           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1605         return FALSE;
1606
1607       if (IS_AST_SYM_VALUE (pbody->right) &&
1608           isSymbolEqual (AST_SYMBOL (pbody->right), sym))
1609         return FALSE;
1610
1611       return isConformingBody (pbody->left, sym, body) &&
1612         isConformingBody (pbody->right, sym, body);
1613
1614     case '~':
1615     case '!':
1616     case RRC:
1617     case RLC:
1618     case GETHBIT:
1619       if (IS_AST_SYM_VALUE (pbody->left) &&
1620           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1621         return FALSE;
1622       return isConformingBody (pbody->left, sym, body);
1623
1624 /*------------------------------------------------------------------*/
1625
1626     case AND_OP:
1627     case OR_OP:
1628     case '>':
1629     case '<':
1630     case LE_OP:
1631     case GE_OP:
1632     case EQ_OP:
1633     case NE_OP:
1634     case '?':
1635     case ':':
1636     case SIZEOF:                /* evaluate wihout code generation */
1637
1638       return isConformingBody (pbody->left, sym, body) &&
1639         isConformingBody (pbody->right, sym, body);
1640
1641 /*------------------------------------------------------------------*/
1642     case '=':
1643
1644       /* if left has a pointer & right has loop
1645          control variable then we cannot */
1646       if (astHasPointer (pbody->left) &&
1647           astHasSymbol (pbody->right, sym))
1648         return FALSE;
1649       if (astHasVolatile (pbody->left))
1650         return FALSE;
1651
1652       if (IS_AST_SYM_VALUE (pbody->left) &&
1653           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1654         return FALSE;
1655
1656       if (astHasVolatile (pbody->left))
1657         return FALSE;
1658
1659       if (astHasDeref(pbody->right)) return FALSE;
1660
1661       return isConformingBody (pbody->left, sym, body) &&
1662         isConformingBody (pbody->right, sym, body);
1663
1664     case MUL_ASSIGN:
1665     case DIV_ASSIGN:
1666     case AND_ASSIGN:
1667     case OR_ASSIGN:
1668     case XOR_ASSIGN:
1669     case RIGHT_ASSIGN:
1670     case LEFT_ASSIGN:
1671     case SUB_ASSIGN:
1672     case ADD_ASSIGN:
1673       assert ("Parser should not have generated this\n");
1674
1675 /*------------------------------------------------------------------*/
1676 /*----------------------------*/
1677       /*      comma operator        */
1678 /*----------------------------*/
1679     case ',':
1680       return isConformingBody (pbody->left, sym, body) &&
1681         isConformingBody (pbody->right, sym, body);
1682
1683 /*------------------------------------------------------------------*/
1684 /*----------------------------*/
1685       /*       function call        */
1686 /*----------------------------*/
1687     case CALL:
1688       return FALSE;
1689
1690 /*------------------------------------------------------------------*/
1691 /*----------------------------*/
1692       /*     return statement       */
1693 /*----------------------------*/
1694     case RETURN:
1695       return FALSE;
1696
1697     case GOTO:
1698       if (isLabelInAst (AST_SYMBOL (pbody->left), body))
1699         return TRUE;
1700       else
1701         return FALSE;
1702     case SWITCH:
1703       if (astHasSymbol (pbody->left, sym))
1704         return FALSE;
1705
1706     default:
1707       break;
1708     }
1709
1710   return isConformingBody (pbody->left, sym, body) &&
1711     isConformingBody (pbody->right, sym, body);
1712
1713
1714
1715 }
1716
1717 /*-----------------------------------------------------------------*/
1718 /* isLoopReversible - takes a for loop as input && returns true    */
1719 /* if the for loop is reversible. If yes will set the value of     */
1720 /* the loop control var & init value & termination value           */
1721 /*-----------------------------------------------------------------*/
1722 bool
1723 isLoopReversible (ast * loop, symbol ** loopCntrl,
1724                   ast ** init, ast ** end)
1725 {
1726   /* if option says don't do it then don't */
1727   if (optimize.noLoopReverse)
1728     return 0;
1729   /* there are several tests to determine this */
1730
1731   /* for loop has to be of the form
1732      for ( <sym> = <const1> ;
1733      [<sym> < <const2>]  ;
1734      [<sym>++] | [<sym> += 1] | [<sym> = <sym> + 1] )
1735      forBody */
1736   if (!isLoopCountable (AST_FOR (loop, initExpr),
1737                         AST_FOR (loop, condExpr),
1738                         AST_FOR (loop, loopExpr),
1739                         loopCntrl, init, end))
1740     return 0;
1741
1742   /* now do some serious checking on the body of the loop
1743    */
1744
1745   return isConformingBody (loop->left, *loopCntrl, loop->left);
1746
1747 }
1748
1749 /*-----------------------------------------------------------------*/
1750 /* replLoopSym - replace the loop sym by loop sym -1               */
1751 /*-----------------------------------------------------------------*/
1752 static void
1753 replLoopSym (ast * body, symbol * sym)
1754 {
1755   /* reached end */
1756   if (!body || IS_AST_LINK (body))
1757     return;
1758
1759   if (IS_AST_SYM_VALUE (body))
1760     {
1761
1762       if (isSymbolEqual (AST_SYMBOL (body), sym))
1763         {
1764
1765           body->type = EX_OP;
1766           body->opval.op = '-';
1767           body->left = newAst_VALUE (symbolVal (sym));
1768           body->right = newAst_VALUE (constVal ("1"));
1769
1770         }
1771
1772       return;
1773
1774     }
1775
1776   replLoopSym (body->left, sym);
1777   replLoopSym (body->right, sym);
1778
1779 }
1780
1781 /*-----------------------------------------------------------------*/
1782 /* reverseLoop - do the actual loop reversal                       */
1783 /*-----------------------------------------------------------------*/
1784 ast *
1785 reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
1786 {
1787   ast *rloop;
1788
1789   /* create the following tree
1790      <sym> = loopCount ;
1791      for_continue:
1792      forbody
1793      <sym> -= 1;
1794      if (sym) goto for_continue ;
1795      <sym> = end */
1796
1797   /* put it together piece by piece */
1798   rloop = newNode (NULLOP,
1799                    createIf (newAst_VALUE (symbolVal (sym)),
1800                              newNode (GOTO,
1801                    newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))),
1802                                       NULL), NULL),
1803                    newNode ('=',
1804                             newAst_VALUE (symbolVal (sym)),
1805                             end));
1806
1807   replLoopSym (loop->left, sym);
1808
1809   rloop = newNode (NULLOP,
1810                    newNode ('=',
1811                             newAst_VALUE (symbolVal (sym)),
1812                             newNode ('-', end, init)),
1813                    createLabel (AST_FOR (loop, continueLabel),
1814                                 newNode (NULLOP,
1815                                          loop->left,
1816                                          newNode (NULLOP,
1817                                                   newNode (SUB_ASSIGN,
1818                                              newAst_VALUE (symbolVal (sym)),
1819                                              newAst_VALUE (constVal ("1"))),
1820                                                   rloop))));
1821
1822   return decorateType (rloop);
1823
1824 }
1825
1826 //#define DEMAND_INTEGER_PROMOTION
1827
1828 #ifdef DEMAND_INTEGER_PROMOTION
1829
1830 /*-----------------------------------------------------------------*/
1831 /* walk a tree looking for the leaves. Add a typecast to the given */
1832 /* type to each value leaf node.           */
1833 /*-----------------------------------------------------------------*/
1834 void
1835 pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr)
1836 {
1837   if (!node || IS_CALLOP(node))
1838     {
1839       /* WTF? We should never get here. */
1840       return;
1841     }
1842
1843   if (!node->left && !node->right)
1844     {
1845       /* We're at a leaf; if it's a value, apply the typecast */
1846       if (node->type == EX_VALUE && IS_INTEGRAL (TTYPE (node)))
1847         {
1848           *parentPtr = decorateType (newNode (CAST,
1849                                          newAst_LINK (copyLinkChain (type)),
1850                                               node));
1851         }
1852     }
1853   else
1854     {
1855       if (node->left)
1856         {
1857           pushTypeCastToLeaves (type, node->left, &(node->left));
1858         }
1859       if (node->right)
1860         {
1861           pushTypeCastToLeaves (type, node->right, &(node->right));
1862         }
1863     }
1864 }
1865
1866 #endif
1867
1868 /*-----------------------------------------------------------------*/
1869 /* Given an assignment operation in a tree, determine if the LHS   */
1870 /* (the result) has a different (integer) type than the RHS.     */
1871 /* If so, walk the RHS and add a typecast to the type of the LHS   */
1872 /* to all leaf nodes.              */
1873 /*-----------------------------------------------------------------*/
1874 void
1875 propAsgType (ast * tree)
1876 {
1877 #ifdef DEMAND_INTEGER_PROMOTION
1878   if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
1879     {
1880       /* Nothing to do here... */
1881       return;
1882     }
1883
1884   if (getSize (LTYPE (tree)) > getSize (RTYPE (tree)))
1885     {
1886       pushTypeCastToLeaves (LTYPE (tree), tree->right, &(tree->right));
1887     }
1888 #else
1889   (void) tree;
1890 #endif
1891 }
1892
1893 /*-----------------------------------------------------------------*/
1894 /* decorateType - compute type for this tree also does type cheking */
1895 /*          this is done bottom up, since type have to flow upwards */
1896 /*          it also does constant folding, and paramater checking  */
1897 /*-----------------------------------------------------------------*/
1898 ast *
1899 decorateType (ast * tree)
1900 {
1901   int parmNumber;
1902   sym_link *p;
1903
1904   if (!tree)
1905     return tree;
1906
1907   /* if already has type then do nothing */
1908   if (tree->decorated)
1909     return tree;
1910
1911   tree->decorated = 1;
1912
1913   /* print the line          */
1914   /* if not block & function */
1915   if (tree->type == EX_OP &&
1916       (tree->opval.op != FUNCTION &&
1917        tree->opval.op != BLOCK &&
1918        tree->opval.op != NULLOP))
1919     {
1920       filename = tree->filename;
1921       lineno = tree->lineno;
1922     }
1923
1924   /* if any child is an error | this one is an error do nothing */
1925   if (tree->isError ||
1926       (tree->left && tree->left->isError) ||
1927       (tree->right && tree->right->isError))
1928     return tree;
1929
1930 /*------------------------------------------------------------------*/
1931 /*----------------------------*/
1932   /*   leaf has been reached    */
1933 /*----------------------------*/
1934   /* if this is of type value */
1935   /* just get the type        */
1936   if (tree->type == EX_VALUE)
1937     {
1938
1939       if (IS_LITERAL (tree->opval.val->etype))
1940         {
1941
1942           /* if this is a character array then declare it */
1943           if (IS_ARRAY (tree->opval.val->type))
1944             tree->opval.val = stringToSymbol (tree->opval.val);
1945
1946           /* otherwise just copy the type information */
1947           COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
1948           if (funcInChain (tree->opval.val->type))
1949             {
1950               tree->hasVargs = tree->opval.val->sym->hasVargs;
1951               tree->args = copyValueChain (tree->opval.val->sym->args);
1952             }
1953           return tree;
1954         }
1955
1956       if (tree->opval.val->sym)
1957         {
1958           /* if the undefined flag is set then give error message */
1959           if (tree->opval.val->sym->undefined)
1960             {
1961               werror (E_ID_UNDEF, tree->opval.val->sym->name);
1962               /* assume int */
1963               TTYPE (tree) = TETYPE (tree) =
1964                 tree->opval.val->type = tree->opval.val->sym->type =
1965                 tree->opval.val->etype = tree->opval.val->sym->etype =
1966                 copyLinkChain (INTTYPE);
1967             }
1968           else
1969             {
1970
1971               /* if impilicit i.e. struct/union member then no type */
1972               if (tree->opval.val->sym->implicit)
1973                 TTYPE (tree) = TETYPE (tree) = NULL;
1974
1975               else
1976                 {
1977
1978                   /* else copy the type */
1979                   COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
1980
1981                   /* and mark it as referenced */
1982                   tree->opval.val->sym->isref = 1;
1983                   /* if this is of type function or function pointer */
1984                   if (funcInChain (tree->opval.val->type))
1985                     {
1986                       tree->hasVargs = tree->opval.val->sym->hasVargs;
1987                       tree->args = copyValueChain (tree->opval.val->sym->args);
1988
1989                     }
1990                 }
1991             }
1992         }
1993
1994       return tree;
1995     }
1996
1997   /* if type link for the case of cast */
1998   if (tree->type == EX_LINK)
1999     {
2000       COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.lnk);
2001       return tree;
2002     }
2003
2004   {
2005     ast *dtl, *dtr;
2006
2007     dtl = decorateType (tree->left);
2008     dtr = decorateType (tree->right);
2009
2010     /* this is to take care of situations
2011        when the tree gets rewritten */
2012     if (dtl != tree->left)
2013       tree->left = dtl;
2014     if (dtr != tree->right)
2015       tree->right = dtr;
2016   }
2017
2018   /* depending on type of operator do */
2019
2020   switch (tree->opval.op)
2021     {
2022             /*------------------------------------------------------------------*/
2023             /*----------------------------*/
2024             /*        array node          */
2025             /*----------------------------*/
2026     case '[':
2027
2028       /* determine which is the array & which the index */
2029       if ((IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree))) && IS_INTEGRAL (LTYPE (tree)))
2030         {
2031
2032           ast *tempTree = tree->left;
2033           tree->left = tree->right;
2034           tree->right = tempTree;
2035         }
2036
2037       /* first check if this is a array or a pointer */
2038       if ((!IS_ARRAY (LTYPE (tree))) && (!IS_PTR (LTYPE (tree))))
2039         {
2040           werror (E_NEED_ARRAY_PTR, "[]");
2041           goto errorTreeReturn;
2042         }
2043
2044       /* check if the type of the idx */
2045       if (!IS_INTEGRAL (RTYPE (tree)))
2046         {
2047           werror (E_IDX_NOT_INT);
2048           goto errorTreeReturn;
2049         }
2050
2051       /* if the left is an rvalue then error */
2052       if (LRVAL (tree))
2053         {
2054           werror (E_LVALUE_REQUIRED, "array access");
2055           goto errorTreeReturn;
2056         }
2057       RRVAL (tree) = 1;
2058       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)->next);
2059       if (IS_PTR(LTYPE(tree))) {
2060               SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
2061       }
2062       return tree;
2063
2064       /*------------------------------------------------------------------*/
2065       /*----------------------------*/
2066       /*      struct/union          */
2067       /*----------------------------*/
2068     case '.':
2069       /* if this is not a structure */
2070       if (!IS_STRUCT (LTYPE (tree)))
2071         {
2072           werror (E_STRUCT_UNION, ".");
2073           goto errorTreeReturn;
2074         }
2075       TTYPE (tree) = structElemType (LTYPE (tree),
2076                                      (tree->right->type == EX_VALUE ?
2077                                tree->right->opval.val : NULL), &tree->args);
2078       TETYPE (tree) = getSpec (TTYPE (tree));
2079       return tree;
2080
2081       /*------------------------------------------------------------------*/
2082       /*----------------------------*/
2083       /*    struct/union pointer    */
2084       /*----------------------------*/
2085     case PTR_OP:
2086       /* if not pointer to a structure */
2087       if (!IS_PTR (LTYPE (tree)))
2088         {
2089           werror (E_PTR_REQD);
2090           goto errorTreeReturn;
2091         }
2092
2093       if (!IS_STRUCT (LTYPE (tree)->next))
2094         {
2095           werror (E_STRUCT_UNION, "->");
2096           goto errorTreeReturn;
2097         }
2098
2099       TTYPE (tree) = structElemType (LTYPE (tree)->next,
2100                                      (tree->right->type == EX_VALUE ?
2101                                tree->right->opval.val : NULL), &tree->args);
2102       TETYPE (tree) = getSpec (TTYPE (tree));
2103       return tree;
2104
2105 /*------------------------------------------------------------------*/
2106 /*----------------------------*/
2107       /*  ++/-- operation           */
2108 /*----------------------------*/
2109     case INC_OP:                /* incerement operator unary so left only */
2110     case DEC_OP:
2111       {
2112         sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree));
2113         COPYTYPE (TTYPE (tree), TETYPE (tree), ltc);
2114         if (!tree->initMode && IS_CONSTANT (TETYPE (tree)))
2115           werror (E_CODE_WRITE, "++/--");
2116
2117         if (tree->right)
2118           RLVAL (tree) = 1;
2119         else
2120           LLVAL (tree) = 1;
2121         return tree;
2122       }
2123
2124 /*------------------------------------------------------------------*/
2125 /*----------------------------*/
2126       /*  bitwise and               */
2127 /*----------------------------*/
2128     case '&':                   /* can be unary   */
2129       /* if right is NULL then unary operation  */
2130       if (tree->right)          /* not an unary operation */
2131         {
2132
2133           if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2134             {
2135               werror (E_BITWISE_OP);
2136               werror (W_CONTINUE, "left & right types are ");
2137               printTypeChain (LTYPE (tree), stderr);
2138               fprintf (stderr, ",");
2139               printTypeChain (RTYPE (tree), stderr);
2140               fprintf (stderr, "\n");
2141               goto errorTreeReturn;
2142             }
2143
2144           /* if they are both literal */
2145           if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2146             {
2147               tree->type = EX_VALUE;
2148               tree->opval.val = valBitwise (valFromType (LETYPE (tree)),
2149                                           valFromType (RETYPE (tree)), '&');
2150
2151               tree->right = tree->left = NULL;
2152               TETYPE (tree) = tree->opval.val->etype;
2153               TTYPE (tree) = tree->opval.val->type;
2154               return tree;
2155             }
2156
2157           /* see if this is a GETHBIT operation if yes
2158              then return that */
2159           {
2160             ast *otree = optimizeGetHbit (tree);
2161
2162             if (otree != tree)
2163               return decorateType (otree);
2164           }
2165
2166 #if 0
2167           // we can't do this because of "(int & 0xff) << 3"
2168
2169           /* if right or left is literal then result of that type */
2170           if (IS_LITERAL (RTYPE (tree)))
2171             {
2172
2173               TTYPE (tree) = copyLinkChain (RTYPE (tree));
2174               TETYPE (tree) = getSpec (TTYPE (tree));
2175               SPEC_SCLS (TETYPE (tree)) = S_AUTO;
2176             }
2177           else
2178             {
2179               if (IS_LITERAL (LTYPE (tree)))
2180                 {
2181                   TTYPE (tree) = copyLinkChain (LTYPE (tree));
2182                   TETYPE (tree) = getSpec (TTYPE (tree));
2183                   SPEC_SCLS (TETYPE (tree)) = S_AUTO;
2184
2185                 }
2186               else
2187                 {
2188                   TTYPE (tree) =
2189                     computeType (LTYPE (tree), RTYPE (tree));
2190                   TETYPE (tree) = getSpec (TTYPE (tree));
2191                 }
2192             }
2193 #else
2194           TTYPE (tree) =
2195             computeType (LTYPE (tree), RTYPE (tree));
2196           TETYPE (tree) = getSpec (TTYPE (tree));
2197 #endif
2198           LRVAL (tree) = RRVAL (tree) = 1;
2199           return tree;
2200         }
2201
2202 /*------------------------------------------------------------------*/
2203 /*----------------------------*/
2204       /*  address of                */
2205 /*----------------------------*/
2206       p = newLink ();
2207       p->class = DECLARATOR;
2208       /* if bit field then error */
2209       if (IS_BITVAR (tree->left->etype))
2210         {
2211           werror (E_ILLEGAL_ADDR, "addrress of bit variable");
2212           goto errorTreeReturn;
2213         }
2214
2215       if (SPEC_SCLS (tree->left->etype) == S_REGISTER)
2216         {
2217           werror (E_ILLEGAL_ADDR, "address of register variable");
2218           goto errorTreeReturn;
2219         }
2220
2221       if (IS_FUNC (LTYPE (tree)))
2222         {
2223           werror (E_ILLEGAL_ADDR, "address of function");
2224           goto errorTreeReturn;
2225         }
2226
2227       if (LRVAL (tree))
2228         {
2229           werror (E_LVALUE_REQUIRED, "address of");
2230           goto errorTreeReturn;
2231         }
2232       if (SPEC_SCLS (tree->left->etype) == S_CODE)
2233         {
2234           DCL_TYPE (p) = CPOINTER;
2235           DCL_PTR_CONST (p) = port->mem.code_ro;
2236         }
2237       else if (SPEC_SCLS (tree->left->etype) == S_XDATA)
2238         DCL_TYPE (p) = FPOINTER;
2239       else if (SPEC_SCLS (tree->left->etype) == S_XSTACK)
2240         DCL_TYPE (p) = PPOINTER;
2241       else if (SPEC_SCLS (tree->left->etype) == S_IDATA)
2242         DCL_TYPE (p) = IPOINTER;
2243       else if (SPEC_SCLS (tree->left->etype) == S_EEPROM)
2244         DCL_TYPE (p) = EEPPOINTER;
2245       else
2246         DCL_TYPE (p) = POINTER;
2247
2248       if (IS_AST_SYM_VALUE (tree->left))
2249         {
2250           AST_SYMBOL (tree->left)->addrtaken = 1;
2251           AST_SYMBOL (tree->left)->allocreq = 1;
2252         }
2253
2254       p->next = LTYPE (tree);
2255       TTYPE (tree) = p;
2256       TETYPE (tree) = getSpec (TTYPE (tree));
2257       DCL_PTR_CONST (p) = SPEC_CONST (TETYPE (tree));
2258       DCL_PTR_VOLATILE (p) = SPEC_VOLATILE (TETYPE (tree));
2259       LLVAL (tree) = 1;
2260       TLVAL (tree) = 1;
2261       return tree;
2262
2263 /*------------------------------------------------------------------*/
2264 /*----------------------------*/
2265       /*  bitwise or                */
2266 /*----------------------------*/
2267     case '|':
2268       /* if the rewrite succeeds then don't go any furthur */
2269       {
2270         ast *wtree = optimizeRRCRLC (tree);
2271         if (wtree != tree)
2272           return decorateType (wtree);
2273       }
2274 /*------------------------------------------------------------------*/
2275 /*----------------------------*/
2276       /*  bitwise xor               */
2277 /*----------------------------*/
2278     case '^':
2279       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2280         {
2281           werror (E_BITWISE_OP);
2282           werror (W_CONTINUE, "left & right types are ");
2283           printTypeChain (LTYPE (tree), stderr);
2284           fprintf (stderr, ",");
2285           printTypeChain (RTYPE (tree), stderr);
2286           fprintf (stderr, "\n");
2287           goto errorTreeReturn;
2288         }
2289
2290       /* if they are both literal then */
2291       /* rewrite the tree */
2292       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2293         {
2294           tree->type = EX_VALUE;
2295           tree->opval.val = valBitwise (valFromType (LETYPE (tree)),
2296                                         valFromType (RETYPE (tree)),
2297                                         tree->opval.op);
2298           tree->right = tree->left = NULL;
2299           TETYPE (tree) = tree->opval.val->etype;
2300           TTYPE (tree) = tree->opval.val->type;
2301           return tree;
2302         }
2303       LRVAL (tree) = RRVAL (tree) = 1;
2304       TETYPE (tree) = getSpec (TTYPE (tree) =
2305                                computeType (LTYPE (tree),
2306                                             RTYPE (tree)));
2307
2308 /*------------------------------------------------------------------*/
2309 /*----------------------------*/
2310       /*  division                  */
2311 /*----------------------------*/
2312     case '/':
2313       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
2314         {
2315           werror (E_INVALID_OP, "divide");
2316           goto errorTreeReturn;
2317         }
2318       /* if they are both literal then */
2319       /* rewrite the tree */
2320       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2321         {
2322           tree->type = EX_VALUE;
2323           tree->opval.val = valDiv (valFromType (LETYPE (tree)),
2324                                     valFromType (RETYPE (tree)));
2325           tree->right = tree->left = NULL;
2326           TETYPE (tree) = getSpec (TTYPE (tree) =
2327                                    tree->opval.val->type);
2328           return tree;
2329         }
2330       LRVAL (tree) = RRVAL (tree) = 1;
2331       TETYPE (tree) = getSpec (TTYPE (tree) =
2332                                computeType (LTYPE (tree),
2333                                             RTYPE (tree)));
2334       return tree;
2335
2336 /*------------------------------------------------------------------*/
2337 /*----------------------------*/
2338       /*            modulus         */
2339 /*----------------------------*/
2340     case '%':
2341       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2342         {
2343           werror (E_BITWISE_OP);
2344           werror (W_CONTINUE, "left & right types are ");
2345           printTypeChain (LTYPE (tree), stderr);
2346           fprintf (stderr, ",");
2347           printTypeChain (RTYPE (tree), stderr);
2348           fprintf (stderr, "\n");
2349           goto errorTreeReturn;
2350         }
2351       /* if they are both literal then */
2352       /* rewrite the tree */
2353       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2354         {
2355           tree->type = EX_VALUE;
2356           tree->opval.val = valMod (valFromType (LETYPE (tree)),
2357                                     valFromType (RETYPE (tree)));
2358           tree->right = tree->left = NULL;
2359           TETYPE (tree) = getSpec (TTYPE (tree) =
2360                                    tree->opval.val->type);
2361           return tree;
2362         }
2363       LRVAL (tree) = RRVAL (tree) = 1;
2364       TETYPE (tree) = getSpec (TTYPE (tree) =
2365                                computeType (LTYPE (tree),
2366                                             RTYPE (tree)));
2367       return tree;
2368
2369 /*------------------------------------------------------------------*/
2370 /*----------------------------*/
2371 /*  address dereference       */
2372 /*----------------------------*/
2373     case '*':                   /* can be unary  : if right is null then unary operation */
2374       if (!tree->right)
2375         {
2376           if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree)))
2377             {
2378               werror (E_PTR_REQD);
2379               goto errorTreeReturn;
2380             }
2381
2382           if (LRVAL (tree))
2383             {
2384               werror (E_LVALUE_REQUIRED, "pointer deref");
2385               goto errorTreeReturn;
2386             }
2387           TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
2388                                         LTYPE (tree)->next : NULL);
2389           TETYPE (tree) = getSpec (TTYPE (tree));
2390           tree->args = tree->left->args;
2391           tree->hasVargs = tree->left->hasVargs;
2392           SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
2393           return tree;
2394         }
2395
2396 /*------------------------------------------------------------------*/
2397 /*----------------------------*/
2398       /*      multiplication        */
2399 /*----------------------------*/
2400       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
2401         {
2402           werror (E_INVALID_OP, "multiplication");
2403           goto errorTreeReturn;
2404         }
2405
2406       /* if they are both literal then */
2407       /* rewrite the tree */
2408       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2409         {
2410           tree->type = EX_VALUE;
2411           tree->opval.val = valMult (valFromType (LETYPE (tree)),
2412                                      valFromType (RETYPE (tree)));
2413           tree->right = tree->left = NULL;
2414           TETYPE (tree) = getSpec (TTYPE (tree) =
2415                                    tree->opval.val->type);
2416           return tree;
2417         }
2418
2419       /* if left is a literal exchange left & right */
2420       if (IS_LITERAL (LTYPE (tree)))
2421         {
2422           ast *tTree = tree->left;
2423           tree->left = tree->right;
2424           tree->right = tTree;
2425         }
2426
2427       LRVAL (tree) = RRVAL (tree) = 1;
2428       /* promote result to int if left & right are char
2429          this will facilitate hardware multiplies 8bit x 8bit = 16bit */
2430       if (IS_CHAR(LETYPE(tree)) && IS_CHAR(RETYPE(tree))) {
2431         TETYPE (tree) = getSpec (TTYPE (tree) =
2432                                  computeType (LTYPE (tree),
2433                                               RTYPE (tree)));
2434         SPEC_NOUN(TETYPE(tree)) = V_INT;
2435       } else {
2436         TETYPE (tree) = getSpec (TTYPE (tree) =
2437                                  computeType (LTYPE (tree),
2438                                               RTYPE (tree)));
2439       }
2440       return tree;
2441
2442 /*------------------------------------------------------------------*/
2443 /*----------------------------*/
2444       /*    unary '+' operator      */
2445 /*----------------------------*/
2446     case '+':
2447       /* if unary plus */
2448       if (!tree->right)
2449         {
2450           if (!IS_INTEGRAL (LTYPE (tree)))
2451             {
2452               werror (E_UNARY_OP, '+');
2453               goto errorTreeReturn;
2454             }
2455
2456           /* if left is a literal then do it */
2457           if (IS_LITERAL (LTYPE (tree)))
2458             {
2459               tree->type = EX_VALUE;
2460               tree->opval.val = valFromType (LETYPE (tree));
2461               tree->left = NULL;
2462               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2463               return tree;
2464             }
2465           LRVAL (tree) = 1;
2466           COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2467           return tree;
2468         }
2469
2470 /*------------------------------------------------------------------*/
2471 /*----------------------------*/
2472       /*      addition              */
2473 /*----------------------------*/
2474
2475       /* this is not a unary operation */
2476       /* if both pointers then problem */
2477       if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) &&
2478           (IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree))))
2479         {
2480           werror (E_PTR_PLUS_PTR);
2481           goto errorTreeReturn;
2482         }
2483
2484       if (!IS_ARITHMETIC (LTYPE (tree)) &&
2485           !IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree)))
2486         {
2487           werror (E_PLUS_INVALID, "+");
2488           goto errorTreeReturn;
2489         }
2490
2491       if (!IS_ARITHMETIC (RTYPE (tree)) &&
2492           !IS_PTR (RTYPE (tree)) && !IS_ARRAY (RTYPE (tree)))
2493         {
2494           werror (E_PLUS_INVALID, "+");
2495           goto errorTreeReturn;
2496         }
2497       /* if they are both literal then */
2498       /* rewrite the tree */
2499       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2500         {
2501           tree->type = EX_VALUE;
2502           tree->opval.val = valPlus (valFromType (LETYPE (tree)),
2503                                      valFromType (RETYPE (tree)));
2504           tree->right = tree->left = NULL;
2505           TETYPE (tree) = getSpec (TTYPE (tree) =
2506                                    tree->opval.val->type);
2507           return tree;
2508         }
2509
2510       /* if the right is a pointer or left is a literal
2511          xchange left & right */
2512       if (IS_ARRAY (RTYPE (tree)) ||
2513           IS_PTR (RTYPE (tree)) ||
2514           IS_LITERAL (LTYPE (tree)))
2515         {
2516           ast *tTree = tree->left;
2517           tree->left = tree->right;
2518           tree->right = tTree;
2519         }
2520
2521       LRVAL (tree) = RRVAL (tree) = 1;
2522       /* if the left is a pointer */
2523       if (IS_PTR (LTYPE (tree)))
2524         TETYPE (tree) = getSpec (TTYPE (tree) =
2525                                  LTYPE (tree));
2526       else
2527         TETYPE (tree) = getSpec (TTYPE (tree) =
2528                                  computeType (LTYPE (tree),
2529                                               RTYPE (tree)));
2530       return tree;
2531
2532 /*------------------------------------------------------------------*/
2533 /*----------------------------*/
2534       /*      unary '-'             */
2535 /*----------------------------*/
2536     case '-':                   /* can be unary   */
2537       /* if right is null then unary */
2538       if (!tree->right)
2539         {
2540
2541           if (!IS_ARITHMETIC (LTYPE (tree)))
2542             {
2543               werror (E_UNARY_OP, tree->opval.op);
2544               goto errorTreeReturn;
2545             }
2546
2547           /* if left is a literal then do it */
2548           if (IS_LITERAL (LTYPE (tree)))
2549             {
2550               tree->type = EX_VALUE;
2551               tree->opval.val = valUnaryPM (valFromType (LETYPE (tree)));
2552               tree->left = NULL;
2553               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2554               SPEC_USIGN(TETYPE(tree)) = 0;
2555               return tree;
2556             }
2557           LRVAL (tree) = 1;
2558           TTYPE (tree) = LTYPE (tree);
2559           return tree;
2560         }
2561
2562 /*------------------------------------------------------------------*/
2563 /*----------------------------*/
2564       /*    subtraction             */
2565 /*----------------------------*/
2566
2567       if (!(IS_PTR (LTYPE (tree)) ||
2568             IS_ARRAY (LTYPE (tree)) ||
2569             IS_ARITHMETIC (LTYPE (tree))))
2570         {
2571           werror (E_PLUS_INVALID, "-");
2572           goto errorTreeReturn;
2573         }
2574
2575       if (!(IS_PTR (RTYPE (tree)) ||
2576             IS_ARRAY (RTYPE (tree)) ||
2577             IS_ARITHMETIC (RTYPE (tree))))
2578         {
2579           werror (E_PLUS_INVALID, "-");
2580           goto errorTreeReturn;
2581         }
2582
2583       if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) &&
2584           !(IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)) ||
2585             IS_INTEGRAL (RTYPE (tree))))
2586         {
2587           werror (E_PLUS_INVALID, "-");
2588           goto errorTreeReturn;
2589         }
2590
2591       /* if they are both literal then */
2592       /* rewrite the tree */
2593       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2594         {
2595           tree->type = EX_VALUE;
2596           tree->opval.val = valMinus (valFromType (LETYPE (tree)),
2597                                       valFromType (RETYPE (tree)));
2598           tree->right = tree->left = NULL;
2599           TETYPE (tree) = getSpec (TTYPE (tree) =
2600                                    tree->opval.val->type);
2601           return tree;
2602         }
2603
2604       /* if the left & right are equal then zero */
2605       if (isAstEqual (tree->left, tree->right))
2606         {
2607           tree->type = EX_VALUE;
2608           tree->left = tree->right = NULL;
2609           tree->opval.val = constVal ("0");
2610           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2611           return tree;
2612         }
2613
2614       /* if both of them are pointers or arrays then */
2615       /* the result is going to be an integer        */
2616       if ((IS_ARRAY (LTYPE (tree)) || IS_PTR (LTYPE (tree))) &&
2617           (IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree))))
2618         TETYPE (tree) = TTYPE (tree) = newIntLink ();
2619       else
2620         /* if only the left is a pointer */
2621         /* then result is a pointer      */
2622       if (IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree)))
2623         TETYPE (tree) = getSpec (TTYPE (tree) =
2624                                  LTYPE (tree));
2625       else
2626         TETYPE (tree) = getSpec (TTYPE (tree) =
2627                                  computeType (LTYPE (tree),
2628                                               RTYPE (tree)));
2629       LRVAL (tree) = RRVAL (tree) = 1;
2630       return tree;
2631
2632 /*------------------------------------------------------------------*/
2633 /*----------------------------*/
2634       /*    compliment              */
2635 /*----------------------------*/
2636     case '~':
2637       /* can be only integral type */
2638       if (!IS_INTEGRAL (LTYPE (tree)))
2639         {
2640           werror (E_UNARY_OP, tree->opval.op);
2641           goto errorTreeReturn;
2642         }
2643
2644       /* if left is a literal then do it */
2645       if (IS_LITERAL (LTYPE (tree)))
2646         {
2647           tree->type = EX_VALUE;
2648           tree->opval.val = valComplement (valFromType (LETYPE (tree)));
2649           tree->left = NULL;
2650           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2651           return tree;
2652         }
2653       LRVAL (tree) = 1;
2654       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2655       return tree;
2656
2657 /*------------------------------------------------------------------*/
2658 /*----------------------------*/
2659       /*           not              */
2660 /*----------------------------*/
2661     case '!':
2662       /* can be pointer */
2663       if (!IS_ARITHMETIC (LTYPE (tree)) &&
2664           !IS_PTR (LTYPE (tree)) &&
2665           !IS_ARRAY (LTYPE (tree)))
2666         {
2667           werror (E_UNARY_OP, tree->opval.op);
2668           goto errorTreeReturn;
2669         }
2670
2671       /* if left is a literal then do it */
2672       if (IS_LITERAL (LTYPE (tree)))
2673         {
2674           tree->type = EX_VALUE;
2675           tree->opval.val = valNot (valFromType (LETYPE (tree)));
2676           tree->left = NULL;
2677           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2678           return tree;
2679         }
2680       LRVAL (tree) = 1;
2681       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2682       return tree;
2683
2684 /*------------------------------------------------------------------*/
2685 /*----------------------------*/
2686       /*           shift            */
2687 /*----------------------------*/
2688     case RRC:
2689     case RLC:
2690       TTYPE (tree) = LTYPE (tree);
2691       TETYPE (tree) = LETYPE (tree);
2692       return tree;
2693
2694     case GETHBIT:
2695       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2696       return tree;
2697
2698     case LEFT_OP:
2699     case RIGHT_OP:
2700       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (tree->left->etype))
2701         {
2702           werror (E_SHIFT_OP_INVALID);
2703           werror (W_CONTINUE, "left & right types are ");
2704           printTypeChain (LTYPE (tree), stderr);
2705           fprintf (stderr, ",");
2706           printTypeChain (RTYPE (tree), stderr);
2707           fprintf (stderr, "\n");
2708           goto errorTreeReturn;
2709         }
2710
2711       /* if they are both literal then */
2712       /* rewrite the tree */
2713       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2714         {
2715           tree->type = EX_VALUE;
2716           tree->opval.val = valShift (valFromType (LETYPE (tree)),
2717                                       valFromType (RETYPE (tree)),
2718                                       (tree->opval.op == LEFT_OP ? 1 : 0));
2719           tree->right = tree->left = NULL;
2720           TETYPE (tree) = getSpec (TTYPE (tree) =
2721                                    tree->opval.val->type);
2722           return tree;
2723         }
2724       /* if only the right side is a literal & we are
2725          shifting more than size of the left operand then zero */
2726       if (IS_LITERAL (RTYPE (tree)) &&
2727           ((unsigned) floatFromVal (valFromType (RETYPE (tree)))) >=
2728           (getSize (LTYPE (tree)) * 8))
2729         {
2730           werror (W_SHIFT_CHANGED,
2731                   (tree->opval.op == LEFT_OP ? "left" : "right"));
2732           tree->type = EX_VALUE;
2733           tree->left = tree->right = NULL;
2734           tree->opval.val = constVal ("0");
2735           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2736           return tree;
2737         }
2738       LRVAL (tree) = RRVAL (tree) = 1;
2739       if (IS_LITERAL (LTYPE (tree)) && !IS_LITERAL (RTYPE (tree)))
2740         {
2741           COPYTYPE (TTYPE (tree), TETYPE (tree), RTYPE (tree));
2742         }
2743       else
2744         {
2745           COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2746         }
2747       return tree;
2748
2749       /*------------------------------------------------------------------*/
2750       /*----------------------------*/
2751       /*         casting            */
2752       /*----------------------------*/
2753     case CAST:                  /* change the type   */
2754       /* cannot cast to an aggregate type */
2755       if (IS_AGGREGATE (LTYPE (tree)))
2756         {
2757           werror (E_CAST_ILLEGAL);
2758           goto errorTreeReturn;
2759         }
2760
2761       /* make sure the type is complete and sane */
2762       checkTypeSanity(LETYPE(tree), "(cast)");
2763
2764       /* if the right is a literal replace the tree */
2765       if (IS_LITERAL (RETYPE (tree))) {
2766               if (!IS_PTR (LTYPE (tree))) {
2767                       tree->type = EX_VALUE;
2768                       tree->opval.val =
2769                               valCastLiteral (LTYPE (tree),
2770                                               floatFromVal (valFromType (RETYPE (tree))));
2771                       tree->left = NULL;
2772                       tree->right = NULL;
2773                       TTYPE (tree) = tree->opval.val->type;
2774                       tree->values.literalFromCast = 1;
2775               } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree))) {
2776                       sym_link *rest = LTYPE(tree)->next;
2777                       werror(W_LITERAL_GENERIC);
2778                       TTYPE(tree) = newLink();
2779                       DCL_TYPE(TTYPE(tree)) = FPOINTER;
2780                       TTYPE(tree)->next = rest;
2781                       tree->left->opval.lnk = TTYPE(tree);
2782                       LRVAL (tree) = 1;
2783               } else {
2784                       TTYPE (tree) = LTYPE (tree);
2785                       LRVAL (tree) = 1;
2786               }
2787       } else {
2788               TTYPE (tree) = LTYPE (tree);
2789               LRVAL (tree) = 1;
2790       }
2791
2792       TETYPE (tree) = getSpec (TTYPE (tree));
2793
2794       return tree;
2795
2796 /*------------------------------------------------------------------*/
2797 /*----------------------------*/
2798       /*       logical &&, ||       */
2799 /*----------------------------*/
2800     case AND_OP:
2801     case OR_OP:
2802       /* each must me arithmetic type or be a pointer */
2803       if (!IS_PTR (LTYPE (tree)) &&
2804           !IS_ARRAY (LTYPE (tree)) &&
2805           !IS_INTEGRAL (LTYPE (tree)))
2806         {
2807           werror (E_COMPARE_OP);
2808           goto errorTreeReturn;
2809         }
2810
2811       if (!IS_PTR (RTYPE (tree)) &&
2812           !IS_ARRAY (RTYPE (tree)) &&
2813           !IS_INTEGRAL (RTYPE (tree)))
2814         {
2815           werror (E_COMPARE_OP);
2816           goto errorTreeReturn;
2817         }
2818       /* if they are both literal then */
2819       /* rewrite the tree */
2820       if (IS_LITERAL (RTYPE (tree)) &&
2821           IS_LITERAL (LTYPE (tree)))
2822         {
2823           tree->type = EX_VALUE;
2824           tree->opval.val = valLogicAndOr (valFromType (LETYPE (tree)),
2825                                            valFromType (RETYPE (tree)),
2826                                            tree->opval.op);
2827           tree->right = tree->left = NULL;
2828           TETYPE (tree) = getSpec (TTYPE (tree) =
2829                                    tree->opval.val->type);
2830           return tree;
2831         }
2832       LRVAL (tree) = RRVAL (tree) = 1;
2833       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2834       return tree;
2835
2836 /*------------------------------------------------------------------*/
2837 /*----------------------------*/
2838       /*     comparison operators   */
2839 /*----------------------------*/
2840     case '>':
2841     case '<':
2842     case LE_OP:
2843     case GE_OP:
2844     case EQ_OP:
2845     case NE_OP:
2846       {
2847         ast *lt = optimizeCompare (tree);
2848
2849         if (tree != lt)
2850           return lt;
2851       }
2852
2853       /* if they are pointers they must be castable */
2854       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)))
2855         {
2856           if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
2857             {
2858               werror (E_COMPARE_OP);
2859               fprintf (stderr, "comparing type ");
2860               printTypeChain (LTYPE (tree), stderr);
2861               fprintf (stderr, "to type ");
2862               printTypeChain (RTYPE (tree), stderr);
2863               fprintf (stderr, "\n");
2864               goto errorTreeReturn;
2865             }
2866         }
2867       /* else they should be promotable to one another */
2868       else
2869         {
2870           if (!((IS_PTR (LTYPE (tree)) && IS_LITERAL (RTYPE (tree))) ||
2871                 (IS_PTR (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))))
2872
2873             if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
2874               {
2875                 werror (E_COMPARE_OP);
2876                 fprintf (stderr, "comparing type ");
2877                 printTypeChain (LTYPE (tree), stderr);
2878                 fprintf (stderr, "to type ");
2879                 printTypeChain (RTYPE (tree), stderr);
2880                 fprintf (stderr, "\n");
2881                 goto errorTreeReturn;
2882               }
2883         }
2884
2885       /* if they are both literal then */
2886       /* rewrite the tree */
2887       if (IS_LITERAL (RTYPE (tree)) &&
2888           IS_LITERAL (LTYPE (tree)))
2889         {
2890           tree->type = EX_VALUE;
2891           tree->opval.val = valCompare (valFromType (LETYPE (tree)),
2892                                         valFromType (RETYPE (tree)),
2893                                         tree->opval.op);
2894           tree->right = tree->left = NULL;
2895           TETYPE (tree) = getSpec (TTYPE (tree) =
2896                                    tree->opval.val->type);
2897           return tree;
2898         }
2899       LRVAL (tree) = RRVAL (tree) = 1;
2900       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2901       return tree;
2902
2903 /*------------------------------------------------------------------*/
2904 /*----------------------------*/
2905       /*             sizeof         */
2906 /*----------------------------*/
2907     case SIZEOF:                /* evaluate wihout code generation */
2908       /* change the type to a integer */
2909       tree->type = EX_VALUE;
2910       sprintf (buffer, "%d", (getSize (tree->right->ftype)));
2911       tree->opval.val = constVal (buffer);
2912       tree->right = tree->left = NULL;
2913       TETYPE (tree) = getSpec (TTYPE (tree) =
2914                                tree->opval.val->type);
2915       return tree;
2916
2917 /*------------------------------------------------------------------*/
2918 /*----------------------------*/
2919       /* conditional operator  '?'  */
2920 /*----------------------------*/
2921     case '?':
2922       /* the type is value of the colon operator (on the right) */
2923       assert(IS_COLON_OP(tree->right));
2924       TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree).
2925       TETYPE (tree) = getSpec (TTYPE (tree));
2926       return tree;
2927
2928     case ':':
2929       /* if they don't match we have a problem */
2930       if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
2931         {
2932           werror (E_TYPE_MISMATCH, "conditional operator", " ");
2933           goto errorTreeReturn;
2934         }
2935
2936       TTYPE (tree) = computeType (LTYPE (tree), RTYPE (tree));
2937       TETYPE (tree) = getSpec (TTYPE (tree));
2938       return tree;
2939
2940
2941 /*------------------------------------------------------------------*/
2942 /*----------------------------*/
2943       /*    assignment operators    */
2944 /*----------------------------*/
2945     case MUL_ASSIGN:
2946     case DIV_ASSIGN:
2947       /* for these it must be both must be integral */
2948       if (!IS_ARITHMETIC (LTYPE (tree)) ||
2949           !IS_ARITHMETIC (RTYPE (tree)))
2950         {
2951           werror (E_OPS_INTEGRAL);
2952           goto errorTreeReturn;
2953         }
2954       RRVAL (tree) = 1;
2955       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree));
2956
2957       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
2958         werror (E_CODE_WRITE, " ");
2959
2960       if (LRVAL (tree))
2961         {
2962           werror (E_LVALUE_REQUIRED, "*= or /=");
2963           goto errorTreeReturn;
2964         }
2965       LLVAL (tree) = 1;
2966
2967       propAsgType (tree);
2968
2969       return tree;
2970
2971     case AND_ASSIGN:
2972     case OR_ASSIGN:
2973     case XOR_ASSIGN:
2974     case RIGHT_ASSIGN:
2975     case LEFT_ASSIGN:
2976       /* for these it must be both must be integral */
2977       if (!IS_INTEGRAL (LTYPE (tree)) ||
2978           !IS_INTEGRAL (RTYPE (tree)))
2979         {
2980           werror (E_OPS_INTEGRAL);
2981           goto errorTreeReturn;
2982         }
2983       RRVAL (tree) = 1;
2984       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree));
2985
2986       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
2987         werror (E_CODE_WRITE, " ");
2988
2989       if (LRVAL (tree))
2990         {
2991           werror (E_LVALUE_REQUIRED, "&= or |= or ^= or >>= or <<=");
2992           goto errorTreeReturn;
2993         }
2994       LLVAL (tree) = 1;
2995
2996       propAsgType (tree);
2997
2998       return tree;
2999
3000 /*------------------------------------------------------------------*/
3001 /*----------------------------*/
3002       /*    -= operator             */
3003 /*----------------------------*/
3004     case SUB_ASSIGN:
3005       if (!(IS_PTR (LTYPE (tree)) ||
3006             IS_ARITHMETIC (LTYPE (tree))))
3007         {
3008           werror (E_PLUS_INVALID, "-=");
3009           goto errorTreeReturn;
3010         }
3011
3012       if (!(IS_PTR (RTYPE (tree)) ||
3013             IS_ARITHMETIC (RTYPE (tree))))
3014         {
3015           werror (E_PLUS_INVALID, "-=");
3016           goto errorTreeReturn;
3017         }
3018       RRVAL (tree) = 1;
3019       TETYPE (tree) = getSpec (TTYPE (tree) =
3020                                computeType (LTYPE (tree),
3021                                             RTYPE (tree)));
3022
3023       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
3024         werror (E_CODE_WRITE, " ");
3025
3026       if (LRVAL (tree))
3027         {
3028           werror (E_LVALUE_REQUIRED, "-=");
3029           goto errorTreeReturn;
3030         }
3031       LLVAL (tree) = 1;
3032
3033       propAsgType (tree);
3034
3035       return tree;
3036
3037 /*------------------------------------------------------------------*/
3038 /*----------------------------*/
3039       /*          += operator       */
3040 /*----------------------------*/
3041     case ADD_ASSIGN:
3042       /* this is not a unary operation */
3043       /* if both pointers then problem */
3044       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)))
3045         {
3046           werror (E_PTR_PLUS_PTR);
3047           goto errorTreeReturn;
3048         }
3049
3050       if (!IS_ARITHMETIC (LTYPE (tree)) && !IS_PTR (LTYPE (tree)))
3051         {
3052           werror (E_PLUS_INVALID, "+=");
3053           goto errorTreeReturn;
3054         }
3055
3056       if (!IS_ARITHMETIC (RTYPE (tree)) && !IS_PTR (RTYPE (tree)))
3057         {
3058           werror (E_PLUS_INVALID, "+=");
3059           goto errorTreeReturn;
3060         }
3061       RRVAL (tree) = 1;
3062       TETYPE (tree) = getSpec (TTYPE (tree) =
3063                                computeType (LTYPE (tree),
3064                                             RTYPE (tree)));
3065
3066       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
3067         werror (E_CODE_WRITE, " ");
3068
3069       if (LRVAL (tree))
3070         {
3071           werror (E_LVALUE_REQUIRED, "+=");
3072           goto errorTreeReturn;
3073         }
3074
3075       tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
3076       tree->opval.op = '=';
3077
3078       propAsgType (tree);
3079
3080       return tree;
3081
3082 /*------------------------------------------------------------------*/
3083 /*----------------------------*/
3084       /*      straight assignemnt   */
3085 /*----------------------------*/
3086     case '=':
3087       /* cannot be an aggregate */
3088       if (IS_AGGREGATE (LTYPE (tree)))
3089         {
3090           werror (E_AGGR_ASSIGN);
3091           goto errorTreeReturn;
3092         }
3093
3094       /* they should either match or be castable */
3095       if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
3096         {
3097           werror (E_TYPE_MISMATCH, "assignment", " ");
3098           fprintf (stderr, "type --> '");
3099           printTypeChain (RTYPE (tree), stderr);
3100           fprintf (stderr, "' ");
3101           fprintf (stderr, "assigned to type --> '");
3102           printTypeChain (LTYPE (tree), stderr);
3103           fprintf (stderr, "'\n");
3104           goto errorTreeReturn;
3105         }
3106
3107       /* if the left side of the tree is of type void
3108          then report error */
3109       if (IS_VOID (LTYPE (tree)))
3110         {
3111           werror (E_CAST_ZERO);
3112           fprintf (stderr, "type --> '");
3113           printTypeChain (RTYPE (tree), stderr);
3114           fprintf (stderr, "' ");
3115           fprintf (stderr, "assigned to type --> '");
3116           printTypeChain (LTYPE (tree), stderr);
3117           fprintf (stderr, "'\n");
3118         }
3119
3120       /* extra checks for pointer types */
3121       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)) &&
3122           !IS_GENPTR (LTYPE (tree)))
3123         {
3124           if (DCL_TYPE (LTYPE (tree)) != DCL_TYPE (RTYPE (tree)))
3125             werror (W_PTR_ASSIGN);
3126         }
3127
3128       TETYPE (tree) = getSpec (TTYPE (tree) =
3129                                LTYPE (tree));
3130       RRVAL (tree) = 1;
3131       LLVAL (tree) = 1;
3132       if (!tree->initMode ) {
3133               if (IS_CONSTANT (LETYPE (tree))) {
3134                       werror (E_CODE_WRITE, " ");
3135               }
3136       }
3137       if (LRVAL (tree))
3138         {
3139           werror (E_LVALUE_REQUIRED, "=");
3140           goto errorTreeReturn;
3141         }
3142
3143       propAsgType (tree);
3144
3145       return tree;
3146
3147 /*------------------------------------------------------------------*/
3148 /*----------------------------*/
3149       /*      comma operator        */
3150 /*----------------------------*/
3151     case ',':
3152       TETYPE (tree) = getSpec (TTYPE (tree) = RTYPE (tree));
3153       return tree;
3154
3155 /*------------------------------------------------------------------*/
3156 /*----------------------------*/
3157       /*       function call        */
3158 /*----------------------------*/
3159     case CALL:
3160       parmNumber = 1;
3161
3162       if (processParms (tree->left,
3163                         tree->left->args,
3164                         tree->right, &parmNumber, TRUE))
3165         goto errorTreeReturn;
3166
3167       if (options.stackAuto || IS_RENT (LETYPE (tree)))
3168         {
3169           tree->left->args = reverseVal (tree->left->args);
3170           reverseParms (tree->right);
3171         }
3172
3173       tree->args = tree->left->args;
3174       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
3175       return tree;
3176
3177 /*------------------------------------------------------------------*/
3178 /*----------------------------*/
3179       /*     return statement       */
3180 /*----------------------------*/
3181     case RETURN:
3182       if (!tree->right)
3183         goto voidcheck;
3184
3185       if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
3186         {
3187           werror (W_RETURN_MISMATCH);
3188           goto errorTreeReturn;
3189         }
3190
3191       if (IS_VOID (currFunc->type->next)
3192           && tree->right &&
3193           !IS_VOID (RTYPE (tree)))
3194         {
3195           werror (E_FUNC_VOID);
3196           goto errorTreeReturn;
3197         }
3198
3199       /* if there is going to be a casing required then add it */
3200       if (compareType (currFunc->type->next, RTYPE (tree)) < 0)
3201         {
3202 #if 0 && defined DEMAND_INTEGER_PROMOTION
3203           if (IS_INTEGRAL (currFunc->type->next))
3204             {
3205               pushTypeCastToLeaves (currFunc->type->next, tree->right, &(tree->right));
3206             }
3207           else
3208 #endif
3209             {
3210               tree->right =
3211                 decorateType (newNode (CAST,
3212                          newAst_LINK (copyLinkChain (currFunc->type->next)),
3213                                        tree->right));
3214             }
3215         }
3216
3217       RRVAL (tree) = 1;
3218       return tree;
3219
3220     voidcheck:
3221
3222       if (!IS_VOID (currFunc->type->next) && tree->right == NULL)
3223         {
3224           werror (E_VOID_FUNC, currFunc->name);
3225           goto errorTreeReturn;
3226         }
3227
3228       TTYPE (tree) = TETYPE (tree) = NULL;
3229       return tree;
3230
3231 /*------------------------------------------------------------------*/
3232 /*----------------------------*/
3233       /*     switch statement       */
3234 /*----------------------------*/
3235     case SWITCH:
3236       /* the switch value must be an integer */
3237       if (!IS_INTEGRAL (LTYPE (tree)))
3238         {
3239           werror (E_SWITCH_NON_INTEGER);
3240           goto errorTreeReturn;
3241         }
3242       LRVAL (tree) = 1;
3243       TTYPE (tree) = TETYPE (tree) = NULL;
3244       return tree;
3245
3246 /*------------------------------------------------------------------*/
3247 /*----------------------------*/
3248       /* ifx Statement              */
3249 /*----------------------------*/
3250     case IFX:
3251       tree->left = backPatchLabels (tree->left,
3252                                     tree->trueLabel,
3253                                     tree->falseLabel);
3254       TTYPE (tree) = TETYPE (tree) = NULL;
3255       return tree;
3256
3257 /*------------------------------------------------------------------*/
3258 /*----------------------------*/
3259       /* for Statement              */
3260 /*----------------------------*/
3261     case FOR:
3262
3263       decorateType (resolveSymbols (AST_FOR (tree, initExpr)));
3264       decorateType (resolveSymbols (AST_FOR (tree, condExpr)));
3265       decorateType (resolveSymbols (AST_FOR (tree, loopExpr)));
3266
3267       /* if the for loop is reversible then
3268          reverse it otherwise do what we normally
3269          do */
3270       {
3271         symbol *sym;
3272         ast *init, *end;
3273
3274         if (isLoopReversible (tree, &sym, &init, &end))
3275           return reverseLoop (tree, sym, init, end);
3276         else
3277           return decorateType (createFor (AST_FOR (tree, trueLabel),
3278                                           AST_FOR (tree, continueLabel),
3279                                           AST_FOR (tree, falseLabel),
3280                                           AST_FOR (tree, condLabel),
3281                                           AST_FOR (tree, initExpr),
3282                                           AST_FOR (tree, condExpr),
3283                                           AST_FOR (tree, loopExpr),
3284                                           tree->left));
3285       }
3286     default:
3287       TTYPE (tree) = TETYPE (tree) = NULL;
3288       return tree;
3289     }
3290
3291   /* some error found this tree will be killed */
3292 errorTreeReturn:
3293   TTYPE (tree) = TETYPE (tree) = newCharLink ();
3294   tree->opval.op = NULLOP;
3295   tree->isError = 1;
3296
3297   return tree;
3298 }
3299
3300 /*-----------------------------------------------------------------*/
3301 /* sizeofOp - processes size of operation                          */
3302 /*-----------------------------------------------------------------*/
3303 value *
3304 sizeofOp (sym_link * type)
3305 {
3306   char buff[10];
3307
3308   /* make sure the type is complete and sane */
3309   checkTypeSanity(type, "(sizeof)");
3310
3311   /* get the size and convert it to character  */
3312   sprintf (buff, "%d", getSize (type));
3313
3314   /* now convert into value  */
3315   return constVal (buff);
3316 }
3317
3318
3319 #define IS_AND(ex) (ex->type == EX_OP && ex->opval.op == AND_OP )
3320 #define IS_OR(ex)  (ex->type == EX_OP && ex->opval.op == OR_OP )
3321 #define IS_NOT(ex) (ex->type == EX_OP && ex->opval.op == '!' )
3322 #define IS_ANDORNOT(ex) (IS_AND(ex) || IS_OR(ex) || IS_NOT(ex))
3323 #define IS_IFX(ex) (ex->type == EX_OP && ex->opval.op == IFX )
3324 #define IS_LT(ex)  (ex->type == EX_OP && ex->opval.op == '<' )
3325 #define IS_GT(ex)  (ex->type == EX_OP && ex->opval.op == '>')
3326
3327 /*-----------------------------------------------------------------*/
3328 /* backPatchLabels - change and or not operators to flow control    */
3329 /*-----------------------------------------------------------------*/
3330 ast *
3331 backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel)
3332 {
3333
3334   if (!tree)
3335     return NULL;
3336
3337   if (!(IS_ANDORNOT (tree)))
3338     return tree;
3339
3340   /* if this an and */
3341   if (IS_AND (tree))
3342     {
3343       static int localLbl = 0;
3344       symbol *localLabel;
3345
3346       sprintf (buffer, "_and_%d", localLbl++);
3347       localLabel = newSymbol (buffer, NestLevel);
3348
3349       tree->left = backPatchLabels (tree->left, localLabel, falseLabel);
3350
3351       /* if left is already a IFX then just change the if true label in that */
3352       if (!IS_IFX (tree->left))
3353         tree->left = newIfxNode (tree->left, localLabel, falseLabel);
3354
3355       tree->right = backPatchLabels (tree->right, trueLabel, falseLabel);
3356       /* right is a IFX then just join */
3357       if (IS_IFX (tree->right))
3358         return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right));
3359
3360       tree->right = createLabel (localLabel, tree->right);
3361       tree->right = newIfxNode (tree->right, trueLabel, falseLabel);
3362
3363       return newNode (NULLOP, tree->left, tree->right);
3364     }
3365
3366   /* if this is an or operation */
3367   if (IS_OR (tree))
3368     {
3369       static int localLbl = 0;
3370       symbol *localLabel;
3371
3372       sprintf (buffer, "_or_%d", localLbl++);
3373       localLabel = newSymbol (buffer, NestLevel);
3374
3375       tree->left = backPatchLabels (tree->left, trueLabel, localLabel);
3376
3377       /* if left is already a IFX then just change the if true label in that */
3378       if (!IS_IFX (tree->left))
3379         tree->left = newIfxNode (tree->left, trueLabel, localLabel);
3380
3381       tree->right = backPatchLabels (tree->right, trueLabel, falseLabel);
3382       /* right is a IFX then just join */
3383       if (IS_IFX (tree->right))
3384         return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right));
3385
3386       tree->right = createLabel (localLabel, tree->right);
3387       tree->right = newIfxNode (tree->right, trueLabel, falseLabel);
3388
3389       return newNode (NULLOP, tree->left, tree->right);
3390     }
3391
3392   /* change not */
3393   if (IS_NOT (tree))
3394     {
3395       int wasnot = IS_NOT (tree->left);
3396       tree->left = backPatchLabels (tree->left, falseLabel, trueLabel);
3397
3398       /* if the left is already a IFX */
3399       if (!IS_IFX (tree->left))
3400         tree->left = newNode (IFX, tree->left, NULL);
3401
3402       if (wasnot)
3403         {
3404           tree->left->trueLabel = trueLabel;
3405           tree->left->falseLabel = falseLabel;
3406         }
3407       else
3408         {
3409           tree->left->trueLabel = falseLabel;
3410           tree->left->falseLabel = trueLabel;
3411         }
3412       return tree->left;
3413     }
3414
3415   if (IS_IFX (tree))
3416     {
3417       tree->trueLabel = trueLabel;
3418       tree->falseLabel = falseLabel;
3419     }
3420
3421   return tree;
3422 }
3423
3424
3425 /*-----------------------------------------------------------------*/
3426 /* createBlock - create expression tree for block                  */
3427 /*-----------------------------------------------------------------*/
3428 ast *
3429 createBlock (symbol * decl, ast * body)
3430 {
3431   ast *ex;
3432
3433   /* if the block has nothing */
3434   if (!body)
3435     return NULL;
3436
3437   ex = newNode (BLOCK, NULL, body);
3438   ex->values.sym = decl;
3439
3440   ex->right = ex->right;
3441   ex->level++;
3442   ex->lineno = 0;
3443   return ex;
3444 }
3445
3446 /*-----------------------------------------------------------------*/
3447 /* createLabel - creates the expression tree for labels            */
3448 /*-----------------------------------------------------------------*/
3449 ast *
3450 createLabel (symbol * label, ast * stmnt)
3451 {
3452   symbol *csym;
3453   char name[SDCC_NAME_MAX + 1];
3454   ast *rValue;
3455
3456   /* must create fresh symbol if the symbol name  */
3457   /* exists in the symbol table, since there can  */
3458   /* be a variable with the same name as the labl */
3459   if ((csym = findSym (SymbolTab, NULL, label->name)) &&
3460       (csym->level == label->level))
3461     label = newSymbol (label->name, label->level);
3462
3463   /* change the name before putting it in add _ */
3464   sprintf (name, "%s", label->name);
3465
3466   /* put the label in the LabelSymbol table    */
3467   /* but first check if a label of the same    */
3468   /* name exists                               */
3469   if ((csym = findSym (LabelTab, NULL, name)))
3470     werror (E_DUPLICATE_LABEL, label->name);
3471   else
3472     addSym (LabelTab, label, name, label->level, 0, 0);
3473
3474   label->islbl = 1;
3475   label->key = labelKey++;
3476   rValue = newNode (LABEL, newAst_VALUE (symbolVal (label)), stmnt);
3477   rValue->lineno = 0;
3478
3479   return rValue;
3480 }
3481
3482 /*-----------------------------------------------------------------*/
3483 /* createCase - generates the parsetree for a case statement       */
3484 /*-----------------------------------------------------------------*/
3485 ast *
3486 createCase (ast * swStat, ast * caseVal, ast * stmnt)
3487 {
3488   char caseLbl[SDCC_NAME_MAX + 1];
3489   ast *rexpr;
3490   value *val;
3491
3492   /* if the switch statement does not exist */
3493   /* then case is out of context            */
3494   if (!swStat)
3495     {
3496       werror (E_CASE_CONTEXT);
3497       return NULL;
3498     }
3499
3500   caseVal = decorateType (resolveSymbols (caseVal));
3501   /* if not a constant then error  */
3502   if (!IS_LITERAL (caseVal->ftype))
3503     {
3504       werror (E_CASE_CONSTANT);
3505       return NULL;
3506     }
3507
3508   /* if not a integer than error */
3509   if (!IS_INTEGRAL (caseVal->ftype))
3510     {
3511       werror (E_CASE_NON_INTEGER);
3512       return NULL;
3513     }
3514
3515   /* find the end of the switch values chain   */
3516   if (!(val = swStat->values.switchVals.swVals))
3517     swStat->values.switchVals.swVals = caseVal->opval.val;
3518   else
3519     {
3520       /* also order the cases according to value */
3521       value *pval = NULL;
3522       int cVal = (int) floatFromVal (caseVal->opval.val);
3523       while (val && (int) floatFromVal (val) < cVal)
3524         {
3525           pval = val;
3526           val = val->next;
3527         }
3528
3529       /* if we reached the end then */
3530       if (!val)
3531         {
3532           pval->next = caseVal->opval.val;
3533         }
3534       else
3535         {
3536           /* we found a value greater than */
3537           /* the current value we must add this */
3538           /* before the value */
3539           caseVal->opval.val->next = val;
3540
3541           /* if this was the first in chain */
3542           if (swStat->values.switchVals.swVals == val)
3543             swStat->values.switchVals.swVals =
3544               caseVal->opval.val;
3545           else
3546             pval->next = caseVal->opval.val;
3547         }
3548
3549     }
3550
3551   /* create the case label   */
3552   sprintf (caseLbl, "_case_%d_%d",
3553            swStat->values.switchVals.swNum,
3554            (int) floatFromVal (caseVal->opval.val));
3555
3556   rexpr = createLabel (newSymbol (caseLbl, 0), stmnt);
3557   rexpr->lineno = 0;
3558   return rexpr;
3559 }
3560
3561 /*-----------------------------------------------------------------*/
3562 /* createDefault - creates the parse tree for the default statement */
3563 /*-----------------------------------------------------------------*/
3564 ast *
3565 createDefault (ast * swStat, ast * stmnt)
3566 {
3567   char defLbl[SDCC_NAME_MAX + 1];
3568
3569   /* if the switch statement does not exist */
3570   /* then case is out of context            */
3571   if (!swStat)
3572     {
3573       werror (E_CASE_CONTEXT);
3574       return NULL;
3575     }
3576
3577   /* turn on the default flag   */
3578   swStat->values.switchVals.swDefault = 1;
3579
3580   /* create the label  */
3581   sprintf (defLbl, "_default_%d", swStat->values.switchVals.swNum);
3582   return createLabel (newSymbol (defLbl, 0), stmnt);
3583 }
3584
3585 /*-----------------------------------------------------------------*/
3586 /* createIf - creates the parsetree for the if statement           */
3587 /*-----------------------------------------------------------------*/
3588 ast *
3589 createIf (ast * condAst, ast * ifBody, ast * elseBody)
3590 {
3591   static int Lblnum = 0;
3592   ast *ifTree;
3593   symbol *ifTrue, *ifFalse, *ifEnd;
3594
3595   /* if neither exists */
3596   if (!elseBody && !ifBody)
3597     return condAst;
3598
3599   /* create the labels */
3600   sprintf (buffer, "_iffalse_%d", Lblnum);
3601   ifFalse = newSymbol (buffer, NestLevel);
3602   /* if no else body then end == false */
3603   if (!elseBody)
3604     ifEnd = ifFalse;
3605   else
3606     {
3607       sprintf (buffer, "_ifend_%d", Lblnum);
3608       ifEnd = newSymbol (buffer, NestLevel);
3609     }
3610
3611   sprintf (buffer, "_iftrue_%d", Lblnum);
3612   ifTrue = newSymbol (buffer, NestLevel);
3613
3614   Lblnum++;
3615
3616   /* attach the ifTrue label to the top of it body */
3617   ifBody = createLabel (ifTrue, ifBody);
3618   /* attach a goto end to the ifBody if else is present */
3619   if (elseBody)
3620     {
3621       ifBody = newNode (NULLOP, ifBody,
3622                         newNode (GOTO,
3623                                  newAst_VALUE (symbolVal (ifEnd)),
3624                                  NULL));
3625       /* put the elseLabel on the else body */
3626       elseBody = createLabel (ifFalse, elseBody);
3627       /* out the end at the end of the body */
3628       elseBody = newNode (NULLOP,
3629                           elseBody,
3630                           createLabel (ifEnd, NULL));
3631     }
3632   else
3633     {
3634       ifBody = newNode (NULLOP, ifBody,
3635                         createLabel (ifFalse, NULL));
3636     }
3637   condAst = backPatchLabels (condAst, ifTrue, ifFalse);
3638   if (IS_IFX (condAst))
3639     ifTree = condAst;
3640   else
3641     ifTree = newIfxNode (condAst, ifTrue, ifFalse);
3642
3643   return newNode (NULLOP, ifTree,
3644                   newNode (NULLOP, ifBody, elseBody));
3645
3646 }
3647
3648 /*-----------------------------------------------------------------*/
3649 /* createDo - creates parse tree for do                            */
3650 /*        _dobody_n:                                               */
3651 /*            statements                                           */
3652 /*        _docontinue_n:                                           */
3653 /*            condition_expression +-> trueLabel -> _dobody_n      */
3654 /*                                 |                               */
3655 /*                                 +-> falseLabel-> _dobreak_n     */
3656 /*        _dobreak_n:                                              */
3657 /*-----------------------------------------------------------------*/
3658 ast *
3659 createDo (symbol * trueLabel, symbol * continueLabel,
3660           symbol * falseLabel, ast * condAst, ast * doBody)
3661 {
3662   ast *doTree;
3663
3664
3665   /* if the body does not exist then it is simple */
3666   if (!doBody)
3667     {
3668       condAst = backPatchLabels (condAst, continueLabel, NULL);
3669       doTree = (IS_IFX (condAst) ? createLabel (continueLabel, condAst)
3670                 : newNode (IFX, createLabel (continueLabel, condAst), NULL));
3671       doTree->trueLabel = continueLabel;
3672       doTree->falseLabel = NULL;
3673       return doTree;
3674     }
3675
3676   /* otherwise we have a body */
3677   condAst = backPatchLabels (condAst, trueLabel, falseLabel);
3678
3679   /* attach the body label to the top */
3680   doBody = createLabel (trueLabel, doBody);
3681   /* attach the continue label to end of body */
3682   doBody = newNode (NULLOP, doBody,
3683                     createLabel (continueLabel, NULL));
3684
3685   /* now put the break label at the end */
3686   if (IS_IFX (condAst))
3687     doTree = condAst;
3688   else
3689     doTree = newIfxNode (condAst, trueLabel, falseLabel);
3690
3691   doTree = newNode (NULLOP, doTree, createLabel (falseLabel, NULL));
3692
3693   /* putting it together */
3694   return newNode (NULLOP, doBody, doTree);
3695 }
3696
3697 /*-----------------------------------------------------------------*/
3698 /* createFor - creates parse tree for 'for' statement              */
3699 /*        initExpr                                                 */
3700 /*   _forcond_n:                                                   */
3701 /*        condExpr  +-> trueLabel -> _forbody_n                    */
3702 /*                  |                                              */
3703 /*                  +-> falseLabel-> _forbreak_n                   */
3704 /*   _forbody_n:                                                   */
3705 /*        statements                                               */
3706 /*   _forcontinue_n:                                               */
3707 /*        loopExpr                                                 */
3708 /*        goto _forcond_n ;                                        */
3709 /*   _forbreak_n:                                                  */
3710 /*-----------------------------------------------------------------*/
3711 ast *
3712 createFor (symbol * trueLabel, symbol * continueLabel,
3713            symbol * falseLabel, symbol * condLabel,
3714            ast * initExpr, ast * condExpr, ast * loopExpr,
3715            ast * forBody)
3716 {
3717   ast *forTree;
3718
3719   /* if loopexpression not present then we can generate it */
3720   /* the same way as a while */
3721   if (!loopExpr)
3722     return newNode (NULLOP, initExpr,
3723                     createWhile (trueLabel, continueLabel,
3724                                  falseLabel, condExpr, forBody));
3725   /* vanilla for statement */
3726   condExpr = backPatchLabels (condExpr, trueLabel, falseLabel);
3727
3728   if (condExpr && !IS_IFX (condExpr))
3729     condExpr = newIfxNode (condExpr, trueLabel, falseLabel);
3730
3731
3732   /* attach condition label to condition */
3733   condExpr = createLabel (condLabel, condExpr);
3734
3735   /* attach body label to body */
3736   forBody = createLabel (trueLabel, forBody);
3737
3738   /* attach continue to forLoop expression & attach */
3739   /* goto the forcond @ and of loopExpression       */
3740   loopExpr = createLabel (continueLabel,
3741                           newNode (NULLOP,
3742                                    loopExpr,
3743                                    newNode (GOTO,
3744                                        newAst_VALUE (symbolVal (condLabel)),
3745                                             NULL)));
3746   /* now start putting them together */
3747   forTree = newNode (NULLOP, initExpr, condExpr);
3748   forTree = newNode (NULLOP, forTree, forBody);
3749   forTree = newNode (NULLOP, forTree, loopExpr);
3750   /* finally add the break label */
3751   forTree = newNode (NULLOP, forTree,
3752                      createLabel (falseLabel, NULL));
3753   return forTree;
3754 }
3755
3756 /*-----------------------------------------------------------------*/
3757 /* createWhile - creates parse tree for while statement            */
3758 /*               the while statement will be created as follows    */
3759 /*                                                                 */
3760 /*      _while_continue_n:                                         */
3761 /*            condition_expression +-> trueLabel -> _while_boby_n  */
3762 /*                                 |                               */
3763 /*                                 +-> falseLabel -> _while_break_n */
3764 /*      _while_body_n:                                             */
3765 /*            statements                                           */
3766 /*            goto _while_continue_n                               */
3767 /*      _while_break_n:                                            */
3768 /*-----------------------------------------------------------------*/
3769 ast *
3770 createWhile (symbol * trueLabel, symbol * continueLabel,
3771              symbol * falseLabel, ast * condExpr, ast * whileBody)
3772 {
3773   ast *whileTree;
3774
3775   /* put the continue label */
3776   condExpr = backPatchLabels (condExpr, trueLabel, falseLabel);
3777   condExpr = createLabel (continueLabel, condExpr);
3778   condExpr->lineno = 0;
3779
3780   /* put the body label in front of the body */
3781   whileBody = createLabel (trueLabel, whileBody);
3782   whileBody->lineno = 0;
3783   /* put a jump to continue at the end of the body */
3784   /* and put break label at the end of the body */
3785   whileBody = newNode (NULLOP,
3786                        whileBody,
3787                        newNode (GOTO,
3788                                 newAst_VALUE (symbolVal (continueLabel)),
3789                                 createLabel (falseLabel, NULL)));
3790
3791   /* put it all together */
3792   if (IS_IFX (condExpr))
3793     whileTree = condExpr;
3794   else
3795     {
3796       whileTree = newNode (IFX, condExpr, NULL);
3797       /* put the true & false labels in place */
3798       whileTree->trueLabel = trueLabel;
3799       whileTree->falseLabel = falseLabel;
3800     }
3801
3802   return newNode (NULLOP, whileTree, whileBody);
3803 }
3804
3805 /*-----------------------------------------------------------------*/
3806 /* optimizeGetHbit - get highest order bit of the expression       */
3807 /*-----------------------------------------------------------------*/
3808 ast *
3809 optimizeGetHbit (ast * tree)
3810 {
3811   int i, j;
3812   /* if this is not a bit and */
3813   if (!IS_BITAND (tree))
3814     return tree;
3815
3816   /* will look for tree of the form
3817      ( expr >> ((sizeof expr) -1) ) & 1 */
3818   if (!IS_AST_LIT_VALUE (tree->right))
3819     return tree;
3820
3821   if (AST_LIT_VALUE (tree->right) != 1)
3822     return tree;
3823
3824   if (!IS_RIGHT_OP (tree->left))
3825     return tree;
3826
3827   if (!IS_AST_LIT_VALUE (tree->left->right))
3828     return tree;
3829
3830   if ((i = (int) AST_LIT_VALUE (tree->left->right)) !=
3831       (j = (getSize (TTYPE (tree->left->left)) * 8 - 1)))
3832     return tree;
3833
3834   return decorateType (newNode (GETHBIT, tree->left->left, NULL));
3835
3836 }
3837
3838 /*-----------------------------------------------------------------*/
3839 /* optimizeRRCRLC :- optimize for Rotate Left/Right with carry     */
3840 /*-----------------------------------------------------------------*/
3841 ast *
3842 optimizeRRCRLC (ast * root)
3843 {
3844   /* will look for trees of the form
3845      (?expr << 1) | (?expr >> 7) or
3846      (?expr >> 7) | (?expr << 1) will make that
3847      into a RLC : operation ..
3848      Will also look for
3849      (?expr >> 1) | (?expr << 7) or
3850      (?expr << 7) | (?expr >> 1) will make that
3851      into a RRC operation
3852      note : by 7 I mean (number of bits required to hold the
3853      variable -1 ) */
3854   /* if the root operations is not a | operation the not */
3855   if (!IS_BITOR (root))
3856     return root;
3857
3858   /* I have to think of a better way to match patterns this sucks */
3859   /* that aside let start looking for the first case : I use a the
3860      negative check a lot to improve the efficiency */
3861   /* (?expr << 1) | (?expr >> 7) */
3862   if (IS_LEFT_OP (root->left) &&
3863       IS_RIGHT_OP (root->right))
3864     {
3865
3866       if (!SPEC_USIGN (TETYPE (root->left->left)))
3867         return root;
3868
3869       if (!IS_AST_LIT_VALUE (root->left->right) ||
3870           !IS_AST_LIT_VALUE (root->right->right))
3871         goto tryNext0;
3872
3873       /* make sure it is the same expression */
3874       if (!isAstEqual (root->left->left,
3875                        root->right->left))
3876         goto tryNext0;
3877
3878       if (AST_LIT_VALUE (root->left->right) != 1)
3879         goto tryNext0;
3880
3881       if (AST_LIT_VALUE (root->right->right) !=
3882           (getSize (TTYPE (root->left->left)) * 8 - 1))
3883         goto tryNext0;
3884
3885       /* whew got the first case : create the AST */
3886       return newNode (RLC, root->left->left, NULL);
3887     }
3888
3889 tryNext0:
3890   /* check for second case */
3891   /* (?expr >> 7) | (?expr << 1) */
3892   if (IS_LEFT_OP (root->right) &&
3893       IS_RIGHT_OP (root->left))
3894     {
3895
3896       if (!SPEC_USIGN (TETYPE (root->left->left)))
3897         return root;
3898
3899       if (!IS_AST_LIT_VALUE (root->left->right) ||
3900           !IS_AST_LIT_VALUE (root->right->right))
3901         goto tryNext1;
3902
3903       /* make sure it is the same symbol */
3904       if (!isAstEqual (root->left->left,
3905                        root->right->left))
3906         goto tryNext1;
3907
3908       if (AST_LIT_VALUE (root->right->right) != 1)
3909         goto tryNext1;
3910
3911       if (AST_LIT_VALUE (root->left->right) !=
3912           (getSize (TTYPE (root->left->left)) * 8 - 1))
3913         goto tryNext1;
3914
3915       /* whew got the first case : create the AST */
3916       return newNode (RLC, root->left->left, NULL);
3917
3918     }
3919
3920 tryNext1:
3921   /* third case for RRC */
3922   /*  (?symbol >> 1) | (?symbol << 7) */
3923   if (IS_LEFT_OP (root->right) &&
3924       IS_RIGHT_OP (root->left))
3925     {
3926
3927       if (!SPEC_USIGN (TETYPE (root->left->left)))
3928         return root;
3929
3930       if (!IS_AST_LIT_VALUE (root->left->right) ||
3931           !IS_AST_LIT_VALUE (root->right->right))
3932         goto tryNext2;
3933
3934       /* make sure it is the same symbol */
3935       if (!isAstEqual (root->left->left,
3936                        root->right->left))
3937         goto tryNext2;
3938
3939       if (AST_LIT_VALUE (root->left->right) != 1)
3940         goto tryNext2;
3941
3942       if (AST_LIT_VALUE (root->right->right) !=
3943           (getSize (TTYPE (root->left->left)) * 8 - 1))
3944         goto tryNext2;
3945
3946       /* whew got the first case : create the AST */
3947       return newNode (RRC, root->left->left, NULL);
3948
3949     }
3950 tryNext2:
3951   /* fourth and last case for now */
3952   /* (?symbol << 7) | (?symbol >> 1) */
3953   if (IS_RIGHT_OP (root->right) &&
3954       IS_LEFT_OP (root->left))
3955     {
3956
3957       if (!SPEC_USIGN (TETYPE (root->left->left)))
3958         return root;
3959
3960       if (!IS_AST_LIT_VALUE (root->left->right) ||
3961           !IS_AST_LIT_VALUE (root->right->right))
3962         return root;
3963
3964       /* make sure it is the same symbol */
3965       if (!isAstEqual (root->left->left,
3966                        root->right->left))
3967         return root;
3968
3969       if (AST_LIT_VALUE (root->right->right) != 1)
3970         return root;
3971
3972       if (AST_LIT_VALUE (root->left->right) !=
3973           (getSize (TTYPE (root->left->left)) * 8 - 1))
3974         return root;
3975
3976       /* whew got the first case : create the AST */
3977       return newNode (RRC, root->left->left, NULL);
3978
3979     }
3980
3981   /* not found return root */
3982   return root;
3983 }
3984
3985 /*-----------------------------------------------------------------*/
3986 /* optimizeCompare - otimizes compares for bit variables     */
3987 /*-----------------------------------------------------------------*/
3988 ast *
3989 optimizeCompare (ast * root)
3990 {
3991   ast *optExpr = NULL;
3992   value *vleft;
3993   value *vright;
3994   unsigned int litValue;
3995
3996   /* if nothing then return nothing */
3997   if (!root)
3998     return NULL;
3999
4000   /* if not a compare op then do leaves */
4001   if (!IS_COMPARE_OP (root))
4002     {
4003       root->left = optimizeCompare (root->left);
4004       root->right = optimizeCompare (root->right);
4005       return root;
4006     }
4007
4008   /* if left & right are the same then depending
4009      of the operation do */
4010   if (isAstEqual (root->left, root->right))
4011     {
4012       switch (root->opval.op)
4013         {
4014         case '>':
4015         case '<':
4016         case NE_OP:
4017           optExpr = newAst_VALUE (constVal ("0"));
4018           break;
4019         case GE_OP:
4020         case LE_OP:
4021         case EQ_OP:
4022           optExpr = newAst_VALUE (constVal ("1"));
4023           break;
4024         }
4025
4026       return decorateType (optExpr);
4027     }
4028
4029   vleft = (root->left->type == EX_VALUE ?
4030            root->left->opval.val : NULL);
4031
4032   vright = (root->right->type == EX_VALUE ?
4033             root->right->opval.val : NULL);
4034
4035   /* if left is a BITVAR in BITSPACE */
4036   /* and right is a LITERAL then opt- */
4037   /* imize else do nothing       */
4038   if (vleft && vright &&
4039       IS_BITVAR (vleft->etype) &&
4040       IN_BITSPACE (SPEC_OCLS (vleft->etype)) &&
4041       IS_LITERAL (vright->etype))
4042     {
4043
4044       /* if right side > 1 then comparison may never succeed */
4045       if ((litValue = (int) floatFromVal (vright)) > 1)
4046         {
4047           werror (W_BAD_COMPARE);
4048           goto noOptimize;
4049         }
4050
4051       if (litValue)
4052         {
4053           switch (root->opval.op)
4054             {
4055             case '>':           /* bit value greater than 1 cannot be */
4056               werror (W_BAD_COMPARE);
4057               goto noOptimize;
4058               break;
4059
4060             case '<':           /* bit value < 1 means 0 */
4061             case NE_OP:
4062               optExpr = newNode ('!', newAst_VALUE (vleft), NULL);
4063               break;
4064
4065             case LE_OP: /* bit value <= 1 means no check */
4066               optExpr = newAst_VALUE (vright);
4067               break;
4068
4069             case GE_OP: /* bit value >= 1 means only check for = */
4070             case EQ_OP:
4071               optExpr = newAst_VALUE (vleft);
4072               break;
4073             }
4074         }
4075       else
4076         {                       /* literal is zero */
4077           switch (root->opval.op)
4078             {
4079             case '<':           /* bit value < 0 cannot be */
4080               werror (W_BAD_COMPARE);
4081               goto noOptimize;
4082               break;
4083
4084             case '>':           /* bit value > 0 means 1 */
4085             case NE_OP:
4086               optExpr = newAst_VALUE (vleft);
4087               break;
4088
4089             case LE_OP: /* bit value <= 0 means no check */
4090             case GE_OP: /* bit value >= 0 means no check */
4091               werror (W_BAD_COMPARE);
4092               goto noOptimize;
4093               break;
4094
4095             case EQ_OP: /* bit == 0 means ! of bit */
4096               optExpr = newNode ('!', newAst_VALUE (vleft), NULL);
4097               break;
4098             }
4099         }
4100       return decorateType (resolveSymbols (optExpr));
4101     }                           /* end-of-if of BITVAR */
4102
4103 noOptimize:
4104   return root;
4105 }
4106 /*-----------------------------------------------------------------*/
4107 /* addSymToBlock : adds the symbol to the first block we find      */
4108 /*-----------------------------------------------------------------*/
4109 void
4110 addSymToBlock (symbol * sym, ast * tree)
4111 {
4112   /* reached end of tree or a leaf */
4113   if (!tree || IS_AST_LINK (tree) || IS_AST_VALUE (tree))
4114     return;
4115
4116   /* found a block */
4117   if (IS_AST_OP (tree) &&
4118       tree->opval.op == BLOCK)
4119     {
4120
4121       symbol *lsym = copySymbol (sym);
4122
4123       lsym->next = AST_VALUES (tree, sym);
4124       AST_VALUES (tree, sym) = lsym;
4125       return;
4126     }
4127
4128   addSymToBlock (sym, tree->left);
4129   addSymToBlock (sym, tree->right);
4130 }
4131
4132 /*-----------------------------------------------------------------*/
4133 /* processRegParms - do processing for register parameters         */
4134 /*-----------------------------------------------------------------*/
4135 static void
4136 processRegParms (value * args, ast * body)
4137 {
4138   while (args)
4139     {
4140       if (IS_REGPARM (args->etype))
4141         addSymToBlock (args->sym, body);
4142       args = args->next;
4143     }
4144 }
4145
4146 /*-----------------------------------------------------------------*/
4147 /* resetParmKey - resets the operandkeys for the symbols           */
4148 /*-----------------------------------------------------------------*/
4149 DEFSETFUNC (resetParmKey)
4150 {
4151   symbol *sym = item;
4152
4153   sym->key = 0;
4154   sym->defs = NULL;
4155   sym->uses = NULL;
4156   sym->remat = 0;
4157   return 1;
4158 }
4159
4160 /*-----------------------------------------------------------------*/
4161 /* createFunction - This is the key node that calls the iCode for  */
4162 /*                  generating the code for a function. Note code  */
4163 /*                  is generated function by function, later when  */
4164 /*                  add inter-procedural analysis this will change */
4165 /*-----------------------------------------------------------------*/
4166 ast *
4167 createFunction (symbol * name, ast * body)
4168 {
4169   ast *ex;
4170   symbol *csym;
4171   int stack = 0;
4172   sym_link *fetype;
4173   iCode *piCode = NULL;
4174
4175   /* if check function return 0 then some problem */
4176   if (checkFunction (name) == 0)
4177     return NULL;
4178
4179   /* create a dummy block if none exists */
4180   if (!body)
4181     body = newNode (BLOCK, NULL, NULL);
4182
4183   noLineno++;
4184
4185   /* check if the function name already in the symbol table */
4186   if ((csym = findSym (SymbolTab, NULL, name->name)))
4187     {
4188       name = csym;
4189       /* special case for compiler defined functions
4190          we need to add the name to the publics list : this
4191          actually means we are now compiling the compiler
4192          support routine */
4193       if (name->cdef)
4194         {
4195           addSet (&publics, name);
4196         }
4197     }
4198   else
4199     {
4200       addSymChain (name);
4201       allocVariables (name);
4202     }
4203   name->lastLine = yylineno;
4204   currFunc = name;
4205   processFuncArgs (currFunc, 0);
4206
4207   /* set the stack pointer */
4208   /* PENDING: check this for the mcs51 */
4209   stackPtr = -port->stack.direction * port->stack.call_overhead;
4210   if (IS_ISR (name->etype))
4211     stackPtr -= port->stack.direction * port->stack.isr_overhead;
4212   if (IS_RENT (name->etype) || options.stackAuto)
4213     stackPtr -= port->stack.direction * port->stack.reent_overhead;
4214
4215   xstackPtr = -port->stack.direction * port->stack.call_overhead;
4216
4217   fetype = getSpec (name->type);        /* get the specifier for the function */
4218   /* if this is a reentrant function then */
4219   if (IS_RENT (fetype))
4220     reentrant++;
4221
4222   allocParms (name->args);      /* allocate the parameters */
4223
4224   /* do processing for parameters that are passed in registers */
4225   processRegParms (name->args, body);
4226
4227   /* set the stack pointer */
4228   stackPtr = 0;
4229   xstackPtr = -1;
4230
4231   /* allocate & autoinit the block variables */
4232   processBlockVars (body, &stack, ALLOCATE);
4233
4234   /* save the stack information */
4235   if (options.useXstack)
4236     name->xstack = SPEC_STAK (fetype) = stack;
4237   else
4238     name->stack = SPEC_STAK (fetype) = stack;
4239
4240   /* name needs to be mangled */
4241   sprintf (name->rname, "%s%s", port->fun_prefix, name->name);
4242
4243   body = resolveSymbols (body); /* resolve the symbols */
4244   body = decorateType (body);   /* propagateType & do semantic checks */
4245
4246   ex = newAst_VALUE (symbolVal (name));         /* create name       */
4247   ex = newNode (FUNCTION, ex, body);
4248   ex->values.args = name->args;
4249
4250   if (fatalError)
4251     {
4252       werror (E_FUNC_NO_CODE, name->name);
4253       goto skipall;
4254     }
4255
4256   /* create the node & generate intermediate code */
4257   GcurMemmap = code;
4258   codeOutFile = code->oFile;
4259   piCode = iCodeFromAst (ex);
4260
4261   if (fatalError)
4262     {
4263       werror (E_FUNC_NO_CODE, name->name);
4264       goto skipall;
4265     }
4266
4267   eBBlockFromiCode (piCode);
4268
4269   /* if there are any statics then do them */
4270   if (staticAutos)
4271     {
4272       GcurMemmap = statsg;
4273       codeOutFile = statsg->oFile;
4274       eBBlockFromiCode (iCodeFromAst (decorateType (resolveSymbols (staticAutos))));
4275       staticAutos = NULL;
4276     }
4277
4278 skipall:
4279
4280   /* dealloc the block variables */
4281   processBlockVars (body, &stack, DEALLOCATE);
4282   /* deallocate paramaters */
4283   deallocParms (name->args);
4284
4285   if (IS_RENT (fetype))
4286     reentrant--;
4287
4288   /* we are done freeup memory & cleanup */
4289   noLineno--;
4290   labelKey = 1;
4291   name->key = 0;
4292   name->fbody = 1;
4293   addSet (&operKeyReset, name);
4294   applyToSet (operKeyReset, resetParmKey);
4295
4296   if (options.debug)
4297     cdbStructBlock (1, cdbFile);
4298
4299   cleanUpLevel (LabelTab, 0);
4300   cleanUpBlock (StructTab, 1);
4301   cleanUpBlock (TypedefTab, 1);
4302
4303   xstack->syms = NULL;
4304   istack->syms = NULL;
4305   return NULL;
4306 }
4307
4308
4309 #define INDENT(x,f) { int i ; for (i=0;i < x; i++) fprintf(f," "); }
4310 /*-----------------------------------------------------------------*/
4311 /* ast_print : prints the ast (for debugging purposes)             */
4312 /*-----------------------------------------------------------------*/
4313
4314 void ast_print (ast * tree, FILE *outfile, int indent)
4315 {
4316
4317         if (!tree) return ;
4318
4319         /* can print only decorated trees */
4320         if (!tree->decorated) return;
4321
4322         /* if any child is an error | this one is an error do nothing */
4323         if (tree->isError ||
4324             (tree->left && tree->left->isError) ||
4325             (tree->right && tree->right->isError)) {
4326                 fprintf(outfile,"ERROR_NODE(%p)\n",tree);
4327         }
4328
4329
4330         /* print the line          */
4331         /* if not block & function */
4332         if (tree->type == EX_OP &&
4333             (tree->opval.op != FUNCTION &&
4334              tree->opval.op != BLOCK &&
4335              tree->opval.op != NULLOP)) {
4336         }
4337
4338         if (tree->opval.op == FUNCTION) {
4339                 fprintf(outfile,"FUNCTION (%p) type (",tree);
4340                 printTypeChain (tree->ftype,outfile);
4341                 fprintf(outfile,")\n");
4342                 ast_print(tree->left,outfile,indent+4);
4343                 ast_print(tree->right,outfile,indent+4);
4344                 return ;
4345         }
4346         if (tree->opval.op == BLOCK) {
4347                 symbol *decls = tree->values.sym;
4348                 fprintf(outfile,"{\n");
4349                 while (decls) {
4350                         INDENT(indent+4,outfile);
4351                         fprintf(outfile,"DECLARE SYMBOL %s, type(",decls->name);
4352                         printTypeChain(decls->type,outfile);
4353                         fprintf(outfile,")\n");
4354
4355                         decls = decls->next;
4356                 }
4357                 ast_print(tree->right,outfile,indent+4);
4358                 fprintf(outfile,"}\n");
4359                 return;
4360         }
4361         if (tree->opval.op == NULLOP) {
4362                 fprintf(outfile,"\n");
4363                 ast_print(tree->left,outfile,indent);
4364                 fprintf(outfile,"\n");
4365                 ast_print(tree->right,outfile,indent);
4366                 return ;
4367         }
4368         INDENT(indent,outfile);
4369
4370         /*------------------------------------------------------------------*/
4371         /*----------------------------*/
4372         /*   leaf has been reached    */
4373         /*----------------------------*/
4374         /* if this is of type value */
4375         /* just get the type        */
4376         if (tree->type == EX_VALUE) {
4377
4378                 if (IS_LITERAL (tree->opval.val->etype)) {
4379                         fprintf(outfile,"CONSTANT (%p) value = %d, 0x%x, %g", tree,
4380                                 (int) floatFromVal(tree->opval.val),
4381                                 (int) floatFromVal(tree->opval.val),
4382                                 floatFromVal(tree->opval.val));
4383                 } else if (tree->opval.val->sym) {
4384                         /* if the undefined flag is set then give error message */
4385                         if (tree->opval.val->sym->undefined) {
4386                                 fprintf(outfile,"UNDEFINED SYMBOL ");
4387                         } else {
4388                                 fprintf(outfile,"SYMBOL ");
4389                         }
4390                         fprintf(outfile,"(%p) name= %s ",tree,tree->opval.val->sym->name);
4391                 }
4392                 if (tree->ftype) {
4393                         fprintf(outfile," type (");
4394                         printTypeChain(tree->ftype,outfile);
4395                         fprintf(outfile,")\n");
4396                 } else {
4397                         fprintf(outfile,"\n");
4398                 }
4399                 return ;
4400         }
4401
4402         /* if type link for the case of cast */
4403         if (tree->type == EX_LINK) {
4404                 fprintf(outfile,"TYPENODE (%p) type = (",tree);
4405                 printTypeChain(tree->opval.lnk,outfile);
4406                 fprintf(outfile,")\n");
4407                 return ;
4408         }
4409
4410
4411         /* depending on type of operator do */
4412
4413         switch (tree->opval.op) {
4414                 /*------------------------------------------------------------------*/
4415                 /*----------------------------*/
4416                 /*        array node          */
4417                 /*----------------------------*/
4418         case '[':
4419                 fprintf(outfile,"ARRAY_OP (%p) type (",tree);
4420                 printTypeChain(tree->ftype,outfile);
4421                 fprintf(outfile,")\n");
4422                 ast_print(tree->left,outfile,indent+4);
4423                 ast_print(tree->right,outfile,indent+4);
4424                 return;
4425
4426                 /*------------------------------------------------------------------*/
4427                 /*----------------------------*/
4428                 /*      struct/union          */
4429                 /*----------------------------*/
4430         case '.':
4431                 fprintf(outfile,"STRUCT_ACCESS (%p) type (",tree);
4432                 printTypeChain(tree->ftype,outfile);
4433                 fprintf(outfile,")\n");
4434                 ast_print(tree->left,outfile,indent+4);
4435                 ast_print(tree->right,outfile,indent+4);
4436                 return ;
4437
4438                 /*------------------------------------------------------------------*/
4439                 /*----------------------------*/
4440                 /*    struct/union pointer    */
4441                 /*----------------------------*/
4442         case PTR_OP:
4443                 fprintf(outfile,"PTR_ACCESS (%p) type (",tree);
4444                 printTypeChain(tree->ftype,outfile);
4445                 fprintf(outfile,")\n");
4446                 ast_print(tree->left,outfile,indent+4);
4447                 ast_print(tree->right,outfile,indent+4);
4448                 return ;
4449
4450                 /*------------------------------------------------------------------*/
4451                 /*----------------------------*/
4452                 /*  ++/-- operation           */
4453                 /*----------------------------*/
4454         case INC_OP:            /* incerement operator unary so left only */
4455                 fprintf(outfile,"INC_OP (%p) type (",tree);
4456                 printTypeChain(tree->ftype,outfile);
4457                 fprintf(outfile,")\n");
4458                 ast_print(tree->left,outfile,indent+4);
4459                 return ;
4460
4461         case DEC_OP:
4462                 fprintf(outfile,"DEC_OP (%p) type (",tree);
4463                 printTypeChain(tree->ftype,outfile);
4464                 fprintf(outfile,")\n");
4465                 ast_print(tree->left,outfile,indent+4);
4466                 return ;
4467
4468                 /*------------------------------------------------------------------*/
4469                 /*----------------------------*/
4470                 /*  bitwise and               */
4471                 /*----------------------------*/
4472         case '&':
4473                 if (tree->right) {
4474                         fprintf(outfile,"& (%p) type (",tree);
4475                         printTypeChain(tree->ftype,outfile);
4476                         fprintf(outfile,")\n");
4477                         ast_print(tree->left,outfile,indent+4);
4478                         ast_print(tree->right,outfile,indent+4);
4479                 } else {
4480                         fprintf(outfile,"ADDRESS_OF (%p) type (",tree);
4481                         printTypeChain(tree->ftype,outfile);
4482                         fprintf(outfile,")\n");
4483                         ast_print(tree->left,outfile,indent+4);
4484                         ast_print(tree->right,outfile,indent+4);
4485                 }
4486                 return ;
4487                 /*----------------------------*/
4488                 /*  bitwise or                */
4489                 /*----------------------------*/
4490         case '|':
4491                 fprintf(outfile,"OR (%p) type (",tree);
4492                 printTypeChain(tree->ftype,outfile);
4493                 fprintf(outfile,")\n");
4494                 ast_print(tree->left,outfile,indent+4);
4495                 ast_print(tree->right,outfile,indent+4);
4496                 return ;
4497                 /*------------------------------------------------------------------*/
4498                 /*----------------------------*/
4499                 /*  bitwise xor               */
4500                 /*----------------------------*/
4501         case '^':
4502                 fprintf(outfile,"XOR (%p) type (",tree);
4503                 printTypeChain(tree->ftype,outfile);
4504                 fprintf(outfile,")\n");
4505                 ast_print(tree->left,outfile,indent+4);
4506                 ast_print(tree->right,outfile,indent+4);
4507                 return ;
4508
4509                 /*------------------------------------------------------------------*/
4510                 /*----------------------------*/
4511                 /*  division                  */
4512                 /*----------------------------*/
4513         case '/':
4514                 fprintf(outfile,"DIV (%p) type (",tree);
4515                 printTypeChain(tree->ftype,outfile);
4516                 fprintf(outfile,")\n");
4517                 ast_print(tree->left,outfile,indent+4);
4518                 ast_print(tree->right,outfile,indent+4);
4519                 return ;
4520                 /*------------------------------------------------------------------*/
4521                 /*----------------------------*/
4522                 /*            modulus         */
4523                 /*----------------------------*/
4524         case '%':
4525                 fprintf(outfile,"MOD (%p) type (",tree);
4526                 printTypeChain(tree->ftype,outfile);
4527                 fprintf(outfile,")\n");
4528                 ast_print(tree->left,outfile,indent+4);
4529                 ast_print(tree->right,outfile,indent+4);
4530                 return ;
4531
4532                 /*------------------------------------------------------------------*/
4533                 /*----------------------------*/
4534                 /*  address dereference       */
4535                 /*----------------------------*/
4536         case '*':                       /* can be unary  : if right is null then unary operation */
4537                 if (!tree->right) {
4538                         fprintf(outfile,"DEREF (%p) type (",tree);
4539                         printTypeChain(tree->ftype,outfile);
4540                         fprintf(outfile,")\n");
4541                         ast_print(tree->left,outfile,indent+4);
4542                         return ;
4543                 }
4544                 /*------------------------------------------------------------------*/
4545                 /*----------------------------*/
4546                 /*      multiplication        */
4547                 /*----------------------------*/
4548                 fprintf(outfile,"MULT (%p) type (",tree);
4549                 printTypeChain(tree->ftype,outfile);
4550                 fprintf(outfile,")\n");
4551                 ast_print(tree->left,outfile,indent+4);
4552                 ast_print(tree->right,outfile,indent+4);
4553                 return ;
4554
4555
4556                 /*------------------------------------------------------------------*/
4557                 /*----------------------------*/
4558                 /*    unary '+' operator      */
4559                 /*----------------------------*/
4560         case '+':
4561                 /* if unary plus */
4562                 if (!tree->right) {
4563                         fprintf(outfile,"UPLUS (%p) type (",tree);
4564                         printTypeChain(tree->ftype,outfile);
4565                         fprintf(outfile,")\n");
4566                         ast_print(tree->left,outfile,indent+4);
4567                 } else {
4568                         /*------------------------------------------------------------------*/
4569                         /*----------------------------*/
4570                         /*      addition              */
4571                         /*----------------------------*/
4572                         fprintf(outfile,"ADD (%p) type (",tree);
4573                         printTypeChain(tree->ftype,outfile);
4574                         fprintf(outfile,")\n");
4575                         ast_print(tree->left,outfile,indent+4);
4576                         ast_print(tree->right,outfile,indent+4);
4577                 }
4578                 return;
4579                 /*------------------------------------------------------------------*/
4580                 /*----------------------------*/
4581                 /*      unary '-'             */
4582                 /*----------------------------*/
4583         case '-':                       /* can be unary   */
4584                 if (!tree->right) {
4585                         fprintf(outfile,"UMINUS (%p) type (",tree);
4586                         printTypeChain(tree->ftype,outfile);
4587                         fprintf(outfile,")\n");
4588                         ast_print(tree->left,outfile,indent+4);
4589                 } else {
4590                         /*------------------------------------------------------------------*/
4591                         /*----------------------------*/
4592                         /*      subtraction           */
4593                         /*----------------------------*/
4594                         fprintf(outfile,"SUB (%p) type (",tree);
4595                         printTypeChain(tree->ftype,outfile);
4596                         fprintf(outfile,")\n");
4597                         ast_print(tree->left,outfile,indent+4);
4598                         ast_print(tree->right,outfile,indent+4);
4599                 }
4600                 return;
4601                 /*------------------------------------------------------------------*/
4602                 /*----------------------------*/
4603                 /*    compliment              */
4604                 /*----------------------------*/
4605         case '~':
4606                 fprintf(outfile,"COMPL (%p) type (",tree);
4607                 printTypeChain(tree->ftype,outfile);
4608                 fprintf(outfile,")\n");
4609                 ast_print(tree->left,outfile,indent+4);
4610                 return ;
4611                 /*------------------------------------------------------------------*/
4612                 /*----------------------------*/
4613                 /*           not              */
4614                 /*----------------------------*/
4615         case '!':
4616                 fprintf(outfile,"NOT (%p) type (",tree);
4617                 printTypeChain(tree->ftype,outfile);
4618                 fprintf(outfile,")\n");
4619                 ast_print(tree->left,outfile,indent+4);
4620                 return ;
4621                 /*------------------------------------------------------------------*/
4622                 /*----------------------------*/
4623                 /*           shift            */
4624                 /*----------------------------*/
4625         case RRC:
4626                 fprintf(outfile,"RRC (%p) type (",tree);
4627                 printTypeChain(tree->ftype,outfile);
4628                 fprintf(outfile,")\n");
4629                 ast_print(tree->left,outfile,indent+4);
4630                 return ;
4631
4632         case RLC:
4633                 fprintf(outfile,"RLC (%p) type (",tree);
4634                 printTypeChain(tree->ftype,outfile);
4635                 fprintf(outfile,")\n");
4636                 ast_print(tree->left,outfile,indent+4);
4637                 return ;
4638         case GETHBIT:
4639                 fprintf(outfile,"GETHBIT (%p) type (",tree);
4640                 printTypeChain(tree->ftype,outfile);
4641                 fprintf(outfile,")\n");
4642                 ast_print(tree->left,outfile,indent+4);
4643                 return ;
4644         case LEFT_OP:
4645                 fprintf(outfile,"LEFT_SHIFT (%p) type (",tree);
4646                 printTypeChain(tree->ftype,outfile);
4647                 fprintf(outfile,")\n");
4648                 ast_print(tree->left,outfile,indent+4);
4649                 ast_print(tree->right,outfile,indent+4);
4650                 return ;
4651         case RIGHT_OP:
4652                 fprintf(outfile,"RIGHT_SHIFT (%p) type (",tree);
4653                 printTypeChain(tree->ftype,outfile);
4654                 fprintf(outfile,")\n");
4655                 ast_print(tree->left,outfile,indent+4);
4656                 ast_print(tree->right,outfile,indent+4);
4657                 return ;
4658                 /*------------------------------------------------------------------*/
4659                 /*----------------------------*/
4660                 /*         casting            */
4661                 /*----------------------------*/
4662         case CAST:                      /* change the type   */
4663                 fprintf(outfile,"CAST (%p) type (",tree);
4664                 printTypeChain(tree->ftype,outfile);
4665                 fprintf(outfile,")\n");
4666                 ast_print(tree->right,outfile,indent+4);
4667                 return ;
4668
4669         case AND_OP:
4670                 fprintf(outfile,"ANDAND (%p) type (",tree);
4671                 printTypeChain(tree->ftype,outfile);
4672                 fprintf(outfile,")\n");
4673                 ast_print(tree->left,outfile,indent+4);
4674                 ast_print(tree->right,outfile,indent+4);
4675                 return ;
4676         case OR_OP:
4677                 fprintf(outfile,"OROR (%p) type (",tree);
4678                 printTypeChain(tree->ftype,outfile);
4679                 fprintf(outfile,")\n");
4680                 ast_print(tree->left,outfile,indent+4);
4681                 ast_print(tree->right,outfile,indent+4);
4682                 return ;
4683
4684                 /*------------------------------------------------------------------*/
4685                 /*----------------------------*/
4686                 /*     comparison operators   */
4687                 /*----------------------------*/
4688         case '>':
4689                 fprintf(outfile,"GT(>) (%p) type (",tree);
4690                 printTypeChain(tree->ftype,outfile);
4691                 fprintf(outfile,")\n");
4692                 ast_print(tree->left,outfile,indent+4);
4693                 ast_print(tree->right,outfile,indent+4);
4694                 return ;
4695         case '<':
4696                 fprintf(outfile,"LT(<) (%p) type (",tree);
4697                 printTypeChain(tree->ftype,outfile);
4698                 fprintf(outfile,")\n");
4699                 ast_print(tree->left,outfile,indent+4);
4700                 ast_print(tree->right,outfile,indent+4);
4701                 return ;
4702         case LE_OP:
4703                 fprintf(outfile,"LE(<=) (%p) type (",tree);
4704                 printTypeChain(tree->ftype,outfile);
4705                 fprintf(outfile,")\n");
4706                 ast_print(tree->left,outfile,indent+4);
4707                 ast_print(tree->right,outfile,indent+4);
4708                 return ;
4709         case GE_OP:
4710                 fprintf(outfile,"GE(>=) (%p) type (",tree);
4711                 printTypeChain(tree->ftype,outfile);
4712                 fprintf(outfile,")\n");
4713                 ast_print(tree->left,outfile,indent+4);
4714                 ast_print(tree->right,outfile,indent+4);
4715                 return ;
4716         case EQ_OP:
4717                 fprintf(outfile,"EQ(==) (%p) type (",tree);
4718                 printTypeChain(tree->ftype,outfile);
4719                 fprintf(outfile,")\n");
4720                 ast_print(tree->left,outfile,indent+4);
4721                 ast_print(tree->right,outfile,indent+4);
4722                 return ;
4723         case NE_OP:
4724                 fprintf(outfile,"NE(!=) (%p) type (",tree);
4725                 printTypeChain(tree->ftype,outfile);
4726                 fprintf(outfile,")\n");
4727                 ast_print(tree->left,outfile,indent+4);
4728                 ast_print(tree->right,outfile,indent+4);
4729                 /*------------------------------------------------------------------*/
4730                 /*----------------------------*/
4731                 /*             sizeof         */
4732                 /*----------------------------*/
4733         case SIZEOF:            /* evaluate wihout code generation */
4734                 fprintf(outfile,"SIZEOF %d\n",(getSize (tree->right->ftype)));
4735                 return ;
4736
4737                 /*------------------------------------------------------------------*/
4738                 /*----------------------------*/
4739                 /* conditional operator  '?'  */
4740                 /*----------------------------*/
4741         case '?':
4742                 fprintf(outfile,"QUEST(?) (%p) type (",tree);
4743                 printTypeChain(tree->ftype,outfile);
4744                 fprintf(outfile,")\n");
4745                 ast_print(tree->left,outfile,indent+4);
4746                 ast_print(tree->right,outfile,indent+4);
4747
4748         case ':':
4749                 fprintf(outfile,"COLON(:) (%p) type (",tree);
4750                 printTypeChain(tree->ftype,outfile);
4751                 fprintf(outfile,")\n");
4752                 ast_print(tree->left,outfile,indent+4);
4753                 ast_print(tree->right,outfile,indent+4);
4754                 return ;
4755
4756                 /*------------------------------------------------------------------*/
4757                 /*----------------------------*/
4758                 /*    assignment operators    */
4759                 /*----------------------------*/
4760         case MUL_ASSIGN:
4761                 fprintf(outfile,"MULASS(*=) (%p) type (",tree);
4762                 printTypeChain(tree->ftype,outfile);
4763                 fprintf(outfile,")\n");
4764                 ast_print(tree->left,outfile,indent+4);
4765                 ast_print(tree->right,outfile,indent+4);
4766                 return;
4767         case DIV_ASSIGN:
4768                 fprintf(outfile,"DIVASS(/=) (%p) type (",tree);
4769                 printTypeChain(tree->ftype,outfile);
4770                 fprintf(outfile,")\n");
4771                 ast_print(tree->left,outfile,indent+4);
4772                 ast_print(tree->right,outfile,indent+4);
4773                 return;
4774         case AND_ASSIGN:
4775                 fprintf(outfile,"ANDASS(&=) (%p) type (",tree);
4776                 printTypeChain(tree->ftype,outfile);
4777                 fprintf(outfile,")\n");
4778                 ast_print(tree->left,outfile,indent+4);
4779                 ast_print(tree->right,outfile,indent+4);
4780                 return;
4781         case OR_ASSIGN:
4782                 fprintf(outfile,"ORASS(*=) (%p) type (",tree);
4783                 printTypeChain(tree->ftype,outfile);
4784                 fprintf(outfile,")\n");
4785                 ast_print(tree->left,outfile,indent+4);
4786                 ast_print(tree->right,outfile,indent+4);
4787                 return;
4788         case XOR_ASSIGN:
4789                 fprintf(outfile,"XORASS(*=) (%p) type (",tree);
4790                 printTypeChain(tree->ftype,outfile);
4791                 fprintf(outfile,")\n");
4792                 ast_print(tree->left,outfile,indent+4);
4793                 ast_print(tree->right,outfile,indent+4);
4794                 return;
4795         case RIGHT_ASSIGN:
4796                 fprintf(outfile,"RSHFTASS(>>=) (%p) type (",tree);
4797                 printTypeChain(tree->ftype,outfile);
4798                 fprintf(outfile,")\n");
4799                 ast_print(tree->left,outfile,indent+4);
4800                 ast_print(tree->right,outfile,indent+4);
4801                 return;
4802         case LEFT_ASSIGN:
4803                 fprintf(outfile,"LSHFTASS(*=) (%p) type (",tree);
4804                 printTypeChain(tree->ftype,outfile);
4805                 fprintf(outfile,")\n");
4806                 ast_print(tree->left,outfile,indent+4);
4807                 ast_print(tree->right,outfile,indent+4);
4808                 return;
4809                 /*------------------------------------------------------------------*/
4810                 /*----------------------------*/
4811                 /*    -= operator             */
4812                 /*----------------------------*/
4813         case SUB_ASSIGN:
4814                 fprintf(outfile,"SUBASS(-=) (%p) type (",tree);
4815                 printTypeChain(tree->ftype,outfile);
4816                 fprintf(outfile,")\n");
4817                 ast_print(tree->left,outfile,indent+4);
4818                 ast_print(tree->right,outfile,indent+4);
4819                 return;
4820                 /*------------------------------------------------------------------*/
4821                 /*----------------------------*/
4822                 /*          += operator       */
4823                 /*----------------------------*/
4824         case ADD_ASSIGN:
4825                 fprintf(outfile,"ADDASS(+=) (%p) type (",tree);
4826                 printTypeChain(tree->ftype,outfile);
4827                 fprintf(outfile,")\n");
4828                 ast_print(tree->left,outfile,indent+4);
4829                 ast_print(tree->right,outfile,indent+4);
4830                 return;
4831                 /*------------------------------------------------------------------*/
4832                 /*----------------------------*/
4833                 /*      straight assignemnt   */
4834                 /*----------------------------*/
4835         case '=':
4836                 fprintf(outfile,"ASSIGN(=) (%p) type (",tree);
4837                 printTypeChain(tree->ftype,outfile);
4838                 fprintf(outfile,")\n");
4839                 ast_print(tree->left,outfile,indent+4);
4840                 ast_print(tree->right,outfile,indent+4);
4841                 return;
4842                 /*------------------------------------------------------------------*/
4843                 /*----------------------------*/
4844                 /*      comma operator        */
4845                 /*----------------------------*/
4846         case ',':
4847                 fprintf(outfile,"COMMA(,) (%p) type (",tree);
4848                 printTypeChain(tree->ftype,outfile);
4849                 fprintf(outfile,")\n");
4850                 ast_print(tree->left,outfile,indent+4);
4851                 ast_print(tree->right,outfile,indent+4);
4852                 return;
4853                 /*------------------------------------------------------------------*/
4854                 /*----------------------------*/
4855                 /*       function call        */
4856                 /*----------------------------*/
4857         case CALL:
4858         case PCALL:
4859                 fprintf(outfile,"CALL (%p) type (",tree);
4860                 printTypeChain(tree->ftype,outfile);
4861                 fprintf(outfile,")\n");
4862                 ast_print(tree->left,outfile,indent+4);
4863                 ast_print(tree->right,outfile,indent+4);
4864                 return;
4865         case PARAM:
4866                 fprintf(outfile,"PARM ");
4867                 ast_print(tree->left,outfile,indent+4);
4868                 if (tree->right && !IS_AST_PARAM(tree->right)) {
4869                         fprintf(outfile,"PARM ");
4870                         ast_print(tree->right,outfile,indent+4);
4871                 }
4872                 return ;
4873                 /*------------------------------------------------------------------*/
4874                 /*----------------------------*/
4875                 /*     return statement       */
4876                 /*----------------------------*/
4877         case RETURN:
4878                 fprintf(outfile,"RETURN (%p) type (",tree);
4879                 printTypeChain(tree->right->ftype,outfile);
4880                 fprintf(outfile,")\n");
4881                 ast_print(tree->right,outfile,indent+4);
4882                 return ;
4883                 /*------------------------------------------------------------------*/
4884                 /*----------------------------*/
4885                 /*     label statement        */
4886                 /*----------------------------*/
4887         case LABEL :
4888                 fprintf(outfile,"LABEL (%p)",tree);
4889                 ast_print(tree->left,outfile,indent+4);
4890                 ast_print(tree->right,outfile,indent);
4891                 return;
4892                 /*------------------------------------------------------------------*/
4893                 /*----------------------------*/
4894                 /*     switch statement       */
4895                 /*----------------------------*/
4896         case SWITCH:
4897                 {
4898                         value *val;
4899                         fprintf(outfile,"SWITCH (%p) ",tree);
4900                         ast_print(tree->left,outfile,0);
4901                         for (val = tree->values.switchVals.swVals; val ; val = val->next) {
4902                                 INDENT(indent+4,outfile);
4903                                 fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",
4904                                         (int) floatFromVal(val),
4905                                         tree->values.switchVals.swNum,
4906                                         (int) floatFromVal(val));
4907                         }
4908                         ast_print(tree->right,outfile,indent);
4909                 }
4910                 return ;
4911                 /*------------------------------------------------------------------*/
4912                 /*----------------------------*/
4913                 /* ifx Statement              */
4914                 /*----------------------------*/
4915         case IFX:
4916                 ast_print(tree->left,outfile,indent);
4917                 INDENT(indent,outfile);
4918                 fprintf(outfile,"IF (%p) \n",tree);
4919                 if (tree->trueLabel) {
4920                         INDENT(indent,outfile);
4921                         fprintf(outfile,"NE(==) 0 goto %s\n",tree->trueLabel->name);
4922                 }
4923                 if (tree->falseLabel) {
4924                         INDENT(indent,outfile);
4925                         fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name);
4926                 }
4927                 ast_print(tree->right,outfile,indent);
4928                 return ;
4929                 /*------------------------------------------------------------------*/
4930                 /*----------------------------*/
4931                 /* for Statement              */
4932                 /*----------------------------*/
4933         case FOR:
4934                 fprintf(outfile,"FOR (%p) \n",tree);
4935                 if (AST_FOR( tree, initExpr)) {
4936                         INDENT(indent+4,outfile);
4937                         fprintf(outfile,"INIT EXPR ");
4938                         ast_print(AST_FOR(tree, initExpr),outfile,indent+4);
4939                 }
4940                 if (AST_FOR( tree, condExpr)) {
4941                         INDENT(indent+4,outfile);
4942                         fprintf(outfile,"COND EXPR ");
4943                         ast_print(AST_FOR(tree, condExpr),outfile,indent+4);
4944                 }
4945                 if (AST_FOR( tree, loopExpr)) {
4946                         INDENT(indent+4,outfile);
4947                         fprintf(outfile,"LOOP EXPR ");
4948                         ast_print(AST_FOR(tree, loopExpr),outfile,indent+4);
4949                 }
4950                 fprintf(outfile,"FOR LOOP BODY \n");
4951                 ast_print(tree->left,outfile,indent+4);
4952                 return ;
4953         default:
4954             return ;
4955         }
4956 }
4957
4958 void PA(ast *t)
4959 {
4960         ast_print(t,stdout,1);
4961 }