X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=cd93f35b4f4173b883b0006b587c5d19843a4fe7;hb=332b292efce162f00db0c6dfe2a444d38c601b04;hp=c497d19bc41f979dbb99c32fbffde1b78da12a29;hpb=a4578248eab1e359e4cc86eafd6fb48166e53f1d;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index c497d19b..cd93f35b 100644
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -23,7 +23,6 @@
 -------------------------------------------------------------------------*/
 
 #include "common.h"
-#include "newalloc.h"
 
 int currLineno = 0;
 set *astList = NULL;
@@ -46,15 +45,15 @@ int labelKey = 1;
 #define ALLOCATE 1
 #define DEALLOCATE 2
 
-char buffer[1024];
 int noLineno = 0;
 int noAlloc = 0;
 symbol *currFunc;
-ast *createIval (ast *, sym_link *, initList *, ast *);
-ast *createIvalCharPtr (ast *, sym_link *, ast *);
+static ast *createIval (ast *, sym_link *, initList *, ast *);
+static 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;
@@ -67,51 +66,15 @@ ptt (ast * tree)
 
 
 /*-----------------------------------------------------------------*/
-/* newAst - creates a fresh node for an expression tree           */
+/* newAst - creates a fresh node for an expression tree            */
 /*-----------------------------------------------------------------*/
-#if 0
-ast *
-newAst (int type, void *op)
-{
-  ast *ex;
-  static int oldLineno = 0;
-
-  Safe_calloc (1, ex, sizeof (ast));
-
-  ex->type = type;
-  ex->lineno = (noLineno ? oldLineno : yylineno);
-  ex->filename = currFname;
-  ex->level = NestLevel;
-  ex->block = currBlockno;
-  ex->initMode = inInitMode;
-
-  /* depending on the type */
-  switch (type)
-    {
-    case EX_VALUE:
-      ex->opval.val = (value *) op;
-      break;
-    case EX_OP:
-      ex->opval.op = (long) op;
-      break;
-    case EX_LINK:
-      ex->opval.lnk = (sym_link *) op;
-      break;
-    case EX_STMNT:
-      ex->opval.stmnt = (unsigned) op;
-    }
-
-  return ex;
-}
-#endif
-
 static ast *
 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);
@@ -222,7 +185,7 @@ 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;
 
@@ -253,13 +216,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 */
@@ -281,9 +246,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);
@@ -466,6 +428,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
 	    {
@@ -500,38 +463,6 @@ setAstLineno (ast * tree, int lineno)
   return 0;
 }
 
-#if 0
-/* this functions seems to be superfluous?! kmh */
-
-/*-----------------------------------------------------------------*/
-/* resolveFromTable - will return the symbal table value           */
-/*-----------------------------------------------------------------*/
-value *
-resolveFromTable (value * val)
-{
-  symbol *csym;
-
-  if (!val->sym)
-    return val;
-
-  csym = findSymWithLevel (SymbolTab, val->sym);
-
-  /* if found in the symbol table & they r not the same */
-  if (csym && val->sym != csym &&
-      csym->level == val->sym->level &&
-      csym->_isparm &&
-      !csym->ismyparm)
-    {
-
-      val->sym = csym;
-      val->type = csym->type;
-      val->etype = csym->etype;
-    }
-
-  return val;
-}
-#endif
-
 /*-----------------------------------------------------------------*/
 /* funcOfType :- function of type with name                        */
 /*-----------------------------------------------------------------*/
@@ -543,30 +474,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;
@@ -575,10 +506,50 @@ 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                    */
 /*-----------------------------------------------------------------*/
-void 
+static void 
 reverseParms (ast * ptree)
 {
   ast *ttree;
@@ -604,20 +575,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);
@@ -626,17 +595,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;
@@ -649,8 +616,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;
@@ -662,20 +634,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)
@@ -687,18 +646,18 @@ processParms (ast * func,
       if (IS_PTR(ftype) && !IS_GENPTR(ftype))
 	{
 	  newType = newAst_LINK (copyLinkChain(ftype));
-	  DCL_TYPE (newType->opval.lnk) = GPOINTER;
+	  DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
 	}
 
       if (IS_AGGREGATE (ftype))
 	{
 	  newType = newAst_LINK (copyLinkChain (ftype));
-	  DCL_TYPE (newType->opval.lnk) = GPOINTER;
+	  DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
 	}
       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;
@@ -715,9 +674,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);
@@ -743,21 +702,16 @@ processParms (ast * func,
     }
 
   /* the parameter type must be at least castable */
-  if (compareType (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 (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;
@@ -766,11 +720,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);
@@ -780,7 +733,7 @@ processParms (ast * func,
 /*-----------------------------------------------------------------*/
 /* createIvalType - generates ival for basic types                 */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalType (ast * sym, sym_link * type, initList * ilist)
 {
   ast *iExpr;
@@ -796,10 +749,11 @@ createIvalType (ast * sym, sym_link * type, initList * ilist)
 /*-----------------------------------------------------------------*/
 /* createIvalStruct - generates initial value for structures       */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 {
   ast *rast = NULL;
+  ast *lAst;
   symbol *sflds;
   initList *iloop;
 
@@ -814,8 +768,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;
@@ -824,6 +776,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;
 }
 
@@ -831,7 +789,7 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 /*-----------------------------------------------------------------*/
 /* createIvalArray - generates code for array initialization       */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalArray (ast * sym, sym_link * type, initList * ilist)
 {
   ast *rast = NULL;
@@ -881,7 +839,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 	    char *name=sym->opval.val->sym->name;
 	    int lineno=sym->opval.val->sym->lineDef;
 	    
-	    werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+	    werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
 	}
     }
     else
@@ -906,7 +864,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 		// 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);
+		werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
 		
 		break;
 	    }
@@ -926,7 +884,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 /*-----------------------------------------------------------------*/
 /* createIvalCharPtr - generates initial values for char pointers  */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 {
   ast *rast = NULL;
@@ -975,7 +933,7 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 /*-----------------------------------------------------------------*/
 /* createIvalPtr - generates initial value for pointers            */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalPtr (ast * sym, sym_link * type, initList * ilist)
 {
   ast *rast;
@@ -998,7 +956,7 @@ createIvalPtr (ast * sym, sym_link * type, initList * ilist)
 /*-----------------------------------------------------------------*/
 /* createIval - generates code for initial value                   */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
 {
   ast *rast = NULL;
@@ -1021,6 +979,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
@@ -1030,9 +989,7 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
 /*-----------------------------------------------------------------*/
 /* initAggregates - initialises aggregate variables with initv     */
 /*-----------------------------------------------------------------*/
-ast *
-initAggregates (symbol * sym, initList * ival, ast * wid)
-{
+ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
   return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
 }
 
@@ -1040,7 +997,7 @@ initAggregates (symbol * sym, initList * ival, ast * wid)
 /* gatherAutoInit - creates assignment expressions for initial     */
 /*    values                 */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 gatherAutoInit (symbol * autoChain)
 {
   ast *init = NULL;
@@ -1064,22 +1021,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);
 
@@ -1095,11 +1052,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;
@@ -1168,8 +1130,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)
@@ -1186,6 +1148,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)
@@ -1759,73 +1722,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 */
@@ -1881,11 +1777,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;
 	}
 
@@ -1916,13 +1807,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);
-
-		    }
 		}
 	    }
 	}
@@ -1941,7 +1825,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 */
@@ -1955,10 +1841,10 @@ decorateType (ast * tree)
 
   switch (tree->opval.op)
     {
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-      /*        array node          */
-/*----------------------------*/
+	    /*------------------------------------------------------------------*/
+	    /*----------------------------*/
+	    /*        array node          */
+	    /*----------------------------*/
     case '[':
 
       /* determine which is the array & which the index */
@@ -1997,10 +1883,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      struct/union          */
-/*----------------------------*/
+      /*----------------------------*/
     case '.':
       /* if this is not a structure */
       if (!IS_STRUCT (LTYPE (tree)))
@@ -2010,14 +1896,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)))
@@ -2034,8 +1920,35 @@ 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));
+
+      /* adjust the storage class */
+      switch (DCL_TYPE(tree->left->ftype)) {
+      case POINTER:
+      	break;
+      case FPOINTER:
+       	SPEC_SCLS(TETYPE(tree)) = S_XDATA; 
+      	break;
+      case CPOINTER:
+       	SPEC_SCLS(TETYPE(tree)) = S_CODE; 
+      	break;
+      case GPOINTER:
+      	break;
+      case PPOINTER:
+       	SPEC_SCLS(TETYPE(tree)) = S_XSTACK; 
+      	break;
+      case IPOINTER:
+       	SPEC_SCLS(TETYPE(tree)) = S_IDATA;
+      	break;
+      case EEPPOINTER:
+       	SPEC_SCLS(TETYPE(tree)) = S_EEPROM;
+      	break;
+      case UPOINTER:
+      case ARRAY:
+      case FUNCTION:
+      }
+
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -2047,7 +1960,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)
@@ -2069,7 +1982,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);
@@ -2099,38 +2012,10 @@ decorateType (ast * tree)
 	      return decorateType (otree);
 	  }
 
-#if 0 
-	  // we can't do this because of "(int & 0xff) << 3"
-
-	  /* 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;
-
-		}
-	      else
-		{
-		  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));
-#endif
+
 	  LRVAL (tree) = RRVAL (tree) = 1;
 	  return tree;
 	}
@@ -2144,7 +2029,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;
 	}
 
@@ -2160,7 +2045,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;
@@ -2178,8 +2069,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))
 	{
@@ -2215,7 +2108,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);
@@ -2277,7 +2170,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);
@@ -2322,9 +2215,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;
 	}
@@ -2636,7 +2527,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);
@@ -2682,10 +2573,10 @@ decorateType (ast * tree)
 	}
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*         casting            */
-/*----------------------------*/
+      /*----------------------------*/
     case CAST:			/* change the type   */
       /* cannot cast to an aggregate type */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -2697,24 +2588,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;
@@ -2840,15 +2764,99 @@ 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 value of the colon operator (on the right) */
       assert(IS_COLON_OP(tree->right));
-      TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree).
-      TETYPE (tree) = getSpec (TTYPE (tree));
+      /* 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 ':':
@@ -2890,8 +2898,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
     case AND_ASSIGN:
@@ -2919,8 +2925,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -2956,8 +2960,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3001,8 +3003,6 @@ decorateType (ast * tree)
       tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
       tree->opval.op = '=';
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3035,20 +3035,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) =
@@ -3056,9 +3043,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))
 	{
@@ -3066,8 +3052,6 @@ decorateType (ast * tree)
 	  goto errorTreeReturn;
 	}
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3086,17 +3070,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;
 
@@ -3110,7 +3096,8 @@ decorateType (ast * tree)
 
       if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
 	{
-	  werror (E_RETURN_MISMATCH);
+	  werror (W_RETURN_MISMATCH);
+	  printFromToType (RTYPE(tree), currFunc->type->next);
 	  goto errorTreeReturn;
 	}
 
@@ -3125,19 +3112,10 @@ decorateType (ast * tree)
       /* if there is going to be a casing required then add it */
       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;
@@ -3519,8 +3497,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);
@@ -3958,6 +3940,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       */
@@ -4098,8 +4137,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 */
@@ -4128,27 +4170,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;
@@ -4169,10 +4210,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);
@@ -4206,16 +4248,16 @@ 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;
+  if (port->reset_labelKey) labelKey = 1;
   name->key = 0;
-  name->fbody = 1;
+  FUNC_HASBODY(name->type) = 1;
   addSet (&operKeyReset, name);
   applyToSet (operKeyReset, resetParmKey);
 
@@ -4262,25 +4304,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;
 	}
@@ -4313,7 +4370,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 (");
@@ -4345,8 +4403,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;
 
 		/*------------------------------------------------------------------*/
@@ -4357,8 +4415,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 ;
 
 		/*------------------------------------------------------------------*/
@@ -4369,8 +4427,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 ;
 
 		/*------------------------------------------------------------------*/
@@ -4381,14 +4439,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 ;
 
 		/*------------------------------------------------------------------*/
@@ -4400,14 +4458,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 ;
 		/*----------------------------*/
@@ -4417,8 +4475,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 ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4428,8 +4486,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 ;
 		
 		/*------------------------------------------------------------------*/
@@ -4440,8 +4498,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 ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4451,8 +4509,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 ;
 
 		/*------------------------------------------------------------------*/
@@ -4464,7 +4522,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 ;
 		}			
 		/*------------------------------------------------------------------*/
@@ -4474,8 +4532,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 ;
 
 
@@ -4489,7 +4547,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 {
 			/*------------------------------------------------------------------*/
 			/*----------------------------*/
@@ -4498,8 +4556,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;
 		/*------------------------------------------------------------------*/
@@ -4511,7 +4569,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 {
 			/*------------------------------------------------------------------*/
 			/*----------------------------*/
@@ -4520,8 +4578,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;
 		/*------------------------------------------------------------------*/
@@ -4532,7 +4590,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 ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4542,7 +4600,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 ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4552,59 +4610,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 ;
 		
 		/*------------------------------------------------------------------*/
@@ -4615,43 +4675,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         */
@@ -4668,15 +4728,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 ;
 		
 		/*------------------------------------------------------------------*/
@@ -4687,50 +4748,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;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4740,8 +4801,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;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4751,8 +4812,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;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4762,8 +4823,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;	    
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4773,8 +4834,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;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4785,15 +4846,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 ;
 		/*------------------------------------------------------------------*/
@@ -4804,15 +4864,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;
 		/*------------------------------------------------------------------*/
@@ -4825,7 +4885,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,
@@ -4839,18 +4899,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 ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4859,22 +4918,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 ;
@@ -4883,5 +4942,5 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 
 void PA(ast *t)
 {
-	ast_print(t,stdout,1);
+	ast_print(t,stdout,0);
 }