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

   1 /*-------------------------------------------------------------------------
   2   SDCCast.c - source file for parser support & all ast related routines
   3
   4              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #include "common.h"
  26 #include "newalloc.h"
  27
  28 int currLineno = 0;
  29 set *astList = NULL;
  30 set *operKeyReset = NULL;
  31 ast *staticAutos = NULL;
  32 int labelKey = 1;
  33
  34 #define LRVAL(x) x->left->rvalue
  35 #define RRVAL(x) x->right->rvalue
  36 #define TRVAL(x) x->rvalue
  37 #define LLVAL(x) x->left->lvalue
  38 #define RLVAL(x) x->right->lvalue
  39 #define TLVAL(x) x->lvalue
  40 #define RTYPE(x) x->right->ftype
  41 #define RETYPE(x) x->right->etype
  42 #define LTYPE(x) x->left->ftype
  43 #define LETYPE(x) x->left->etype
  44 #define TTYPE(x) x->ftype
  45 #define TETYPE(x) x->etype
  46 #define ALLOCATE 1
  47 #define DEALLOCATE 2
  48
  49 char buffer[1024];
  50 int noLineno = 0;
  51 int noAlloc = 0;
  52 symbol *currFunc;
  53 ast *createIval (ast *, sym_link *, initList *, ast *);
  54 ast *createIvalCharPtr (ast *, sym_link *, ast *);
  55 ast *optimizeRRCRLC (ast *);
  56 ast *optimizeGetHbit (ast *);
  57 ast *backPatchLabels (ast *, symbol *, symbol *);
  58 int inInitMode = 0;
  59 memmap *GcurMemmap=NULL;  /* points to the memmap that's currently active */
  60 FILE *codeOutFile;
  61 int
  62 ptt (ast * tree)
  63 {
  64   printTypeChain (tree->ftype, stdout);
  65   return 0;
  66 }
  67
  68
  69 /*-----------------------------------------------------------------*/
  70 /* newAst - creates a fresh node for an expression tree           */
  71 /*-----------------------------------------------------------------*/
  72 #if 0
  73 ast *
  74 newAst (int type, void *op)
  75 {
  76   ast *ex;
  77   static int oldLineno = 0;
  78
  79   Safe_calloc (1, ex, sizeof (ast));
  80
  81   ex->type = type;
  82   ex->lineno = (noLineno ? oldLineno : yylineno);
  83   ex->filename = currFname;
  84   ex->level = NestLevel;
  85   ex->block = currBlockno;
  86   ex->initMode = inInitMode;
  87
  88   /* depending on the type */
  89   switch (type)
  90     {
  91     case EX_VALUE:
  92       ex->opval.val = (value *) op;
  93       break;
  94     case EX_OP:
  95       ex->opval.op = (long) op;
  96       break;
  97     case EX_LINK:
  98       ex->opval.lnk = (sym_link *) op;
  99       break;
 100     case EX_STMNT:
 101       ex->opval.stmnt = (unsigned) op;
 102     }
 103
 104   return ex;
 105 }
 106 #endif
 107
 108 static ast *
 109 newAst_ (unsigned type)
 110 {
 111   ast *ex;
 112   static int oldLineno = 0;
 113
 114   ex = Safe_calloc (1, sizeof (ast));
 115
 116   ex->type = type;
 117   ex->lineno = (noLineno ? oldLineno : yylineno);
 118   ex->filename = currFname;
 119   ex->level = NestLevel;
 120   ex->block = currBlockno;
 121   ex->initMode = inInitMode;
 122   return ex;
 123 }
 124
 125 ast *
 126 newAst_VALUE (value * val)
 127 {
 128   ast *ex = newAst_ (EX_VALUE);
 129   ex->opval.val = val;
 130   return ex;
 131 }
 132
 133 ast *
 134 newAst_OP (unsigned op)
 135 {
 136   ast *ex = newAst_ (EX_OP);
 137   ex->opval.op = op;
 138   return ex;
 139 }
 140
 141 ast *
 142 newAst_LINK (sym_link * val)
 143 {
 144   ast *ex = newAst_ (EX_LINK);
 145   ex->opval.lnk = val;
 146   return ex;
 147 }
 148
 149 ast *
 150 newAst_STMNT (unsigned val)
 151 {
 152   ast *ex = newAst_ (EX_STMNT);
 153   ex->opval.stmnt = val;
 154   return ex;
 155 }
 156
 157 /*-----------------------------------------------------------------*/
 158 /* newNode - creates a new node                                    */
 159 /*-----------------------------------------------------------------*/
 160 ast *
 161 newNode (long op, ast * left, ast * right)
 162 {
 163   ast *ex;
 164
 165   ex = newAst_OP (op);
 166   ex->left = left;
 167   ex->right = right;
 168
 169   return ex;
 170 }
 171
 172 /*-----------------------------------------------------------------*/
 173 /* newIfxNode - creates a new Ifx Node                             */
 174 /*-----------------------------------------------------------------*/
 175 ast *
 176 newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel)
 177 {
 178   ast *ifxNode;
 179
 180   /* if this is a literal then we already know the result */
 181   if (condAst->etype && IS_LITERAL (condAst->etype))
 182     {
 183       /* then depending on the expression value */
 184       if (floatFromVal (condAst->opval.val))
 185         ifxNode = newNode (GOTO,
 186                            newAst_VALUE (symbolVal (trueLabel)),
 187                            NULL);
 188       else
 189         ifxNode = newNode (GOTO,
 190                            newAst_VALUE (symbolVal (falseLabel)),
 191                            NULL);
 192     }
 193   else
 194     {
 195       ifxNode = newNode (IFX, condAst, NULL);
 196       ifxNode->trueLabel = trueLabel;
 197       ifxNode->falseLabel = falseLabel;
 198     }
 199
 200   return ifxNode;
 201 }
 202
 203 /*-----------------------------------------------------------------*/
 204 /* copyAstValues - copies value portion of ast if needed     */
 205 /*-----------------------------------------------------------------*/
 206 void
 207 copyAstValues (ast * dest, ast * src)
 208 {
 209   switch (src->opval.op)
 210     {
 211     case BLOCK:
 212       dest->values.sym = copySymbolChain (src->values.sym);
 213       break;
 214
 215     case SWITCH:
 216       dest->values.switchVals.swVals =
 217         copyValue (src->values.switchVals.swVals);
 218       dest->values.switchVals.swDefault =
 219         src->values.switchVals.swDefault;
 220       dest->values.switchVals.swNum =
 221         src->values.switchVals.swNum;
 222       break;
 223
 224     case INLINEASM:
 225       dest->values.inlineasm = Safe_calloc (1, strlen (src->values.inlineasm) + 1);
 226       strcpy (dest->values.inlineasm, src->values.inlineasm);
 227       break;
 228
 229     case ARRAYINIT:
 230         dest->values.constlist = copyLiteralList(src->values.constlist);
 231         break;
 232
 233     case FOR:
 234       AST_FOR (dest, trueLabel) = copySymbol (AST_FOR (src, trueLabel));
 235       AST_FOR (dest, continueLabel) = copySymbol (AST_FOR (src, continueLabel));
 236       AST_FOR (dest, falseLabel) = copySymbol (AST_FOR (src, falseLabel));
 237       AST_FOR (dest, condLabel) = copySymbol (AST_FOR (src, condLabel));
 238       AST_FOR (dest, initExpr) = copyAst (AST_FOR (src, initExpr));
 239       AST_FOR (dest, condExpr) = copyAst (AST_FOR (src, condExpr));
 240       AST_FOR (dest, loopExpr) = copyAst (AST_FOR (src, loopExpr));
 241     }
 242
 243 }
 244
 245 /*-----------------------------------------------------------------*/
 246 /* copyAst - makes a copy of a given astession                     */
 247 /*-----------------------------------------------------------------*/
 248 ast *
 249 copyAst (ast * src)
 250 {
 251   ast *dest;
 252
 253   if (!src)
 254     return NULL;
 255
 256   dest = Safe_calloc (1, sizeof (ast));
 257
 258   dest->type = src->type;
 259   dest->lineno = src->lineno;
 260   dest->level = src->level;
 261   dest->funcName = src->funcName;
 262   dest->argSym = src->argSym;
 263
 264   /* if this is a leaf */
 265   /* if value */
 266   if (src->type == EX_VALUE)
 267     {
 268       dest->opval.val = copyValue (src->opval.val);
 269       goto exit;
 270     }
 271
 272   /* if link */
 273   if (src->type == EX_LINK)
 274     {
 275       dest->opval.lnk = copyLinkChain (src->opval.lnk);
 276       goto exit;
 277     }
 278
 279   dest->opval.op = src->opval.op;
 280
 281   /* if this is a node that has special values */
 282   copyAstValues (dest, src);
 283
 284   if (src->ftype)
 285     dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
 286
 287   dest->trueLabel = copySymbol (src->trueLabel);
 288   dest->falseLabel = copySymbol (src->falseLabel);
 289   dest->left = copyAst (src->left);
 290   dest->right = copyAst (src->right);
 291 exit:
 292   return dest;
 293
 294 }
 295
 296 /*-----------------------------------------------------------------*/
 297 /* hasSEFcalls - returns TRUE if tree has a function call          */
 298 /*-----------------------------------------------------------------*/
 299 bool
 300 hasSEFcalls (ast * tree)
 301 {
 302   if (!tree)
 303     return FALSE;
 304
 305   if (tree->type == EX_OP &&
 306       (tree->opval.op == CALL ||
 307        tree->opval.op == PCALL ||
 308        tree->opval.op == '=' ||
 309        tree->opval.op == INC_OP ||
 310        tree->opval.op == DEC_OP))
 311     return TRUE;
 312
 313   return (hasSEFcalls (tree->left) |
 314           hasSEFcalls (tree->right));
 315 }
 316
 317 /*-----------------------------------------------------------------*/
 318 /* isAstEqual - compares two asts & returns 1 if they are equal    */
 319 /*-----------------------------------------------------------------*/
 320 int
 321 isAstEqual (ast * t1, ast * t2)
 322 {
 323   if (!t1 && !t2)
 324     return 1;
 325
 326   if (!t1 || !t2)
 327     return 0;
 328
 329   /* match type */
 330   if (t1->type != t2->type)
 331     return 0;
 332
 333   switch (t1->type)
 334     {
 335     case EX_OP:
 336       if (t1->opval.op != t2->opval.op)
 337         return 0;
 338       return (isAstEqual (t1->left, t2->left) &&
 339               isAstEqual (t1->right, t2->right));
 340       break;
 341
 342     case EX_VALUE:
 343       if (t1->opval.val->sym)
 344         {
 345           if (!t2->opval.val->sym)
 346             return 0;
 347           else
 348             return isSymbolEqual (t1->opval.val->sym,
 349                                   t2->opval.val->sym);
 350         }
 351       else
 352         {
 353           if (t2->opval.val->sym)
 354             return 0;
 355           else
 356             return (floatFromVal (t1->opval.val) ==
 357                     floatFromVal (t2->opval.val));
 358         }
 359       break;
 360
 361       /* only compare these two types */
 362     default:
 363       return 0;
 364     }
 365
 366   return 0;
 367 }
 368
 369 /*-----------------------------------------------------------------*/
 370 /* resolveSymbols - resolve symbols from the symbol table          */
 371 /*-----------------------------------------------------------------*/
 372 ast *
 373 resolveSymbols (ast * tree)
 374 {
 375   /* walk the entire tree and check for values */
 376   /* with symbols if we find one then replace  */
 377   /* symbol with that from the symbol table    */
 378
 379   if (tree == NULL)
 380     return tree;
 381
 382   /* print the line          */
 383   /* if not block & function */
 384   if (tree->type == EX_OP &&
 385       (tree->opval.op != FUNCTION &&
 386        tree->opval.op != BLOCK &&
 387        tree->opval.op != NULLOP))
 388     {
 389       filename = tree->filename;
 390       lineno = tree->lineno;
 391     }
 392
 393   /* make sure we resolve the true & false labels for ifx */
 394   if (tree->type == EX_OP && tree->opval.op == IFX)
 395     {
 396       symbol *csym;
 397
 398       if (tree->trueLabel)
 399         {
 400           if ((csym = findSym (LabelTab, tree->trueLabel,
 401                                tree->trueLabel->name)))
 402             tree->trueLabel = csym;
 403           else
 404             werror (E_LABEL_UNDEF, tree->trueLabel->name);
 405         }
 406
 407       if (tree->falseLabel)
 408         {
 409           if ((csym = findSym (LabelTab,
 410                                tree->falseLabel,
 411                                tree->falseLabel->name)))
 412             tree->falseLabel = csym;
 413           else
 414             werror (E_LABEL_UNDEF, tree->falseLabel->name);
 415         }
 416
 417     }
 418
 419   /* if this is a label resolve it from the labelTab */
 420   if (IS_AST_VALUE (tree) &&
 421       tree->opval.val->sym &&
 422       tree->opval.val->sym->islbl)
 423     {
 424
 425       symbol *csym = findSym (LabelTab, tree->opval.val->sym,
 426                               tree->opval.val->sym->name);
 427
 428       if (!csym)
 429         werror (E_LABEL_UNDEF, tree->opval.val->sym->name);
 430       else
 431         tree->opval.val->sym = csym;
 432
 433       goto resolveChildren;
 434     }
 435
 436   /* do only for leafs */
 437   if (IS_AST_VALUE (tree) &&
 438       tree->opval.val->sym &&
 439       !tree->opval.val->sym->implicit)
 440     {
 441
 442       symbol *csym = findSymWithLevel (SymbolTab, tree->opval.val->sym);
 443
 444       /* if found in the symbol table & they r not the same */
 445       if (csym && tree->opval.val->sym != csym)
 446         {
 447           tree->opval.val->sym = csym;
 448           tree->opval.val->type = csym->type;
 449           tree->opval.val->etype = csym->etype;
 450         }
 451
 452       /* if not found in the symbol table */
 453       /* mark it as undefined assume it is */
 454       /* an integer in data space         */
 455       if (!csym && !tree->opval.val->sym->implicit)
 456         {
 457
 458           /* if this is a function name then */
 459           /* mark it as returning an int     */
 460           if (tree->funcName)
 461             {
 462               tree->opval.val->sym->type = newLink ();
 463               DCL_TYPE (tree->opval.val->sym->type) = FUNCTION;
 464               tree->opval.val->sym->type->next =
 465                 tree->opval.val->sym->etype = newIntLink ();
 466               tree->opval.val->etype = tree->opval.val->etype;
 467               tree->opval.val->type = tree->opval.val->sym->type;
 468               werror (W_IMPLICIT_FUNC, tree->opval.val->sym->name);
 469               allocVariables (tree->opval.val->sym);
 470             }
 471           else
 472             {
 473               tree->opval.val->sym->undefined = 1;
 474               tree->opval.val->type =
 475                 tree->opval.val->etype = newIntLink ();
 476               tree->opval.val->sym->type =
 477                 tree->opval.val->sym->etype = newIntLink ();
 478             }
 479         }
 480     }
 481
 482 resolveChildren:
 483   resolveSymbols (tree->left);
 484   resolveSymbols (tree->right);
 485
 486   return tree;
 487 }
 488
 489 /*-----------------------------------------------------------------*/
 490 /* setAstLineno - walks a ast tree & sets the line number          */
 491 /*-----------------------------------------------------------------*/
 492 int
 493 setAstLineno (ast * tree, int lineno)
 494 {
 495   if (!tree)
 496     return 0;
 497
 498   tree->lineno = lineno;
 499   setAstLineno (tree->left, lineno);
 500   setAstLineno (tree->right, lineno);
 501   return 0;
 502 }
 503
 504 #if 0
 505 /* this functions seems to be superfluous?! kmh */
 506
 507 /*-----------------------------------------------------------------*/
 508 /* resolveFromTable - will return the symbal table value           */
 509 /*-----------------------------------------------------------------*/
 510 value *
 511 resolveFromTable (value * val)
 512 {
 513   symbol *csym;
 514
 515   if (!val->sym)
 516     return val;
 517
 518   csym = findSymWithLevel (SymbolTab, val->sym);
 519
 520   /* if found in the symbol table & they r not the same */
 521   if (csym && val->sym != csym &&
 522       csym->level == val->sym->level &&
 523       csym->_isparm &&
 524       !csym->ismyparm)
 525     {
 526
 527       val->sym = csym;
 528       val->type = csym->type;
 529       val->etype = csym->etype;
 530     }
 531
 532   return val;
 533 }
 534 #endif
 535
 536 /*-----------------------------------------------------------------*/
 537 /* funcOfType :- function of type with name                        */
 538 /*-----------------------------------------------------------------*/
 539 symbol *
 540 funcOfType (char *name, sym_link * type, sym_link * argType,
 541             int nArgs, int rent)
 542 {
 543   symbol *sym;
 544   /* create the symbol */
 545   sym = newSymbol (name, 0);
 546
 547   /* if arguments required */
 548   if (nArgs)
 549     {
 550
 551       value *args;
 552       args = sym->args = newValue ();
 553
 554       while (nArgs--)
 555         {
 556           args->type = copyLinkChain (argType);
 557           args->etype = getSpec (args->type);
 558           if (!nArgs)
 559             break;
 560           args = args->next = newValue ();
 561         }
 562     }
 563
 564   /* setup return value */
 565   sym->type = newLink ();
 566   DCL_TYPE (sym->type) = FUNCTION;
 567   sym->type->next = copyLinkChain (type);
 568   sym->etype = getSpec (sym->type);
 569   SPEC_RENT (sym->etype) = rent;
 570
 571   /* save it */
 572   addSymChain (sym);
 573   sym->cdef = 1;
 574   allocVariables (sym);
 575   return sym;
 576
 577 }
 578
 579 /*-----------------------------------------------------------------*/
 580 /* reverseParms - will reverse a parameter tree                    */
 581 /*-----------------------------------------------------------------*/
 582 void
 583 reverseParms (ast * ptree)
 584 {
 585   ast *ttree;
 586   if (!ptree)
 587     return;
 588
 589   /* top down if we find a nonParm tree then quit */
 590   if (ptree->type == EX_OP && ptree->opval.op == PARAM)
 591     {
 592       ttree = ptree->left;
 593       ptree->left = ptree->right;
 594       ptree->right = ttree;
 595       reverseParms (ptree->left);
 596       reverseParms (ptree->right);
 597     }
 598
 599   return;
 600 }
 601
 602 /*-----------------------------------------------------------------*/
 603 /* processParms  - makes sure the parameters are okay and do some  */
 604 /*                 processing with them                            */
 605 /*-----------------------------------------------------------------*/
 606 int
 607 processParms (ast * func,
 608               value * defParm,
 609               ast * actParm,
 610               int *parmNumber,
 611               bool rightmost)
 612 {
 613   int castError=0;
 614   sym_link *fetype = func->etype;
 615
 616   /* if none of them exist */
 617   if (!defParm && !actParm)
 618     return 0;
 619
 620   if (defParm) {
 621     if (getenv("DEBUG_SANITY")) {
 622       fprintf (stderr, "addSym: %s ", defParm->name);
 623     }
 624     /* make sure the type is complete and sane */
 625     checkTypeSanity(defParm->etype, defParm->name);
 626   }
 627
 628   /* if the function is being called via a pointer &   */
 629   /* it has not been defined a reentrant then we cannot */
 630   /* have parameters                                   */
 631   if (func->type != EX_VALUE && !IS_RENT (fetype) && !options.stackAuto)
 632     {
 633       werror (W_NONRENT_ARGS);
 634       return 1;
 635     }
 636
 637   /* if defined parameters ended but actual parameters */
 638   /* exist and this is not defined as a variable arg   */
 639   /* also check if statckAuto option is specified      */
 640   if ((!defParm) && actParm && (!func->hasVargs) &&
 641       !options.stackAuto && !IS_RENT (fetype))
 642     {
 643       werror (E_TOO_MANY_PARMS);
 644       return 1;
 645     }
 646
 647   /* if defined parameters present but no actual parameters */
 648   if (defParm && !actParm)
 649     {
 650       werror (E_TOO_FEW_PARMS);
 651       return 1;
 652     }
 653
 654   /* If this is a varargs function... */
 655   if (!defParm && actParm && func->hasVargs)
 656     {
 657       ast *newType = NULL;
 658       sym_link *ftype;
 659
 660       if (IS_CAST_OP (actParm)
 661           || (IS_AST_LIT_VALUE (actParm) && actParm->values.literalFromCast))
 662         {
 663           /* Parameter was explicitly typecast; don't touch it. */
 664           return 0;
 665         }
 666
 667       /* The ternary ('?') operator is weird: the ftype of the
 668        * operator is the type of the condition, but it will return a
 669        * (possibly) different type.
 670        */
 671       if (IS_TERNARY_OP(actParm))
 672       {
 673           assert(IS_COLON_OP(actParm->right));
 674           assert(actParm->right->left);
 675           ftype = actParm->right->left->ftype;
 676       }
 677       else
 678       {
 679           ftype = actParm->ftype;
 680       }
 681
 682       /* If it's a small integer, upcast to int. */
 683       if (IS_INTEGRAL (ftype)
 684           && (getSize (ftype) < (unsigned) INTSIZE))
 685         {
 686           newType = newAst_LINK(INTTYPE);
 687         }
 688
 689       if (IS_PTR(ftype) && !IS_GENPTR(ftype))
 690         {
 691           newType = newAst_LINK (copyLinkChain(ftype));
 692           DCL_TYPE (newType->opval.lnk) = GPOINTER;
 693         }
 694
 695       if (IS_AGGREGATE (ftype))
 696         {
 697           newType = newAst_LINK (copyLinkChain (ftype));
 698           DCL_TYPE (newType->opval.lnk) = GPOINTER;
 699         }
 700       if (newType)
 701         {
 702           /* cast required; change this op to a cast. */
 703           ast *parmCopy = resolveSymbols (copyAst (actParm));
 704
 705           actParm->type = EX_OP;
 706           actParm->opval.op = CAST;
 707           actParm->left = newType;
 708           actParm->right = parmCopy;
 709           decorateType (actParm);
 710         }
 711       else if (actParm->type == EX_OP && actParm->opval.op == PARAM)
 712         {
 713           return (processParms (func, NULL, actParm->left, parmNumber, FALSE) ||
 714           processParms (func, NULL, actParm->right, parmNumber, rightmost));
 715         }
 716       return 0;
 717     }
 718
 719   /* if defined parameters ended but actual has not & */
 720   /* stackAuto                */
 721   if (!defParm && actParm &&
 722       (options.stackAuto || IS_RENT (fetype)))
 723     return 0;
 724
 725   resolveSymbols (actParm);
 726   /* if this is a PARAM node then match left & right */
 727   if (actParm->type == EX_OP && actParm->opval.op == PARAM)
 728     {
 729       return (processParms (func, defParm, actParm->left, parmNumber, FALSE) ||
 730               processParms (func, defParm->next, actParm->right, parmNumber, rightmost));
 731     }
 732   else
 733     {
 734       /* If we have found a value node by following only right-hand links,
 735        * then we know that there are no more values after us.
 736        *
 737        * Therefore, if there are more defined parameters, the caller didn't
 738        * supply enough.
 739        */
 740       if (rightmost && defParm->next)
 741         {
 742           werror (E_TOO_FEW_PARMS);
 743           return 1;
 744         }
 745     }
 746
 747
 748   /* the parameter type must be at least castable */
 749   if (compareType (defParm->type, actParm->ftype) == 0)
 750     {
 751       castError++;
 752     }
 753
 754 #ifdef JWK20010916
 755   if (!IS_SPEC(defParm->type) && !IS_SPEC(actParm->ftype)) {
 756     // now we have two pointers, check if they point to the same
 757     sym_link *dtype=defParm->type, *atype=actParm->ftype;
 758     do {
 759       dtype=dtype->next;
 760       atype=atype->next;
 761       if (
 762           (dtype->next && !atype->next) ||
 763           (!dtype->next && atype->next) ||
 764           compareType (dtype, atype)!=1) {
 765         castError++;
 766       }
 767     } while (dtype->next && atype->next);
 768     if (IS_SPEC(dtype) && IS_SPEC(atype)) {
 769       // ok so far, we have two etypes, they must have the same SCLASS
 770       if (SPEC_SCLS(dtype)!=SPEC_SCLS(atype)) {
 771         castError++;
 772       }
 773     }
 774   }
 775 #endif
 776
 777   if (castError) {
 778     werror (W_INCOMPAT_CAST);
 779     fprintf (stderr, "type --> '");
 780     printTypeChain (actParm->ftype, stderr);
 781     fprintf (stderr, "' ");
 782     fprintf (stderr, "assigned to type --> '");
 783     printTypeChain (defParm->type, stderr);
 784     fprintf (stderr, "'\n");
 785   }
 786
 787   /* if the parameter is castable then add the cast */
 788   if (compareType (defParm->type, actParm->ftype) < 0)
 789     {
 790       ast *pTree = resolveSymbols (copyAst (actParm));
 791
 792       /* now change the current one to a cast */
 793       actParm->type = EX_OP;
 794       actParm->opval.op = CAST;
 795       actParm->left = newAst_LINK (defParm->type);
 796       actParm->right = pTree;
 797       actParm->etype = defParm->etype;
 798       actParm->ftype = defParm->type;
 799     }
 800
 801 /*    actParm->argSym = resolveFromTable(defParm)->sym ; */
 802
 803   actParm->argSym = defParm->sym;
 804   /* make a copy and change the regparm type to the defined parm */
 805   actParm->etype = getSpec (actParm->ftype = copyLinkChain (actParm->ftype));
 806   SPEC_REGPARM (actParm->etype) = SPEC_REGPARM (defParm->etype);
 807   (*parmNumber)++;
 808   return 0;
 809 }
 810 /*-----------------------------------------------------------------*/
 811 /* createIvalType - generates ival for basic types                 */
 812 /*-----------------------------------------------------------------*/
 813 ast *
 814 createIvalType (ast * sym, sym_link * type, initList * ilist)
 815 {
 816   ast *iExpr;
 817
 818   /* if initList is deep */
 819   if (ilist->type == INIT_DEEP)
 820     ilist = ilist->init.deep;
 821
 822   iExpr = decorateType (resolveSymbols (list2expr (ilist)));
 823   return decorateType (newNode ('=', sym, iExpr));
 824 }
 825
 826 /*-----------------------------------------------------------------*/
 827 /* createIvalStruct - generates initial value for structures       */
 828 /*-----------------------------------------------------------------*/
 829 ast *
 830 createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 831 {
 832   ast *rast = NULL;
 833   symbol *sflds;
 834   initList *iloop;
 835
 836   sflds = SPEC_STRUCT (type)->fields;
 837   if (ilist->type != INIT_DEEP)
 838     {
 839       werror (E_INIT_STRUCT, "");
 840       return NULL;
 841     }
 842
 843   iloop = ilist->init.deep;
 844
 845   for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
 846     {
 847       ast *lAst;
 848
 849       /* if we have come to end */
 850       if (!iloop)
 851         break;
 852       sflds->implicit = 1;
 853       lAst = newNode (PTR_OP, newNode ('&', sym, NULL), newAst_VALUE (symbolVal (sflds)));
 854       lAst = decorateType (resolveSymbols (lAst));
 855       rast = decorateType (resolveSymbols (createIval (lAst, sflds->type, iloop, rast)));
 856     }
 857   return rast;
 858 }
 859
 860
 861 /*-----------------------------------------------------------------*/
 862 /* createIvalArray - generates code for array initialization       */
 863 /*-----------------------------------------------------------------*/
 864 ast *
 865 createIvalArray (ast * sym, sym_link * type, initList * ilist)
 866 {
 867   ast *rast = NULL;
 868   initList *iloop;
 869   int lcnt = 0, size = 0;
 870   literalList *literalL;
 871
 872   /* take care of the special   case  */
 873   /* array of characters can be init  */
 874   /* by a string                      */
 875   if (IS_CHAR (type->next))
 876     if ((rast = createIvalCharPtr (sym,
 877                                    type,
 878                         decorateType (resolveSymbols (list2expr (ilist))))))
 879
 880       return decorateType (resolveSymbols (rast));
 881
 882     /* not the special case             */
 883     if (ilist->type != INIT_DEEP)
 884     {
 885         werror (E_INIT_STRUCT, "");
 886         return NULL;
 887     }
 888
 889     iloop = ilist->init.deep;
 890     lcnt = DCL_ELEM (type);
 891
 892     if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL))
 893     {
 894         ast *aSym;
 895
 896         aSym = decorateType (resolveSymbols(sym));
 897
 898         rast = newNode(ARRAYINIT, aSym, NULL);
 899         rast->values.constlist = literalL;
 900
 901         // Make sure size is set to length of initializer list.
 902         while (iloop)
 903         {
 904             size++;
 905             iloop = iloop->next;
 906         }
 907
 908         if (lcnt && size > lcnt)
 909         {
 910             // Array size was specified, and we have more initializers than needed.
 911             char *name=sym->opval.val->sym->name;
 912             int lineno=sym->opval.val->sym->lineDef;
 913
 914             werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
 915         }
 916     }
 917     else
 918     {
 919         for (;;)
 920         {
 921             ast *aSym;
 922
 923             aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++))));
 924             aSym = decorateType (resolveSymbols (aSym));
 925             rast = createIval (aSym, type->next, iloop, rast);
 926             iloop = (iloop ? iloop->next : NULL);
 927             if (!iloop)
 928             {
 929                 break;
 930             }
 931
 932             /* no of elements given and we    */
 933             /* have generated for all of them */
 934             if (!--lcnt)
 935             {
 936                 // there has to be a better way
 937                 char *name=sym->opval.val->sym->name;
 938                 int lineno=sym->opval.val->sym->lineDef;
 939                 werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
 940
 941                 break;
 942             }
 943         }
 944     }
 945
 946     /* if we have not been given a size  */
 947     if (!DCL_ELEM (type))
 948     {
 949         DCL_ELEM (type) = size;
 950     }
 951
 952     return decorateType (resolveSymbols (rast));
 953 }
 954
 955
 956 /*-----------------------------------------------------------------*/
 957 /* createIvalCharPtr - generates initial values for char pointers  */
 958 /*-----------------------------------------------------------------*/
 959 ast *
 960 createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 961 {
 962   ast *rast = NULL;
 963
 964   /* if this is a pointer & right is a literal array then */
 965   /* just assignment will do                              */
 966   if (IS_PTR (type) && ((IS_LITERAL (iexpr->etype) ||
 967                          SPEC_SCLS (iexpr->etype) == S_CODE)
 968                         && IS_ARRAY (iexpr->ftype)))
 969     return newNode ('=', sym, iexpr);
 970
 971   /* left side is an array so we have to assign each */
 972   /* element                                         */
 973   if ((IS_LITERAL (iexpr->etype) ||
 974        SPEC_SCLS (iexpr->etype) == S_CODE)
 975       && IS_ARRAY (iexpr->ftype))
 976     {
 977       /* for each character generate an assignment */
 978       /* to the array element */
 979       char *s = SPEC_CVAL (iexpr->etype).v_char;
 980       int i = 0;
 981
 982       while (*s)
 983         {
 984           rast = newNode (NULLOP,
 985                           rast,
 986                           newNode ('=',
 987                                    newNode ('[', sym,
 988                                    newAst_VALUE (valueFromLit ((float) i))),
 989                                    newAst_VALUE (valueFromLit (*s))));
 990           i++;
 991           s++;
 992         }
 993       rast = newNode (NULLOP,
 994                       rast,
 995                       newNode ('=',
 996                                newNode ('[', sym,
 997                                    newAst_VALUE (valueFromLit ((float) i))),
 998                                newAst_VALUE (valueFromLit (*s))));
 999       return decorateType (resolveSymbols (rast));
1000     }
1001
1002   return NULL;
1003 }
1004
1005 /*-----------------------------------------------------------------*/
1006 /* createIvalPtr - generates initial value for pointers            */
1007 /*-----------------------------------------------------------------*/
1008 ast *
1009 createIvalPtr (ast * sym, sym_link * type, initList * ilist)
1010 {
1011   ast *rast;
1012   ast *iexpr;
1013
1014   /* if deep then   */
1015   if (ilist->type == INIT_DEEP)
1016     ilist = ilist->init.deep;
1017
1018   iexpr = decorateType (resolveSymbols (list2expr (ilist)));
1019
1020   /* if character pointer */
1021   if (IS_CHAR (type->next))
1022     if ((rast = createIvalCharPtr (sym, type, iexpr)))
1023       return rast;
1024
1025   return newNode ('=', sym, iexpr);
1026 }
1027
1028 /*-----------------------------------------------------------------*/
1029 /* createIval - generates code for initial value                   */
1030 /*-----------------------------------------------------------------*/
1031 ast *
1032 createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
1033 {
1034   ast *rast = NULL;
1035
1036   if (!ilist)
1037     return NULL;
1038
1039   /* if structure then    */
1040   if (IS_STRUCT (type))
1041     rast = createIvalStruct (sym, type, ilist);
1042   else
1043     /* if this is a pointer */
1044   if (IS_PTR (type))
1045     rast = createIvalPtr (sym, type, ilist);
1046   else
1047     /* if this is an array   */
1048   if (IS_ARRAY (type))
1049     rast = createIvalArray (sym, type, ilist);
1050   else
1051     /* if type is SPECIFIER */
1052   if (IS_SPEC (type))
1053     rast = createIvalType (sym, type, ilist);
1054
1055   if (wid)
1056     return decorateType (resolveSymbols (newNode (NULLOP, wid, rast)));
1057   else
1058     return decorateType (resolveSymbols (rast));
1059 }
1060
1061 /*-----------------------------------------------------------------*/
1062 /* initAggregates - initialises aggregate variables with initv     */
1063 /*-----------------------------------------------------------------*/
1064
1065 /* this has to go */ void printIval (symbol *, sym_link *, initList *, FILE *);
1066
1067 ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
1068   ast *ast;
1069   symbol *newSym;
1070
1071   if (getenv("TRY_THE_NEW_INITIALIZER")) {
1072
1073     if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
1074       fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
1075                "with -mmcs51 and --model-large");
1076       exit(404);
1077     }
1078
1079     if (SPEC_OCLS(sym->etype)==xdata &&
1080         getSize(sym->type) > 16) { // else it isn't worth it: do it the old way
1081
1082       // copy this symbol
1083       newSym=copySymbol (sym);
1084       SPEC_OCLS(newSym->etype)=code;
1085       sprintf (newSym->name, "%s_init__", sym->name);
1086       sprintf (newSym->rname,"%s_init__", sym->rname);
1087       addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
1088
1089       // emit it in the static segment
1090       addSet(&statsg->syms, newSym);
1091
1092       // now memcpy() the entire array from cseg
1093       ast=newNode (ARRAYINIT, // ASSIGN_AGGREGATE
1094                    newAst_VALUE (symbolVal (sym)),
1095                    newAst_VALUE (symbolVal (newSym)));
1096       return decorateType(resolveSymbols(ast));
1097     }
1098   }
1099
1100   return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
1101 }
1102
1103 /*-----------------------------------------------------------------*/
1104 /* gatherAutoInit - creates assignment expressions for initial     */
1105 /*    values                 */
1106 /*-----------------------------------------------------------------*/
1107 ast *
1108 gatherAutoInit (symbol * autoChain)
1109 {
1110   ast *init = NULL;
1111   ast *work;
1112   symbol *sym;
1113
1114   inInitMode = 1;
1115   for (sym = autoChain; sym; sym = sym->next)
1116     {
1117
1118       /* resolve the symbols in the ival */
1119       if (sym->ival)
1120         resolveIvalSym (sym->ival);
1121
1122       /* if this is a static variable & has an */
1123       /* initial value the code needs to be lifted */
1124       /* here to the main portion since they can be */
1125       /* initialised only once at the start    */
1126       if (IS_STATIC (sym->etype) && sym->ival &&
1127           SPEC_SCLS (sym->etype) != S_CODE)
1128         {
1129           symbol *newSym;
1130
1131           // this can only be a constant
1132           if (!inInitMode && !IS_LITERAL(sym->ival->init.node->etype)) {
1133             werror (E_CONST_EXPECTED);
1134           }
1135
1136           /* insert the symbol into the symbol table */
1137           /* with level = 0 & name = rname       */
1138           newSym = copySymbol (sym);
1139           addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
1140
1141           /* now lift the code to main */
1142           if (IS_AGGREGATE (sym->type))
1143             work = initAggregates (sym, sym->ival, NULL);
1144           else
1145             work = newNode ('=', newAst_VALUE (symbolVal (newSym)),
1146                             list2expr (sym->ival));
1147
1148           setAstLineno (work, sym->lineDef);
1149
1150           sym->ival = NULL;
1151           if (staticAutos)
1152             staticAutos = newNode (NULLOP, staticAutos, work);
1153           else
1154             staticAutos = work;
1155
1156           continue;
1157         }
1158
1159       /* if there is an initial value */
1160       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
1161         {
1162           if (IS_AGGREGATE (sym->type))
1163             work = initAggregates (sym, sym->ival, NULL);
1164           else
1165             work = newNode ('=', newAst_VALUE (symbolVal (sym)),
1166                             list2expr (sym->ival));
1167
1168           setAstLineno (work, sym->lineDef);
1169           sym->ival = NULL;
1170           if (init)
1171             init = newNode (NULLOP, init, work);
1172           else
1173             init = work;
1174         }
1175     }
1176   inInitMode = 0;
1177   return init;
1178 }
1179
1180 /*-----------------------------------------------------------------*/
1181 /* stringToSymbol - creates a symbol from a literal string         */
1182 /*-----------------------------------------------------------------*/
1183 static value *
1184 stringToSymbol (value * val)
1185 {
1186   char name[SDCC_NAME_MAX + 1];
1187   static int charLbl = 0;
1188   symbol *sym;
1189
1190   sprintf (name, "_str_%d", charLbl++);
1191   sym = newSymbol (name, 0);    /* make it @ level 0 */
1192   strcpy (sym->rname, name);
1193
1194   /* copy the type from the value passed */
1195   sym->type = copyLinkChain (val->type);
1196   sym->etype = getSpec (sym->type);
1197   /* change to storage class & output class */
1198   SPEC_SCLS (sym->etype) = S_CODE;
1199   SPEC_CVAL (sym->etype).v_char = SPEC_CVAL (val->etype).v_char;
1200   SPEC_STAT (sym->etype) = 1;
1201   /* make the level & block = 0 */
1202   sym->block = sym->level = 0;
1203   sym->isstrlit = 1;
1204   /* create an ival */
1205   sym->ival = newiList (INIT_NODE, newAst_VALUE (val));
1206   if (noAlloc == 0)
1207     {
1208       /* allocate it */
1209       addSymChain (sym);
1210       allocVariables (sym);
1211     }
1212   sym->ival = NULL;
1213   return symbolVal (sym);
1214
1215 }
1216
1217 /*-----------------------------------------------------------------*/
1218 /* processBlockVars - will go thru the ast looking for block if    */
1219 /*                    a block is found then will allocate the syms */
1220 /*                    will also gather the auto inits present      */
1221 /*-----------------------------------------------------------------*/
1222 ast *
1223 processBlockVars (ast * tree, int *stack, int action)
1224 {
1225   if (!tree)
1226     return NULL;
1227
1228   /* if this is a block */
1229   if (tree->type == EX_OP && tree->opval.op == BLOCK)
1230     {
1231       ast *autoInit;
1232
1233       if (action == ALLOCATE)
1234         {
1235           *stack += allocVariables (tree->values.sym);
1236           autoInit = gatherAutoInit (tree->values.sym);
1237
1238           /* if there are auto inits then do them */
1239           if (autoInit)
1240             tree->left = newNode (NULLOP, autoInit, tree->left);
1241         }
1242       else                      /* action is deallocate */
1243         deallocLocal (tree->values.sym);
1244     }
1245
1246   processBlockVars (tree->left, stack, action);
1247   processBlockVars (tree->right, stack, action);
1248   return tree;
1249 }
1250
1251 /*-----------------------------------------------------------------*/
1252 /* constExprValue - returns the value of a constant expression     */
1253 /*-----------------------------------------------------------------*/
1254 value *
1255 constExprValue (ast * cexpr, int check)
1256 {
1257   cexpr = decorateType (resolveSymbols (cexpr));
1258
1259   /* if this is not a constant then */
1260   if (!IS_LITERAL (cexpr->ftype))
1261     {
1262       /* then check if this is a literal array
1263          in code segment */
1264       if (SPEC_SCLS (cexpr->etype) == S_CODE &&
1265           SPEC_CVAL (cexpr->etype).v_char &&
1266           IS_ARRAY (cexpr->ftype))
1267         {
1268           value *val = valFromType (cexpr->ftype);
1269           SPEC_SCLS (val->etype) = S_LITERAL;
1270           val->sym = cexpr->opval.val->sym;
1271           val->sym->type = copyLinkChain (cexpr->ftype);
1272           val->sym->etype = getSpec (val->sym->type);
1273           strcpy (val->name, cexpr->opval.val->sym->rname);
1274           return val;
1275         }
1276
1277       /* if we are casting a literal value then */
1278       if (IS_AST_OP (cexpr) &&
1279           cexpr->opval.op == CAST &&
1280           IS_LITERAL (cexpr->left->ftype))
1281         return valCastLiteral (cexpr->ftype,
1282                                floatFromVal (cexpr->left->opval.val));
1283
1284       if (IS_AST_VALUE (cexpr))
1285         return cexpr->opval.val;
1286
1287       if (check)
1288         werror (E_CONST_EXPECTED, "found expression");
1289
1290       return NULL;
1291     }
1292
1293   /* return the value */
1294   return cexpr->opval.val;
1295
1296 }
1297
1298 /*-----------------------------------------------------------------*/
1299 /* isLabelInAst - will return true if a given label is found       */
1300 /*-----------------------------------------------------------------*/
1301 bool
1302 isLabelInAst (symbol * label, ast * tree)
1303 {
1304   if (!tree || IS_AST_VALUE (tree) || IS_AST_LINK (tree))
1305     return FALSE;
1306
1307   if (IS_AST_OP (tree) &&
1308       tree->opval.op == LABEL &&
1309       isSymbolEqual (AST_SYMBOL (tree->left), label))
1310     return TRUE;
1311
1312   return isLabelInAst (label, tree->right) &&
1313     isLabelInAst (label, tree->left);
1314
1315 }
1316
1317 /*-----------------------------------------------------------------*/
1318 /* isLoopCountable - return true if the loop count can be determi- */
1319 /* -ned at compile time .                                          */
1320 /*-----------------------------------------------------------------*/
1321 bool
1322 isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr,
1323                  symbol ** sym, ast ** init, ast ** end)
1324 {
1325
1326   /* the loop is considered countable if the following
1327      conditions are true :-
1328
1329      a) initExpr :- <sym> = <const>
1330      b) condExpr :- <sym> < <const1>
1331      c) loopExpr :- <sym> ++
1332    */
1333
1334   /* first check the initExpr */
1335   if (IS_AST_OP (initExpr) &&
1336       initExpr->opval.op == '=' &&      /* is assignment */
1337       IS_AST_SYM_VALUE (initExpr->left))
1338     {                           /* left is a symbol */
1339
1340       *sym = AST_SYMBOL (initExpr->left);
1341       *init = initExpr->right;
1342     }
1343   else
1344     return FALSE;
1345
1346   /* for now the symbol has to be of
1347      integral type */
1348   if (!IS_INTEGRAL ((*sym)->type))
1349     return FALSE;
1350
1351   /* now check condExpr */
1352   if (IS_AST_OP (condExpr))
1353     {
1354
1355       switch (condExpr->opval.op)
1356         {
1357         case '<':
1358           if (IS_AST_SYM_VALUE (condExpr->left) &&
1359               isSymbolEqual (*sym, AST_SYMBOL (condExpr->left)) &&
1360               IS_AST_LIT_VALUE (condExpr->right))
1361             {
1362               *end = condExpr->right;
1363               break;
1364             }
1365           return FALSE;
1366
1367         case '!':
1368           if (IS_AST_OP (condExpr->left) &&
1369               condExpr->left->opval.op == '>' &&
1370               IS_AST_LIT_VALUE (condExpr->left->right) &&
1371               IS_AST_SYM_VALUE (condExpr->left->left) &&
1372               isSymbolEqual (*sym, AST_SYMBOL (condExpr->left->left)))
1373             {
1374
1375               *end = newNode ('+', condExpr->left->right,
1376                               newAst_VALUE (constVal ("1")));
1377               break;
1378             }
1379           return FALSE;
1380
1381         default:
1382           return FALSE;
1383         }
1384
1385     }
1386
1387   /* check loop expression is of the form <sym>++ */
1388   if (!IS_AST_OP (loopExpr))
1389     return FALSE;
1390
1391   /* check if <sym> ++ */
1392   if (loopExpr->opval.op == INC_OP)
1393     {
1394
1395       if (loopExpr->left)
1396         {
1397           /* pre */
1398           if (IS_AST_SYM_VALUE (loopExpr->left) &&
1399               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)))
1400             return TRUE;
1401
1402         }
1403       else
1404         {
1405           /* post */
1406           if (IS_AST_SYM_VALUE (loopExpr->right) &&
1407               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->right)))
1408             return TRUE;
1409         }
1410
1411     }
1412   else
1413     {
1414       /* check for += */
1415       if (loopExpr->opval.op == ADD_ASSIGN)
1416         {
1417
1418           if (IS_AST_SYM_VALUE (loopExpr->left) &&
1419               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) &&
1420               IS_AST_LIT_VALUE (loopExpr->right) &&
1421               (int) AST_LIT_VALUE (loopExpr->right) != 1)
1422             return TRUE;
1423         }
1424     }
1425
1426   return FALSE;
1427 }
1428
1429 /*-----------------------------------------------------------------*/
1430 /* astHasVolatile - returns true if ast contains any volatile      */
1431 /*-----------------------------------------------------------------*/
1432 bool
1433 astHasVolatile (ast * tree)
1434 {
1435   if (!tree)
1436     return FALSE;
1437
1438   if (TETYPE (tree) && IS_VOLATILE (TETYPE (tree)))
1439     return TRUE;
1440
1441   if (IS_AST_OP (tree))
1442     return astHasVolatile (tree->left) ||
1443       astHasVolatile (tree->right);
1444   else
1445     return FALSE;
1446 }
1447
1448 /*-----------------------------------------------------------------*/
1449 /* astHasPointer - return true if the ast contains any ptr variable */
1450 /*-----------------------------------------------------------------*/
1451 bool
1452 astHasPointer (ast * tree)
1453 {
1454   if (!tree)
1455     return FALSE;
1456
1457   if (IS_AST_LINK (tree))
1458     return TRUE;
1459
1460   /* if we hit an array expression then check
1461      only the left side */
1462   if (IS_AST_OP (tree) && tree->opval.op == '[')
1463     return astHasPointer (tree->left);
1464
1465   if (IS_AST_VALUE (tree))
1466     return IS_PTR (tree->ftype) || IS_ARRAY (tree->ftype);
1467
1468   return astHasPointer (tree->left) ||
1469     astHasPointer (tree->right);
1470
1471 }
1472
1473 /*-----------------------------------------------------------------*/
1474 /* astHasSymbol - return true if the ast has the given symbol      */
1475 /*-----------------------------------------------------------------*/
1476 bool
1477 astHasSymbol (ast * tree, symbol * sym)
1478 {
1479   if (!tree || IS_AST_LINK (tree))
1480     return FALSE;
1481
1482   if (IS_AST_VALUE (tree))
1483     {
1484       if (IS_AST_SYM_VALUE (tree))
1485         return isSymbolEqual (AST_SYMBOL (tree), sym);
1486       else
1487         return FALSE;
1488     }
1489
1490   return astHasSymbol (tree->left, sym) ||
1491     astHasSymbol (tree->right, sym);
1492 }
1493
1494 /*-----------------------------------------------------------------*/
1495 /* astHasDeref - return true if the ast has an indirect access     */
1496 /*-----------------------------------------------------------------*/
1497 static bool
1498 astHasDeref (ast * tree)
1499 {
1500   if (!tree || IS_AST_LINK (tree) || IS_AST_VALUE(tree))
1501     return FALSE;
1502
1503   if (tree->opval.op == '*' && tree->right == NULL) return TRUE;
1504
1505   return astHasDeref (tree->left) || astHasDeref (tree->right);
1506 }
1507
1508 /*-----------------------------------------------------------------*/
1509 /* isConformingBody - the loop body has to conform to a set of rules */
1510 /* for the loop to be considered reversible read on for rules      */
1511 /*-----------------------------------------------------------------*/
1512 bool
1513 isConformingBody (ast * pbody, symbol * sym, ast * body)
1514 {
1515
1516   /* we are going to do a pre-order traversal of the
1517      tree && check for the following conditions. (essentially
1518      a set of very shallow tests )
1519      a) the sym passed does not participate in
1520      any arithmetic operation
1521      b) There are no function calls
1522      c) all jumps are within the body
1523      d) address of loop control variable not taken
1524      e) if an assignment has a pointer on the
1525      left hand side make sure right does not have
1526      loop control variable */
1527
1528   /* if we reach the end or a leaf then true */
1529   if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody))
1530     return TRUE;
1531
1532
1533   /* if anything else is "volatile" */
1534   if (IS_VOLATILE (TETYPE (pbody)))
1535     return FALSE;
1536
1537   /* we will walk the body in a pre-order traversal for
1538      efficiency sake */
1539   switch (pbody->opval.op)
1540     {
1541 /*------------------------------------------------------------------*/
1542     case '[':
1543       return isConformingBody (pbody->right, sym, body);
1544
1545 /*------------------------------------------------------------------*/
1546     case PTR_OP:
1547     case '.':
1548       return TRUE;
1549
1550 /*------------------------------------------------------------------*/
1551     case INC_OP:                /* incerement operator unary so left only */
1552     case DEC_OP:
1553
1554       /* sure we are not sym is not modified */
1555       if (pbody->left &&
1556           IS_AST_SYM_VALUE (pbody->left) &&
1557           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1558         return FALSE;
1559
1560       if (pbody->right &&
1561           IS_AST_SYM_VALUE (pbody->right) &&
1562           isSymbolEqual (AST_SYMBOL (pbody->right), sym))
1563         return FALSE;
1564
1565       return TRUE;
1566
1567 /*------------------------------------------------------------------*/
1568
1569     case '*':                   /* can be unary  : if right is null then unary operation */
1570     case '+':
1571     case '-':
1572     case '&':
1573
1574       /* if right is NULL then unary operation  */
1575 /*------------------------------------------------------------------*/
1576 /*----------------------------*/
1577       /*  address of                */
1578 /*----------------------------*/
1579       if (!pbody->right)
1580         {
1581           if (IS_AST_SYM_VALUE (pbody->left) &&
1582               isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1583             return FALSE;
1584           else
1585             return isConformingBody (pbody->left, sym, body);
1586         }
1587       else
1588         {
1589           if (astHasSymbol (pbody->left, sym) ||
1590               astHasSymbol (pbody->right, sym))
1591             return FALSE;
1592         }
1593
1594
1595 /*------------------------------------------------------------------*/
1596     case '|':
1597     case '^':
1598     case '/':
1599     case '%':
1600     case LEFT_OP:
1601     case RIGHT_OP:
1602
1603       if (IS_AST_SYM_VALUE (pbody->left) &&
1604           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1605         return FALSE;
1606
1607       if (IS_AST_SYM_VALUE (pbody->right) &&
1608           isSymbolEqual (AST_SYMBOL (pbody->right), sym))
1609         return FALSE;
1610
1611       return isConformingBody (pbody->left, sym, body) &&
1612         isConformingBody (pbody->right, sym, body);
1613
1614     case '~':
1615     case '!':
1616     case RRC:
1617     case RLC:
1618     case GETHBIT:
1619       if (IS_AST_SYM_VALUE (pbody->left) &&
1620           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1621         return FALSE;
1622       return isConformingBody (pbody->left, sym, body);
1623
1624 /*------------------------------------------------------------------*/
1625
1626     case AND_OP:
1627     case OR_OP:
1628     case '>':
1629     case '<':
1630     case LE_OP:
1631     case GE_OP:
1632     case EQ_OP:
1633     case NE_OP:
1634     case '?':
1635     case ':':
1636     case SIZEOF:                /* evaluate wihout code generation */
1637
1638       return isConformingBody (pbody->left, sym, body) &&
1639         isConformingBody (pbody->right, sym, body);
1640
1641 /*------------------------------------------------------------------*/
1642     case '=':
1643
1644       /* if left has a pointer & right has loop
1645          control variable then we cannot */
1646       if (astHasPointer (pbody->left) &&
1647           astHasSymbol (pbody->right, sym))
1648         return FALSE;
1649       if (astHasVolatile (pbody->left))
1650         return FALSE;
1651
1652       if (IS_AST_SYM_VALUE (pbody->left) &&
1653           isSymbolEqual (AST_SYMBOL (pbody->left), sym))
1654         return FALSE;
1655
1656       if (astHasVolatile (pbody->left))
1657         return FALSE;
1658
1659       if (astHasDeref(pbody->right)) return FALSE;
1660
1661       return isConformingBody (pbody->left, sym, body) &&
1662         isConformingBody (pbody->right, sym, body);
1663
1664     case MUL_ASSIGN:
1665     case DIV_ASSIGN:
1666     case AND_ASSIGN:
1667     case OR_ASSIGN:
1668     case XOR_ASSIGN:
1669     case RIGHT_ASSIGN:
1670     case LEFT_ASSIGN:
1671     case SUB_ASSIGN:
1672     case ADD_ASSIGN:
1673       assert ("Parser should not have generated this\n");
1674
1675 /*------------------------------------------------------------------*/
1676 /*----------------------------*/
1677       /*      comma operator        */
1678 /*----------------------------*/
1679     case ',':
1680       return isConformingBody (pbody->left, sym, body) &&
1681         isConformingBody (pbody->right, sym, body);
1682
1683 /*------------------------------------------------------------------*/
1684 /*----------------------------*/
1685       /*       function call        */
1686 /*----------------------------*/
1687     case CALL:
1688       return FALSE;
1689
1690 /*------------------------------------------------------------------*/
1691 /*----------------------------*/
1692       /*     return statement       */
1693 /*----------------------------*/
1694     case RETURN:
1695       return FALSE;
1696
1697     case GOTO:
1698       if (isLabelInAst (AST_SYMBOL (pbody->left), body))
1699         return TRUE;
1700       else
1701         return FALSE;
1702     case SWITCH:
1703       if (astHasSymbol (pbody->left, sym))
1704         return FALSE;
1705
1706     default:
1707       break;
1708     }
1709
1710   return isConformingBody (pbody->left, sym, body) &&
1711     isConformingBody (pbody->right, sym, body);
1712
1713
1714
1715 }
1716
1717 /*-----------------------------------------------------------------*/
1718 /* isLoopReversible - takes a for loop as input && returns true    */
1719 /* if the for loop is reversible. If yes will set the value of     */
1720 /* the loop control var & init value & termination value           */
1721 /*-----------------------------------------------------------------*/
1722 bool
1723 isLoopReversible (ast * loop, symbol ** loopCntrl,
1724                   ast ** init, ast ** end)
1725 {
1726   /* if option says don't do it then don't */
1727   if (optimize.noLoopReverse)
1728     return 0;
1729   /* there are several tests to determine this */
1730
1731   /* for loop has to be of the form
1732      for ( <sym> = <const1> ;
1733      [<sym> < <const2>]  ;
1734      [<sym>++] | [<sym> += 1] | [<sym> = <sym> + 1] )
1735      forBody */
1736   if (!isLoopCountable (AST_FOR (loop, initExpr),
1737                         AST_FOR (loop, condExpr),
1738                         AST_FOR (loop, loopExpr),
1739                         loopCntrl, init, end))
1740     return 0;
1741
1742   /* now do some serious checking on the body of the loop
1743    */
1744
1745   return isConformingBody (loop->left, *loopCntrl, loop->left);
1746
1747 }
1748
1749 /*-----------------------------------------------------------------*/
1750 /* replLoopSym - replace the loop sym by loop sym -1               */
1751 /*-----------------------------------------------------------------*/
1752 static void
1753 replLoopSym (ast * body, symbol * sym)
1754 {
1755   /* reached end */
1756   if (!body || IS_AST_LINK (body))
1757     return;
1758
1759   if (IS_AST_SYM_VALUE (body))
1760     {
1761
1762       if (isSymbolEqual (AST_SYMBOL (body), sym))
1763         {
1764
1765           body->type = EX_OP;
1766           body->opval.op = '-';
1767           body->left = newAst_VALUE (symbolVal (sym));
1768           body->right = newAst_VALUE (constVal ("1"));
1769
1770         }
1771
1772       return;
1773
1774     }
1775
1776   replLoopSym (body->left, sym);
1777   replLoopSym (body->right, sym);
1778
1779 }
1780
1781 /*-----------------------------------------------------------------*/
1782 /* reverseLoop - do the actual loop reversal                       */
1783 /*-----------------------------------------------------------------*/
1784 ast *
1785 reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
1786 {
1787   ast *rloop;
1788
1789   /* create the following tree
1790      <sym> = loopCount ;
1791      for_continue:
1792      forbody
1793      <sym> -= 1;
1794      if (sym) goto for_continue ;
1795      <sym> = end */
1796
1797   /* put it together piece by piece */
1798   rloop = newNode (NULLOP,
1799                    createIf (newAst_VALUE (symbolVal (sym)),
1800                              newNode (GOTO,
1801                    newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))),
1802                                       NULL), NULL),
1803                    newNode ('=',
1804                             newAst_VALUE (symbolVal (sym)),
1805                             end));
1806
1807   replLoopSym (loop->left, sym);
1808
1809   rloop = newNode (NULLOP,
1810                    newNode ('=',
1811                             newAst_VALUE (symbolVal (sym)),
1812                             newNode ('-', end, init)),
1813                    createLabel (AST_FOR (loop, continueLabel),
1814                                 newNode (NULLOP,
1815                                          loop->left,
1816                                          newNode (NULLOP,
1817                                                   newNode (SUB_ASSIGN,
1818                                              newAst_VALUE (symbolVal (sym)),
1819                                              newAst_VALUE (constVal ("1"))),
1820                                                   rloop))));
1821
1822   return decorateType (rloop);
1823
1824 }
1825
1826 //#define DEMAND_INTEGER_PROMOTION
1827
1828 #ifdef DEMAND_INTEGER_PROMOTION
1829
1830 /*-----------------------------------------------------------------*/
1831 /* walk a tree looking for the leaves. Add a typecast to the given */
1832 /* type to each value leaf node.           */
1833 /*-----------------------------------------------------------------*/
1834 void
1835 pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr)
1836 {
1837   if (!node || IS_CALLOP(node))
1838     {
1839       /* WTF? We should never get here. */
1840       return;
1841     }
1842
1843   if (!node->left && !node->right)
1844     {
1845       /* We're at a leaf; if it's a value, apply the typecast */
1846       if (node->type == EX_VALUE && IS_INTEGRAL (TTYPE (node)))
1847         {
1848           *parentPtr = decorateType (newNode (CAST,
1849                                          newAst_LINK (copyLinkChain (type)),
1850                                               node));
1851         }
1852     }
1853   else
1854     {
1855       if (node->left)
1856         {
1857           pushTypeCastToLeaves (type, node->left, &(node->left));
1858         }
1859       if (node->right)
1860         {
1861           pushTypeCastToLeaves (type, node->right, &(node->right));
1862         }
1863     }
1864 }
1865
1866 #endif
1867
1868 /*-----------------------------------------------------------------*/
1869 /* Given an assignment operation in a tree, determine if the LHS   */
1870 /* (the result) has a different (integer) type than the RHS.     */
1871 /* If so, walk the RHS and add a typecast to the type of the LHS   */
1872 /* to all leaf nodes.              */
1873 /*-----------------------------------------------------------------*/
1874 void
1875 propAsgType (ast * tree)
1876 {
1877 #ifdef DEMAND_INTEGER_PROMOTION
1878   if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
1879     {
1880       /* Nothing to do here... */
1881       return;
1882     }
1883
1884   if (getSize (LTYPE (tree)) > getSize (RTYPE (tree)))
1885     {
1886       pushTypeCastToLeaves (LTYPE (tree), tree->right, &(tree->right));
1887     }
1888 #else
1889   (void) tree;
1890 #endif
1891 }
1892
1893 /*-----------------------------------------------------------------*/
1894 /* decorateType - compute type for this tree also does type cheking */
1895 /*          this is done bottom up, since type have to flow upwards */
1896 /*          it also does constant folding, and paramater checking  */
1897 /*-----------------------------------------------------------------*/
1898 ast *
1899 decorateType (ast * tree)
1900 {
1901   int parmNumber;
1902   sym_link *p;
1903
1904   if (!tree)
1905     return tree;
1906
1907   /* if already has type then do nothing */
1908   if (tree->decorated)
1909     return tree;
1910
1911   tree->decorated = 1;
1912
1913   /* print the line          */
1914   /* if not block & function */
1915   if (tree->type == EX_OP &&
1916       (tree->opval.op != FUNCTION &&
1917        tree->opval.op != BLOCK &&
1918        tree->opval.op != NULLOP))
1919     {
1920       filename = tree->filename;
1921       lineno = tree->lineno;
1922     }
1923
1924   /* if any child is an error | this one is an error do nothing */
1925   if (tree->isError ||
1926       (tree->left && tree->left->isError) ||
1927       (tree->right && tree->right->isError))
1928     return tree;
1929
1930 /*------------------------------------------------------------------*/
1931 /*----------------------------*/
1932   /*   leaf has been reached    */
1933 /*----------------------------*/
1934   /* if this is of type value */
1935   /* just get the type        */
1936   if (tree->type == EX_VALUE)
1937     {
1938
1939       if (IS_LITERAL (tree->opval.val->etype))
1940         {
1941
1942           /* if this is a character array then declare it */
1943           if (IS_ARRAY (tree->opval.val->type))
1944             tree->opval.val = stringToSymbol (tree->opval.val);
1945
1946           /* otherwise just copy the type information */
1947           COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
1948           if (funcInChain (tree->opval.val->type))
1949             {
1950               tree->hasVargs = tree->opval.val->sym->hasVargs;
1951               tree->args = copyValueChain (tree->opval.val->sym->args);
1952             }
1953           return tree;
1954         }
1955
1956       if (tree->opval.val->sym)
1957         {
1958           /* if the undefined flag is set then give error message */
1959           if (tree->opval.val->sym->undefined)
1960             {
1961               werror (E_ID_UNDEF, tree->opval.val->sym->name);
1962               /* assume int */
1963               TTYPE (tree) = TETYPE (tree) =
1964                 tree->opval.val->type = tree->opval.val->sym->type =
1965                 tree->opval.val->etype = tree->opval.val->sym->etype =
1966                 copyLinkChain (INTTYPE);
1967             }
1968           else
1969             {
1970
1971               /* if impilicit i.e. struct/union member then no type */
1972               if (tree->opval.val->sym->implicit)
1973                 TTYPE (tree) = TETYPE (tree) = NULL;
1974
1975               else
1976                 {
1977
1978                   /* else copy the type */
1979                   COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
1980
1981                   /* and mark it as referenced */
1982                   tree->opval.val->sym->isref = 1;
1983                   /* if this is of type function or function pointer */
1984                   if (funcInChain (tree->opval.val->type))
1985                     {
1986                       tree->hasVargs = tree->opval.val->sym->hasVargs;
1987                       tree->args = copyValueChain (tree->opval.val->sym->args);
1988
1989                     }
1990                 }
1991             }
1992         }
1993
1994       return tree;
1995     }
1996
1997   /* if type link for the case of cast */
1998   if (tree->type == EX_LINK)
1999     {
2000       COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.lnk);
2001       return tree;
2002     }
2003
2004   {
2005     ast *dtl, *dtr;
2006
2007     dtl = decorateType (tree->left);
2008     dtr = decorateType (tree->right);
2009
2010     /* this is to take care of situations
2011        when the tree gets rewritten */
2012     if (dtl != tree->left)
2013       tree->left = dtl;
2014     if (dtr != tree->right)
2015       tree->right = dtr;
2016   }
2017
2018   /* depending on type of operator do */
2019
2020   switch (tree->opval.op)
2021     {
2022 /*------------------------------------------------------------------*/
2023 /*----------------------------*/
2024       /*        array node          */
2025 /*----------------------------*/
2026     case '[':
2027
2028       /* determine which is the array & which the index */
2029       if ((IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree))) && IS_INTEGRAL (LTYPE (tree)))
2030         {
2031
2032           ast *tempTree = tree->left;
2033           tree->left = tree->right;
2034           tree->right = tempTree;
2035         }
2036
2037       /* first check if this is a array or a pointer */
2038       if ((!IS_ARRAY (LTYPE (tree))) && (!IS_PTR (LTYPE (tree))))
2039         {
2040           werror (E_NEED_ARRAY_PTR, "[]");
2041           goto errorTreeReturn;
2042         }
2043
2044       /* check if the type of the idx */
2045       if (!IS_INTEGRAL (RTYPE (tree)))
2046         {
2047           werror (E_IDX_NOT_INT);
2048           goto errorTreeReturn;
2049         }
2050
2051       /* if the left is an rvalue then error */
2052       if (LRVAL (tree))
2053         {
2054           werror (E_LVALUE_REQUIRED, "array access");
2055           goto errorTreeReturn;
2056         }
2057       RRVAL (tree) = 1;
2058       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)->next);
2059       if (IS_PTR(LTYPE(tree))) {
2060               SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
2061       }
2062       return tree;
2063
2064 /*------------------------------------------------------------------*/
2065 /*----------------------------*/
2066       /*      struct/union          */
2067 /*----------------------------*/
2068     case '.':
2069       /* if this is not a structure */
2070       if (!IS_STRUCT (LTYPE (tree)))
2071         {
2072           werror (E_STRUCT_UNION, ".");
2073           goto errorTreeReturn;
2074         }
2075       TTYPE (tree) = structElemType (LTYPE (tree),
2076                                      (tree->right->type == EX_VALUE ?
2077                                tree->right->opval.val : NULL), &tree->args);
2078       TETYPE (tree) = getSpec (TTYPE (tree));
2079       return tree;
2080
2081 /*------------------------------------------------------------------*/
2082 /*----------------------------*/
2083       /*    struct/union pointer    */
2084 /*----------------------------*/
2085     case PTR_OP:
2086       /* if not pointer to a structure */
2087       if (!IS_PTR (LTYPE (tree)))
2088         {
2089           werror (E_PTR_REQD);
2090           goto errorTreeReturn;
2091         }
2092
2093       if (!IS_STRUCT (LTYPE (tree)->next))
2094         {
2095           werror (E_STRUCT_UNION, "->");
2096           goto errorTreeReturn;
2097         }
2098
2099       TTYPE (tree) = structElemType (LTYPE (tree)->next,
2100                                      (tree->right->type == EX_VALUE ?
2101                                tree->right->opval.val : NULL), &tree->args);
2102       TETYPE (tree) = getSpec (TTYPE (tree));
2103       return tree;
2104
2105 /*------------------------------------------------------------------*/
2106 /*----------------------------*/
2107       /*  ++/-- operation           */
2108 /*----------------------------*/
2109     case INC_OP:                /* incerement operator unary so left only */
2110     case DEC_OP:
2111       {
2112         sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree));
2113         COPYTYPE (TTYPE (tree), TETYPE (tree), ltc);
2114         if (!tree->initMode && IS_CONSTANT (TETYPE (tree)))
2115           werror (E_CODE_WRITE, "++/--");
2116
2117         if (tree->right)
2118           RLVAL (tree) = 1;
2119         else
2120           LLVAL (tree) = 1;
2121         return tree;
2122       }
2123
2124 /*------------------------------------------------------------------*/
2125 /*----------------------------*/
2126       /*  bitwise and               */
2127 /*----------------------------*/
2128     case '&':                   /* can be unary   */
2129       /* if right is NULL then unary operation  */
2130       if (tree->right)          /* not an unary operation */
2131         {
2132
2133           if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2134             {
2135               werror (E_BITWISE_OP);
2136               werror (W_CONTINUE, "left & right types are ");
2137               printTypeChain (LTYPE (tree), stderr);
2138               fprintf (stderr, ",");
2139               printTypeChain (RTYPE (tree), stderr);
2140               fprintf (stderr, "\n");
2141               goto errorTreeReturn;
2142             }
2143
2144           /* if they are both literal */
2145           if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2146             {
2147               tree->type = EX_VALUE;
2148               tree->opval.val = valBitwise (valFromType (LETYPE (tree)),
2149                                           valFromType (RETYPE (tree)), '&');
2150
2151               tree->right = tree->left = NULL;
2152               TETYPE (tree) = tree->opval.val->etype;
2153               TTYPE (tree) = tree->opval.val->type;
2154               return tree;
2155             }
2156
2157           /* see if this is a GETHBIT operation if yes
2158              then return that */
2159           {
2160             ast *otree = optimizeGetHbit (tree);
2161
2162             if (otree != tree)
2163               return decorateType (otree);
2164           }
2165
2166 #if 0
2167           // we can't do this because of "(int & 0xff) << 3"
2168
2169           /* if right or left is literal then result of that type */
2170           if (IS_LITERAL (RTYPE (tree)))
2171             {
2172
2173               TTYPE (tree) = copyLinkChain (RTYPE (tree));
2174               TETYPE (tree) = getSpec (TTYPE (tree));
2175               SPEC_SCLS (TETYPE (tree)) = S_AUTO;
2176             }
2177           else
2178             {
2179               if (IS_LITERAL (LTYPE (tree)))
2180                 {
2181                   TTYPE (tree) = copyLinkChain (LTYPE (tree));
2182                   TETYPE (tree) = getSpec (TTYPE (tree));
2183                   SPEC_SCLS (TETYPE (tree)) = S_AUTO;
2184
2185                 }
2186               else
2187                 {
2188                   TTYPE (tree) =
2189                     computeType (LTYPE (tree), RTYPE (tree));
2190                   TETYPE (tree) = getSpec (TTYPE (tree));
2191                 }
2192             }
2193 #else
2194           TTYPE (tree) =
2195             computeType (LTYPE (tree), RTYPE (tree));
2196           TETYPE (tree) = getSpec (TTYPE (tree));
2197 #endif
2198           LRVAL (tree) = RRVAL (tree) = 1;
2199           return tree;
2200         }
2201
2202 /*------------------------------------------------------------------*/
2203 /*----------------------------*/
2204       /*  address of                */
2205 /*----------------------------*/
2206       p = newLink ();
2207       p->class = DECLARATOR;
2208       /* if bit field then error */
2209       if (IS_BITVAR (tree->left->etype))
2210         {
2211           werror (E_ILLEGAL_ADDR, "addrress of bit variable");
2212           goto errorTreeReturn;
2213         }
2214
2215       if (SPEC_SCLS (tree->left->etype) == S_REGISTER)
2216         {
2217           werror (E_ILLEGAL_ADDR, "address of register variable");
2218           goto errorTreeReturn;
2219         }
2220
2221       if (IS_FUNC (LTYPE (tree)))
2222         {
2223           werror (E_ILLEGAL_ADDR, "address of function");
2224           goto errorTreeReturn;
2225         }
2226
2227       if (LRVAL (tree))
2228         {
2229           werror (E_LVALUE_REQUIRED, "address of");
2230           goto errorTreeReturn;
2231         }
2232       if (SPEC_SCLS (tree->left->etype) == S_CODE)
2233         {
2234           DCL_TYPE (p) = CPOINTER;
2235           DCL_PTR_CONST (p) = port->mem.code_ro;
2236         }
2237       else if (SPEC_SCLS (tree->left->etype) == S_XDATA)
2238         DCL_TYPE (p) = FPOINTER;
2239       else if (SPEC_SCLS (tree->left->etype) == S_XSTACK)
2240         DCL_TYPE (p) = PPOINTER;
2241       else if (SPEC_SCLS (tree->left->etype) == S_IDATA)
2242         DCL_TYPE (p) = IPOINTER;
2243       else if (SPEC_SCLS (tree->left->etype) == S_EEPROM)
2244         DCL_TYPE (p) = EEPPOINTER;
2245       else
2246         DCL_TYPE (p) = POINTER;
2247
2248       if (IS_AST_SYM_VALUE (tree->left))
2249         {
2250           AST_SYMBOL (tree->left)->addrtaken = 1;
2251           AST_SYMBOL (tree->left)->allocreq = 1;
2252         }
2253
2254       p->next = LTYPE (tree);
2255       TTYPE (tree) = p;
2256       TETYPE (tree) = getSpec (TTYPE (tree));
2257       DCL_PTR_CONST (p) = SPEC_CONST (TETYPE (tree));
2258       DCL_PTR_VOLATILE (p) = SPEC_VOLATILE (TETYPE (tree));
2259       LLVAL (tree) = 1;
2260       TLVAL (tree) = 1;
2261       return tree;
2262
2263 /*------------------------------------------------------------------*/
2264 /*----------------------------*/
2265       /*  bitwise or                */
2266 /*----------------------------*/
2267     case '|':
2268       /* if the rewrite succeeds then don't go any furthur */
2269       {
2270         ast *wtree = optimizeRRCRLC (tree);
2271         if (wtree != tree)
2272           return decorateType (wtree);
2273       }
2274 /*------------------------------------------------------------------*/
2275 /*----------------------------*/
2276       /*  bitwise xor               */
2277 /*----------------------------*/
2278     case '^':
2279       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2280         {
2281           werror (E_BITWISE_OP);
2282           werror (W_CONTINUE, "left & right types are ");
2283           printTypeChain (LTYPE (tree), stderr);
2284           fprintf (stderr, ",");
2285           printTypeChain (RTYPE (tree), stderr);
2286           fprintf (stderr, "\n");
2287           goto errorTreeReturn;
2288         }
2289
2290       /* if they are both literal then */
2291       /* rewrite the tree */
2292       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2293         {
2294           tree->type = EX_VALUE;
2295           tree->opval.val = valBitwise (valFromType (LETYPE (tree)),
2296                                         valFromType (RETYPE (tree)),
2297                                         tree->opval.op);
2298           tree->right = tree->left = NULL;
2299           TETYPE (tree) = tree->opval.val->etype;
2300           TTYPE (tree) = tree->opval.val->type;
2301           return tree;
2302         }
2303       LRVAL (tree) = RRVAL (tree) = 1;
2304       TETYPE (tree) = getSpec (TTYPE (tree) =
2305                                computeType (LTYPE (tree),
2306                                             RTYPE (tree)));
2307
2308 /*------------------------------------------------------------------*/
2309 /*----------------------------*/
2310       /*  division                  */
2311 /*----------------------------*/
2312     case '/':
2313       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
2314         {
2315           werror (E_INVALID_OP, "divide");
2316           goto errorTreeReturn;
2317         }
2318       /* if they are both literal then */
2319       /* rewrite the tree */
2320       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2321         {
2322           tree->type = EX_VALUE;
2323           tree->opval.val = valDiv (valFromType (LETYPE (tree)),
2324                                     valFromType (RETYPE (tree)));
2325           tree->right = tree->left = NULL;
2326           TETYPE (tree) = getSpec (TTYPE (tree) =
2327                                    tree->opval.val->type);
2328           return tree;
2329         }
2330       LRVAL (tree) = RRVAL (tree) = 1;
2331       TETYPE (tree) = getSpec (TTYPE (tree) =
2332                                computeType (LTYPE (tree),
2333                                             RTYPE (tree)));
2334       return tree;
2335
2336 /*------------------------------------------------------------------*/
2337 /*----------------------------*/
2338       /*            modulus         */
2339 /*----------------------------*/
2340     case '%':
2341       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
2342         {
2343           werror (E_BITWISE_OP);
2344           werror (W_CONTINUE, "left & right types are ");
2345           printTypeChain (LTYPE (tree), stderr);
2346           fprintf (stderr, ",");
2347           printTypeChain (RTYPE (tree), stderr);
2348           fprintf (stderr, "\n");
2349           goto errorTreeReturn;
2350         }
2351       /* if they are both literal then */
2352       /* rewrite the tree */
2353       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2354         {
2355           tree->type = EX_VALUE;
2356           tree->opval.val = valMod (valFromType (LETYPE (tree)),
2357                                     valFromType (RETYPE (tree)));
2358           tree->right = tree->left = NULL;
2359           TETYPE (tree) = getSpec (TTYPE (tree) =
2360                                    tree->opval.val->type);
2361           return tree;
2362         }
2363       LRVAL (tree) = RRVAL (tree) = 1;
2364       TETYPE (tree) = getSpec (TTYPE (tree) =
2365                                computeType (LTYPE (tree),
2366                                             RTYPE (tree)));
2367       return tree;
2368
2369 /*------------------------------------------------------------------*/
2370 /*----------------------------*/
2371 /*  address dereference       */
2372 /*----------------------------*/
2373     case '*':                   /* can be unary  : if right is null then unary operation */
2374       if (!tree->right)
2375         {
2376           if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree)))
2377             {
2378               werror (E_PTR_REQD);
2379               goto errorTreeReturn;
2380             }
2381
2382           if (LRVAL (tree))
2383             {
2384               werror (E_LVALUE_REQUIRED, "pointer deref");
2385               goto errorTreeReturn;
2386             }
2387           TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
2388                                         LTYPE (tree)->next : NULL);
2389           TETYPE (tree) = getSpec (TTYPE (tree));
2390           tree->args = tree->left->args;
2391           tree->hasVargs = tree->left->hasVargs;
2392           SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
2393           return tree;
2394         }
2395
2396 /*------------------------------------------------------------------*/
2397 /*----------------------------*/
2398       /*      multiplication        */
2399 /*----------------------------*/
2400       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
2401         {
2402           werror (E_INVALID_OP, "multiplication");
2403           goto errorTreeReturn;
2404         }
2405
2406       /* if they are both literal then */
2407       /* rewrite the tree */
2408       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2409         {
2410           tree->type = EX_VALUE;
2411           tree->opval.val = valMult (valFromType (LETYPE (tree)),
2412                                      valFromType (RETYPE (tree)));
2413           tree->right = tree->left = NULL;
2414           TETYPE (tree) = getSpec (TTYPE (tree) =
2415                                    tree->opval.val->type);
2416           return tree;
2417         }
2418
2419       /* if left is a literal exchange left & right */
2420       if (IS_LITERAL (LTYPE (tree)))
2421         {
2422           ast *tTree = tree->left;
2423           tree->left = tree->right;
2424           tree->right = tTree;
2425         }
2426
2427       LRVAL (tree) = RRVAL (tree) = 1;
2428       /* promote result to int if left & right are char
2429          this will facilitate hardware multiplies 8bit x 8bit = 16bit */
2430       if (IS_CHAR(LETYPE(tree)) && IS_CHAR(RETYPE(tree))) {
2431         TETYPE (tree) = getSpec (TTYPE (tree) =
2432                                  computeType (LTYPE (tree),
2433                                               RTYPE (tree)));
2434         SPEC_NOUN(TETYPE(tree)) = V_INT;
2435       } else {
2436         TETYPE (tree) = getSpec (TTYPE (tree) =
2437                                  computeType (LTYPE (tree),
2438                                               RTYPE (tree)));
2439       }
2440       return tree;
2441
2442 /*------------------------------------------------------------------*/
2443 /*----------------------------*/
2444       /*    unary '+' operator      */
2445 /*----------------------------*/
2446     case '+':
2447       /* if unary plus */
2448       if (!tree->right)
2449         {
2450           if (!IS_INTEGRAL (LTYPE (tree)))
2451             {
2452               werror (E_UNARY_OP, '+');
2453               goto errorTreeReturn;
2454             }
2455
2456           /* if left is a literal then do it */
2457           if (IS_LITERAL (LTYPE (tree)))
2458             {
2459               tree->type = EX_VALUE;
2460               tree->opval.val = valFromType (LETYPE (tree));
2461               tree->left = NULL;
2462               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2463               return tree;
2464             }
2465           LRVAL (tree) = 1;
2466           COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2467           return tree;
2468         }
2469
2470 /*------------------------------------------------------------------*/
2471 /*----------------------------*/
2472       /*      addition              */
2473 /*----------------------------*/
2474
2475       /* this is not a unary operation */
2476       /* if both pointers then problem */
2477       if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) &&
2478           (IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree))))
2479         {
2480           werror (E_PTR_PLUS_PTR);
2481           goto errorTreeReturn;
2482         }
2483
2484       if (!IS_ARITHMETIC (LTYPE (tree)) &&
2485           !IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree)))
2486         {
2487           werror (E_PLUS_INVALID, "+");
2488           goto errorTreeReturn;
2489         }
2490
2491       if (!IS_ARITHMETIC (RTYPE (tree)) &&
2492           !IS_PTR (RTYPE (tree)) && !IS_ARRAY (RTYPE (tree)))
2493         {
2494           werror (E_PLUS_INVALID, "+");
2495           goto errorTreeReturn;
2496         }
2497       /* if they are both literal then */
2498       /* rewrite the tree */
2499       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2500         {
2501           tree->type = EX_VALUE;
2502           tree->opval.val = valPlus (valFromType (LETYPE (tree)),
2503                                      valFromType (RETYPE (tree)));
2504           tree->right = tree->left = NULL;
2505           TETYPE (tree) = getSpec (TTYPE (tree) =
2506                                    tree->opval.val->type);
2507           return tree;
2508         }
2509
2510       /* if the right is a pointer or left is a literal
2511          xchange left & right */
2512       if (IS_ARRAY (RTYPE (tree)) ||
2513           IS_PTR (RTYPE (tree)) ||
2514           IS_LITERAL (LTYPE (tree)))
2515         {
2516           ast *tTree = tree->left;
2517           tree->left = tree->right;
2518           tree->right = tTree;
2519         }
2520
2521       LRVAL (tree) = RRVAL (tree) = 1;
2522       /* if the left is a pointer */
2523       if (IS_PTR (LTYPE (tree)))
2524         TETYPE (tree) = getSpec (TTYPE (tree) =
2525                                  LTYPE (tree));
2526       else
2527         TETYPE (tree) = getSpec (TTYPE (tree) =
2528                                  computeType (LTYPE (tree),
2529                                               RTYPE (tree)));
2530       return tree;
2531
2532 /*------------------------------------------------------------------*/
2533 /*----------------------------*/
2534       /*      unary '-'             */
2535 /*----------------------------*/
2536     case '-':                   /* can be unary   */
2537       /* if right is null then unary */
2538       if (!tree->right)
2539         {
2540
2541           if (!IS_ARITHMETIC (LTYPE (tree)))
2542             {
2543               werror (E_UNARY_OP, tree->opval.op);
2544               goto errorTreeReturn;
2545             }
2546
2547           /* if left is a literal then do it */
2548           if (IS_LITERAL (LTYPE (tree)))
2549             {
2550               tree->type = EX_VALUE;
2551               tree->opval.val = valUnaryPM (valFromType (LETYPE (tree)));
2552               tree->left = NULL;
2553               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2554               SPEC_USIGN(TETYPE(tree)) = 0;
2555               return tree;
2556             }
2557           LRVAL (tree) = 1;
2558           TTYPE (tree) = LTYPE (tree);
2559           return tree;
2560         }
2561
2562 /*------------------------------------------------------------------*/
2563 /*----------------------------*/
2564       /*    subtraction             */
2565 /*----------------------------*/
2566
2567       if (!(IS_PTR (LTYPE (tree)) ||
2568             IS_ARRAY (LTYPE (tree)) ||
2569             IS_ARITHMETIC (LTYPE (tree))))
2570         {
2571           werror (E_PLUS_INVALID, "-");
2572           goto errorTreeReturn;
2573         }
2574
2575       if (!(IS_PTR (RTYPE (tree)) ||
2576             IS_ARRAY (RTYPE (tree)) ||
2577             IS_ARITHMETIC (RTYPE (tree))))
2578         {
2579           werror (E_PLUS_INVALID, "-");
2580           goto errorTreeReturn;
2581         }
2582
2583       if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) &&
2584           !(IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)) ||
2585             IS_INTEGRAL (RTYPE (tree))))
2586         {
2587           werror (E_PLUS_INVALID, "-");
2588           goto errorTreeReturn;
2589         }
2590
2591       /* if they are both literal then */
2592       /* rewrite the tree */
2593       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2594         {
2595           tree->type = EX_VALUE;
2596           tree->opval.val = valMinus (valFromType (LETYPE (tree)),
2597                                       valFromType (RETYPE (tree)));
2598           tree->right = tree->left = NULL;
2599           TETYPE (tree) = getSpec (TTYPE (tree) =
2600                                    tree->opval.val->type);
2601           return tree;
2602         }
2603
2604       /* if the left & right are equal then zero */
2605       if (isAstEqual (tree->left, tree->right))
2606         {
2607           tree->type = EX_VALUE;
2608           tree->left = tree->right = NULL;
2609           tree->opval.val = constVal ("0");
2610           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2611           return tree;
2612         }
2613
2614       /* if both of them are pointers or arrays then */
2615       /* the result is going to be an integer        */
2616       if ((IS_ARRAY (LTYPE (tree)) || IS_PTR (LTYPE (tree))) &&
2617           (IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree))))
2618         TETYPE (tree) = TTYPE (tree) = newIntLink ();
2619       else
2620         /* if only the left is a pointer */
2621         /* then result is a pointer      */
2622       if (IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree)))
2623         TETYPE (tree) = getSpec (TTYPE (tree) =
2624                                  LTYPE (tree));
2625       else
2626         TETYPE (tree) = getSpec (TTYPE (tree) =
2627                                  computeType (LTYPE (tree),
2628                                               RTYPE (tree)));
2629       LRVAL (tree) = RRVAL (tree) = 1;
2630       return tree;
2631
2632 /*------------------------------------------------------------------*/
2633 /*----------------------------*/
2634       /*    compliment              */
2635 /*----------------------------*/
2636     case '~':
2637       /* can be only integral type */
2638       if (!IS_INTEGRAL (LTYPE (tree)))
2639         {
2640           werror (E_UNARY_OP, tree->opval.op);
2641           goto errorTreeReturn;
2642         }
2643
2644       /* if left is a literal then do it */
2645       if (IS_LITERAL (LTYPE (tree)))
2646         {
2647           tree->type = EX_VALUE;
2648           tree->opval.val = valComplement (valFromType (LETYPE (tree)));
2649           tree->left = NULL;
2650           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2651           return tree;
2652         }
2653       LRVAL (tree) = 1;
2654       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2655       return tree;
2656
2657 /*------------------------------------------------------------------*/
2658 /*----------------------------*/
2659       /*           not              */
2660 /*----------------------------*/
2661     case '!':
2662       /* can be pointer */
2663       if (!IS_ARITHMETIC (LTYPE (tree)) &&
2664           !IS_PTR (LTYPE (tree)) &&
2665           !IS_ARRAY (LTYPE (tree)))
2666         {
2667           werror (E_UNARY_OP, tree->opval.op);
2668           goto errorTreeReturn;
2669         }
2670
2671       /* if left is a literal then do it */
2672       if (IS_LITERAL (LTYPE (tree)))
2673         {
2674           tree->type = EX_VALUE;
2675           tree->opval.val = valNot (valFromType (LETYPE (tree)));
2676           tree->left = NULL;
2677           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2678           return tree;
2679         }
2680       LRVAL (tree) = 1;
2681       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2682       return tree;
2683
2684 /*------------------------------------------------------------------*/
2685 /*----------------------------*/
2686       /*           shift            */
2687 /*----------------------------*/
2688     case RRC:
2689     case RLC:
2690       TTYPE (tree) = LTYPE (tree);
2691       TETYPE (tree) = LETYPE (tree);
2692       return tree;
2693
2694     case GETHBIT:
2695       TTYPE (tree) = TETYPE (tree) = newCharLink ();
2696       return tree;
2697
2698     case LEFT_OP:
2699     case RIGHT_OP:
2700       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (tree->left->etype))
2701         {
2702           werror (E_SHIFT_OP_INVALID);
2703           werror (W_CONTINUE, "left & right types are ");
2704           printTypeChain (LTYPE (tree), stderr);
2705           fprintf (stderr, ",");
2706           printTypeChain (RTYPE (tree), stderr);
2707           fprintf (stderr, "\n");
2708           goto errorTreeReturn;
2709         }
2710
2711       /* if they are both literal then */
2712       /* rewrite the tree */
2713       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
2714         {
2715           tree->type = EX_VALUE;
2716           tree->opval.val = valShift (valFromType (LETYPE (tree)),
2717                                       valFromType (RETYPE (tree)),
2718                                       (tree->opval.op == LEFT_OP ? 1 : 0));
2719           tree->right = tree->left = NULL;
2720           TETYPE (tree) = getSpec (TTYPE (tree) =
2721                                    tree->opval.val->type);
2722           return tree;
2723         }
2724       /* if only the right side is a literal & we are
2725          shifting more than size of the left operand then zero */
2726       if (IS_LITERAL (RTYPE (tree)) &&
2727           ((unsigned) floatFromVal (valFromType (RETYPE (tree)))) >=
2728           (getSize (LTYPE (tree)) * 8))
2729         {
2730           werror (W_SHIFT_CHANGED,
2731                   (tree->opval.op == LEFT_OP ? "left" : "right"));
2732           tree->type = EX_VALUE;
2733           tree->left = tree->right = NULL;
2734           tree->opval.val = constVal ("0");
2735           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
2736           return tree;
2737         }
2738       LRVAL (tree) = RRVAL (tree) = 1;
2739       if (IS_LITERAL (LTYPE (tree)) && !IS_LITERAL (RTYPE (tree)))
2740         {
2741           COPYTYPE (TTYPE (tree), TETYPE (tree), RTYPE (tree));
2742         }
2743       else
2744         {
2745           COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
2746         }
2747       return tree;
2748
2749 /*------------------------------------------------------------------*/
2750 /*----------------------------*/
2751       /*         casting            */
2752 /*----------------------------*/
2753     case CAST:                  /* change the type   */
2754       /* cannot cast to an aggregate type */
2755       if (IS_AGGREGATE (LTYPE (tree)))
2756         {
2757           werror (E_CAST_ILLEGAL);
2758           goto errorTreeReturn;
2759         }
2760
2761       /* make sure the type is complete and sane */
2762       checkTypeSanity(LETYPE(tree), "(cast)");
2763
2764       /* if the right is a literal replace the tree */
2765       if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree)))
2766         {
2767           tree->type = EX_VALUE;
2768           tree->opval.val =
2769             valCastLiteral (LTYPE (tree),
2770                             floatFromVal (valFromType (RETYPE (tree))));
2771           tree->left = NULL;
2772           tree->right = NULL;
2773           TTYPE (tree) = tree->opval.val->type;
2774           tree->values.literalFromCast = 1;
2775         }
2776       else
2777         {
2778           TTYPE (tree) = LTYPE (tree);
2779           LRVAL (tree) = 1;
2780         }
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 }