X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=61c5655bf6be7dfee42c8ba9522d618a664c23b9;hb=6c935a87a40491361403ca56c18d1a0c7f590626;hp=6b384a7e77b929368aa5a4e4a4f55a84eec1466f;hpb=9388b031d56edbb7a48626d6fb573d3a411f61fd;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index 6b384a7e..61c5655b 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,16 @@ 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 *);
+static ast *optimizeCompare (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 +67,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,9 +186,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));
@@ -241,20 +210,22 @@ copyAstValues (ast * dest, ast * src)
 /* copyAst - makes a copy of a given astession                     */
 /*-----------------------------------------------------------------*/
 ast *
-copyAst (ast * src)
+copyAst (ast * src) 
 {
   ast *dest;
 
   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 */
@@ -276,9 +247,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);
@@ -288,6 +256,31 @@ exit:
 
 }
 
+/*-----------------------------------------------------------------*/
+/* removeIncDecOps: remove for side effects in *_ASSIGN's          */
+/*                  "*s++ += 3" -> "*s++ = *s++ + 3"               */
+/*-----------------------------------------------------------------*/
+ast *removeIncDecOps (ast * tree) {
+
+  // traverse the tree and remove inc/dec ops
+
+  if (!tree)
+    return NULL;
+
+  if (tree->type == EX_OP && 
+      (tree->opval.op == INC_OP || tree->opval.op == DEC_OP)) {
+    if (tree->left)
+      tree=tree->left;
+    else 
+      tree=tree->right;
+  }
+
+  tree->left=removeIncDecOps(tree->left);
+  tree->right=removeIncDecOps(tree->right);
+ 
+ return tree;
+}
+
 /*-----------------------------------------------------------------*/
 /* hasSEFcalls - returns TRUE if tree has a function call          */
 /*-----------------------------------------------------------------*/
@@ -374,6 +367,7 @@ resolveSymbols (ast * tree)
   if (tree == NULL)
     return tree;
 
+#if 0
   /* print the line          */
   /* if not block & function */
   if (tree->type == EX_OP &&
@@ -384,6 +378,7 @@ resolveSymbols (ast * tree)
       filename = tree->filename;
       lineno = tree->lineno;
     }
+#endif
 
   /* make sure we resolve the true & false labels for ifx */
   if (tree->type == EX_OP && tree->opval.op == IFX)
@@ -461,6 +456,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
 	    {
@@ -483,8 +479,7 @@ resolveChildren:
 /*-----------------------------------------------------------------*/
 /* setAstLineno - walks a ast tree & sets the line number          */
 /*-----------------------------------------------------------------*/
-int 
-setAstLineno (ast * tree, int lineno)
+int setAstLineno (ast * tree, int lineno)
 {
   if (!tree)
     return 0;
@@ -495,38 +490,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                        */
 /*-----------------------------------------------------------------*/
@@ -538,30 +501,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 ? 1 : 0;
+
   /* 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;
@@ -570,10 +533,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;
@@ -599,20 +602,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);
@@ -621,17 +622,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;
@@ -644,8 +643,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;
@@ -657,20 +661,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)
@@ -682,18 +673,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;
@@ -710,9 +701,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);
@@ -738,21 +729,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;
@@ -761,21 +747,21 @@ 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);
+  SPEC_ARGREG  (actParm->etype) = SPEC_ARGREG (defParm->etype);
   (*parmNumber)++;
   return 0;
 }
 /*-----------------------------------------------------------------*/
 /* createIvalType - generates ival for basic types                 */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalType (ast * sym, sym_link * type, initList * ilist)
 {
   ast *iExpr;
@@ -791,10 +777,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;
 
@@ -809,8 +796,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;
@@ -819,6 +804,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;
 }
 
@@ -826,12 +817,13 @@ 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;
   initList *iloop;
   int lcnt = 0, size = 0;
+  literalList *literalL;
 
   /* take care of the special   case  */
   /* array of characters can be init  */
@@ -843,58 +835,84 @@ 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++;
+	ast *aSym;
 
-      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;
-
-      /* 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));
 }
 
 
 /*-----------------------------------------------------------------*/
 /* createIvalCharPtr - generates initial values for char pointers  */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 {
   ast *rast = NULL;
@@ -912,7 +930,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;
@@ -935,6 +952,13 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
 			       newNode ('[', sym,
 				   newAst_VALUE (valueFromLit ((float) i))),
 			       newAst_VALUE (valueFromLit (*s))));
+
+      // now we don't need iexpr's symbol anymore
+      {
+	symbol *sym=AST_SYMBOL(iexpr);
+	memmap *segment=SPEC_OCLS(sym->etype);
+	deleteSetItem(&segment->syms, sym);
+      }
       return decorateType (resolveSymbols (rast));
     }
 
@@ -944,7 +968,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;
@@ -967,7 +991,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;
@@ -990,6 +1014,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
@@ -999,9 +1024,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);
 }
 
@@ -1009,7 +1032,7 @@ initAggregates (symbol * sym, initList * ival, ast * wid)
 /* gatherAutoInit - creates assignment expressions for initial     */
 /*    values                 */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 gatherAutoInit (symbol * autoChain)
 {
   ast *init = NULL;
@@ -1033,22 +1056,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);
 
@@ -1064,13 +1087,30 @@ gatherAutoInit (symbol * autoChain)
       /* if there is an initial value */
       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
 	{
-	  if (IS_AGGREGATE (sym->type))
+	  initList *ilist=sym->ival;
+	  
+	  while (ilist->type == INIT_DEEP) {
+	    ilist = ilist->init.deep;
+	  }
+
+	  /* update lineno for error msg */
+	  lineno=sym->lineDef;
+	  setAstLineno (ilist->init.node, lineno);
+	  
+	  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));
-
+	  }
+	  
+	  // just to be sure
 	  setAstLineno (work, sym->lineDef);
+
 	  sym->ival = NULL;
 	  if (init)
 	    init = newNode (NULLOP, init, work);
@@ -1137,8 +1177,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)
@@ -1153,8 +1193,68 @@ processBlockVars (ast * tree, int *stack, int action)
   return tree;
 }
 
+/*-------------------------------------------------------------*/
+/* constExprTree - returns TRUE if this tree is a constant     */
+/*                 expression                                  */
+/*-------------------------------------------------------------*/
+bool constExprTree (ast *cexpr) {
+
+  if (!cexpr) {
+    return TRUE;
+  }
+
+  cexpr = decorateType (resolveSymbols (cexpr));
+  
+  switch (cexpr->type) 
+    {
+    case EX_VALUE:
+      if (IS_AST_LIT_VALUE(cexpr)) {
+	// this is a literal
+	return TRUE;
+      }
+      if (IS_AST_SYM_VALUE(cexpr) && IS_FUNC(AST_SYMBOL(cexpr)->type)) {
+	// a function's address will never change
+	return TRUE;
+      }
+      if (IS_AST_SYM_VALUE(cexpr) && 
+	  IN_CODESPACE(SPEC_OCLS(AST_SYMBOL(cexpr)->etype))) {
+	// a symbol in code space will never change
+	// This is only for the 'char *s="hallo"' case and will have to leave
+	return TRUE;
+      }
+      return FALSE;
+    case EX_LINK:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+	      "unexpected link in expression tree\n");
+      return FALSE;
+    case EX_OP:
+      if (cexpr->opval.op==ARRAYINIT) {
+	// this is a list of literals
+	return TRUE;
+      }
+      if (cexpr->opval.op=='=') {
+	return constExprTree(cexpr->right);
+      }
+      if (cexpr->opval.op==CAST) {
+	// jwk: cast ignored, maybe we should throw a warning here
+	return constExprTree(cexpr->right);
+      }
+      if (cexpr->opval.op=='&') { 
+	return TRUE;
+      }
+      if (cexpr->opval.op==CALL || cexpr->opval.op==PCALL) {
+	return FALSE;
+      }
+      if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) {
+	return TRUE;
+      }
+    }
+  return FALSE;
+}  
+    
 /*-----------------------------------------------------------------*/
 /* constExprValue - returns the value of a constant expression     */
+/*                  or NULL if it is not a constant expression     */
 /*-----------------------------------------------------------------*/
 value *
 constExprValue (ast * cexpr, int check)
@@ -1182,9 +1282,9 @@ constExprValue (ast * cexpr, int check)
       /* if we are casting a literal value then */
       if (IS_AST_OP (cexpr) &&
 	  cexpr->opval.op == CAST &&
-	  IS_LITERAL (cexpr->left->ftype))
+	  IS_LITERAL (cexpr->right->ftype))
 	return valCastLiteral (cexpr->ftype,
-			       floatFromVal (cexpr->left->opval.val));
+			       floatFromVal (cexpr->right->opval.val));
 
       if (IS_AST_VALUE (cexpr))
 	return cexpr->opval.val;
@@ -1391,11 +1491,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      */
@@ -1419,8 +1533,7 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
   /* if we reach the end or a leaf then true */
   if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody))
     return TRUE;
-
-
+  
   /* if anything else is "volatile" */
   if (IS_VOLATILE (TETYPE (pbody)))
     return FALSE;
@@ -1431,6 +1544,10 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
     {
 /*------------------------------------------------------------------*/
     case '[':
+      // if the loopvar is used as an index
+      if (astHasSymbol(pbody->right, sym)) {
+	return FALSE;
+      }
       return isConformingBody (pbody->right, sym, body);
 
 /*------------------------------------------------------------------*/
@@ -1540,12 +1657,21 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
       if (astHasVolatile (pbody->left))
 	return FALSE;
 
-      if (IS_AST_SYM_VALUE (pbody->left) &&
-	  isSymbolEqual (AST_SYMBOL (pbody->left), sym))
-	return FALSE;
+      if (IS_AST_SYM_VALUE (pbody->left)) {
+	// if the loopvar has an assignment
+	if (isSymbolEqual (AST_SYMBOL (pbody->left), sym))
+	  return FALSE;
+	// if the loopvar is used in another (maybe conditional) block
+	if (astHasSymbol (pbody->right, sym) &&
+	    (pbody->level > body->level)) {
+	  return FALSE;
+	}
+      }
 
       if (astHasVolatile (pbody->left))
 	return FALSE;
+      
+      if (astHasDeref(pbody->right)) return FALSE;
 
       return isConformingBody (pbody->left, sym, body) &&
 	isConformingBody (pbody->right, sym, body);
@@ -1574,6 +1700,9 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
       /*       function call        */
 /*----------------------------*/
     case CALL:
+	/* if local & not passed as paramater then ok */
+	if (sym->level && !astHasSymbol(pbody->right,sym)) 
+	    return TRUE;
       return FALSE;
 
 /*------------------------------------------------------------------*/
@@ -1687,14 +1816,15 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
   rloop = newNode (NULLOP,
 		   createIf (newAst_VALUE (symbolVal (sym)),
 			     newNode (GOTO,
-		   newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))),
+				      newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))),
 				      NULL), NULL),
 		   newNode ('=',
 			    newAst_VALUE (symbolVal (sym)),
 			    end));
-
+  
   replLoopSym (loop->left, sym);
-
+  setAstLineno (rloop, init->lineno);
+  
   rloop = newNode (NULLOP,
 		   newNode ('=',
 			    newAst_VALUE (symbolVal (sym)),
@@ -1704,79 +1834,13 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
 					 loop->left,
 					 newNode (NULLOP,
 						  newNode (SUB_ASSIGN,
-					     newAst_VALUE (symbolVal (sym)),
-					     newAst_VALUE (constVal ("1"))),
+							   newAst_VALUE (symbolVal (sym)),
+							   newAst_VALUE (constVal ("1"))),
 						  rloop))));
-
+  
+  rloop->lineno=init->lineno;
   return decorateType (rloop);
-
-}
-
-#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
+  
 }
 
 /*-----------------------------------------------------------------*/
@@ -1799,6 +1863,7 @@ decorateType (ast * tree)
 
   tree->decorated = 1;
 
+#if 0
   /* print the line          */
   /* if not block & function */
   if (tree->type == EX_OP &&
@@ -1809,6 +1874,7 @@ decorateType (ast * tree)
       filename = tree->filename;
       lineno = tree->lineno;
     }
+#endif
 
   /* if any child is an error | this one is an error do nothing */
   if (tree->isError ||
@@ -1834,11 +1900,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;
 	}
 
@@ -1869,13 +1930,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);
-
-		    }
 		}
 	    }
 	}
@@ -1894,7 +1948,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 */
@@ -1902,16 +1958,32 @@ decorateType (ast * tree)
       tree->left = dtl;
     if (dtr != tree->right)
       tree->right = dtr;
+
+    /* special case for left shift operation : cast up right->left if type of left
+       has greater size than right */
+    if (tree->left && tree->right && tree->right->opval.op == LEFT_OP) {
+	int lsize = getSize(LTYPE(tree));
+	int rsize = getSize(RTYPE(tree));
+
+	if (lsize > rsize) {
+	    tree->right->decorated = 0;
+	    tree->right->left = newNode( CAST, (lsize == 2 ? 
+					       newAst_LINK(newIntLink()) : 
+					       newAst_LINK(newLongLink())),
+					tree->right->left);
+	    tree->right = decorateType(tree->right);
+	}
+    }
   }
 
   /* depending on type of operator do */
 
   switch (tree->opval.op)
     {
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-      /*        array node          */
-/*----------------------------*/
+	/*------------------------------------------------------------------*/
+	/*----------------------------*/
+	/*        array node          */
+	/*----------------------------*/
     case '[':
 
       /* determine which is the array & which the index */
@@ -1950,10 +2022,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      struct/union          */
-/*----------------------------*/
+      /*----------------------------*/
     case '.':
       /* if this is not a structure */
       if (!IS_STRUCT (LTYPE (tree)))
@@ -1963,14 +2035,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)))
@@ -1987,20 +2059,47 @@ 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;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  ++/-- operation           */
-/*----------------------------*/
+      /*----------------------------*/
     case INC_OP:		/* incerement operator unary so left only */
     case DEC_OP:
       {
 	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)
@@ -2010,10 +2109,10 @@ decorateType (ast * tree)
 	return tree;
       }
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise and               */
-/*----------------------------*/
+      /*----------------------------*/
     case '&':			/* can be unary   */
       /* if right is NULL then unary operation  */
       if (tree->right)		/* not an unary operation */
@@ -2022,7 +2121,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);
@@ -2052,44 +2151,24 @@ 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;
 	}
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  address of                */
-/*----------------------------*/
+      /*----------------------------*/
       p = newLink ();
       p->class = DECLARATOR;
       /* 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;
 	}
 
@@ -2101,11 +2180,17 @@ decorateType (ast * tree)
 
       if (IS_FUNC (LTYPE (tree)))
 	{
-	  werror (E_ILLEGAL_ADDR, "address of function");
+	  // this ought to be ignored
+	  return (tree->left);
+	}
+
+      if (IS_LITERAL(LTYPE(tree)))
+	{
+	  werror (E_ILLEGAL_ADDR, "address of literal");
 	  goto errorTreeReturn;
 	}
 
-      if (LRVAL (tree))
+     if (LRVAL (tree))
 	{
 	  werror (E_LVALUE_REQUIRED, "address of");
 	  goto errorTreeReturn;
@@ -2123,8 +2208,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))
 	{
@@ -2141,10 +2228,10 @@ decorateType (ast * tree)
       TLVAL (tree) = 1;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise or                */
-/*----------------------------*/
+      /*----------------------------*/
     case '|':
       /* if the rewrite succeeds then don't go any furthur */
       {
@@ -2152,15 +2239,15 @@ decorateType (ast * tree)
 	if (wtree != tree)
 	  return decorateType (wtree);
       }
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  bitwise xor               */
-/*----------------------------*/
+      /*----------------------------*/
     case '^':
       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);
@@ -2186,10 +2273,10 @@ decorateType (ast * tree)
 			       computeType (LTYPE (tree),
 					    RTYPE (tree)));
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*  division                  */
-/*----------------------------*/
+      /*----------------------------*/
     case '/':
       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
 	{
@@ -2214,15 +2301,15 @@ decorateType (ast * tree)
 					    RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*            modulus         */
-/*----------------------------*/
+      /*----------------------------*/
     case '%':
       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);
@@ -2247,10 +2334,10 @@ decorateType (ast * tree)
 					    RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-/*  address dereference       */
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
+      /*  address dereference       */
+      /*----------------------------*/
     case '*':			/* can be unary  : if right is null then unary operation */
       if (!tree->right)
 	{
@@ -2267,17 +2354,15 @@ 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;
 	}
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      multiplication        */
-/*----------------------------*/
+      /*----------------------------*/
       if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree)))
 	{
 	  werror (E_INVALID_OP, "multiplication");
@@ -2320,10 +2405,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    unary '+' operator      */
-/*----------------------------*/
+      /*----------------------------*/
     case '+':
       /* if unary plus */
       if (!tree->right)
@@ -2348,10 +2433,10 @@ decorateType (ast * tree)
 	  return tree;
 	}
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      addition              */
-/*----------------------------*/
+      /*----------------------------*/
 
       /* this is not a unary operation */
       /* if both pointers then problem */
@@ -2401,7 +2486,7 @@ decorateType (ast * tree)
 
       LRVAL (tree) = RRVAL (tree) = 1;
       /* if the left is a pointer */
-      if (IS_PTR (LTYPE (tree)))
+      if (IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree)))
 	TETYPE (tree) = getSpec (TTYPE (tree) =
 				 LTYPE (tree));
       else
@@ -2410,10 +2495,10 @@ decorateType (ast * tree)
 					      RTYPE (tree)));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      unary '-'             */
-/*----------------------------*/
+      /*----------------------------*/
     case '-':			/* can be unary   */
       /* if right is null then unary */
       if (!tree->right)
@@ -2440,10 +2525,10 @@ decorateType (ast * tree)
 	  return tree;
 	}
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    subtraction             */
-/*----------------------------*/
+      /*----------------------------*/
 
       if (!(IS_PTR (LTYPE (tree)) ||
 	    IS_ARRAY (LTYPE (tree)) ||
@@ -2510,10 +2595,10 @@ decorateType (ast * tree)
       LRVAL (tree) = RRVAL (tree) = 1;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    compliment              */
-/*----------------------------*/
+      /*----------------------------*/
     case '~':
       /* can be only integral type */
       if (!IS_INTEGRAL (LTYPE (tree)))
@@ -2535,10 +2620,10 @@ decorateType (ast * tree)
       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*           not              */
-/*----------------------------*/
+      /*----------------------------*/
     case '!':
       /* can be pointer */
       if (!IS_ARITHMETIC (LTYPE (tree)) &&
@@ -2562,10 +2647,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*           shift            */
-/*----------------------------*/
+      /*----------------------------*/
     case RRC:
     case RLC:
       TTYPE (tree) = LTYPE (tree);
@@ -2581,7 +2666,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);
@@ -2602,19 +2687,46 @@ decorateType (ast * tree)
 				   tree->opval.val->type);
 	  return tree;
 	}
+#if 0
+      /* a left shift must be done with at least 16bits */
+      if ((tree->opval.op==LEFT_OP) && (getSize(LTYPE(tree))<2)) {
+	// insert a cast
+	if (IS_AST_SYM_VALUE(tree->left) || IS_AST_OP(tree->left)) {
+	  tree->left = 
+	    decorateType (newNode (CAST,
+				   newAst_LINK(copyLinkChain(LTYPE(tree))),
+				   tree->left));
+	  SPEC_NOUN(tree->left->left->ftype)=V_INT;
+	} else {
+	  // must be a literal, we can do it right away
+	  SPEC_NOUN(tree->left->opval.val->type)=V_INT;
+	}
+      }
+#endif
       /* if only the right side is a literal & we are
          shifting more than size of the left operand then zero */
       if (IS_LITERAL (RTYPE (tree)) &&
 	  ((unsigned) floatFromVal (valFromType (RETYPE (tree)))) >=
 	  (getSize (LTYPE (tree)) * 8))
 	{
-	  werror (W_SHIFT_CHANGED,
-		  (tree->opval.op == LEFT_OP ? "left" : "right"));
-	  tree->type = EX_VALUE;
-	  tree->left = tree->right = NULL;
-	  tree->opval.val = constVal ("0");
-	  TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
-	  return tree;
+	    /* if left shift then cast up */
+	    if (tree->opval.op==LEFT_OP) {
+		int size = getSize(LTYPE(tree));
+		tree->left = 
+		    decorateType (newNode (CAST,
+					   (size == 1 ? newAst_LINK(newIntLink()) : 
+					    (size == 2 ? newAst_LINK(newLongLink()) : 
+					     newAst_LINK(newIntLink()))),
+					   tree->left));
+	    } else {
+		werror (W_SHIFT_CHANGED,
+			(tree->opval.op == LEFT_OP ? "left" : "right"));
+		tree->type = EX_VALUE;
+		tree->left = tree->right = NULL;
+		tree->opval.val = constVal ("0");
+		TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
+		return tree;
+	    }
 	}
       LRVAL (tree) = RRVAL (tree) = 1;
       if (IS_LITERAL (LTYPE (tree)) && !IS_LITERAL (RTYPE (tree)))
@@ -2627,10 +2739,10 @@ decorateType (ast * tree)
 	}
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*         casting            */
-/*----------------------------*/
+      /*----------------------------*/
     case CAST:			/* change the type   */
       /* cannot cast to an aggregate type */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -2642,32 +2754,69 @@ 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
+      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 0 // this is already checked, now this could be explicit
+      /* 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)) 
 	{
-	  TTYPE (tree) = LTYPE (tree);
-	  LRVAL (tree) = 1;
+	  werror(W_CAST_STRUCT_PTR,SPEC_STRUCT(RETYPE(tree))->tag,
+		 SPEC_STRUCT(LETYPE(tree))->tag);
 	}
-
+#endif
+      /* 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;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*       logical &&, ||       */
-/*----------------------------*/
+      /*----------------------------*/
     case AND_OP:
     case OR_OP:
       /* each must me arithmetic type or be a pointer */
@@ -2704,10 +2853,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     comparison operators   */
-/*----------------------------*/
+      /*----------------------------*/
     case '>':
     case '<':
     case LE_OP:
@@ -2752,7 +2901,18 @@ decorateType (ast * tree)
 		goto errorTreeReturn;
 	      }
 	}
+      /* if unsigned value < 0  then always false */
+      /* if (unsigned value) > 0 then (unsigned value) */
+      if (SPEC_USIGN(LETYPE(tree)) && IS_LITERAL(RTYPE(tree)) && 
+	  ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) {
 
+	  if (tree->opval.op == '<') {
+	      return tree->right;
+	  }
+	  if (tree->opval.op == '>') {
+	      return tree->left;
+	  }
+      }
       /* if they are both literal then */
       /* rewrite the tree */
       if (IS_LITERAL (RTYPE (tree)) &&
@@ -2771,10 +2931,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = newCharLink ();
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*             sizeof         */
-/*----------------------------*/
+      /*----------------------------*/
     case SIZEOF:		/* evaluate wihout code generation */
       /* change the type to a integer */
       tree->type = EX_VALUE;
@@ -2785,15 +2945,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 ':':
@@ -2809,10 +3053,11 @@ decorateType (ast * tree)
       return tree;
 
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+#if 0 // assignment operators are converted by the parser
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    assignment operators    */
-/*----------------------------*/
+      /*----------------------------*/
     case MUL_ASSIGN:
     case DIV_ASSIGN:
       /* for these it must be both must be integral */
@@ -2835,8 +3080,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
     case AND_ASSIGN:
@@ -2864,14 +3107,12 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    -= operator             */
-/*----------------------------*/
+      /*----------------------------*/
     case SUB_ASSIGN:
       if (!(IS_PTR (LTYPE (tree)) ||
 	    IS_ARITHMETIC (LTYPE (tree))))
@@ -2901,14 +3142,12 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*          += operator       */
-/*----------------------------*/
+      /*----------------------------*/
     case ADD_ASSIGN:
       /* this is not a unary operation */
       /* if both pointers then problem */
@@ -2946,14 +3185,13 @@ decorateType (ast * tree)
       tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
       tree->opval.op = '=';
 
-      propAsgType (tree);
-
       return tree;
+#endif
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      straight assignemnt   */
-/*----------------------------*/
+      /*----------------------------*/
     case '=':
       /* cannot be an aggregate */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -2966,13 +3204,8 @@ decorateType (ast * tree)
       if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	{
 	  werror (E_TYPE_MISMATCH, "assignment", " ");
-	  fprintf (stderr, "type --> '");
-	  printTypeChain (RTYPE (tree), stderr);
-	  fprintf (stderr, "' ");
-	  fprintf (stderr, "assigned to type --> '");
-	  printTypeChain (LTYPE (tree), stderr);
-	  fprintf (stderr, "'\n");
-	  goto errorTreeReturn;
+	  printFromToType(RTYPE(tree),LTYPE(tree));
+	  //goto errorTreeReturn;
 	}
 
       /* if the left side of the tree is of type void
@@ -2980,20 +3213,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 +3221,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,51 +3230,52 @@ decorateType (ast * tree)
 	  goto errorTreeReturn;
 	}
 
-      propAsgType (tree);
-
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      comma operator        */
-/*----------------------------*/
+      /*----------------------------*/
     case ',':
       TETYPE (tree) = getSpec (TTYPE (tree) = RTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*       function call        */
-/*----------------------------*/
+      /*----------------------------*/
     case CALL:
       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;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     return statement       */
-/*----------------------------*/
+      /*----------------------------*/
     case RETURN:
       if (!tree->right)
 	goto voidcheck;
 
       if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
 	{
-	  werror (E_RETURN_MISMATCH);
+	  werror (W_RETURN_MISMATCH);
+	  printFromToType (RTYPE(tree), currFunc->type->next);
 	  goto errorTreeReturn;
 	}
 
@@ -3070,19 +3290,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;
@@ -3099,10 +3310,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*     switch statement       */
-/*----------------------------*/
+      /*----------------------------*/
     case SWITCH:
       /* the switch value must be an integer */
       if (!IS_INTEGRAL (LTYPE (tree)))
@@ -3114,10 +3325,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /* ifx Statement              */
-/*----------------------------*/
+      /*----------------------------*/
     case IFX:
       tree->left = backPatchLabels (tree->left,
 				    tree->trueLabel,
@@ -3125,10 +3336,10 @@ decorateType (ast * tree)
       TTYPE (tree) = TETYPE (tree) = NULL;
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /* for Statement              */
-/*----------------------------*/
+      /*----------------------------*/
     case FOR:
 
       decorateType (resolveSymbols (AST_FOR (tree, initExpr)));
@@ -3464,8 +3675,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);
@@ -3856,7 +4071,7 @@ tryNext2:
 /*-----------------------------------------------------------------*/
 /* optimizeCompare - otimizes compares for bit variables     */
 /*-----------------------------------------------------------------*/
-ast *
+static ast *
 optimizeCompare (ast * root)
 {
   ast *optExpr = NULL;
@@ -4043,8 +4258,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 +4291,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 +4331,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 +4369,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;
+  if (port->reset_labelKey) 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 +4425,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 +4491,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 +4524,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 +4536,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 +4548,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 +4560,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 +4579,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 +4596,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 +4607,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 +4619,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 +4630,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 +4643,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 +4653,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 +4668,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 +4677,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 +4690,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 +4699,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 +4711,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 +4721,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 +4731,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 +4796,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 +4849,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 +4869,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 +4922,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 +4933,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 +4944,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 +4955,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 +4967,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 ;
 		/*------------------------------------------------------------------*/
@@ -4747,17 +4983,19 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		/*----------------------------*/
 	case RETURN:
 		fprintf(outfile,"RETURN (%p) type (",tree);
-		printTypeChain(tree->right->ftype,outfile);
+		if (tree->right) {
+		    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 +5008,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 +5022,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 +5041,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 +5065,5 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 
 void PA(ast *t)
 {
-	ast_print(t,stdout,1);
+	ast_print(t,stdout,0);
 }