X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=52e51ba446f393514edc865b0413a1d356d6abba;hb=493fa3118ec8e61be835bdffbf11a5494d9fab18;hp=41eb8313f58c4ac09e6492e85db1af8a8b15d579;hpb=0de080001628cebd436f7fbb070234c83c6bff64;p=fw%2Fsdcc

diff --git a/src/SDCCast.c b/src/SDCCast.c
index 41eb8313..52e51ba4 100644
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -559,6 +559,7 @@ funcOfType (char *name, sym_link * type, sym_link * argType,
 	{
 	  args->type = copyLinkChain (argType);
 	  args->etype = getSpec (args->type);
+	  SPEC_EXTR(args->etype)=1;
 	  if (!nArgs)
 	    break;
 	  args = args->next = newValue ();
@@ -605,7 +606,7 @@ processParms (ast * func,
 	      value *defParm,
 	      ast * actParm,
 	      int *parmNumber, // unused, although updated
-	      bool rightmost) // double checked?
+	      bool rightmost)
 {
   /* if none of them exist */
   if (!defParm && !actParm)
@@ -661,20 +662,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)
@@ -697,7 +685,7 @@ processParms (ast * func,
       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;
@@ -751,7 +739,7 @@ processParms (ast * func,
   /* 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;
@@ -760,6 +748,8 @@ processParms (ast * func,
       actParm->right = pTree;
       actParm->etype = defParm->etype;
       actParm->ftype = defParm->type;
+      actParm->decorated=0; /* force typechecking */
+      decorateType (actParm);
     }
 
   /* make a copy and change the regparm type to the defined parm */
@@ -814,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;
 }
 
@@ -871,7 +867,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 	    char *name=sym->opval.val->sym->name;
 	    int lineno=sym->opval.val->sym->lineDef;
 	    
-	    werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+	    werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
 	}
     }
     else
@@ -896,7 +892,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist)
 		// there has to be a better way
 		char *name=sym->opval.val->sym->name;
 		int lineno=sym->opval.val->sym->lineDef;
-		werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+		werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
 		
 		break;
 	    }
@@ -1099,11 +1095,16 @@ gatherAutoInit (symbol * autoChain)
 	  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);
 
@@ -1119,11 +1120,16 @@ gatherAutoInit (symbol * autoChain)
       /* if there is an initial value */
       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
 	{
-	  if (IS_AGGREGATE (sym->type))
+	  if (IS_AGGREGATE (sym->type)) {
 	    work = initAggregates (sym, sym->ival, NULL);
-	  else
+	  } else {
+	    if (getNelements(sym->type, sym->ival)>1) {
+	      werror (W_EXCESS_INITIALIZERS, "scalar", 
+		      sym->name, sym->lineDef);
+	    }
 	    work = newNode ('=', newAst_VALUE (symbolVal (sym)),
 			    list2expr (sym->ival));
+	  }
 
 	  setAstLineno (work, sym->lineDef);
 	  sym->ival = NULL;
@@ -2087,38 +2093,10 @@ decorateType (ast * tree)
 	      return decorateType (otree);
 	  }
 
-#if 0 
-	  // we can't do this because of "(int & 0xff) << 3"
-
-	  /* if right or left is literal then result of that type */
-	  if (IS_LITERAL (RTYPE (tree)))
-	    {
-
-	      TTYPE (tree) = copyLinkChain (RTYPE (tree));
-	      TETYPE (tree) = getSpec (TTYPE (tree));
-	      SPEC_SCLS (TETYPE (tree)) = S_AUTO;
-	    }
-	  else
-	    {
-	      if (IS_LITERAL (LTYPE (tree)))
-		{
-		  TTYPE (tree) = copyLinkChain (LTYPE (tree));
-		  TETYPE (tree) = getSpec (TTYPE (tree));
-		  SPEC_SCLS (TETYPE (tree)) = S_AUTO;
-
-		}
-	      else
-		{
-		  TTYPE (tree) =
-		    computeType (LTYPE (tree), RTYPE (tree));
-		  TETYPE (tree) = getSpec (TTYPE (tree));
-		}
-	    }
-#else
 	  TTYPE (tree) =
 	    computeType (LTYPE (tree), RTYPE (tree));
 	  TETYPE (tree) = getSpec (TTYPE (tree));
-#endif
+
 	  LRVAL (tree) = RRVAL (tree) = 1;
 	  return tree;
 	}
@@ -2172,8 +2150,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))
 	{
@@ -2719,6 +2699,12 @@ decorateType (ast * tree)
 	      LRVAL (tree) = 1;
       }
 #else
+      /* if pointer to struct then check names */
+      if (IS_PTR(LTYPE(tree)) && IS_STRUCT(LTYPE(tree)->next) &&
+	  IS_PTR(RTYPE(tree)) && IS_STRUCT(RTYPE(tree)->next) &&
+	  strcmp(SPEC_STRUCT(LETYPE(tree))->tag,SPEC_STRUCT(RETYPE(tree))->tag)) {
+	      werror(W_CAST_STRUCT_PTR,SPEC_STRUCT(RETYPE(tree))->tag,SPEC_STRUCT(LETYPE(tree))->tag);
+      }
       /* if the right is a literal replace the tree */
       if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree))) {
 	tree->type = EX_VALUE;
@@ -2733,8 +2719,7 @@ decorateType (ast * tree)
 	TTYPE (tree) = LTYPE (tree);
 	LRVAL (tree) = 1;
       }
-#endif
-
+#endif      
       TETYPE (tree) = getSpec (TTYPE (tree));
 
       return tree;
@@ -2876,7 +2861,7 @@ decorateType (ast * tree)
 	      return tree->right->right ;
 	  }
       } else {
-	  TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree).
+	  TTYPE (tree) = RTYPE(tree);
 	  TETYPE (tree) = getSpec (TTYPE (tree));
       }
       return tree;
@@ -3093,13 +3078,14 @@ decorateType (ast * tree)
 
       if (processParms (tree->left,
 			FUNC_ARGS(tree->left->ftype),
-			tree->right, &parmNumber, TRUE))
+			tree->right, &parmNumber, TRUE)) {
 	goto errorTreeReturn;
+      }
 
       if (options.stackAuto || IFFUNC_ISREENT (LTYPE (tree)))
 	{
-	  //IFFUNC_ARGS(tree->left->ftype) = 
-	  //reverseVal (IFFUNC_ARGS(tree->left->ftype));
+	  //FUNC_ARGS(tree->left->ftype) = 
+	  //reverseVal (FUNC_ARGS(tree->left->ftype));
 	  reverseParms (tree->right);
 	}
 
@@ -4100,6 +4086,9 @@ 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, NULL) == 0)
     return NULL;
@@ -4130,7 +4119,10 @@ createFunction (symbol * name, ast * body)
     }
   name->lastLine = yylineno;
   currFunc = name;
-  processFuncArgs (currFunc, 0);
+
+#if 0 // jwk: this is now done in addDecl()
+  processFuncArgs (currFunc);
+#endif
 
   /* set the stack pointer */
   /* PENDING: check this for the mcs51 */
@@ -4171,7 +4163,7 @@ 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 = FUNC_ARGS(name->type);
   ex->decorated=1;
@@ -4265,27 +4257,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+4,outfile);
+		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+4,outfile);
+		INDENT(indent,outfile);
 		fprintf(outfile,"}\n");
 		return;
 	}
@@ -4318,7 +4323,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 (");
@@ -4591,7 +4597,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);
@@ -4795,10 +4803,9 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 		ast_print(tree->right,outfile,indent+4);
 		return;
 	case PARAM:
-		fprintf(outfile,"PARM ");
+		fprintf(outfile,"PARMS\n");
 		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);
 		}
 		return ;
@@ -4888,5 +4895,5 @@ void ast_print (ast * tree, FILE *outfile, int indent)
 
 void PA(ast *t)
 {
-	ast_print(t,stdout,1);
+	ast_print(t,stdout,0);
 }