X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=25640f80b516a75ac0f34a730d41a3c8fbd5fdef;hb=0b9d8951b4695de31eb6a9471df839a2e689c05d;hp=e5b321cad83b0c5533cdb6fe35939a4a653b4fec;hpb=74a75cd59f262e48be5141982112043c3e27ba3b;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index e5b321ca..25640f80 100644
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -46,7 +46,6 @@ int labelKey = 1;
 #define ALLOCATE 1
 #define DEALLOCATE 2
 
-char buffer[1024];
 int noLineno = 0;
 int noAlloc = 0;
 symbol *currFunc;
@@ -180,7 +179,6 @@ newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel)
   /* if this is a literal then we already know the result */
   if (condAst->etype && IS_LITERAL (condAst->etype))
     {
-
       /* then depending on the expression value */
       if (floatFromVal (condAst->opval.val))
 	ifxNode = newNode (GOTO,
@@ -225,7 +223,12 @@ copyAstValues (ast * dest, ast * src)
     case INLINEASM:
       dest->values.inlineasm = Safe_calloc (1, 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));
@@ -462,6 +465,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
 	    {
@@ -611,12 +615,20 @@ processParms (ast * func,
   if (!defParm && !actParm)
     return 0;
 
+  if (defParm) {
+    if (getenv("DEBUG_SANITY")) {
+      fprintf (stderr, "addSym: %s ", defParm->name);
+    }
+    /* make sure the type is complete and sane */
+    checkTypeSanity(defParm->etype, defParm->name);
+  }
+
   /* 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)
     {
-      werror (E_NONRENT_ARGS);
+      werror (W_NONRENT_ARGS);
       return 1;
     }
 
@@ -641,6 +653,7 @@ processParms (ast * func,
   if (!defParm && actParm && func->hasVargs)
     {
       ast *newType = NULL;
+      sym_link *ftype;
 
       if (IS_CAST_OP (actParm)
 	  || (IS_AST_LIT_VALUE (actParm) && actParm->values.literalFromCast))
@@ -649,25 +662,39 @@ 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;
+      }
+          
       /* If it's a small integer, upcast to int. */
-      if (IS_INTEGRAL (actParm->ftype)
-	  && getSize (actParm->ftype) < (unsigned) INTSIZE)
+      if (IS_INTEGRAL (ftype)
+	  && (getSize (ftype) < (unsigned) INTSIZE))
 	{
-	  newType = newAst_LINK (INTTYPE);
+	  newType = newAst_LINK(INTTYPE);
 	}
 
-      if (IS_PTR (actParm->ftype) && !IS_GENPTR (actParm->ftype))
+      if (IS_PTR(ftype) && !IS_GENPTR(ftype))
 	{
-	  newType = newAst_LINK (copyLinkChain (actParm->ftype));
+	  newType = newAst_LINK (copyLinkChain(ftype));
 	  DCL_TYPE (newType->opval.lnk) = GPOINTER;
 	}
 
-      if (IS_AGGREGATE (actParm->ftype))
+      if (IS_AGGREGATE (ftype))
 	{
-	  newType = newAst_LINK (copyLinkChain (actParm->ftype));
+	  newType = newAst_LINK (copyLinkChain (ftype));
 	  DCL_TYPE (newType->opval.lnk) = GPOINTER;
 	}
-
       if (newType)
 	{
 	  /* cast required; change this op to a cast. */
@@ -715,20 +742,20 @@ processParms (ast * func,
 	}
     }
 
+
   /* the parameter type must be at least castable */
-  if (checkType (defParm->type, actParm->ftype) == 0)
-    {
-      werror (E_TYPE_MISMATCH_PARM, *parmNumber);
-      werror (E_CONTINUE, "defined type ");
-      printTypeChain (defParm->type, stderr);
-      fprintf (stderr, "\n");
-      werror (E_CONTINUE, "actual type ");
-      printTypeChain (actParm->ftype, stderr);
-      fprintf (stderr, "\n");
-    }
+  if (compareType (defParm->type, actParm->ftype) == 0) {
+    werror (E_INCOMPAT_TYPES);
+    fprintf (stderr, "type --> '");
+    printTypeChain (actParm->ftype, stderr);
+    fprintf (stderr, "' ");
+    fprintf (stderr, "assigned to type --> '");
+    printTypeChain (defParm->type, stderr);
+    fprintf (stderr, "'\n");
+  }
 
   /* if the parameter is castable then add the cast */
-  if (checkType (defParm->type, actParm->ftype) < 0)
+  if (compareType (defParm->type, actParm->ftype) < 0)
     {
       ast *pTree = resolveSymbols (copyAst (actParm));
 
@@ -810,6 +837,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
   ast *rast = NULL;
   initList *iloop;
   int lcnt = 0, size = 0;
+  literalList *literalL;
 
   /* take care of the special   case  */
   /* array of characters can be init  */
@@ -821,43 +849,77 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 
       return decorateType (resolveSymbols (rast));
 
-  /* not the special case             */
-  if (ilist->type != INIT_DEEP)
+    /* not the special case             */
+    if (ilist->type != INIT_DEEP)
     {
-      werror (E_INIT_STRUCT, "");
-      return NULL;
+	werror (E_INIT_STRUCT, "");
+	return NULL;
     }
 
-  iloop = ilist->init.deep;
-  lcnt = DCL_ELEM (type);
+    iloop = ilist->init.deep;
+    lcnt = DCL_ELEM (type);
 
-  for (;;)
+    if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL))
     {
-      ast *aSym;
-      size++;
+	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)
-	break;
+	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_EXESS_ARRAY_INITIALIZERS, 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_EXESS_ARRAY_INITIALIZERS, name, lineno);
+		
+		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));
 }
 
 
@@ -882,7 +944,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;
@@ -960,6 +1021,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
@@ -969,9 +1031,42 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
 /*-----------------------------------------------------------------*/
 /* initAggregates - initialises aggregate variables with initv     */
 /*-----------------------------------------------------------------*/
-ast *
-initAggregates (symbol * sym, initList * ival, ast * wid)
-{
+
+/* this has to go */ void printIval (symbol *, sym_link *, initList *, FILE *);
+
+ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
+  ast *ast;
+  symbol *newSym;
+
+  if (getenv("TRY_THE_NEW_INITIALIZER")) {
+
+    if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
+      fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
+	       "with -mmcs51 and --model-large");
+      exit(404);
+    }
+
+    if (SPEC_OCLS(sym->etype)==xdata &&
+	getSize(sym->type) > 16) { // else it isn't worth it: do it the old way
+
+      // copy this symbol
+      newSym=copySymbol (sym);
+      SPEC_OCLS(newSym->etype)=code;
+      sprintf (newSym->name, "%s_init__", sym->name);
+      sprintf (newSym->rname,"%s_init__", sym->rname);
+      addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
+
+      // emit it in the static segment
+      addSet(&statsg->syms, newSym);
+
+      // now memcpy() the entire array from cseg
+      ast=newNode (ARRAYINIT, // ASSIGN_AGGREGATE
+		   newAst_VALUE (symbolVal (sym)), 
+		   newAst_VALUE (symbolVal (newSym)));
+      return decorateType(resolveSymbols(ast));
+    }
+  }
+  
   return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
 }
 
@@ -1002,11 +1097,16 @@ gatherAutoInit (symbol * autoChain)
 	  SPEC_SCLS (sym->etype) != S_CODE)
 	{
 	  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);
+	  addSym (SymbolTab, newSym, newSym->rname, 0, 0, 1);
 
 	  /* now lift the code to main */
 	  if (IS_AGGREGATE (sym->type))
@@ -1102,8 +1202,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)
@@ -1120,6 +1220,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)
@@ -1356,11 +1457,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      */
@@ -1511,6 +1626,8 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
 
       if (astHasVolatile (pbody->left))
 	return FALSE;
+      
+      if (astHasDeref(pbody->right)) return FALSE;
 
       return isConformingBody (pbody->left, sym, body) &&
 	isConformingBody (pbody->right, sym, body);
@@ -1677,7 +1794,7 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
 
 }
 
-#define DEMAND_INTEGER_PROMOTION
+//#define DEMAND_INTEGER_PROMOTION
 
 #ifdef DEMAND_INTEGER_PROMOTION
 
@@ -1873,10 +1990,10 @@ decorateType (ast * tree)
 
   switch (tree->opval.op)
     {
-/*------------------------------------------------------------------*/
-/*----------------------------*/
-      /*        array node          */
-/*----------------------------*/
+	    /*------------------------------------------------------------------*/
+	    /*----------------------------*/
+	    /*        array node          */
+	    /*----------------------------*/
     case '[':
 
       /* determine which is the array & which the index */
@@ -1915,10 +2032,10 @@ decorateType (ast * tree)
       }
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*      struct/union          */
-/*----------------------------*/
+      /*----------------------------*/
     case '.':
       /* if this is not a structure */
       if (!IS_STRUCT (LTYPE (tree)))
@@ -1932,10 +2049,10 @@ decorateType (ast * tree)
       TETYPE (tree) = getSpec (TTYPE (tree));
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*    struct/union pointer    */
-/*----------------------------*/
+      /*----------------------------*/
     case PTR_OP:
       /* if not pointer to a structure */
       if (!IS_PTR (LTYPE (tree)))
@@ -1965,7 +2082,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)
@@ -1987,7 +2104,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);
@@ -2017,6 +2134,9 @@ decorateType (ast * tree)
 	      return decorateType (otree);
 	  }
 
+#if 0 
+	  // we can't do this because of "(int & 0xff) << 3"
+
 	  /* if right or left is literal then result of that type */
 	  if (IS_LITERAL (RTYPE (tree)))
 	    {
@@ -2041,6 +2161,11 @@ decorateType (ast * tree)
 		  TETYPE (tree) = getSpec (TTYPE (tree));
 		}
 	    }
+#else
+	  TTYPE (tree) =
+	    computeType (LTYPE (tree), RTYPE (tree));
+	  TETYPE (tree) = getSpec (TTYPE (tree));
+#endif
 	  LRVAL (tree) = RRVAL (tree) = 1;
 	  return tree;
 	}
@@ -2125,7 +2250,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);
@@ -2187,7 +2312,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);
@@ -2271,19 +2396,17 @@ decorateType (ast * tree)
 	}
 
       LRVAL (tree) = RRVAL (tree) = 1;
-      /* promote result to int if left & right are char / short 
+      /* promote result to int if left & right are char
 	 this will facilitate hardware multiplies 8bit x 8bit = 16bit */
-      if ((IS_CHAR(LETYPE(tree)) || IS_SHORT(LETYPE(tree))) && 
-	   (IS_CHAR(RETYPE(tree)) || IS_SHORT(RETYPE(tree)))) {
-	      TETYPE (tree) = getSpec (TTYPE (tree) =
-				       computeType (LTYPE (tree),
-						    RTYPE (tree)));
-	      SPEC_NOUN(TETYPE(tree)) = V_INT;
-	      SPEC_SHORT(TETYPE(tree))=0;
+      if (IS_CHAR(LETYPE(tree)) && IS_CHAR(RETYPE(tree))) {
+	TETYPE (tree) = getSpec (TTYPE (tree) =
+				 computeType (LTYPE (tree),
+					      RTYPE (tree)));
+	SPEC_NOUN(TETYPE(tree)) = V_INT;
       } else {
-	      TETYPE (tree) = getSpec (TTYPE (tree) =
-				       computeType (LTYPE (tree),
-						    RTYPE (tree)));
+	TETYPE (tree) = getSpec (TTYPE (tree) =
+				 computeType (LTYPE (tree),
+					      RTYPE (tree)));
       }
       return tree;
 
@@ -2548,7 +2671,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);
@@ -2594,10 +2717,10 @@ decorateType (ast * tree)
 	}
       return tree;
 
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+      /*------------------------------------------------------------------*/
+      /*----------------------------*/
       /*         casting            */
-/*----------------------------*/
+      /*----------------------------*/
     case CAST:			/* change the type   */
       /* cannot cast to an aggregate type */
       if (IS_AGGREGATE (LTYPE (tree)))
@@ -2605,24 +2728,55 @@ decorateType (ast * tree)
 	  werror (E_CAST_ILLEGAL);
 	  goto errorTreeReturn;
 	}
+      
+      /* make sure the type is complete and sane */
+      checkTypeSanity(LETYPE(tree), "(cast)");
 
+#if 0
       /* if the right is a literal replace the tree */
-      if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree)))
-	{
-	  tree->type = EX_VALUE;
-	  tree->opval.val =
-	    valCastLiteral (LTYPE (tree),
-			    floatFromVal (valFromType (RETYPE (tree))));
-	  tree->left = NULL;
-	  tree->right = NULL;
-	  TTYPE (tree) = tree->opval.val->type;
-	  tree->values.literalFromCast = 1;
-	}
-      else
-	{
-	  TTYPE (tree) = LTYPE (tree);
-	  LRVAL (tree) = 1;
-	}
+      if (IS_LITERAL (RETYPE (tree))) {
+	      if (!IS_PTR (LTYPE (tree))) {
+		      tree->type = EX_VALUE;
+		      tree->opval.val =
+			      valCastLiteral (LTYPE (tree),
+					      floatFromVal (valFromType (RETYPE (tree))));
+		      tree->left = NULL;
+		      tree->right = NULL;
+		      TTYPE (tree) = tree->opval.val->type;
+		      tree->values.literalFromCast = 1;
+	      } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) && 
+			 ((int)floatFromVal(valFromType(RETYPE(tree)))) !=0 ) /* special case of NULL */  {
+		      sym_link *rest = LTYPE(tree)->next;
+		      werror(W_LITERAL_GENERIC);		      
+		      TTYPE(tree) = newLink();
+		      DCL_TYPE(TTYPE(tree)) = FPOINTER;
+		      TTYPE(tree)->next = rest;
+		      tree->left->opval.lnk = TTYPE(tree);
+		      LRVAL (tree) = 1;
+	      } else {
+		      TTYPE (tree) = LTYPE (tree);
+		      LRVAL (tree) = 1;
+	      }
+      } else {
+	      TTYPE (tree) = LTYPE (tree);
+	      LRVAL (tree) = 1;
+      }
+#else
+      /* if 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));
 
@@ -2688,7 +2842,7 @@ decorateType (ast * tree)
       /* if they are pointers they must be castable */
       if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)))
 	{
-	  if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+	  if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	    {
 	      werror (E_COMPARE_OP);
 	      fprintf (stderr, "comparing type ");
@@ -2705,7 +2859,7 @@ decorateType (ast * tree)
 	  if (!((IS_PTR (LTYPE (tree)) && IS_LITERAL (RTYPE (tree))) ||
 		(IS_PTR (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))))
 
-	    if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+	    if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	      {
 		werror (E_COMPARE_OP);
 		fprintf (stderr, "comparing type ");
@@ -2754,14 +2908,15 @@ decorateType (ast * tree)
       /* conditional operator  '?'  */
 /*----------------------------*/
     case '?':
-      /* the type is one on the left */
-      TTYPE (tree) = LTYPE (tree);
+      /* 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));
       return tree;
 
     case ':':
       /* if they don't match we have a problem */
-      if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+      if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	{
 	  werror (E_TYPE_MISMATCH, "conditional operator", " ");
 	  goto errorTreeReturn;
@@ -2926,7 +3081,7 @@ decorateType (ast * tree)
 	}
 
       /* they should either match or be castable */
-      if (checkType (LTYPE (tree), RTYPE (tree)) == 0)
+      if (compareType (LTYPE (tree), RTYPE (tree)) == 0)
 	{
 	  werror (E_TYPE_MISMATCH, "assignment", " ");
 	  fprintf (stderr, "type --> '");
@@ -2951,22 +3106,13 @@ decorateType (ast * tree)
 	  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);
-	}
-
       TETYPE (tree) = getSpec (TTYPE (tree) =
 			       LTYPE (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))
 	{
@@ -3016,9 +3162,9 @@ decorateType (ast * tree)
       if (!tree->right)
 	goto voidcheck;
 
-      if (checkType (currFunc->type->next, RTYPE (tree)) == 0)
+      if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
 	{
-	  werror (E_RETURN_MISMATCH);
+	  werror (W_RETURN_MISMATCH);
 	  goto errorTreeReturn;
 	}
 
@@ -3031,7 +3177,7 @@ decorateType (ast * tree)
 	}
 
       /* if there is going to be a casing required then add it */
-      if (checkType (currFunc->type->next, RTYPE (tree)) < 0)
+      if (compareType (currFunc->type->next, RTYPE (tree)) < 0)
 	{
 #if 0 && defined DEMAND_INTEGER_PROMOTION
 	  if (IS_INTEGRAL (currFunc->type->next))
@@ -3139,6 +3285,9 @@ sizeofOp (sym_link * type)
 {
   char buff[10];
 
+  /* make sure the type is complete and sane */
+  checkTypeSanity(type, "(sizeof)");
+
   /* get the size and convert it to character  */
   sprintf (buff, "%d", getSize (type));
 
@@ -3300,7 +3449,7 @@ createLabel (symbol * label, ast * stmnt)
   if ((csym = findSym (LabelTab, NULL, name)))
     werror (E_DUPLICATE_LABEL, label->name);
   else
-    addSym (LabelTab, label, name, label->level, 0);
+    addSym (LabelTab, label, name, label->level, 0, 0);
 
   label->islbl = 1;
   label->key = labelKey++;
@@ -4124,7 +4273,7 @@ skipall:
   addSet (&operKeyReset, name);
   applyToSet (operKeyReset, resetParmKey);
 
-  if (options.debug && !options.nodebug)
+  if (options.debug)
     cdbStructBlock (1, cdbFile);
 
   cleanUpLevel (LabelTab, 0);