X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=990b4061a47ce1d4e1cf63470befa24136a18cc7;hb=40e2a53c6ad6345313ec47f83c03962aedb7bb9e;hp=fe878f9f29cda6b71acf43f0f1b849cdb0bb9496;hpb=817beb07e406ae505fb0b1354d42025a1bfd14ce;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index fe878f9f..990b4061 100644
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -47,7 +47,7 @@ int labelKey = 1;
 
 int noLineno = 0;
 int noAlloc = 0;
-symbol *currFunc;
+symbol *currFunc=NULL;
 static ast *createIval (ast *, sym_link *, initList *, ast *);
 static ast *createIvalCharPtr (ast *, sym_link *, ast *);
 static ast *optimizeCompare (ast *);
@@ -78,7 +78,7 @@ newAst_ (unsigned type)
   ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
-  ex->lineno = (noLineno ? oldLineno : yylineno);
+  ex->lineno = (noLineno ? oldLineno : mylineno);
   ex->filename = currFname;
   ex->level = NestLevel;
   ex->block = currBlockno;
@@ -110,14 +110,6 @@ newAst_LINK (sym_link * val)
   return ex;
 }
 
-ast *
-newAst_STMNT (unsigned val)
-{
-  ast *ex = newAst_ (EX_STMNT);
-  ex->opval.stmnt = val;
-  return ex;
-}
-
 /*-----------------------------------------------------------------*/
 /* newNode - creates a new node                                    */
 /*-----------------------------------------------------------------*/
@@ -448,7 +440,7 @@ resolveSymbols (ast * tree)
 	  /* mark it as returning an int     */
 	  if (tree->funcName)
 	    {
-	      tree->opval.val->sym->type = newLink ();
+	      tree->opval.val->sym->type = newLink (DECLARATOR);
 	      DCL_TYPE (tree->opval.val->sym->type) = FUNCTION;
 	      tree->opval.val->sym->type->next =
 		tree->opval.val->sym->etype = newIntLink ();
@@ -501,7 +493,7 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
   sym = newSymbol (name, 0);
 
   /* setup return value */
-  sym->type = newLink ();
+  sym->type = newLink (DECLARATOR);
   DCL_TYPE (sym->type) = FUNCTION;
   sym->type->next = copyLinkChain (type);
   sym->etype = getSpec (sym->type);
@@ -545,7 +537,7 @@ funcOfTypeVarg (char *name, char * rtype, int nArgs , char **atypes)
     sym = newSymbol (name, 0);
     
     /* setup return value */
-    sym->type = newLink ();
+    sym->type = newLink (DECLARATOR);
     DCL_TYPE (sym->type) = FUNCTION;
     sym->type->next = typeFromStr(rtype);
     sym->etype = getSpec (sym->type);
@@ -1211,14 +1203,14 @@ processBlockVars (ast * tree, int *stack, int action)
       ast *autoInit;
 
       if (action == ALLOCATE)
-	{
+        {
 	  *stack += allocVariables (tree->values.sym);
 	  autoInit = gatherAutoInit (tree->values.sym);
-
+	
 	  /* if there are auto inits then do them */
 	  if (autoInit)
 	    tree->left = newNode (NULLOP, autoInit, tree->left);
-	}
+        }
       else			/* action is deallocate */
 	deallocLocal (tree->values.sym);
     }
@@ -1228,6 +1220,7 @@ processBlockVars (ast * tree, int *stack, int action)
   return tree;
 }
 
+
 /*-------------------------------------------------------------*/
 /* constExprTree - returns TRUE if this tree is a constant     */
 /*                 expression                                  */
@@ -1239,7 +1232,7 @@ bool constExprTree (ast *cexpr) {
   }
 
   cexpr = decorateType (resolveSymbols (cexpr));
-  
+
   switch (cexpr->type) 
     {
     case EX_VALUE:
@@ -1259,6 +1252,7 @@ bool constExprTree (ast *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
+        //printf(" code space symbol");
 	return TRUE;
       }
       return FALSE;
@@ -1275,7 +1269,7 @@ bool constExprTree (ast *cexpr) {
 	return constExprTree(cexpr->right);
       }
       if (cexpr->opval.op==CAST) {
-	// jwk: cast ignored, maybe we should throw a warning here
+	// cast ignored, maybe we should throw a warning here?
 	return constExprTree(cexpr->right);
       }
       if (cexpr->opval.op=='&') { 
@@ -1287,9 +1281,12 @@ bool constExprTree (ast *cexpr) {
       if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) {
 	return TRUE;
       }
+      return FALSE;
+    case EX_OPERAND:
+      return IS_CONSTANT(operandType(cexpr->opval.oprnd));
     }
   return FALSE;
-}  
+}
     
 /*-----------------------------------------------------------------*/
 /* constExprValue - returns the value of a constant expression     */
@@ -1322,11 +1319,15 @@ constExprValue (ast * cexpr, int check)
       if (IS_AST_OP (cexpr) &&
 	  cexpr->opval.op == CAST &&
 	  IS_LITERAL (cexpr->right->ftype))
+        {
 	return valCastLiteral (cexpr->ftype,
 			       floatFromVal (cexpr->right->opval.val));
+        }
 
       if (IS_AST_VALUE (cexpr))
+        {
 	return cexpr->opval.val;
+        }
 
       if (check)
 	werror (E_CONST_EXPECTED, "found expression");
@@ -1702,7 +1703,7 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
 	  return FALSE;
 	// if the loopvar is used in another (maybe conditional) block
 	if (astHasSymbol (pbody->right, sym) &&
-	    (pbody->level > body->level)) {
+	    (pbody->level >= body->level)) {
 	  return FALSE;
 	}
       }
@@ -1998,11 +1999,13 @@ decorateType (ast * tree)
       tree->left = dtl;
     if (dtr != tree->right)
       tree->right = dtr;
+    if ((dtl && dtl->isError) || (dtr && dtr->isError))
+      return tree;
 
     if (IS_AST_OP(tree) &&
 	(tree->opval.op == CAST || tree->opval.op == '=') &&
 	(getSize(LTYPE(tree)) > getSize(RTYPE(tree))) &&
-	(getSize(RTYPE(tree)) < INTSIZE)) {
+	(getSize(RTYPE(tree)) < (unsigned) INTSIZE)) {
       // this is a cast/assign to a bigger type
       if (IS_AST_OP(tree->right) &&
 	  IS_INTEGRAL(tree->right->ftype) &&
@@ -2061,9 +2064,6 @@ decorateType (ast * tree)
 	}
       RRVAL (tree) = 1;
       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)->next);
-      if (IS_PTR(LTYPE(tree))) {
-	      SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
-      }
       return tree;
 
       /*------------------------------------------------------------------*/
@@ -2132,6 +2132,39 @@ decorateType (ast * tree)
       case FUNCTION:
       	break;
       }
+      
+      if (IS_ADDRESS_OF_OP (tree->left) && IS_AST_SYM_VALUE(tree->left->left)
+          && SPEC_ABSA (AST_SYMBOL (tree->left->left)->etype))
+        {
+            /* If defined    struct type at addr var
+               then rewrite  (&struct var)->member
+               as            temp
+               and define    membertype at (addr+offsetof(struct var,member)) temp
+            */
+            symbol *sym;
+            symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree)),
+					        AST_SYMBOL(tree->right));
+
+            sym = newSymbol(genSymName (0), 0);
+            sym->type = TTYPE (tree);
+            sym->etype = getSpec(sym->type);
+            sym->lineDef = tree->lineno;
+            sym->cdef = 1;
+            sym->isref = 1;
+            SPEC_STAT (sym->etype) = 1;
+            SPEC_ADDR (sym->etype) = SPEC_ADDR (AST_SYMBOL (tree->left->left)->etype)
+                                     + element->offset;
+            SPEC_ABSA(sym->etype) = 1;
+            addSym (SymbolTab, sym, sym->name, 0, 0, 0);
+            allocGlobal (sym);
+            
+            AST_VALUE (tree) = symbolVal(sym);
+            TLVAL (tree) = 1;
+            TRVAL (tree) = 0;
+            tree->type = EX_VALUE;
+            tree->left = NULL;
+            tree->right = NULL;          
+        }
 
       return tree;
 
@@ -2139,13 +2172,13 @@ decorateType (ast * tree)
       /*----------------------------*/
       /*  ++/-- operation           */
       /*----------------------------*/
-    case INC_OP:		/* incerement operator unary so left only */
+    case INC_OP:		/* increment 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)))
-	  werror (E_CODE_WRITE, "++/--");
+        if (!tree->initMode && IS_CONSTANT(TTYPE(tree)))
+	  werror (E_CODE_WRITE, tree->opval.op==INC_OP ? "++" : "--");
 
 	if (tree->right)
 	  RLVAL (tree) = 1;
@@ -2208,8 +2241,7 @@ decorateType (ast * tree)
       /*----------------------------*/
       /*  address of                */
       /*----------------------------*/
-      p = newLink ();
-      p->class = DECLARATOR;
+      p = newLink (DECLARATOR);
       /* if bit field then error */
       if (IS_BITVAR (tree->left->etype))
 	{
@@ -2241,10 +2273,7 @@ decorateType (ast * tree)
 	  goto errorTreeReturn;
 	}
       if (SPEC_SCLS (tree->left->etype) == S_CODE)
-	{
-	  DCL_TYPE (p) = CPOINTER;
-	  DCL_PTR_CONST (p) = port->mem.code_ro;
-	}
+	DCL_TYPE (p) = CPOINTER;
       else if (SPEC_SCLS (tree->left->etype) == S_XDATA)
 	DCL_TYPE (p) = FPOINTER;
       else if (SPEC_SCLS (tree->left->etype) == S_XSTACK)
@@ -2267,10 +2296,24 @@ decorateType (ast * tree)
       p->next = LTYPE (tree);
       TTYPE (tree) = p;
       TETYPE (tree) = getSpec (TTYPE (tree));
-      DCL_PTR_CONST (p) = SPEC_CONST (TETYPE (tree));
-      DCL_PTR_VOLATILE (p) = SPEC_VOLATILE (TETYPE (tree));
       LLVAL (tree) = 1;
       TLVAL (tree) = 1;
+
+      #if 0      
+      if (IS_AST_OP (tree->left) && tree->left->opval.op == PTR_OP
+          && IS_AST_VALUE (tree->left->left) && !IS_AST_SYM_VALUE (tree->left->left))
+        {  
+          symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree->left)),
+				      AST_SYMBOL(tree->left->right));
+	  AST_VALUE(tree) = valPlus(AST_VALUE(tree->left->left),
+                                    valueFromLit(element->offset));
+	  tree->left = NULL;
+	  tree->right = NULL;
+	  tree->type = EX_VALUE;
+	  tree->values.literalFromCast = 1;
+        }
+      #endif
+      
       return tree;
 
       /*------------------------------------------------------------------*/
@@ -2398,10 +2441,13 @@ decorateType (ast * tree)
 	      werror (E_LVALUE_REQUIRED, "pointer deref");
 	      goto errorTreeReturn;
 	    }
-	  TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
-					LTYPE (tree)->next : NULL);
- 	  TETYPE (tree) = getSpec (TTYPE (tree));
-	  SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
+	  if (IS_ADDRESS_OF_OP(tree->left))
+            {
+              /* replace *&obj with obj */
+              return tree->left->left;
+            }
+          TTYPE (tree) = copyLinkChain (LTYPE (tree)->next);
+	  TETYPE (tree) = getSpec (TTYPE (tree));
 	  return tree;
 	}
 
@@ -2565,7 +2611,7 @@ decorateType (ast * tree)
 	      return tree;
 	    }
 	  LRVAL (tree) = 1;
-	  TTYPE (tree) = LTYPE (tree);
+	  TETYPE(tree) = getSpec (TTYPE (tree) = LTYPE (tree));
 	  return tree;
 	}
 
@@ -2788,11 +2834,11 @@ decorateType (ast * tree)
 		      tree->right = NULL;
 		      TTYPE (tree) = tree->opval.val->type;
 		      tree->values.literalFromCast = 1;
-	      } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) && 
+	      } 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();
+		      werror(W_LITERAL_GENERIC);
+		      TTYPE(tree) = newLink(DECLARATOR);
 		      DCL_TYPE(TTYPE(tree)) = FPOINTER;
 		      TTYPE(tree)->next = rest;
 		      tree->left->opval.lnk = TTYPE(tree);
@@ -2810,26 +2856,114 @@ decorateType (ast * tree)
       /* 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)) 
+	  strcmp(SPEC_STRUCT(LETYPE(tree))->tag,SPEC_STRUCT(RETYPE(tree))->tag))
 	{
 	  werror(W_CAST_STRUCT_PTR,SPEC_STRUCT(RETYPE(tree))->tag,
 		 SPEC_STRUCT(LETYPE(tree))->tag);
 	}
 #endif
-      /* if the right is a literal replace the tree */
-      if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree))) {
-	tree->type = EX_VALUE;
+      if (IS_ADDRESS_OF_OP(tree->right)
+          && IS_AST_SYM_VALUE (tree->right->left)
+          && SPEC_ABSA (AST_SYMBOL (tree->right->left)->etype)) {
+	    
+        tree->type = EX_VALUE;
 	tree->opval.val =
 	  valCastLiteral (LTYPE (tree),
-			  floatFromVal (valFromType (RETYPE (tree))));
+			  SPEC_ADDR (AST_SYMBOL (tree->right->left)->etype));
+	TTYPE (tree) = tree->opval.val->type;
+        TETYPE (tree) = getSpec (TTYPE (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;
+        return tree;
+      }
+      
+      /* handle offsetof macro:            */
+      /* #define offsetof(TYPE, MEMBER) \  */
+      /* ((unsigned) &((TYPE *)0)->MEMBER) */      
+      if (IS_ADDRESS_OF_OP(tree->right)
+          && IS_AST_OP (tree->right->left)
+          && tree->right->left->opval.op == PTR_OP
+          && IS_AST_OP (tree->right->left->left)
+          && tree->right->left->left->opval.op == CAST
+          && IS_AST_LIT_VALUE(tree->right->left->left->right)) {
+            
+        symbol *element = getStructElement (
+          SPEC_STRUCT (LETYPE(tree->right->left)),
+	  AST_SYMBOL(tree->right->left->right)
+        );
+	
+        if (element) {
+          tree->type = EX_VALUE;
+	  tree->opval.val = valCastLiteral (
+	    LTYPE (tree),
+	    element->offset
+            + floatFromVal (valFromType (RETYPE (tree->right->left->left)))
+          );
+        
+	  TTYPE (tree) = tree->opval.val->type;
+          TETYPE (tree) = getSpec (TTYPE (tree));
+	  tree->left = NULL;
+	  tree->right = NULL;
+          return tree;
+        }
       }
+      
+      /* if the right is a literal replace the tree */
+      if (IS_LITERAL (RETYPE (tree))) {
+        if (IS_PTR (LTYPE (tree)) && !IS_GENPTR (LTYPE (tree)) ) {
+          /* rewrite      (type *)litaddr
+             as           &temp
+             and define   type at litaddr temp
+             (but only if type's storage class is not generic)
+          */
+          ast *newTree = newNode ('&', NULL, NULL);
+          symbol *sym;
+
+          TTYPE (newTree) = LTYPE (tree);
+          TETYPE (newTree) = getSpec(LTYPE (tree));
+
+          /* define a global symbol at the casted address*/
+          sym = newSymbol(genSymName (0), 0);
+          sym->type = LTYPE (tree)->next;
+          if (!sym->type)
+            sym->type = newLink (V_VOID);
+          sym->etype = getSpec(sym->type);
+          SPEC_SCLS (sym->etype) = sclsFromPtr (LTYPE (tree));
+          sym->lineDef = tree->lineno;
+          sym->cdef = 1;
+          sym->isref = 1;
+          SPEC_STAT (sym->etype) = 1;
+          SPEC_ADDR(sym->etype) = floatFromVal (valFromType (RETYPE (tree)));
+          SPEC_ABSA(sym->etype) = 1;
+          addSym (SymbolTab, sym, sym->name, 0, 0, 0);
+          allocGlobal (sym);
+
+          newTree->left = newAst_VALUE(symbolVal(sym));
+          newTree->left->lineno = tree->lineno;
+          LTYPE (newTree) = sym->type;
+          LETYPE (newTree) = sym->etype;
+	  LLVAL (newTree) = 1;
+          LRVAL (newTree) = 0;
+          TLVAL (newTree) = 1;
+          return newTree;
+        }
+        if (!IS_PTR (LTYPE (tree))) {
+	  tree->type = EX_VALUE;
+	  tree->opval.val =
+	  valCastLiteral (LTYPE (tree),
+			  floatFromVal (valFromType (RETYPE (tree))));
+	  TTYPE (tree) = tree->opval.val->type;
+	  tree->left = NULL;
+	  tree->right = NULL;
+	  tree->values.literalFromCast = 1;
+	  TETYPE (tree) = getSpec (TTYPE (tree));
+          return tree;
+        }
+      }
+      TTYPE (tree) = LTYPE (tree);
+      LRVAL (tree) = 1;
+      
 #endif      
       TETYPE (tree) = getSpec (TTYPE (tree));
 
@@ -2895,10 +3029,17 @@ decorateType (ast * tree)
       /* if they are pointers they must be castable */
       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)))
 	{
+	  if (tree->opval.op==EQ_OP && 
+	      !IS_GENPTR(LTYPE(tree)) && IS_GENPTR(RTYPE(tree))) {
+	    // we cannot cast a gptr to a !gptr: switch the leaves
+	    struct ast *s=tree->left;
+	    tree->left=tree->right;
+	    tree->right=s;
+	  }
 	  if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	    {
 	      werror (E_COMPARE_OP);
-	      fprintf (stderr, "comparing type ");
+	      fprintf (stderr, "comparring type ");
 	      printTypeChain (LTYPE (tree), stderr);
 	      fprintf (stderr, "to type ");
 	      printTypeChain (RTYPE (tree), stderr);
@@ -2925,7 +3066,7 @@ decorateType (ast * tree)
 	}
       /* if unsigned value < 0  then always false */
       /* if (unsigned value) > 0 then (unsigned value) */
-      if (SPEC_USIGN(LETYPE(tree)) && IS_LITERAL(RTYPE(tree)) && 
+      if (SPEC_USIGN(LETYPE(tree)) && IS_LITERAL(RTYPE(tree))  && 
 	  ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) {
 
 	  if (tree->opval.op == '<') {
@@ -2994,6 +3135,9 @@ decorateType (ast * tree)
 		case V_STRUCT:
 		    typeofv = TYPEOF_STRUCT;
 		    break;
+		case V_BITFIELD:
+		    typeofv = TYPEOF_BITFIELD;
+		    break;
 		case V_BIT:
 		    typeofv = TYPEOF_BIT;
 		    break;
@@ -3092,12 +3236,12 @@ decorateType (ast * tree)
       RRVAL (tree) = 1;
       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree));
 
-      if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
-	werror (E_CODE_WRITE, " ");
+      if (!tree->initMode && IS_CONSTANT (LTYPE (tree)))
+	werror (E_CODE_WRITE, *tree->opval.op==MUL_ASSIGN ? "*=" : "/=");
 
       if (LRVAL (tree))
 	{
-	  werror (E_LVALUE_REQUIRED, "*= or /=");
+	  werror (E_LVALUE_REQUIRED, *tree->opval.op==MUL_ASSIGN ? "*=" : "/=");
 	  goto errorTreeReturn;
 	}
       LLVAL (tree) = 1;
@@ -3120,7 +3264,7 @@ decorateType (ast * tree)
       TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree));
 
       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
-	werror (E_CODE_WRITE, " ");
+	werror (E_CODE_WRITE, "&= or |= or ^= or >>= or <<=");
 
       if (LRVAL (tree))
 	{
@@ -3155,7 +3299,7 @@ decorateType (ast * tree)
 					    RTYPE (tree)));
 
       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
-	werror (E_CODE_WRITE, " ");
+	werror (E_CODE_WRITE, "-=");
 
       if (LRVAL (tree))
 	{
@@ -3196,7 +3340,7 @@ decorateType (ast * tree)
 					    RTYPE (tree)));
 
       if (!tree->initMode && IS_CONSTANT (LETYPE (tree)))
-	werror (E_CODE_WRITE, " ");
+	werror (E_CODE_WRITE, "+=");
 
       if (LRVAL (tree))
 	{
@@ -3227,7 +3371,6 @@ decorateType (ast * tree)
 	{
 	  werror (E_TYPE_MISMATCH, "assignment", " ");
 	  printFromToType(RTYPE(tree),LTYPE(tree));
-	  //goto errorTreeReturn;
 	}
 
       /* if the left side of the tree is of type void
@@ -3243,8 +3386,8 @@ decorateType (ast * tree)
       RRVAL (tree) = 1;
       LLVAL (tree) = 1;
       if (!tree->initMode ) {
-	if ((IS_SPEC(LETYPE(tree)) && IS_CONSTANT (LETYPE (tree))))
-	  werror (E_CODE_WRITE, " ");
+        if (IS_CONSTANT(LTYPE(tree)))
+	  werror (E_CODE_WRITE, "=");
       }
       if (LRVAL (tree))
 	{
@@ -3278,12 +3421,15 @@ decorateType (ast * tree)
       if ((options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) && 
 	  !IFFUNC_ISBUILTIN(LTYPE(tree)))
 	{
-	  //FUNC_ARGS(tree->left->ftype) = 
-	  //reverseVal (FUNC_ARGS(tree->left->ftype));
 	  reverseParms (tree->right);
 	}
 
-      TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
+      if (IS_CODEPTR(LTYPE(tree))) {
+	TTYPE(tree) = LTYPE(tree)->next->next;
+      } else {
+	TTYPE(tree) = LTYPE(tree)->next;
+      }
+      TETYPE (tree) = getSpec (TTYPE (tree));
       return tree;
 
       /*------------------------------------------------------------------*/
@@ -3325,7 +3471,7 @@ decorateType (ast * tree)
 
       if (!IS_VOID (currFunc->type->next) && tree->right == NULL)
 	{
-	  werror (E_VOID_FUNC, currFunc->name);
+	  werror (W_VOID_FUNC, currFunc->name);
 	  goto errorTreeReturn;
 	}
 
@@ -3447,7 +3593,7 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel)
       static int localLbl = 0;
       symbol *localLabel;
 
-      SNPRINTF(buffer, sizeof(buffer), "_and_%d", localLbl++);
+      SNPRINTF(buffer, sizeof(buffer), "_andif_%d", localLbl++);
       localLabel = newSymbol (buffer, NestLevel);
 
       tree->left = backPatchLabels (tree->left, localLabel, falseLabel);
@@ -3473,7 +3619,7 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel)
       static int localLbl = 0;
       symbol *localLabel;
 
-      SNPRINTF(buffer, sizeof(buffer), "_or_%d", localLbl++);
+      SNPRINTF(buffer, sizeof(buffer), "_orif_%d", localLbl++);
       localLabel = newSymbol (buffer, NestLevel);
 
       tree->left = backPatchLabels (tree->left, trueLabel, localLabel);
@@ -3535,12 +3681,12 @@ createBlock (symbol * decl, ast * body)
   ast *ex;
 
   /* if the block has nothing */
-  if (!body)
+  if (!body && !decl)
     return NULL;
 
   ex = newNode (BLOCK, NULL, body);
   ex->values.sym = decl;
-
+  
   ex->right = ex->right;
   ex->level++;
   ex->lineno = 0;
@@ -4313,7 +4459,7 @@ createFunction (symbol * name, ast * body)
       addSymChain (name);
       allocVariables (name);
     }
-  name->lastLine = yylineno;
+  name->lastLine = mylineno;
   currFunc = name;
 
   /* set the stack pointer */
@@ -4392,6 +4538,7 @@ skipall:
 
   /* dealloc the block variables */
   processBlockVars (body, &stack, DEALLOCATE);
+  outputDebugStackSymbols();
   /* deallocate paramaters */
   deallocParms (FUNC_ARGS(name->type));
 
@@ -4406,8 +4553,8 @@ skipall:
   addSet (&operKeyReset, name);
   applyToSet (operKeyReset, resetParmKey);
 
-  if (options.debug)
-    cdbStructBlock (1, cdbFile);
+  if (options.debug)    
+    cdbStructBlock(1);
 
   cleanUpLevel (LabelTab, 0);
   cleanUpBlock (StructTab, 1);
@@ -4419,7 +4566,7 @@ skipall:
 }
 
 
-#define INDENT(x,f) { int i ; for (i=0;i < x; i++) fprintf(f," "); }
+#define INDENT(x,f) { int i ; fprintf (f, "%d:", tree->lineno); for (i=0;i < x; i++) fprintf(f," "); }
 /*-----------------------------------------------------------------*/
 /* ast_print : prints the ast (for debugging purposes)             */
 /*-----------------------------------------------------------------*/
@@ -4453,7 +4600,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		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);
+		printTypeChain (tree->left->opval.val->type->next,outfile);
 		fprintf(outfile,") args (");
 		do {
 		  if (arg) {
@@ -4487,9 +4634,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		return;
 	}
 	if (tree->opval.op == NULLOP) {
-		fprintf(outfile,"\n");
 		ast_print(tree->left,outfile,indent);
-		fprintf(outfile,"\n");
 		ast_print(tree->right,outfile,indent);
 		return ;
 	}
@@ -4503,11 +4648,14 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 	/* just get the type        */
 	if (tree->type == EX_VALUE) {
 
-		if (IS_LITERAL (tree->opval.val->etype)) {			
-			fprintf(outfile,"CONSTANT (%p) value = %d, 0x%x, %g", tree,
-				(int) floatFromVal(tree->opval.val),
-				(int) floatFromVal(tree->opval.val),
-			        floatFromVal(tree->opval.val));
+		if (IS_LITERAL (tree->opval.val->etype)) {
+			fprintf(outfile,"CONSTANT (%p) value = ", tree);
+			if (SPEC_USIGN (tree->opval.val->etype))
+				fprintf(outfile,"%u", (TYPE_UDWORD) floatFromVal(tree->opval.val));
+			else
+				fprintf(outfile,"%d", (TYPE_DWORD) floatFromVal(tree->opval.val));
+			fprintf(outfile,", 0x%x, %g", (TYPE_UDWORD) floatFromVal(tree->opval.val),
+			                              floatFromVal(tree->opval.val));
 		} else if (tree->opval.val->sym) {
 			/* if the undefined flag is set then give error message */
 			if (tree->opval.val->sym->undefined) {
@@ -4911,14 +5059,14 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		ast_print(tree->right,outfile,indent+2);
 		return;
 	case OR_ASSIGN:
-		fprintf(outfile,"ORASS(*=) (%p) type (",tree);
+		fprintf(outfile,"ORASS(|=) (%p) type (",tree);
 		printTypeChain(tree->ftype,outfile);
 		fprintf(outfile,")\n");
 		ast_print(tree->left,outfile,indent+2);
 		ast_print(tree->right,outfile,indent+2);
 		return;
 	case XOR_ASSIGN:
-		fprintf(outfile,"XORASS(*=) (%p) type (",tree);
+		fprintf(outfile,"XORASS(^=) (%p) type (",tree);
 		printTypeChain(tree->ftype,outfile);
 		fprintf(outfile,")\n");
 		ast_print(tree->left,outfile,indent+2);
@@ -4932,7 +5080,7 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		ast_print(tree->right,outfile,indent+2);
 		return;
 	case LEFT_ASSIGN:
-		fprintf(outfile,"LSHFTASS(*=) (%p) type (",tree);
+		fprintf(outfile,"LSHFTASS(<<=) (%p) type (",tree);
 		printTypeChain(tree->ftype,outfile);
 		fprintf(outfile,")\n");
 		ast_print(tree->left,outfile,indent+2);
@@ -5049,15 +5197,23 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		fprintf(outfile,"IF (%p) \n",tree);
 		ast_print(tree->left,outfile,indent+2);
 		if (tree->trueLabel) {
-			INDENT(indent,outfile);
+			INDENT(indent+2,outfile);
 			fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name);
 		}
 		if (tree->falseLabel) {
-			INDENT(indent,outfile);
+			INDENT(indent+2,outfile);
 			fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name);
 		}
 		ast_print(tree->right,outfile,indent+2);
 		return ;
+		/*----------------------------*/
+		/* goto Statement              */
+		/*----------------------------*/
+	case GOTO:
+		fprintf(outfile,"GOTO (%p) \n",tree);
+		ast_print(tree->left,outfile,indent+2);
+		fprintf(outfile,"\n");
+		return ;
 		/*------------------------------------------------------------------*/
 		/*----------------------------*/
 		/* for Statement              */