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