fixed bug #485513, although a warning should be thrown for non-constant initializers
[fw/sdcc] / src / SDCCast.c
index 1c65e5c9e8d1d76962d88487b19cb9b5ceeb07c8..f5e17f81085b57c0d2e8ea85e6e56187831f91d8 100644 (file)
@@ -23,7 +23,6 @@
 -------------------------------------------------------------------------*/
 
 #include "common.h"
-#include "newalloc.h"
 
 int currLineno = 0;
 set *astList = NULL;
@@ -46,7 +45,6 @@ int labelKey = 1;
 #define ALLOCATE 1
 #define DEALLOCATE 2
 
-char buffer[1024];
 int noLineno = 0;
 int noAlloc = 0;
 symbol *currFunc;
@@ -55,6 +53,7 @@ ast *createIvalCharPtr (ast *, sym_link *, ast *);
 ast *optimizeRRCRLC (ast *);
 ast *optimizeGetHbit (ast *);
 ast *backPatchLabels (ast *, symbol *, symbol *);
+void PA(ast *t);
 int inInitMode = 0;
 memmap *GcurMemmap=NULL;  /* points to the memmap that's currently active */
 FILE *codeOutFile;
@@ -76,7 +75,7 @@ newAst (int type, void *op)
   ast *ex;
   static int oldLineno = 0;
 
-  Safe_calloc (1, ex, sizeof (ast));
+  ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
   ex->lineno = (noLineno ? oldLineno : yylineno);
@@ -111,7 +110,7 @@ newAst_ (unsigned type)
   ast *ex;
   static int oldLineno = 0;
 
-  ex = Safe_calloc (1, sizeof (ast));
+  ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
   ex->lineno = (noLineno ? oldLineno : yylineno);
@@ -180,7 +179,6 @@ newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel)
   /* if this is a literal then we already know the result */
   if (condAst->etype && IS_LITERAL (condAst->etype))
     {
-
       /* then depending on the expression value */
       if (floatFromVal (condAst->opval.val))
        ifxNode = newNode (GOTO,
@@ -223,9 +221,14 @@ copyAstValues (ast * dest, ast * src)
       break;
 
     case INLINEASM:
-      dest->values.inlineasm = Safe_calloc (1, strlen (src->values.inlineasm) + 1);
+      dest->values.inlineasm = Safe_alloc (strlen (src->values.inlineasm) + 1);
       strcpy (dest->values.inlineasm, src->values.inlineasm);
+      break;
 
+    case ARRAYINIT:
+       dest->values.constlist = copyLiteralList(src->values.constlist);
+       break;
+       
     case FOR:
       AST_FOR (dest, trueLabel) = copySymbol (AST_FOR (src, trueLabel));
       AST_FOR (dest, continueLabel) = copySymbol (AST_FOR (src, continueLabel));
@@ -249,13 +252,15 @@ copyAst (ast * src)
   if (!src)
     return NULL;
 
-  dest = Safe_calloc (1, sizeof (ast));
+  dest = Safe_alloc ( sizeof (ast));
 
   dest->type = src->type;
   dest->lineno = src->lineno;
   dest->level = src->level;
   dest->funcName = src->funcName;
-  dest->argSym = src->argSym;
+
+  if (src->ftype)
+    dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
 
   /* if this is a leaf */
   /* if value */
@@ -277,9 +282,6 @@ copyAst (ast * src)
   /* if this is a node that has special values */
   copyAstValues (dest, src);
 
-  if (src->ftype)
-    dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
-
   dest->trueLabel = copySymbol (src->trueLabel);
   dest->falseLabel = copySymbol (src->falseLabel);
   dest->left = copyAst (src->left);
@@ -462,6 +464,7 @@ resolveSymbols (ast * tree)
              tree->opval.val->etype = tree->opval.val->etype;
              tree->opval.val->type = tree->opval.val->sym->type;
              werror (W_IMPLICIT_FUNC, tree->opval.val->sym->name);
+             allocVariables (tree->opval.val->sym);
            }
          else
            {
@@ -539,30 +542,30 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
   /* create the symbol */
   sym = newSymbol (name, 0);
 
+  /* setup return value */
+  sym->type = newLink ();
+  DCL_TYPE (sym->type) = FUNCTION;
+  sym->type->next = copyLinkChain (type);
+  sym->etype = getSpec (sym->type);
+  FUNC_ISREENT(sym->type) = rent;
+
   /* if arguments required */
   if (nArgs)
     {
-
       value *args;
-      args = sym->args = newValue ();
+      args = FUNC_ARGS(sym->type) = newValue ();
 
       while (nArgs--)
        {
          args->type = copyLinkChain (argType);
          args->etype = getSpec (args->type);
+         SPEC_EXTR(args->etype)=1;
          if (!nArgs)
            break;
          args = args->next = newValue ();
        }
     }
 
-  /* setup return value */
-  sym->type = newLink ();
-  DCL_TYPE (sym->type) = FUNCTION;
-  sym->type->next = copyLinkChain (type);
-  sym->etype = getSpec (sym->type);
-  SPEC_RENT (sym->etype) = rent;
-
   /* save it */
   addSymChain (sym);
   sym->cdef = 1;
@@ -571,6 +574,46 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
 
 }
 
+/*-----------------------------------------------------------------*/
+/* funcOfTypeVarg :- function of type with name and argtype        */
+/*-----------------------------------------------------------------*/
+symbol *
+funcOfTypeVarg (char *name, char * rtype, int nArgs , char **atypes)
+{
+  
+    symbol *sym;
+    int i ;
+    /* create the symbol */
+    sym = newSymbol (name, 0);
+    
+    /* setup return value */
+    sym->type = newLink ();
+    DCL_TYPE (sym->type) = FUNCTION;
+    sym->type->next = typeFromStr(rtype);
+    sym->etype = getSpec (sym->type);
+    
+    /* if arguments required */
+    if (nArgs) {
+       value *args;
+       args = FUNC_ARGS(sym->type) = newValue ();
+       
+       for ( i = 0 ; i < nArgs ; i++ ) {
+           args->type = typeFromStr(atypes[i]);
+           args->etype = getSpec (args->type);
+           SPEC_EXTR(args->etype)=1;
+           if ((i + 1) == nArgs) break;
+           args = args->next = newValue ();
+       }
+    }
+    
+    /* save it */
+    addSymChain (sym);
+    sym->cdef = 1;
+    allocVariables (sym);
+    return sym;
+
+}
+
 /*-----------------------------------------------------------------*/
 /* reverseParms - will reverse a parameter tree                    */
 /*-----------------------------------------------------------------*/
@@ -600,20 +643,18 @@ reverseParms (ast * ptree)
 /*-----------------------------------------------------------------*/
 int 
 processParms (ast * func,
-             value * defParm,
+             value *defParm,
              ast * actParm,
-             int *parmNumber,
+             int *parmNumber, // unused, although updated
              bool rightmost)
 {
-  sym_link *fetype = func->etype;
-
   /* if none of them exist */
   if (!defParm && !actParm)
     return 0;
 
   if (defParm) {
     if (getenv("DEBUG_SANITY")) {
-      fprintf (stderr, "addSym: %s ", defParm->name);
+      fprintf (stderr, "processParms: %s ", defParm->name);
     }
     /* make sure the type is complete and sane */
     checkTypeSanity(defParm->etype, defParm->name);
@@ -622,17 +663,15 @@ processParms (ast * func,
   /* if the function is being called via a pointer &   */
   /* it has not been defined a reentrant then we cannot */
   /* have parameters                                   */
-  if (func->type != EX_VALUE && !IS_RENT (fetype) && !options.stackAuto)
+  if (func->type != EX_VALUE && !IFFUNC_ISREENT (func->ftype) && !options.stackAuto)
     {
-      werror (E_NONRENT_ARGS);
+      werror (W_NONRENT_ARGS);
       return 1;
     }
 
   /* if defined parameters ended but actual parameters */
   /* exist and this is not defined as a variable arg   */
-  /* also check if statckAuto option is specified      */
-  if ((!defParm) && actParm && (!func->hasVargs) &&
-      !options.stackAuto && !IS_RENT (fetype))
+  if (!defParm && actParm && !IFFUNC_HASVARARGS(func->ftype))
     {
       werror (E_TOO_MANY_PARMS);
       return 1;
@@ -645,8 +684,13 @@ processParms (ast * func,
       return 1;
     }
 
+  if (IS_VOID(actParm->ftype)) {
+    werror (E_VOID_VALUE_USED);
+    return 1;
+  }
+
   /* If this is a varargs function... */
-  if (!defParm && actParm && func->hasVargs)
+  if (!defParm && actParm && IFFUNC_HASVARARGS(func->ftype))
     {
       ast *newType = NULL;
       sym_link *ftype;
@@ -658,20 +702,7 @@ processParms (ast * func,
          return 0;
        }
 
-      /* The ternary ('?') operator is weird: the ftype of the 
-       * operator is the type of the condition, but it will return a 
-       * (possibly) different type. 
-       */
-      if (IS_TERNARY_OP(actParm))
-      {
-          assert(IS_COLON_OP(actParm->right));
-          assert(actParm->right->left);
-          ftype = actParm->right->left->ftype;
-      }
-      else
-      {
-          ftype = actParm->ftype;
-      }
+      ftype = actParm->ftype;
           
       /* If it's a small integer, upcast to int. */
       if (IS_INTEGRAL (ftype)
@@ -694,7 +725,7 @@ processParms (ast * func,
       if (newType)
        {
          /* cast required; change this op to a cast. */
-         ast *parmCopy = resolveSymbols (copyAst (actParm));
+         ast *parmCopy = decorateType(resolveSymbols (copyAst (actParm)));
 
          actParm->type = EX_OP;
          actParm->opval.op = CAST;
@@ -711,9 +742,9 @@ processParms (ast * func,
     }
 
   /* if defined parameters ended but actual has not & */
-  /* stackAuto                */
+  /* reentrant */
   if (!defParm && actParm &&
-      (options.stackAuto || IS_RENT (fetype)))
+      (options.stackAuto || IFFUNC_ISREENT (func->ftype)))
     return 0;
 
   resolveSymbols (actParm);
@@ -739,21 +770,16 @@ processParms (ast * func,
     }
 
   /* the parameter type must be at least castable */
-  if (checkType (defParm->type, actParm->ftype) == 0)
-    {
-      werror (E_TYPE_MISMATCH_PARM, *parmNumber);
-      werror (E_CONTINUE, "defined type ");
-      printTypeChain (defParm->type, stderr);
-      fprintf (stderr, "\n");
-      werror (E_CONTINUE, "actual type ");
-      printTypeChain (actParm->ftype, stderr);
-      fprintf (stderr, "\n");
-    }
+  if (compareType (defParm->type, actParm->ftype) == 0) {
+    werror (E_INCOMPAT_TYPES);
+    printFromToType (actParm->ftype, defParm->type);
+    return 1;
+  }
 
   /* if the parameter is castable then add the cast */
-  if (checkType (defParm->type, actParm->ftype) < 0)
+  if (compareType (defParm->type, actParm->ftype) < 0)
     {
-      ast *pTree = resolveSymbols (copyAst (actParm));
+      ast *pTree = decorateType(resolveSymbols (copyAst (actParm)));
 
       /* now change the current one to a cast */
       actParm->type = EX_OP;
@@ -762,11 +788,10 @@ processParms (ast * func,
       actParm->right = pTree;
       actParm->etype = defParm->etype;
       actParm->ftype = defParm->type;
+      actParm->decorated=0; /* force typechecking */
+      decorateType (actParm);
     }
 
-/*    actParm->argSym = resolveFromTable(defParm)->sym ; */
-
-  actParm->argSym = defParm->sym;
   /* make a copy and change the regparm type to the defined parm */
   actParm->etype = getSpec (actParm->ftype = copyLinkChain (actParm->ftype));
   SPEC_REGPARM (actParm->etype) = SPEC_REGPARM (defParm->etype);
@@ -796,6 +821,7 @@ ast *
 createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 {
   ast *rast = NULL;
+  ast *lAst;
   symbol *sflds;
   initList *iloop;
 
@@ -810,8 +836,6 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 
   for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
     {
-      ast *lAst;
-
       /* if we have come to end */
       if (!iloop)
        break;
@@ -820,6 +844,12 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist)
       lAst = decorateType (resolveSymbols (lAst));
       rast = decorateType (resolveSymbols (createIval (lAst, sflds->type, iloop, rast)));
     }
+
+  if (iloop) {
+    werror (W_EXCESS_INITIALIZERS, "struct", 
+           sym->opval.val->sym->name, sym->opval.val->sym->lineDef);
+  }
+
   return rast;
 }
 
@@ -833,6 +863,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
   ast *rast = NULL;
   initList *iloop;
   int lcnt = 0, size = 0;
+  literalList *literalL;
 
   /* take care of the special   case  */
   /* array of characters can be init  */
@@ -844,51 +875,77 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 
       return decorateType (resolveSymbols (rast));
 
-  /* not the special case             */
-  if (ilist->type != INIT_DEEP)
+    /* not the special case             */
+    if (ilist->type != INIT_DEEP)
     {
-      werror (E_INIT_STRUCT, "");
-      return NULL;
+       werror (E_INIT_STRUCT, "");
+       return NULL;
     }
 
-  iloop = ilist->init.deep;
-  lcnt = DCL_ELEM (type);
+    iloop = ilist->init.deep;
+    lcnt = DCL_ELEM (type);
 
-  for (;;)
+    if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL))
     {
-      ast *aSym;
-      size++;
-
-      aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size - 1))));
-      aSym = decorateType (resolveSymbols (aSym));
-      rast = createIval (aSym, type->next, iloop, rast);
-      iloop = (iloop ? iloop->next : NULL);
-      if (!iloop)
-       break;
-      /* if not array limits given & we */
-      /* are out of initialisers then   */
-      if (!DCL_ELEM (type) && !iloop)
-       break;
+       ast *aSym;
 
-      /* no of elements given and we    */
-      /* have generated for all of them */
-      if (!--lcnt) {
-       /* if initializers left */
-       if (iloop) {
-         // there has to be a better way
-         char *name=sym->opval.val->sym->name;
-         int lineno=sym->opval.val->sym->lineDef;
-         werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+       aSym = decorateType (resolveSymbols(sym));
+       
+       rast = newNode(ARRAYINIT, aSym, NULL);
+       rast->values.constlist = literalL;
+       
+       // Make sure size is set to length of initializer list.
+       while (iloop)
+       {
+           size++;
+           iloop = iloop->next;
+       }
+       
+       if (lcnt && size > lcnt)
+       {
+           // Array size was specified, and we have more initializers than needed.
+           char *name=sym->opval.val->sym->name;
+           int lineno=sym->opval.val->sym->lineDef;
+           
+           werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
+       }
+    }
+    else
+    {
+       for (;;)
+       {
+           ast *aSym;
+           
+           aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++))));
+           aSym = decorateType (resolveSymbols (aSym));
+           rast = createIval (aSym, type->next, iloop, rast);
+           iloop = (iloop ? iloop->next : NULL);
+           if (!iloop)
+           {
+               break;
+           }
+           
+           /* no of elements given and we    */
+           /* have generated for all of them */
+           if (!--lcnt) 
+           {
+               // there has to be a better way
+               char *name=sym->opval.val->sym->name;
+               int lineno=sym->opval.val->sym->lineDef;
+               werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
+               
+               break;
+           }
        }
-       break;
-      }
     }
 
-  /* if we have not been given a size  */
-  if (!DCL_ELEM (type))
-    DCL_ELEM (type) = size;
+    /* if we have not been given a size  */
+    if (!DCL_ELEM (type))
+    {
+       DCL_ELEM (type) = size;
+    }
 
-  return decorateType (resolveSymbols (rast));
+    return decorateType (resolveSymbols (rast));
 }
 
 
@@ -913,7 +970,6 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
        SPEC_SCLS (iexpr->etype) == S_CODE)
       && IS_ARRAY (iexpr->ftype))
     {
-
       /* for each character generate an assignment */
       /* to the array element */
       char *s = SPEC_CVAL (iexpr->etype).v_char;
@@ -991,6 +1047,7 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
     /* if type is SPECIFIER */
   if (IS_SPEC (type))
     rast = createIvalType (sym, type, ilist);
+  
   if (wid)
     return decorateType (resolveSymbols (newNode (NULLOP, wid, rast)));
   else
@@ -1000,9 +1057,42 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
 /*-----------------------------------------------------------------*/
 /* initAggregates - initialises aggregate variables with initv     */
 /*-----------------------------------------------------------------*/
-ast *
-initAggregates (symbol * sym, initList * ival, ast * wid)
-{
+
+/* this has to go */ void printIval (symbol *, sym_link *, initList *, FILE *);
+
+ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
+  ast *ast;
+  symbol *newSym;
+
+  if (getenv("TRY_THE_NEW_INITIALIZER")) {
+
+    if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
+      fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
+              "with -mmcs51 and --model-large\n");
+      exit(404);
+    }
+
+    if (SPEC_OCLS(sym->etype)==xdata &&
+       getSize(sym->type) > 16) { // else it isn't worth it: do it the old way
+
+      // copy this symbol
+      newSym=copySymbol (sym);
+      SPEC_OCLS(newSym->etype)=code;
+      sprintf (newSym->name, "%s_init__", sym->name);
+      sprintf (newSym->rname,"%s_init__", sym->rname);
+      addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
+
+      // emit it in the static segment
+      addSet(&statsg->syms, newSym);
+
+      // now memcpy() the entire array from cseg
+      ast=newNode (ARRAYINIT, // ASSIGN_AGGREGATE
+                  newAst_VALUE (symbolVal (sym)), 
+                  newAst_VALUE (symbolVal (newSym)));
+      return decorateType(resolveSymbols(ast));
+    }
+  }
+  
   return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
 }
 
@@ -1034,22 +1124,22 @@ gatherAutoInit (symbol * autoChain)
        {
          symbol *newSym;
          
-         // this can only be a constant
-         if (!inInitMode && !IS_LITERAL(sym->ival->init.node->etype)) {
-           werror (E_CONST_EXPECTED);
-         }
-
          /* insert the symbol into the symbol table */
          /* with level = 0 & name = rname       */
          newSym = copySymbol (sym);
-         addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
+         addSym (SymbolTab, newSym, newSym->rname, 0, 0, 1);
 
          /* now lift the code to main */
-         if (IS_AGGREGATE (sym->type))
+         if (IS_AGGREGATE (sym->type)) {
            work = initAggregates (sym, sym->ival, NULL);
-         else
+         } else {
+           if (getNelements(sym->type, sym->ival)>1) {
+             werror (W_EXCESS_INITIALIZERS, "scalar", 
+                     sym->name, sym->lineDef);
+           }
            work = newNode ('=', newAst_VALUE (symbolVal (newSym)),
                            list2expr (sym->ival));
+         }
 
          setAstLineno (work, sym->lineDef);
 
@@ -1065,11 +1155,16 @@ gatherAutoInit (symbol * autoChain)
       /* if there is an initial value */
       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
        {
-         if (IS_AGGREGATE (sym->type))
+         if (IS_AGGREGATE (sym->type)) {
            work = initAggregates (sym, sym->ival, NULL);
-         else
+         } else {
+           if (getNelements(sym->type, sym->ival)>1) {
+             werror (W_EXCESS_INITIALIZERS, "scalar", 
+                     sym->name, sym->lineDef);
+           }
            work = newNode ('=', newAst_VALUE (symbolVal (sym)),
                            list2expr (sym->ival));
+         }
 
          setAstLineno (work, sym->lineDef);
          sym->ival = NULL;
@@ -1138,8 +1233,8 @@ processBlockVars (ast * tree, int *stack, int action)
 
       if (action == ALLOCATE)
        {
-         autoInit = gatherAutoInit (tree->values.sym);
          *stack += allocVariables (tree->values.sym);
+         autoInit = gatherAutoInit (tree->values.sym);
 
          /* if there are auto inits then do them */
          if (autoInit)
@@ -1156,6 +1251,7 @@ processBlockVars (ast * tree, int *stack, int action)
 
 /*-----------------------------------------------------------------*/
 /* constExprValue - returns the value of a constant expression     */
+/*                  or NULL if it is not a constant expression     */
 /*-----------------------------------------------------------------*/
 value *
 constExprValue (ast * cexpr, int check)
@@ -1392,11 +1488,25 @@ astHasSymbol (ast * tree, symbol * sym)
       else
        return FALSE;
     }
-
+  
   return astHasSymbol (tree->left, sym) ||
     astHasSymbol (tree->right, sym);
 }
 
+/*-----------------------------------------------------------------*/
+/* astHasDeref - return true if the ast has an indirect access     */
+/*-----------------------------------------------------------------*/
+static bool 
+astHasDeref (ast * tree)
+{
+  if (!tree || IS_AST_LINK (tree) || IS_AST_VALUE(tree))
+    return FALSE;
+
+  if (tree->opval.op == '*' && tree->right == NULL) return TRUE;
+  
+  return astHasDeref (tree->left) || astHasDeref (tree->right);
+}
+
 /*-----------------------------------------------------------------*/
 /* isConformingBody - the loop body has to conform to a set of rules */
 /* for the loop to be considered reversible read on for rules      */
@@ -1547,6 +1657,8 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
 
       if (astHasVolatile (pbody->left))
        return FALSE;
+      
+      if (astHasDeref(pbody->right)) return FALSE;
 
       return isConformingBody (pbody->left, sym, body) &&
        isConformingBody (pbody->right, sym, body);
@@ -1713,73 +1825,6 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
 
 }
 
-#define DEMAND_INTEGER_PROMOTION
-
-#ifdef DEMAND_INTEGER_PROMOTION
-
-/*-----------------------------------------------------------------*/
-/* walk a tree looking for the leaves. Add a typecast to the given */
-/* type to each value leaf node.           */
-/*-----------------------------------------------------------------*/
-void 
-pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr)
-{
-  if (!node || IS_CALLOP(node))
-    {
-      /* WTF? We should never get here. */
-      return;
-    }
-
-  if (!node->left && !node->right)
-    {
-      /* We're at a leaf; if it's a value, apply the typecast */
-      if (node->type == EX_VALUE && IS_INTEGRAL (TTYPE (node)))
-       {
-         *parentPtr = decorateType (newNode (CAST,
-                                        newAst_LINK (copyLinkChain (type)),
-                                             node));
-       }
-    }
-  else
-    {
-      if (node->left)
-       {
-         pushTypeCastToLeaves (type, node->left, &(node->left));
-       }
-      if (node->right)
-       {
-         pushTypeCastToLeaves (type, node->right, &(node->right));
-       }
-    }
-}
-
-#endif
-
-/*-----------------------------------------------------------------*/
-/* Given an assignment operation in a tree, determine if the LHS   */
-/* (the result) has a different (integer) type than the RHS.     */
-/* If so, walk the RHS and add a typecast to the type of the LHS   */
-/* to all leaf nodes.              */
-/*-----------------------------------------------------------------*/
-void 
-propAsgType (ast * tree)
-{
-#ifdef DEMAND_INTEGER_PROMOTION
-  if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
-    {
-      /* Nothing to do here... */
-      return;
-    }
-
-  if (getSize (LTYPE (tree)) > getSize (RTYPE (tree)))
-    {
-      pushTypeCastToLeaves (LTYPE (tree), tree->right, &(tree->right));
-    }
-#else
-  (void) tree;
-#endif
-}
-
 /*-----------------------------------------------------------------*/
 /* decorateType - compute type for this tree also does type cheking */
 /*          this is done bottom up, since type have to flow upwards */
@@ -1835,11 +1880,6 @@ decorateType (ast * tree)
 
          /* otherwise just copy the type information */
          COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
-         if (funcInChain (tree->opval.val->type))
-           {
-             tree->hasVargs = tree->opval.val->sym->hasVargs;
-             tree->args = copyValueChain (tree->opval.val->sym->args);
-           }
          return tree;
        }
 
@@ -1870,13 +1910,6 @@ decorateType (ast * tree)
 
                  /* and mark it as referenced */
                  tree->opval.val->sym->isref = 1;
-                 /* if this is of type function or function pointer */
-                 if (funcInChain (tree->opval.val->type))
-                   {
-                     tree->hasVargs = tree->opval.val->sym->hasVargs;
-                     tree->args = copyValueChain (tree->opval.val->sym->args);
-
-                   }
                }
            }
        }
@@ -1895,7 +1928,9 @@ decorateType (ast * tree)
     ast *dtl, *dtr;
 
     dtl = decorateType (tree->left);
-    dtr = decorateType (tree->right);
+    /* delay right side for '?' operator since conditional macro expansions might
+       rely on this */
+    dtr = (tree->opval.op == '?' ? tree->right : decorateType (tree->right));
 
     /* this is to take care of situations
        when the tree gets rewritten */
@@ -1909,10 +1944,10 @@ decorateType (ast * tree)
 
   switch (tree->opval.op)
     {
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-      /*        array node          */
-/*----------------------------*/
+           /*------------------------------------------------------------------*/
+           /*----------------------------*/
+           /*        array node          */
+           /*----------------------------*/
     case '[':
 
       /* determine which is the array & which the index */
@@ -1951,10 +1986,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      struct/union          */
-/*----------------------------*/
+      /*----------------------------*/
     case '.':
       /* if this is not a structure */
       if (!IS_STRUCT (LTYPE (tree)))
@@ -1964,14 +1999,14 @@ decorateType (ast * tree)
        }
       TTYPE (tree) = structElemType (LTYPE (tree),
                                     (tree->right->type == EX_VALUE ?
-                              tree->right->opval.val : NULL), &tree->args);
+                              tree->right->opval.val : NULL));
       TETYPE (tree) = getSpec (TTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    struct/union pointer    */
-/*----------------------------*/
+      /*----------------------------*/
     case PTR_OP:
       /* if not pointer to a structure */
       if (!IS_PTR (LTYPE (tree)))
@@ -1988,7 +2023,7 @@ decorateType (ast * tree)
 
       TTYPE (tree) = structElemType (LTYPE (tree)->next,
                                     (tree->right->type == EX_VALUE ?
-                              tree->right->opval.val : NULL), &tree->args);
+                              tree->right->opval.val : NULL));
       TETYPE (tree) = getSpec (TTYPE (tree));
       return tree;
 
@@ -2001,7 +2036,7 @@ decorateType (ast * tree)
       {
        sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree));
        COPYTYPE (TTYPE (tree), TETYPE (tree), ltc);
-       if (!tree->initMode && IS_CONSTANT (TETYPE (tree)))
+       if (!tree->initMode && IS_CONSTANT(TETYPE(tree)))
          werror (E_CODE_WRITE, "++/--");
 
        if (tree->right)
@@ -2023,7 +2058,7 @@ decorateType (ast * tree)
          if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
            {
              werror (E_BITWISE_OP);
-             werror (E_CONTINUE, "left & right types are ");
+             werror (W_CONTINUE, "left & right types are ");
              printTypeChain (LTYPE (tree), stderr);
              fprintf (stderr, ",");
              printTypeChain (RTYPE (tree), stderr);
@@ -2053,30 +2088,10 @@ decorateType (ast * tree)
              return decorateType (otree);
          }
 
-         /* if right or left is literal then result of that type */
-         if (IS_LITERAL (RTYPE (tree)))
-           {
-
-             TTYPE (tree) = copyLinkChain (RTYPE (tree));
-             TETYPE (tree) = getSpec (TTYPE (tree));
-             SPEC_SCLS (TETYPE (tree)) = S_AUTO;
-           }
-         else
-           {
-             if (IS_LITERAL (LTYPE (tree)))
-               {
-                 TTYPE (tree) = copyLinkChain (LTYPE (tree));
-                 TETYPE (tree) = getSpec (TTYPE (tree));
-                 SPEC_SCLS (TETYPE (tree)) = S_AUTO;
+         TTYPE (tree) =
+           computeType (LTYPE (tree), RTYPE (tree));
+         TETYPE (tree) = getSpec (TTYPE (tree));
 
-               }
-             else
-               {
-                 TTYPE (tree) =
-                   computeType (LTYPE (tree), RTYPE (tree));
-                 TETYPE (tree) = getSpec (TTYPE (tree));
-               }
-           }
          LRVAL (tree) = RRVAL (tree) = 1;
          return tree;
        }
@@ -2090,7 +2105,7 @@ decorateType (ast * tree)
       /* if bit field then error */
       if (IS_BITVAR (tree->left->etype))
        {
-         werror (E_ILLEGAL_ADDR, "addrress of bit variable");
+         werror (E_ILLEGAL_ADDR, "address of bit variable");
          goto errorTreeReturn;
        }
 
@@ -2106,7 +2121,13 @@ decorateType (ast * tree)
          goto errorTreeReturn;
        }
 
-      if (LRVAL (tree))
+      if (IS_LITERAL(LTYPE(tree)))
+       {
+         werror (E_ILLEGAL_ADDR, "address of literal");
+         goto errorTreeReturn;
+       }
+
+     if (LRVAL (tree))
        {
          werror (E_LVALUE_REQUIRED, "address of");
          goto errorTreeReturn;
@@ -2124,8 +2145,10 @@ decorateType (ast * tree)
        DCL_TYPE (p) = IPOINTER;
       else if (SPEC_SCLS (tree->left->etype) == S_EEPROM)
        DCL_TYPE (p) = EEPPOINTER;
+      else if (SPEC_OCLS(tree->left->etype))
+         DCL_TYPE (p) = PTR_TYPE(SPEC_OCLS(tree->left->etype));
       else
-       DCL_TYPE (p) = POINTER;
+         DCL_TYPE (p) = POINTER;
 
       if (IS_AST_SYM_VALUE (tree->left))
        {
@@ -2161,7 +2184,7 @@ decorateType (ast * tree)
       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
        {
          werror (E_BITWISE_OP);
-         werror (E_CONTINUE, "left & right types are ");
+         werror (W_CONTINUE, "left & right types are ");
          printTypeChain (LTYPE (tree), stderr);
          fprintf (stderr, ",");
          printTypeChain (RTYPE (tree), stderr);
@@ -2223,7 +2246,7 @@ decorateType (ast * tree)
       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
        {
          werror (E_BITWISE_OP);
-         werror (E_CONTINUE, "left & right types are ");
+         werror (W_CONTINUE, "left & right types are ");
          printTypeChain (LTYPE (tree), stderr);
          fprintf (stderr, ",");
          printTypeChain (RTYPE (tree), stderr);
@@ -2268,9 +2291,7 @@ decorateType (ast * tree)
            }
          TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
                                        LTYPE (tree)->next : NULL);
-         TETYPE (tree) = getSpec (TTYPE (tree));
-         tree->args = tree->left->args;
-         tree->hasVargs = tree->left->hasVargs;
+         TETYPE (tree) = getSpec (TTYPE (tree));
          SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
          return tree;
        }
@@ -2582,7 +2603,7 @@ decorateType (ast * tree)
       if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (tree->left->etype))
        {
          werror (E_SHIFT_OP_INVALID);
-         werror (E_CONTINUE, "left & right types are ");
+         werror (W_CONTINUE, "left & right types are ");
          printTypeChain (LTYPE (tree), stderr);
          fprintf (stderr, ",");
          printTypeChain (RTYPE (tree), stderr);
@@ -2628,10 +2649,10 @@ decorateType (ast * tree)
        }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*         casting            */
-/*----------------------------*/
+      /*----------------------------*/
     case CAST:                 /* change the type   */
       /* cannot cast to an aggregate type */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -2643,24 +2664,57 @@ decorateType (ast * tree)
       /* make sure the type is complete and sane */
       checkTypeSanity(LETYPE(tree), "(cast)");
 
+#if 0
       /* if the right is a literal replace the tree */
-      if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree)))
-       {
-         tree->type = EX_VALUE;
-         tree->opval.val =
-           valCastLiteral (LTYPE (tree),
-                           floatFromVal (valFromType (RETYPE (tree))));
-         tree->left = NULL;
-         tree->right = NULL;
-         TTYPE (tree) = tree->opval.val->type;
-         tree->values.literalFromCast = 1;
-       }
-      else
-       {
-         TTYPE (tree) = LTYPE (tree);
-         LRVAL (tree) = 1;
-       }
-
+      if (IS_LITERAL (RETYPE (tree))) {
+             if (!IS_PTR (LTYPE (tree))) {
+                     tree->type = EX_VALUE;
+                     tree->opval.val =
+                             valCastLiteral (LTYPE (tree),
+                                             floatFromVal (valFromType (RETYPE (tree))));
+                     tree->left = NULL;
+                     tree->right = NULL;
+                     TTYPE (tree) = tree->opval.val->type;
+                     tree->values.literalFromCast = 1;
+             } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) && 
+                        ((int)floatFromVal(valFromType(RETYPE(tree)))) !=0 ) /* special case of NULL */  {
+                     sym_link *rest = LTYPE(tree)->next;
+                     werror(W_LITERAL_GENERIC);                      
+                     TTYPE(tree) = newLink();
+                     DCL_TYPE(TTYPE(tree)) = FPOINTER;
+                     TTYPE(tree)->next = rest;
+                     tree->left->opval.lnk = TTYPE(tree);
+                     LRVAL (tree) = 1;
+             } else {
+                     TTYPE (tree) = LTYPE (tree);
+                     LRVAL (tree) = 1;
+             }
+      } else {
+             TTYPE (tree) = LTYPE (tree);
+             LRVAL (tree) = 1;
+      }
+#else
+      /* if pointer to struct then check names */
+      if (IS_PTR(LTYPE(tree)) && IS_STRUCT(LTYPE(tree)->next) &&
+         IS_PTR(RTYPE(tree)) && IS_STRUCT(RTYPE(tree)->next) &&
+         strcmp(SPEC_STRUCT(LETYPE(tree))->tag,SPEC_STRUCT(RETYPE(tree))->tag)) {
+             werror(W_CAST_STRUCT_PTR,SPEC_STRUCT(RETYPE(tree))->tag,SPEC_STRUCT(LETYPE(tree))->tag);
+      }
+      /* if the right is a literal replace the tree */
+      if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree))) {
+       tree->type = EX_VALUE;
+       tree->opval.val =
+         valCastLiteral (LTYPE (tree),
+                         floatFromVal (valFromType (RETYPE (tree))));
+       tree->left = NULL;
+       tree->right = NULL;
+       TTYPE (tree) = tree->opval.val->type;
+       tree->values.literalFromCast = 1;
+      } else {
+       TTYPE (tree) = LTYPE (tree);
+       LRVAL (tree) = 1;
+      }
+#endif      
       TETYPE (tree) = getSpec (TTYPE (tree));
 
       return tree;
@@ -2725,7 +2779,7 @@ decorateType (ast * tree)
       /* if they are pointers they must be castable */
       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)))
        {
-         if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+         if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
            {
              werror (E_COMPARE_OP);
              fprintf (stderr, "comparing type ");
@@ -2742,7 +2796,7 @@ decorateType (ast * tree)
          if (!((IS_PTR (LTYPE (tree)) && IS_LITERAL (RTYPE (tree))) ||
                (IS_PTR (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))))
 
-           if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+           if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
              {
                werror (E_COMPARE_OP);
                fprintf (stderr, "comparing type ");
@@ -2786,19 +2840,104 @@ decorateType (ast * tree)
                               tree->opval.val->type);
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
+      /*             typeof         */
+      /*----------------------------*/
+    case TYPEOF:
+       /* return typeof enum value */
+       tree->type = EX_VALUE;
+       {
+           int typeofv = 0;
+           if (IS_SPEC(tree->right->ftype)) {
+               switch (SPEC_NOUN(tree->right->ftype)) {
+               case V_INT:
+                   if (SPEC_LONG(tree->right->ftype)) typeofv = TYPEOF_LONG;
+                   else typeofv = TYPEOF_INT;
+                   break;
+               case V_FLOAT:
+                   typeofv = TYPEOF_FLOAT;
+                   break;
+               case V_CHAR:
+                   typeofv = TYPEOF_CHAR;
+                   break;
+               case V_VOID:
+                   typeofv = TYPEOF_VOID;
+                   break;
+               case V_STRUCT:
+                   typeofv = TYPEOF_STRUCT;
+                   break;
+               case V_BIT:
+                   typeofv = TYPEOF_BIT;
+                   break;
+               case V_SBIT:
+                   typeofv = TYPEOF_SBIT;
+                   break;
+               default:
+                   break;
+               }
+           } else {
+               switch (DCL_TYPE(tree->right->ftype)) {
+               case POINTER:
+                   typeofv = TYPEOF_POINTER;
+                   break;
+               case FPOINTER:
+                   typeofv = TYPEOF_FPOINTER;
+                   break;
+               case CPOINTER:
+                   typeofv = TYPEOF_CPOINTER;
+                   break;
+               case GPOINTER:
+                   typeofv = TYPEOF_GPOINTER;
+                   break;
+               case PPOINTER:
+                   typeofv = TYPEOF_PPOINTER;
+                   break;
+               case IPOINTER:
+                   typeofv = TYPEOF_IPOINTER;
+                   break;
+               case ARRAY:
+                   typeofv = TYPEOF_ARRAY;
+                   break;
+               case FUNCTION:
+                   typeofv = TYPEOF_FUNCTION;
+                   break;
+               default:
+                   break;
+               }
+           }
+           sprintf (buffer, "%d", typeofv);
+           tree->opval.val = constVal (buffer);
+           tree->right = tree->left = NULL;
+           TETYPE (tree) = getSpec (TTYPE (tree) =
+                                    tree->opval.val->type);
+       }
+       return tree;
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /* conditional operator  '?'  */
-/*----------------------------*/
+      /*----------------------------*/
     case '?':
-      /* the type is one on the left */
-      TTYPE (tree) = LTYPE (tree);
-      TETYPE (tree) = getSpec (TTYPE (tree));
+      /* the type is value of the colon operator (on the right) */
+      assert(IS_COLON_OP(tree->right));
+      /* if already known then replace the tree : optimizer will do it
+        but faster to do it here */
+      if (IS_LITERAL (LTYPE(tree))) {    
+         if ( ((int) floatFromVal (valFromType (LETYPE (tree)))) != 0) {
+             return decorateType(tree->right->left) ;
+         } else {
+             return decorateType(tree->right->right) ;
+         }
+      } else {
+         tree->right = decorateType(tree->right);
+         TTYPE (tree) = RTYPE(tree);
+         TETYPE (tree) = getSpec (TTYPE (tree));
+      }
       return tree;
 
     case ':':
       /* if they don't match we have a problem */
-      if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+      if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
        {
          werror (E_TYPE_MISMATCH, "conditional operator", " ");
          goto errorTreeReturn;
@@ -2835,8 +2974,6 @@ decorateType (ast * tree)
        }
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
     case AND_ASSIGN:
@@ -2864,8 +3001,6 @@ decorateType (ast * tree)
        }
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -2901,8 +3036,6 @@ decorateType (ast * tree)
        }
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -2946,8 +3079,6 @@ decorateType (ast * tree)
       tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
       tree->opval.op = '=';
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -2963,7 +3094,7 @@ decorateType (ast * tree)
        }
 
       /* they should either match or be castable */
-      if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+      if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
        {
          werror (E_TYPE_MISMATCH, "assignment", " ");
          fprintf (stderr, "type --> '");
@@ -2980,20 +3111,7 @@ decorateType (ast * tree)
       if (IS_VOID (LTYPE (tree)))
        {
          werror (E_CAST_ZERO);
-         fprintf (stderr, "type --> '");
-         printTypeChain (RTYPE (tree), stderr);
-         fprintf (stderr, "' ");
-         fprintf (stderr, "assigned to type --> '");
-         printTypeChain (LTYPE (tree), stderr);
-         fprintf (stderr, "'\n");
-       }
-
-      /* extra checks for pointer types */
-      if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)) &&
-         !IS_GENPTR (LTYPE (tree)))
-       {
-         if (DCL_TYPE (LTYPE (tree)) != DCL_TYPE (RTYPE (tree)))
-           werror (W_PTR_ASSIGN);
+         printFromToType(RTYPE(tree), LTYPE(tree));
        }
 
       TETYPE (tree) = getSpec (TTYPE (tree) =
@@ -3001,9 +3119,8 @@ decorateType (ast * tree)
       RRVAL (tree) = 1;
       LLVAL (tree) = 1;
       if (!tree->initMode ) {
-             if (IS_CONSTANT (LETYPE (tree))) {
-                     werror (E_CODE_WRITE, " ");
-             } 
+       if ((IS_SPEC(LETYPE(tree)) && IS_CONSTANT (LETYPE (tree))))
+         werror (E_CODE_WRITE, " ");
       }
       if (LRVAL (tree))
        {
@@ -3011,8 +3128,6 @@ decorateType (ast * tree)
          goto errorTreeReturn;
        }
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3031,17 +3146,19 @@ decorateType (ast * tree)
       parmNumber = 1;
 
       if (processParms (tree->left,
-                       tree->left->args,
-                       tree->right, &parmNumber, TRUE))
+                       FUNC_ARGS(tree->left->ftype),
+                       tree->right, &parmNumber, TRUE)) {
        goto errorTreeReturn;
+      }
 
-      if (options.stackAuto || IS_RENT (LETYPE (tree)))
+      if ((options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) && 
+         !IFFUNC_ISBUILTIN(LTYPE(tree)))
        {
-         tree->left->args = reverseVal (tree->left->args);
+         //FUNC_ARGS(tree->left->ftype) = 
+         //reverseVal (FUNC_ARGS(tree->left->ftype));
          reverseParms (tree->right);
        }
 
-      tree->args = tree->left->args;
       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
       return tree;
 
@@ -3053,9 +3170,10 @@ decorateType (ast * tree)
       if (!tree->right)
        goto voidcheck;
 
-      if (checkType (currFunc->type->next, RTYPE (tree)) == 0)
+      if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
        {
-         werror (E_RETURN_MISMATCH);
+         werror (W_RETURN_MISMATCH);
+         printFromToType (RTYPE(tree), currFunc->type->next);
          goto errorTreeReturn;
        }
 
@@ -3068,21 +3186,12 @@ decorateType (ast * tree)
        }
 
       /* if there is going to be a casing required then add it */
-      if (checkType (currFunc->type->next, RTYPE (tree)) < 0)
+      if (compareType (currFunc->type->next, RTYPE (tree)) < 0)
        {
-#if 0 && defined DEMAND_INTEGER_PROMOTION
-         if (IS_INTEGRAL (currFunc->type->next))
-           {
-             pushTypeCastToLeaves (currFunc->type->next, tree->right, &(tree->right));
-           }
-         else
-#endif
-           {
-             tree->right =
-               decorateType (newNode (CAST,
-                        newAst_LINK (copyLinkChain (currFunc->type->next)),
-                                      tree->right));
-           }
+         tree->right =
+           decorateType (newNode (CAST,
+                          newAst_LINK (copyLinkChain (currFunc->type->next)),
+                                  tree->right));
        }
 
       RRVAL (tree) = 1;
@@ -3464,8 +3573,12 @@ createIf (ast * condAst, ast * ifBody, ast * elseBody)
   symbol *ifTrue, *ifFalse, *ifEnd;
 
   /* if neither exists */
-  if (!elseBody && !ifBody)
-    return condAst;
+  if (!elseBody && !ifBody) {
+    // if there are no side effects (i++, j() etc)
+    if (!hasSEFcalls(condAst)) {
+      return condAst;
+    }
+  }
 
   /* create the labels */
   sprintf (buffer, "_iffalse_%d", Lblnum);
@@ -3903,6 +4016,63 @@ optimizeCompare (ast * root)
   vright = (root->right->type == EX_VALUE ?
            root->right->opval.val : NULL);
 
+  //#define EXPERIMENTAL
+#ifdef EXPERIMENTAL
+  /* if left is unsigned and right is literal */
+  if (vleft && vright && 
+      IS_UNSIGNED(vleft->etype) &&
+      IS_LITERAL(vright->etype)) {
+    double dval=floatFromVal(vright);
+    int op=root->opval.op;
+
+    fprintf (stderr,"op: '");
+    switch (op) {
+    case LE_OP: fprintf (stderr, "<= '"); break;
+    case EQ_OP: fprintf (stderr, "== '"); break;
+    case GE_OP: fprintf (stderr, ">= '"); break;
+    default: fprintf (stderr, "%c '", op); break;
+    }
+    fprintf (stderr, "%f\n", dval);
+
+    switch (op)
+      {
+      case EQ_OP:
+      case LE_OP:
+      case '<':
+       if (dval<0 || (op=='<' && dval==0)) {
+         // unsigned is never < 0
+         werror (W_IF_NEVER_TRUE);
+         optExpr = newAst_VALUE (constVal("0"));
+         return decorateType (optExpr);
+       }
+       if (dval==0) {
+         if (op==LE_OP) {
+           // change this into a cheaper EQ_OP
+           fprintf (stderr, "warning *** changed '<=' to '==' because of unsigned\n");
+           root->opval.op=EQ_OP;
+           return root;
+         }
+       }
+       break;
+      case GE_OP:
+      case '>':
+       if (dval>0 || (op==GE_OP && dval==0)) {
+         // unsigned is never < 0
+         werror (W_IF_ALWAYS_TRUE);
+         optExpr = newAst_VALUE (constVal("1"));
+         return decorateType (optExpr);
+       }
+       if (dval==0) {
+         if (op=='>') {
+           // change this into a cheaper reversed EQ_OP
+           fprintf (stderr, "warning *** changed '>' to '!=' because of unsigned\n");
+           root->opval.op=EQ_OP;
+         }
+       }
+      }
+  }
+#endif
+
   /* if left is a BITVAR in BITSPACE */
   /* and right is a LITERAL then opt- */
   /* imize else do nothing       */
@@ -4043,8 +4213,11 @@ createFunction (symbol * name, ast * body)
   sym_link *fetype;
   iCode *piCode = NULL;
 
+  if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
+    fprintf (stderr, "SDCCast.c:createFunction(%s)\n", name->name);
+
   /* if check function return 0 then some problem */
-  if (checkFunction (name) == 0)
+  if (checkFunction (name, NULL) == 0)
     return NULL;
 
   /* create a dummy block if none exists */
@@ -4073,27 +4246,26 @@ createFunction (symbol * name, ast * body)
     }
   name->lastLine = yylineno;
   currFunc = name;
-  processFuncArgs (currFunc, 0);
 
   /* set the stack pointer */
   /* PENDING: check this for the mcs51 */
   stackPtr = -port->stack.direction * port->stack.call_overhead;
-  if (IS_ISR (name->etype))
+  if (IFFUNC_ISISR (name->type))
     stackPtr -= port->stack.direction * port->stack.isr_overhead;
-  if (IS_RENT (name->etype) || options.stackAuto)
+  if (IFFUNC_ISREENT (name->type) || options.stackAuto)
     stackPtr -= port->stack.direction * port->stack.reent_overhead;
 
   xstackPtr = -port->stack.direction * port->stack.call_overhead;
 
   fetype = getSpec (name->type);       /* get the specifier for the function */
   /* if this is a reentrant function then */
-  if (IS_RENT (fetype))
+  if (IFFUNC_ISREENT (name->type))
     reentrant++;
 
-  allocParms (name->args);     /* allocate the parameters */
+  allocParms (FUNC_ARGS(name->type));  /* allocate the parameters */
 
   /* do processing for parameters that are passed in registers */
-  processRegParms (name->args, body);
+  processRegParms (FUNC_ARGS(name->type), body);
 
   /* set the stack pointer */
   stackPtr = 0;
@@ -4114,10 +4286,11 @@ createFunction (symbol * name, ast * body)
   body = resolveSymbols (body);        /* resolve the symbols */
   body = decorateType (body);  /* propagateType & do semantic checks */
 
-  ex = newAst_VALUE (symbolVal (name));                /* create name       */
+  ex = newAst_VALUE (symbolVal (name));        /* create name */
   ex = newNode (FUNCTION, ex, body);
-  ex->values.args = name->args;
-
+  ex->values.args = FUNC_ARGS(name->type);
+  ex->decorated=1;
+  if (options.dump_tree) PA(ex);
   if (fatalError)
     {
       werror (E_FUNC_NO_CODE, name->name);
@@ -4151,20 +4324,20 @@ skipall:
   /* dealloc the block variables */
   processBlockVars (body, &stack, DEALLOCATE);
   /* deallocate paramaters */
-  deallocParms (name->args);
+  deallocParms (FUNC_ARGS(name->type));
 
-  if (IS_RENT (fetype))
+  if (IFFUNC_ISREENT (name->type))
     reentrant--;
 
   /* we are done freeup memory & cleanup */
   noLineno--;
   labelKey = 1;
   name->key = 0;
-  name->fbody = 1;
+  FUNC_HASBODY(name->type) = 1;
   addSet (&operKeyReset, name);
   applyToSet (operKeyReset, resetParmKey);
 
-  if (options.debug && !options.nodebug)
+  if (options.debug)
     cdbStructBlock (1, cdbFile);
 
   cleanUpLevel (LabelTab, 0);
@@ -4207,25 +4380,40 @@ void ast_print (ast * tree, FILE *outfile, int indent)
        }
        
        if (tree->opval.op == FUNCTION) {
-               fprintf(outfile,"FUNCTION (%p) type (",tree);
+               int arg=0;
+               value *args=FUNC_ARGS(tree->left->opval.val->type);
+               fprintf(outfile,"FUNCTION (%s=%p) type (", 
+                       tree->left->opval.val->name, tree);
                printTypeChain (tree->ftype,outfile);
+               fprintf(outfile,") args (");
+               do {
+                 if (arg) {
+                   fprintf (outfile, ", ");
+                 }
+                 printTypeChain (args ? args->type : NULL, outfile);
+                 arg++;
+                 args= args ? args->next : NULL;
+               } while (args);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent);
+               ast_print(tree->right,outfile,indent);
                return ;
        }
        if (tree->opval.op == BLOCK) {
                symbol *decls = tree->values.sym;
+               INDENT(indent,outfile);
                fprintf(outfile,"{\n");
                while (decls) {
-                       INDENT(indent+4,outfile);
-                       fprintf(outfile,"DECLARE SYMBOL %s, type(",decls->name);
+                       INDENT(indent+2,outfile);
+                       fprintf(outfile,"DECLARE SYMBOL (%s=%p) type (",
+                               decls->name, decls);
                        printTypeChain(decls->type,outfile);
                        fprintf(outfile,")\n");
                        
                        decls = decls->next;                    
                }
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+2);
+               INDENT(indent,outfile);
                fprintf(outfile,"}\n");
                return;
        }
@@ -4258,7 +4446,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        } else {
                                fprintf(outfile,"SYMBOL ");
                        }
-                       fprintf(outfile,"(%p) name= %s ",tree,tree->opval.val->sym->name);
+                       fprintf(outfile,"(%s=%p)",
+                               tree->opval.val->sym->name,tree);
                }
                if (tree->ftype) {
                        fprintf(outfile," type (");
@@ -4290,8 +4479,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"ARRAY_OP (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
 
                /*------------------------------------------------------------------*/
@@ -4302,8 +4491,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"STRUCT_ACCESS (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
 
                /*------------------------------------------------------------------*/
@@ -4314,8 +4503,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"PTR_ACCESS (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
 
                /*------------------------------------------------------------------*/
@@ -4326,14 +4515,14 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"INC_OP (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
 
        case DEC_OP:
                fprintf(outfile,"DEC_OP (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
 
                /*------------------------------------------------------------------*/
@@ -4345,14 +4534,14 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"& (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
-                       ast_print(tree->right,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
+                       ast_print(tree->right,outfile,indent+2);
                } else {
                        fprintf(outfile,"ADDRESS_OF (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
-                       ast_print(tree->right,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
+                       ast_print(tree->right,outfile,indent+2);
                }
                return ;
                /*----------------------------*/
@@ -4362,8 +4551,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"OR (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4373,8 +4562,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"XOR (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                
                /*------------------------------------------------------------------*/
@@ -4385,8 +4574,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"DIV (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4396,8 +4585,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"MOD (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
 
                /*------------------------------------------------------------------*/
@@ -4409,7 +4598,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"DEREF (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
                        return ;
                }                       
                /*------------------------------------------------------------------*/
@@ -4419,8 +4608,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"MULT (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
 
 
@@ -4434,7 +4623,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"UPLUS (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
                } else {
                        /*------------------------------------------------------------------*/
                        /*----------------------------*/
@@ -4443,8 +4632,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"ADD (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
-                       ast_print(tree->right,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
+                       ast_print(tree->right,outfile,indent+2);
                }
                return;
                /*------------------------------------------------------------------*/
@@ -4456,7 +4645,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"UMINUS (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
                } else {
                        /*------------------------------------------------------------------*/
                        /*----------------------------*/
@@ -4465,8 +4654,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"SUB (%p) type (",tree);
                        printTypeChain(tree->ftype,outfile);
                        fprintf(outfile,")\n");
-                       ast_print(tree->left,outfile,indent+4);
-                       ast_print(tree->right,outfile,indent+4);
+                       ast_print(tree->left,outfile,indent+2);
+                       ast_print(tree->right,outfile,indent+2);
                }
                return;
                /*------------------------------------------------------------------*/
@@ -4477,7 +4666,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"COMPL (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4487,7 +4676,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"NOT (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4497,59 +4686,61 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"RRC (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
 
        case RLC:
                fprintf(outfile,"RLC (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
        case GETHBIT:
                fprintf(outfile,"GETHBIT (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
        case LEFT_OP:
                fprintf(outfile,"LEFT_SHIFT (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case RIGHT_OP:
                fprintf(outfile,"RIGHT_SHIFT (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
                /*         casting            */
                /*----------------------------*/
        case CAST:                      /* change the type   */
-               fprintf(outfile,"CAST (%p) type (",tree);
+               fprintf(outfile,"CAST (%p) from type (",tree);
+               printTypeChain(tree->right->ftype,outfile);
+               fprintf(outfile,") to type (");
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                
        case AND_OP:
                fprintf(outfile,"ANDAND (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case OR_OP:
                fprintf(outfile,"OROR (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                
                /*------------------------------------------------------------------*/
@@ -4560,43 +4751,43 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"GT(>) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case '<':
                fprintf(outfile,"LT(<) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case LE_OP:
                fprintf(outfile,"LE(<=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case GE_OP:
                fprintf(outfile,"GE(>=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case EQ_OP:
                fprintf(outfile,"EQ(==) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
        case NE_OP:
                fprintf(outfile,"NE(!=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                /*------------------------------------------------------------------*/
                /*----------------------------*/
                /*             sizeof         */
@@ -4613,15 +4804,16 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"QUEST(?) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
+               return;
 
        case ':':
                fprintf(outfile,"COLON(:) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                
                /*------------------------------------------------------------------*/
@@ -4632,50 +4824,50 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"MULASS(*=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case DIV_ASSIGN:
                fprintf(outfile,"DIVASS(/=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case AND_ASSIGN:
                fprintf(outfile,"ANDASS(&=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case OR_ASSIGN:
                fprintf(outfile,"ORASS(*=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case XOR_ASSIGN:
                fprintf(outfile,"XORASS(*=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case RIGHT_ASSIGN:
                fprintf(outfile,"RSHFTASS(>>=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case LEFT_ASSIGN:
                fprintf(outfile,"LSHFTASS(*=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4685,8 +4877,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"SUBASS(-=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4696,8 +4888,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"ADDASS(+=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4707,8 +4899,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"ASSIGN(=) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;     
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4718,8 +4910,8 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"COMMA(,) (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4730,15 +4922,14 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"CALL (%p) type (",tree);
                printTypeChain(tree->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->left,outfile,indent+4);
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
+               ast_print(tree->right,outfile,indent+2);
                return;
        case PARAM:
-               fprintf(outfile,"PARM ");
-               ast_print(tree->left,outfile,indent+4);
-               if (tree->right && !IS_AST_PARAM(tree->right)) {
-                       fprintf(outfile,"PARM ");
-                       ast_print(tree->right,outfile,indent+4);
+               fprintf(outfile,"PARMS\n");
+               ast_print(tree->left,outfile,indent+2);
+               if (tree->right /*&& !IS_AST_PARAM(tree->right)*/) {
+                       ast_print(tree->right,outfile,indent+2);
                }
                return ;
                /*------------------------------------------------------------------*/
@@ -4749,15 +4940,15 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                fprintf(outfile,"RETURN (%p) type (",tree);
                printTypeChain(tree->right->ftype,outfile);
                fprintf(outfile,")\n");
-               ast_print(tree->right,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
                /*     label statement        */
                /*----------------------------*/
        case LABEL :
-               fprintf(outfile,"LABEL (%p)",tree);
-               ast_print(tree->left,outfile,indent+4);
+               fprintf(outfile,"LABEL (%p)\n",tree);
+               ast_print(tree->left,outfile,indent+2);
                ast_print(tree->right,outfile,indent);
                return;
                /*------------------------------------------------------------------*/
@@ -4770,7 +4961,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                        fprintf(outfile,"SWITCH (%p) ",tree);
                        ast_print(tree->left,outfile,0);
                        for (val = tree->values.switchVals.swVals; val ; val = val->next) {
-                               INDENT(indent+4,outfile);
+                               INDENT(indent+2,outfile);
                                fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",
                                        (int) floatFromVal(val),
                                        tree->values.switchVals.swNum,
@@ -4784,18 +4975,17 @@ void ast_print (ast * tree, FILE *outfile, int indent)
                /* ifx Statement              */
                /*----------------------------*/
        case IFX:
-               ast_print(tree->left,outfile,indent);
-               INDENT(indent,outfile);
                fprintf(outfile,"IF (%p) \n",tree);
+               ast_print(tree->left,outfile,indent+2);
                if (tree->trueLabel) {
                        INDENT(indent,outfile);
-                       fprintf(outfile,"NE(==) 0 goto %s\n",tree->trueLabel->name);
+                       fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name);
                }
                if (tree->falseLabel) {
                        INDENT(indent,outfile);
                        fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name);
                }
-               ast_print(tree->right,outfile,indent);
+               ast_print(tree->right,outfile,indent+2);
                return ;
                /*------------------------------------------------------------------*/
                /*----------------------------*/
@@ -4804,22 +4994,22 @@ void ast_print (ast * tree, FILE *outfile, int indent)
        case FOR:
                fprintf(outfile,"FOR (%p) \n",tree);
                if (AST_FOR( tree, initExpr)) {
-                       INDENT(indent+4,outfile);
+                       INDENT(indent+2,outfile);
                        fprintf(outfile,"INIT EXPR ");
-                       ast_print(AST_FOR(tree, initExpr),outfile,indent+4);
+                       ast_print(AST_FOR(tree, initExpr),outfile,indent+2);
                }
                if (AST_FOR( tree, condExpr)) {
-                       INDENT(indent+4,outfile);
+                       INDENT(indent+2,outfile);
                        fprintf(outfile,"COND EXPR ");
-                       ast_print(AST_FOR(tree, condExpr),outfile,indent+4);
+                       ast_print(AST_FOR(tree, condExpr),outfile,indent+2);
                }
                if (AST_FOR( tree, loopExpr)) {
-                       INDENT(indent+4,outfile);
+                       INDENT(indent+2,outfile);
                        fprintf(outfile,"LOOP EXPR ");
-                       ast_print(AST_FOR(tree, loopExpr),outfile,indent+4);
+                       ast_print(AST_FOR(tree, loopExpr),outfile,indent+2);
                }
                fprintf(outfile,"FOR LOOP BODY \n");
-               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->left,outfile,indent+2);
                return ;
        default:
            return ;
@@ -4828,5 +5018,5 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 
 void PA(ast *t)
 {
-       ast_print(t,stdout,1);
+       ast_print(t,stdout,0);
 }