X-Git-Url: https://git.gag.com/?a=blobdiff_plain;ds=sidebyside;f=src%2FSDCCast.c;h=0277d7ff20e9b64e0546af0a0dacefff012123f8;hb=56a9e990dcc18d296ee20344d96bde03dad9e8a2;hp=d782ea75b9c3683dae646b76eb3a94ccab21441e;hpb=b25f80f09934704e74e85cc3f0b9fb42e812ac07;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index d782ea75..0277d7ff 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,7 +45,6 @@ int labelKey = 1;
 #define ALLOCATE 1
 #define DEALLOCATE 2
 
-char buffer[1024];
 int noLineno = 0;
 int noAlloc = 0;
 symbol *currFunc;
@@ -55,6 +53,7 @@ ast *createIvalCharPtr (ast *, sym_link *, ast *);
 ast *optimizeRRCRLC (ast *);
 ast *optimizeGetHbit (ast *);
 ast *backPatchLabels (ast *, symbol *, symbol *);
+void PA(ast *t);
 int inInitMode = 0;
 memmap *GcurMemmap=NULL;  /* points to the memmap that's currently active */
 FILE *codeOutFile;
@@ -76,7 +75,7 @@ newAst (int type, void *op)
   ast *ex;
   static int oldLineno = 0;
 
-  Safe_calloc (1, ex, sizeof (ast));
+  ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
   ex->lineno = (noLineno ? oldLineno : yylineno);
@@ -111,7 +110,7 @@ newAst_ (unsigned type)
   ast *ex;
   static int oldLineno = 0;
 
-  ex = Safe_calloc (1, sizeof (ast));
+  ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
   ex->lineno = (noLineno ? oldLineno : yylineno);
@@ -222,7 +221,7 @@ copyAstValues (ast * dest, ast * src)
       break;
 
     case INLINEASM:
-      dest->values.inlineasm = Safe_calloc (1, strlen (src->values.inlineasm) + 1);
+      dest->values.inlineasm = Safe_alloc (strlen (src->values.inlineasm) + 1);
       strcpy (dest->values.inlineasm, src->values.inlineasm);
       break;
 
@@ -253,13 +252,15 @@ copyAst (ast * src)
   if (!src)
     return NULL;
 
-  dest = Safe_calloc (1, sizeof (ast));
+  dest = Safe_alloc ( sizeof (ast));
 
   dest->type = src->type;
   dest->lineno = src->lineno;
   dest->level = src->level;
   dest->funcName = src->funcName;
-  dest->argSym = src->argSym;
+
+  if (src->ftype)
+    dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
 
   /* if this is a leaf */
   /* if value */
@@ -281,9 +282,6 @@ copyAst (ast * src)
   /* if this is a node that has special values */
   copyAstValues (dest, src);
 
-  if (src->ftype)
-    dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
-
   dest->trueLabel = copySymbol (src->trueLabel);
   dest->falseLabel = copySymbol (src->falseLabel);
   dest->left = copyAst (src->left);
@@ -544,12 +542,18 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
   /* create the symbol */
   sym = newSymbol (name, 0);
 
+  /* setup return value */
+  sym->type = newLink ();
+  DCL_TYPE (sym->type) = FUNCTION;
+  sym->type->next = copyLinkChain (type);
+  sym->etype = getSpec (sym->type);
+  FUNC_ISREENT(sym->type) = rent;
+
   /* if arguments required */
   if (nArgs)
     {
-
       value *args;
-      args = sym->args = newValue ();
+      args = FUNC_ARGS(sym->type) = newValue ();
 
       while (nArgs--)
 	{
@@ -561,13 +565,6 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
 	}
     }
 
-  /* 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;
@@ -605,21 +602,18 @@ reverseParms (ast * ptree)
 /*-----------------------------------------------------------------*/
 int 
 processParms (ast * func,
-	      value * defParm,
+	      value *defParm,
 	      ast * actParm,
-	      int *parmNumber,
-	      bool rightmost)
+	      int *parmNumber, // unused, although updated
+	      bool rightmost) // double checked?
 {
-  int castError=0;
-  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);
@@ -628,7 +622,7 @@ 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 (W_NONRENT_ARGS);
       return 1;
@@ -636,9 +630,7 @@ processParms (ast * func,
 
   /* 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;
@@ -651,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;
@@ -717,9 +714,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);
@@ -744,44 +741,11 @@ processParms (ast * func,
 	}
     }
 
-
   /* the parameter type must be at least castable */
-  if (compareType (defParm->type, actParm->ftype) == 0)
-    {
-      castError++;
-    }
-
-#ifdef JWK20010916
-  if (!IS_SPEC(defParm->type) && !IS_SPEC(actParm->ftype)) {
-    // now we have two pointers, check if they point to the same
-    sym_link *dtype=defParm->type, *atype=actParm->ftype;
-    do {
-      dtype=dtype->next;
-      atype=atype->next;
-      if (
-	  (dtype->next && !atype->next) ||
-	  (!dtype->next && atype->next) ||
-	  compareType (dtype, atype)!=1) {
-	castError++;
-      }
-    } while (dtype->next && atype->next);
-    if (IS_SPEC(dtype) && IS_SPEC(atype)) {
-      // ok so far, we have two etypes, they must have the same SCLASS
-      if (SPEC_SCLS(dtype)!=SPEC_SCLS(atype)) {
-	castError++;
-      }
-    }
-  }
-#endif
-
-  if (castError) {
-    werror (W_INCOMPAT_CAST);
-    fprintf (stderr, "type --> '");
-    printTypeChain (actParm->ftype, stderr);
-    fprintf (stderr, "' ");
-    fprintf (stderr, "assigned to type --> '");
-    printTypeChain (defParm->type, 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 */
@@ -798,9 +762,6 @@ processParms (ast * func,
       actParm->ftype = defParm->type;
     }
 
-/*    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);
@@ -830,6 +791,7 @@ ast *
 createIvalStruct (ast * sym, sym_link * type, initList * ilist)
 {
   ast *rast = NULL;
+  ast *lAst;
   symbol *sflds;
   initList *iloop;
 
@@ -844,8 +806,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;
@@ -1072,7 +1032,7 @@ ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
 
     if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
       fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
-	       "with -mmcs51 and --model-large");
+	       "with -mmcs51 and --model-large\n");
       exit(404);
     }
 
@@ -1136,7 +1096,7 @@ gatherAutoInit (symbol * autoChain)
 	  /* 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))
@@ -1250,6 +1210,7 @@ processBlockVars (ast * tree, int *stack, int action)
 
 /*-----------------------------------------------------------------*/
 /* constExprValue - returns the value of a constant expression     */
+/*                  or NULL if it is not a constant expression     */
 /*-----------------------------------------------------------------*/
 value *
 constExprValue (ast * cexpr, int check)
@@ -1287,7 +1248,7 @@ constExprValue (ast * cexpr, int check)
       if (check)
 	werror (E_CONST_EXPECTED, "found expression");
 
-      return constVal("0");
+      return NULL;
     }
 
   /* return the value */
@@ -1865,31 +1826,6 @@ pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr)
 
 #endif
 
-/*-----------------------------------------------------------------*/
-/* Given an assignment operation in a tree, determine if the LHS   */
-/* (the result) has a different (integer) type than the RHS.     */
-/* If so, walk the RHS and add a typecast to the type of the LHS   */
-/* to all leaf nodes.              */
-/*-----------------------------------------------------------------*/
-void 
-propAsgType (ast * tree)
-{
-#ifdef DEMAND_INTEGER_PROMOTION
-  if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
-    {
-      /* Nothing to do here... */
-      return;
-    }
-
-  if (getSize (LTYPE (tree)) > getSize (RTYPE (tree)))
-    {
-      pushTypeCastToLeaves (LTYPE (tree), tree->right, &(tree->right));
-    }
-#else
-  (void) tree;
-#endif
-}
-
 /*-----------------------------------------------------------------*/
 /* decorateType - compute type for this tree also does type cheking */
 /*          this is done bottom up, since type have to flow upwards */
@@ -1945,11 +1881,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;
 	}
 
@@ -1980,13 +1911,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);
-
-		    }
 		}
 	    }
 	}
@@ -2074,7 +1998,7 @@ 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;
 
@@ -2098,7 +2022,7 @@ decorateType (ast * tree)
 
       TTYPE (tree) = structElemType (LTYPE (tree)->next,
 				     (tree->right->type == EX_VALUE ?
-			       tree->right->opval.val : NULL), &tree->args);
+			       tree->right->opval.val : NULL));
       TETYPE (tree) = getSpec (TTYPE (tree));
       return tree;
 
@@ -2111,7 +2035,7 @@ decorateType (ast * tree)
       {
 	sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree));
 	COPYTYPE (TTYPE (tree), TETYPE (tree), ltc);
-	if (!tree->initMode && IS_CONSTANT (TETYPE (tree)))
+	if (!tree->initMode && IS_CONSTANT(TETYPE(tree)))
 	  werror (E_CODE_WRITE, "++/--");
 
 	if (tree->right)
@@ -2208,7 +2132,7 @@ decorateType (ast * tree)
       /* if bit field then error */
       if (IS_BITVAR (tree->left->etype))
 	{
-	  werror (E_ILLEGAL_ADDR, "addrress of bit variable");
+	  werror (E_ILLEGAL_ADDR, "address of bit variable");
 	  goto errorTreeReturn;
 	}
 
@@ -2224,7 +2148,13 @@ decorateType (ast * tree)
 	  goto errorTreeReturn;
 	}
 
-      if (LRVAL (tree))
+      if (IS_LITERAL(LTYPE(tree)))
+	{
+	  werror (E_ILLEGAL_ADDR, "address of literal");
+	  goto errorTreeReturn;
+	}
+
+     if (LRVAL (tree))
 	{
 	  werror (E_LVALUE_REQUIRED, "address of");
 	  goto errorTreeReturn;
@@ -2386,9 +2316,7 @@ decorateType (ast * tree)
 	    }
 	  TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
 					LTYPE (tree)->next : NULL);
-	  TETYPE (tree) = getSpec (TTYPE (tree));
-	  tree->args = tree->left->args;
-	  tree->hasVargs = tree->left->hasVargs;
+ 	  TETYPE (tree) = getSpec (TTYPE (tree));
 	  SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
 	  return tree;
 	}
@@ -2761,7 +2689,7 @@ decorateType (ast * tree)
       /* make sure the type is complete and sane */
       checkTypeSanity(LETYPE(tree), "(cast)");
 
-#if 1
+#if 0
       /* if the right is a literal replace the tree */
       if (IS_LITERAL (RETYPE (tree))) {
 	      if (!IS_PTR (LTYPE (tree))) {
@@ -2932,15 +2860,25 @@ decorateType (ast * 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 tree->right->left ;
+	  } else {
+	      return tree->right->right ;
+	  }
+      } else {
+	  TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree).
+	  TETYPE (tree) = getSpec (TTYPE (tree));
+      }
       return tree;
 
     case ':':
@@ -2982,8 +2920,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
     case AND_ASSIGN:
@@ -3011,8 +2947,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3048,8 +2982,6 @@ decorateType (ast * tree)
 	}
       LLVAL (tree) = 1;
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3093,8 +3025,6 @@ decorateType (ast * tree)
       tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
       tree->opval.op = '=';
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3127,20 +3057,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) =
@@ -3148,9 +3065,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))
 	{
@@ -3158,8 +3074,6 @@ decorateType (ast * tree)
 	  goto errorTreeReturn;
 	}
 
-      propAsgType (tree);
-
       return tree;
 
 /*------------------------------------------------------------------*/
@@ -3178,17 +3092,17 @@ decorateType (ast * tree)
       parmNumber = 1;
 
       if (processParms (tree->left,
-			tree->left->args,
+			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)))
 	{
-	  tree->left->args = reverseVal (tree->left->args);
+	  //IFFUNC_ARGS(tree->left->ftype) = 
+	  //reverseVal (IFFUNC_ARGS(tree->left->ftype));
 	  reverseParms (tree->right);
 	}
 
-      tree->args = tree->left->args;
       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
       return tree;
 
@@ -3203,6 +3117,7 @@ decorateType (ast * tree)
       if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
 	{
 	  werror (W_RETURN_MISMATCH);
+	  printFromToType (RTYPE(tree), currFunc->type->next);
 	  goto errorTreeReturn;
 	}
 
@@ -3217,19 +3132,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;
@@ -3611,8 +3517,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);
@@ -4191,7 +4101,7 @@ createFunction (symbol * name, ast * body)
   iCode *piCode = NULL;
 
   /* 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 */
@@ -4225,22 +4135,22 @@ createFunction (symbol * name, ast * body)
   /* 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;
@@ -4263,8 +4173,9 @@ createFunction (symbol * name, ast * body)
 
   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);
@@ -4298,16 +4209,16 @@ skipall:
   /* dealloc the block variables */
   processBlockVars (body, &stack, DEALLOCATE);
   /* deallocate paramaters */
-  deallocParms (name->args);
+  deallocParms (FUNC_ARGS(name->type));
 
-  if (IS_RENT (fetype))
+  if (IFFUNC_ISREENT (name->type))
     reentrant--;
 
   /* we are done freeup memory & cleanup */
   noLineno--;
   labelKey = 1;
   name->key = 0;
-  name->fbody = 1;
+  FUNC_HASBODY(name->type) = 1;
   addSet (&operKeyReset, name);
   applyToSet (operKeyReset, resetParmKey);
 
@@ -4354,25 +4265,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->type, outfile);
+		  arg++;
+		  args=args->next;
+		} 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);
+			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);
+		INDENT(indent,outfile);
 		fprintf(outfile,"}\n");
 		return;
 	}
@@ -4405,7 +4331,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 (");
@@ -4678,7 +4605,9 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		/*         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);
@@ -4762,6 +4691,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		fprintf(outfile,")\n");
 		ast_print(tree->left,outfile,indent+4);
 		ast_print(tree->right,outfile,indent+4);
+		return;
 
 	case ':':
 		fprintf(outfile,"COLON(:) (%p) type (",tree);
@@ -4931,18 +4861,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+4);
 		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+4);
 		return ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
@@ -4975,5 +4904,5 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 
 void PA(ast *t)
 {
-	ast_print(t,stdout,1);
+	ast_print(t,stdout,0);
 }