-------------------------------------------------------------------------*/
#include "common.h"
-#include "newalloc.h"
int currLineno = 0;
set *astList = NULL;
#define ALLOCATE 1
#define DEALLOCATE 2
-char buffer[1024];
int noLineno = 0;
int noAlloc = 0;
symbol *currFunc;
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);
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);
/* 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,
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));
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 this is a leaf */
/* if value */
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
{
/* 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--)
{
}
}
- /* 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;
/*-----------------------------------------------------------------*/
int
processParms (ast * func,
- value * defParm,
+ value *defParm,
ast * actParm,
- int *parmNumber,
- bool rightmost)
+ int *parmNumber, // unused, although updated
+ bool rightmost) // double checked?
{
- 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);
/* 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;
}
/* If this is a varargs function... */
- if (!defParm && actParm && func->hasVargs)
+ if (!defParm && actParm && IFFUNC_HASVARARGS(func->ftype))
{
ast *newType = NULL;
sym_link *ftype;
}
/* 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);
* Therefore, if there are more defined parameters, the caller didn't
* supply enough.
*/
- if (rightmost && defParm->next)
+ if (0 && rightmost && defParm->next)
{
werror (E_TOO_FEW_PARMS);
return 1;
}
/* 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");
+ return 1;
+ }
/* 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));
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);
ast *rast = NULL;
initList *iloop;
int lcnt = 0, size = 0;
+ literalList *literalL;
/* take care of the special case */
/* array of characters can be init */
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++;
-
- 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;
+ ast *aSym;
- /* 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_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;
+ }
}
- 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));
}
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;
/* if type is SPECIFIER */
if (IS_SPEC (type))
rast = createIvalType (sym, type, ilist);
+
if (wid)
return decorateType (resolveSymbols (newNode (NULLOP, wid, rast)));
else
/*-----------------------------------------------------------------*/
/* 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);
}
symbol *newSym;
// this can only be a constant
- if (!IS_LITERAL(sym->ival->init.node->etype)) {
+ 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 (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)
/*-----------------------------------------------------------------*/
/* constExprValue - returns the value of a constant expression */
+/* or NULL if it is not a constant expression */
/*-----------------------------------------------------------------*/
value *
constExprValue (ast * cexpr, int check)
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 */
if (astHasVolatile (pbody->left))
return FALSE;
+
+ if (astHasDeref(pbody->right)) return FALSE;
return isConformingBody (pbody->left, sym, body) &&
isConformingBody (pbody->right, sym, body);
}
-#define DEMAND_INTEGER_PROMOTION
+//#define DEMAND_INTEGER_PROMOTION
#ifdef DEMAND_INTEGER_PROMOTION
#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 */
/* 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;
}
/* 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);
-
- }
}
}
}
switch (tree->opval.op)
{
-/*------------------------------------------------------------------*/
-/*----------------------------*/
- /* array node */
-/*----------------------------*/
+ /*------------------------------------------------------------------*/
+ /*----------------------------*/
+ /* array node */
+ /*----------------------------*/
case '[':
/* determine which is the array & which the index */
}
return tree;
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+ /*------------------------------------------------------------------*/
+ /*----------------------------*/
/* struct/union */
-/*----------------------------*/
+ /*----------------------------*/
case '.':
/* if this is not a structure */
if (!IS_STRUCT (LTYPE (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)))
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;
{
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)
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);
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)))
{
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;
}
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);
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);
}
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;
}
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);
}
return tree;
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+ /*------------------------------------------------------------------*/
+ /*----------------------------*/
/* casting */
-/*----------------------------*/
+ /*----------------------------*/
case CAST: /* change the type */
/* cannot cast to an aggregate type */
if (IS_AGGREGATE (LTYPE (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
- {
- 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));
/* 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 ");
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 ");
tree->opval.val->type);
return tree;
-/*------------------------------------------------------------------*/
-/*----------------------------*/
+ /*------------------------------------------------------------------*/
+ /*----------------------------*/
/* conditional operator '?' */
-/*----------------------------*/
+ /*----------------------------*/
case '?':
- /* the type is one on the left */
- TTYPE (tree) = LTYPE (tree);
- TETYPE (tree) = getSpec (TTYPE (tree));
+ /* the type is value of the colon operator (on the right) */
+ assert(IS_COLON_OP(tree->right));
+ /* 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 ':':
/* 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;
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
case AND_ASSIGN:
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
tree->opval.op = '=';
- propAsgType (tree);
-
return 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 --> '");
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))
{
goto errorTreeReturn;
}
- propAsgType (tree);
-
return 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;
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);
+ fprintf (stderr, "from type '");
+ printTypeChain (RTYPE(tree), stderr);
+ fprintf (stderr, "' to type '");
+ printTypeChain (currFunc->type->next, stderr);
+ fprintf (stderr, "'\n");
goto errorTreeReturn;
}
}
/* 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))
- {
- 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;
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);
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 */
/* 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;
ex = newAst_VALUE (symbolVal (name)); /* create name */
ex = newNode (FUNCTION, ex, body);
- ex->values.args = name->args;
+ ex->values.args = FUNC_ARGS(name->type);
if (fatalError)
{
/* 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);
- if (options.debug && !options.nodebug)
+ if (options.debug)
cdbStructBlock (1, cdbFile);
cleanUpLevel (LabelTab, 0);
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);