X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=5fd567323c44e56ee27c456b757f2b77786108d6;hb=9725bf579734cef770151f001d78a8972436a9cd;hp=05db77f88062641f72ebedacfe9bbcdbb688d2cd;hpb=3e6464a967f5cf3ec03876630c676b1ad5dfdf97;p=fw%2Fsdcc diff --git a/src/SDCCast.c b/src/SDCCast.c index 05db77f8..5fd56732 100644 --- a/src/SDCCast.c +++ b/src/SDCCast.c @@ -47,9 +47,10 @@ int labelKey = 1; int noLineno = 0; int noAlloc = 0; -symbol *currFunc; -ast *createIval (ast *, sym_link *, initList *, ast *); -ast *createIvalCharPtr (ast *, sym_link *, ast *); +symbol *currFunc=NULL; +static ast *createIval (ast *, sym_link *, initList *, ast *); +static ast *createIvalCharPtr (ast *, sym_link *, ast *); +static ast *optimizeCompare (ast *); ast *optimizeRRCRLC (ast *); ast *optimizeGetHbit (ast *); ast *backPatchLabels (ast *, symbol *, symbol *); @@ -66,44 +67,8 @@ ptt (ast * tree) /*-----------------------------------------------------------------*/ -/* newAst - creates a fresh node for an expression tree */ +/* newAst - creates a fresh node for an expression tree */ /*-----------------------------------------------------------------*/ -#if 0 -ast * -newAst (int type, void *op) -{ - ast *ex; - static int oldLineno = 0; - - ex = Safe_alloc ( sizeof (ast)); - - ex->type = type; - ex->lineno = (noLineno ? oldLineno : yylineno); - ex->filename = currFname; - ex->level = NestLevel; - ex->block = currBlockno; - ex->initMode = inInitMode; - - /* depending on the type */ - switch (type) - { - case EX_VALUE: - ex->opval.val = (value *) op; - break; - case EX_OP: - ex->opval.op = (long) op; - break; - case EX_LINK: - ex->opval.lnk = (sym_link *) op; - break; - case EX_STMNT: - ex->opval.stmnt = (unsigned) op; - } - - return ex; -} -#endif - static ast * newAst_ (unsigned type) { @@ -145,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 */ /*-----------------------------------------------------------------*/ @@ -221,8 +178,7 @@ copyAstValues (ast * dest, ast * src) break; case INLINEASM: - dest->values.inlineasm = Safe_alloc (strlen (src->values.inlineasm) + 1); - strcpy (dest->values.inlineasm, src->values.inlineasm); + dest->values.inlineasm = Safe_strdup(src->values.inlineasm); break; case ARRAYINIT: @@ -245,7 +201,7 @@ copyAstValues (ast * dest, ast * src) /* copyAst - makes a copy of a given astession */ /*-----------------------------------------------------------------*/ ast * -copyAst (ast * src) +copyAst (ast * src) { ast *dest; @@ -291,6 +247,31 @@ exit: } +/*-----------------------------------------------------------------*/ +/* removeIncDecOps: remove for side effects in *_ASSIGN's */ +/* "*s++ += 3" -> "*s++ = *s++ + 3" */ +/*-----------------------------------------------------------------*/ +ast *removeIncDecOps (ast * tree) { + + // traverse the tree and remove inc/dec ops + + if (!tree) + return NULL; + + if (tree->type == EX_OP && + (tree->opval.op == INC_OP || tree->opval.op == DEC_OP)) { + if (tree->left) + tree=tree->left; + else + tree=tree->right; + } + + tree->left=removeIncDecOps(tree->left); + tree->right=removeIncDecOps(tree->right); + + return tree; +} + /*-----------------------------------------------------------------*/ /* hasSEFcalls - returns TRUE if tree has a function call */ /*-----------------------------------------------------------------*/ @@ -377,6 +358,7 @@ resolveSymbols (ast * tree) if (tree == NULL) return tree; +#if 0 /* print the line */ /* if not block & function */ if (tree->type == EX_OP && @@ -387,6 +369,7 @@ resolveSymbols (ast * tree) filename = tree->filename; lineno = tree->lineno; } +#endif /* make sure we resolve the true & false labels for ifx */ if (tree->type == EX_OP && tree->opval.op == IFX) @@ -457,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 (); @@ -487,8 +470,7 @@ resolveChildren: /*-----------------------------------------------------------------*/ /* setAstLineno - walks a ast tree & sets the line number */ /*-----------------------------------------------------------------*/ -int -setAstLineno (ast * tree, int lineno) +int setAstLineno (ast * tree, int lineno) { if (!tree) return 0; @@ -499,38 +481,6 @@ setAstLineno (ast * tree, int lineno) return 0; } -#if 0 -/* this functions seems to be superfluous?! kmh */ - -/*-----------------------------------------------------------------*/ -/* resolveFromTable - will return the symbal table value */ -/*-----------------------------------------------------------------*/ -value * -resolveFromTable (value * val) -{ - symbol *csym; - - if (!val->sym) - return val; - - csym = findSymWithLevel (SymbolTab, val->sym); - - /* if found in the symbol table & they r not the same */ - if (csym && val->sym != csym && - csym->level == val->sym->level && - csym->_isparm && - !csym->ismyparm) - { - - val->sym = csym; - val->type = csym->type; - val->etype = csym->etype; - } - - return val; -} -#endif - /*-----------------------------------------------------------------*/ /* funcOfType :- function of type with name */ /*-----------------------------------------------------------------*/ @@ -543,11 +493,11 @@ 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); - FUNC_ISREENT(sym->type) = rent; + FUNC_ISREENT(sym->type) = rent ? 1 : 0; /* if arguments required */ if (nArgs) @@ -587,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); @@ -617,7 +567,7 @@ funcOfTypeVarg (char *name, char * rtype, int nArgs , char **atypes) /*-----------------------------------------------------------------*/ /* reverseParms - will reverse a parameter tree */ /*-----------------------------------------------------------------*/ -void +static void reverseParms (ast * ptree) { ast *ttree; @@ -708,19 +658,32 @@ processParms (ast * func, if (IS_INTEGRAL (ftype) && (getSize (ftype) < (unsigned) INTSIZE)) { - newType = newAst_LINK(INTTYPE); + if (IS_AST_OP(actParm) && + (actParm->opval.op == LEFT_OP || + actParm->opval.op == '*' || + actParm->opval.op == '+' || + actParm->opval.op == '-') && + actParm->right) { + // we should cast an operand instead of the result + actParm->decorated = 0; + actParm->left = newNode( CAST, newAst_LINK(newIntLink()), + actParm->left); + actParm = decorateType(actParm); + } else { + newType = newAst_LINK(INTTYPE); + } } if (IS_PTR(ftype) && !IS_GENPTR(ftype)) { newType = newAst_LINK (copyLinkChain(ftype)); - DCL_TYPE (newType->opval.lnk) = GPOINTER; + DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; } if (IS_AGGREGATE (ftype)) { newType = newAst_LINK (copyLinkChain (ftype)); - DCL_TYPE (newType->opval.lnk) = GPOINTER; + DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; } if (newType) { @@ -795,13 +758,14 @@ processParms (ast * func, /* 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); + SPEC_ARGREG (actParm->etype) = SPEC_ARGREG (defParm->etype); (*parmNumber)++; return 0; } /*-----------------------------------------------------------------*/ /* createIvalType - generates ival for basic types */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIvalType (ast * sym, sym_link * type, initList * ilist) { ast *iExpr; @@ -817,7 +781,7 @@ createIvalType (ast * sym, sym_link * type, initList * ilist) /*-----------------------------------------------------------------*/ /* createIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIvalStruct (ast * sym, sym_link * type, initList * ilist) { ast *rast = NULL; @@ -857,7 +821,7 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist) /*-----------------------------------------------------------------*/ /* createIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIvalArray (ast * sym, sym_link * type, initList * ilist) { ast *rast = NULL; @@ -952,7 +916,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist) /*-----------------------------------------------------------------*/ /* createIvalCharPtr - generates initial values for char pointers */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr) { ast *rast = NULL; @@ -992,6 +956,10 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr) newNode ('[', sym, newAst_VALUE (valueFromLit ((float) i))), newAst_VALUE (valueFromLit (*s)))); + + // now WE don't need iexpr's symbol anymore + freeStringSymbol(AST_SYMBOL(iexpr)); + return decorateType (resolveSymbols (rast)); } @@ -1001,7 +969,7 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr) /*-----------------------------------------------------------------*/ /* createIvalPtr - generates initial value for pointers */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIvalPtr (ast * sym, sym_link * type, initList * ilist) { ast *rast; @@ -1024,7 +992,7 @@ createIvalPtr (ast * sym, sym_link * type, initList * ilist) /*-----------------------------------------------------------------*/ /* createIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -ast * +static ast * createIval (ast * sym, sym_link * type, initList * ilist, ast * wid) { ast *rast = NULL; @@ -1057,42 +1025,7 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid) /*-----------------------------------------------------------------*/ /* initAggregates - initialises aggregate variables with initv */ /*-----------------------------------------------------------------*/ - -/* 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\n"); - 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); } @@ -1100,7 +1033,7 @@ ast * initAggregates (symbol * sym, initList * ival, ast * wid) { /* gatherAutoInit - creates assignment expressions for initial */ /* values */ /*-----------------------------------------------------------------*/ -ast * +static ast * gatherAutoInit (symbol * autoChain) { ast *init = NULL; @@ -1124,11 +1057,6 @@ gatherAutoInit (symbol * autoChain) { 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); @@ -1160,6 +1088,16 @@ gatherAutoInit (symbol * autoChain) /* if there is an initial value */ if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE) { + initList *ilist=sym->ival; + + while (ilist->type == INIT_DEEP) { + ilist = ilist->init.deep; + } + + /* update lineno for error msg */ + lineno=sym->lineDef; + setAstLineno (ilist->init.node, lineno); + if (IS_AGGREGATE (sym->type)) { work = initAggregates (sym, sym->ival, NULL); } else { @@ -1170,8 +1108,10 @@ gatherAutoInit (symbol * autoChain) work = newNode ('=', newAst_VALUE (symbolVal (sym)), list2expr (sym->ival)); } - + + // just to be sure setAstLineno (work, sym->lineDef); + sym->ival = NULL; if (init) init = newNode (NULLOP, init, work); @@ -1183,6 +1123,20 @@ gatherAutoInit (symbol * autoChain) return init; } +/*-----------------------------------------------------------------*/ +/* freeStringSymbol - delete a literal string if no more usage */ +/*-----------------------------------------------------------------*/ +void freeStringSymbol(symbol *sym) { + /* make sure this is a literal string */ + assert (sym->isstrlit); + if (--sym->isstrlit == 0) { // lower the usage count + memmap *segment=SPEC_OCLS(sym->etype); + if (segment) { + deleteSetItem(&segment->syms, sym); + } + } +} + /*-----------------------------------------------------------------*/ /* stringToSymbol - creates a symbol from a literal string */ /*-----------------------------------------------------------------*/ @@ -1192,10 +1146,22 @@ stringToSymbol (value * val) char name[SDCC_NAME_MAX + 1]; static int charLbl = 0; symbol *sym; + set *sp; + + // have we heard this before? + for (sp=statsg->syms; sp; sp=sp->next) { + sym=sp->item; + if (sym->isstrlit && + !strcmp(SPEC_CVAL(sym->etype).v_char, SPEC_CVAL(val->etype).v_char)) { + // yes, this is old news. Don't publish it again. + sym->isstrlit++; // but raise the usage count + return symbolVal(sym); + } + } - sprintf (name, "_str_%d", charLbl++); + SNPRINTF (name, sizeof(name), "_str_%d", charLbl++); sym = newSymbol (name, 0); /* make it @ level 0 */ - strcpy (sym->rname, name); + strncpyz (sym->rname, name, SDCC_NAME_MAX); /* copy the type from the value passed */ sym->type = copyLinkChain (val->type); @@ -1237,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); } @@ -1254,6 +1220,71 @@ processBlockVars (ast * tree, int *stack, int action) return tree; } +/*-------------------------------------------------------------*/ +/* constExprTree - returns TRUE if this tree is a constant */ +/* expression */ +/*-------------------------------------------------------------*/ +bool constExprTree (ast *cexpr) { + + if (!cexpr) { + return TRUE; + } + + cexpr = decorateType (resolveSymbols (cexpr)); + + switch (cexpr->type) + { + case EX_VALUE: + if (IS_AST_LIT_VALUE(cexpr)) { + // this is a literal + return TRUE; + } + if (IS_AST_SYM_VALUE(cexpr) && IS_FUNC(AST_SYMBOL(cexpr)->type)) { + // a function's address will never change + return TRUE; + } + if (IS_AST_SYM_VALUE(cexpr) && IS_ARRAY(AST_SYMBOL(cexpr)->type)) { + // an array's address will never change + return TRUE; + } + if (IS_AST_SYM_VALUE(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 + return TRUE; + } + return FALSE; + case EX_LINK: + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, + "unexpected link in expression tree\n"); + return FALSE; + case EX_OP: + if (cexpr->opval.op==ARRAYINIT) { + // this is a list of literals + return TRUE; + } + if (cexpr->opval.op=='=') { + return constExprTree(cexpr->right); + } + if (cexpr->opval.op==CAST) { + // cast ignored, maybe we should throw a warning here? + return constExprTree(cexpr->right); + } + if (cexpr->opval.op=='&') { + return TRUE; + } + if (cexpr->opval.op==CALL || cexpr->opval.op==PCALL) { + return FALSE; + } + if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) { + return TRUE; + } + case EX_OPERAND: + return IS_CONSTANT(operandType(cexpr->opval.oprnd)); + } + return FALSE; +} + /*-----------------------------------------------------------------*/ /* constExprValue - returns the value of a constant expression */ /* or NULL if it is not a constant expression */ @@ -1277,16 +1308,16 @@ constExprValue (ast * cexpr, int check) val->sym = cexpr->opval.val->sym; val->sym->type = copyLinkChain (cexpr->ftype); val->sym->etype = getSpec (val->sym->type); - strcpy (val->name, cexpr->opval.val->sym->rname); + strncpyz (val->name, cexpr->opval.val->sym->rname, SDCC_NAME_MAX); return val; } /* if we are casting a literal value then */ if (IS_AST_OP (cexpr) && cexpr->opval.op == CAST && - IS_LITERAL (cexpr->left->ftype)) + IS_LITERAL (cexpr->right->ftype)) return valCastLiteral (cexpr->ftype, - floatFromVal (cexpr->left->opval.val)); + floatFromVal (cexpr->right->opval.val)); if (IS_AST_VALUE (cexpr)) return cexpr->opval.val; @@ -1535,8 +1566,7 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /* if we reach the end or a leaf then true */ if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody)) return TRUE; - - + /* if anything else is "volatile" */ if (IS_VOLATILE (TETYPE (pbody))) return FALSE; @@ -1547,6 +1577,10 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) { /*------------------------------------------------------------------*/ case '[': + // if the loopvar is used as an index + if (astHasSymbol(pbody->right, sym)) { + return FALSE; + } return isConformingBody (pbody->right, sym, body); /*------------------------------------------------------------------*/ @@ -1656,9 +1690,16 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) if (astHasVolatile (pbody->left)) return FALSE; - if (IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; + if (IS_AST_SYM_VALUE (pbody->left)) { + // if the loopvar has an assignment + if (isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; + // if the loopvar is used in another (maybe conditional) block + if (astHasSymbol (pbody->right, sym) && + (pbody->level > body->level)) { + return FALSE; + } + } if (astHasVolatile (pbody->left)) return FALSE; @@ -1692,6 +1733,9 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /* function call */ /*----------------------------*/ case CALL: + /* if local & not passed as paramater then ok */ + if (sym->level && !astHasSymbol(pbody->right,sym)) + return TRUE; return FALSE; /*------------------------------------------------------------------*/ @@ -1805,14 +1849,15 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end) rloop = newNode (NULLOP, createIf (newAst_VALUE (symbolVal (sym)), newNode (GOTO, - newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))), + newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))), NULL), NULL), newNode ('=', newAst_VALUE (symbolVal (sym)), end)); - + replLoopSym (loop->left, sym); - + setAstLineno (rloop, init->lineno); + rloop = newNode (NULLOP, newNode ('=', newAst_VALUE (symbolVal (sym)), @@ -1822,56 +1867,15 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end) loop->left, newNode (NULLOP, newNode (SUB_ASSIGN, - newAst_VALUE (symbolVal (sym)), - newAst_VALUE (constVal ("1"))), + newAst_VALUE (symbolVal (sym)), + newAst_VALUE (constVal ("1"))), rloop)))); - + + rloop->lineno=init->lineno; return decorateType (rloop); - -} - -//#define DEMAND_INTEGER_PROMOTION - -#ifdef DEMAND_INTEGER_PROMOTION - -/*-----------------------------------------------------------------*/ -/* walk a tree looking for the leaves. Add a typecast to the given */ -/* type to each value leaf node. */ -/*-----------------------------------------------------------------*/ -void -pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr) -{ - if (!node || IS_CALLOP(node)) - { - /* WTF? We should never get here. */ - return; - } - - if (!node->left && !node->right) - { - /* We're at a leaf; if it's a value, apply the typecast */ - if (node->type == EX_VALUE && IS_INTEGRAL (TTYPE (node))) - { - *parentPtr = decorateType (newNode (CAST, - newAst_LINK (copyLinkChain (type)), - node)); - } - } - else - { - if (node->left) - { - pushTypeCastToLeaves (type, node->left, &(node->left)); - } - if (node->right) - { - pushTypeCastToLeaves (type, node->right, &(node->right)); - } - } + } -#endif - /*-----------------------------------------------------------------*/ /* decorateType - compute type for this tree also does type cheking */ /* this is done bottom up, since type have to flow upwards */ @@ -1892,6 +1896,7 @@ decorateType (ast * tree) tree->decorated = 1; +#if 0 /* print the line */ /* if not block & function */ if (tree->type == EX_OP && @@ -1902,6 +1907,7 @@ decorateType (ast * tree) filename = tree->filename; lineno = tree->lineno; } +#endif /* if any child is an error | this one is an error do nothing */ if (tree->isError || @@ -1913,6 +1919,7 @@ decorateType (ast * tree) /*----------------------------*/ /* leaf has been reached */ /*----------------------------*/ + lineno=tree->lineno; /* if this is of type value */ /* just get the type */ if (tree->type == EX_VALUE) @@ -1985,16 +1992,36 @@ decorateType (ast * tree) tree->left = dtl; if (dtr != tree->right) tree->right = dtr; + + if (IS_AST_OP(tree) && + (tree->opval.op == CAST || tree->opval.op == '=') && + (getSize(LTYPE(tree)) > getSize(RTYPE(tree))) && + (getSize(RTYPE(tree)) < INTSIZE)) { + // this is a cast/assign to a bigger type + if (IS_AST_OP(tree->right) && + IS_INTEGRAL(tree->right->ftype) && + (tree->right->opval.op == LEFT_OP || + tree->right->opval.op == '*' || + tree->right->opval.op == '+' || + tree->right->opval.op == '-') && + tree->right->right) { + // we should cast an operand instead of the result + tree->right->decorated = 0; + tree->right->left = newNode( CAST, newAst_LINK(newIntLink()), + tree->right->left); + tree->right = decorateType(tree->right); + } + } } /* depending on type of operator do */ switch (tree->opval.op) { - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* array node */ - /*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* array node */ + /*----------------------------*/ case '[': /* determine which is the array & which the index */ @@ -2029,7 +2056,7 @@ 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)); + SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree)); } return tree; @@ -2056,7 +2083,7 @@ decorateType (ast * tree) /*----------------------------*/ case PTR_OP: /* if not pointer to a structure */ - if (!IS_PTR (LTYPE (tree))) + if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE(tree))) { werror (E_PTR_REQD); goto errorTreeReturn; @@ -2072,19 +2099,47 @@ decorateType (ast * tree) (tree->right->type == EX_VALUE ? tree->right->opval.val : NULL)); TETYPE (tree) = getSpec (TTYPE (tree)); + + /* adjust the storage class */ + switch (DCL_TYPE(tree->left->ftype)) { + case POINTER: + break; + case FPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_XDATA; + break; + case CPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_CODE; + break; + case GPOINTER: + break; + case PPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_XSTACK; + break; + case IPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_IDATA; + break; + case EEPPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_EEPROM; + break; + case UPOINTER: + case ARRAY: + case FUNCTION: + break; + } + return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* ++/-- operation */ -/*----------------------------*/ + /*----------------------------*/ case INC_OP: /* incerement 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, "++/--"); + werror (E_CODE_WRITE, tree->opval.op==INC_OP ? "++" : "--"); if (tree->right) RLVAL (tree) = 1; @@ -2093,10 +2148,10 @@ decorateType (ast * tree) return tree; } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* bitwise and */ -/*----------------------------*/ + /*----------------------------*/ case '&': /* can be unary */ /* if right is NULL then unary operation */ if (tree->right) /* not an unary operation */ @@ -2143,12 +2198,11 @@ decorateType (ast * tree) return tree; } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* address of */ -/*----------------------------*/ - p = newLink (); - p->class = DECLARATOR; + /*----------------------------*/ + p = newLink (DECLARATOR); /* if bit field then error */ if (IS_BITVAR (tree->left->etype)) { @@ -2164,8 +2218,8 @@ decorateType (ast * tree) if (IS_FUNC (LTYPE (tree))) { - werror (E_ILLEGAL_ADDR, "address of function"); - goto errorTreeReturn; + // this ought to be ignored + return (tree->left); } if (IS_LITERAL(LTYPE(tree))) @@ -2206,27 +2260,28 @@ 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)); + DCL_PTR_CONST (p) = SPEC_CONST (TETYPE (tree)); + DCL_PTR_VOLATILE (p) = SPEC_VOLATILE (TETYPE (tree)); LLVAL (tree) = 1; TLVAL (tree) = 1; return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* bitwise or */ -/*----------------------------*/ + /*----------------------------*/ case '|': /* if the rewrite succeeds then don't go any furthur */ { ast *wtree = optimizeRRCRLC (tree); if (wtree != tree) return decorateType (wtree); + // fall through } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* bitwise xor */ -/*----------------------------*/ + /*----------------------------*/ case '^': if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) { @@ -2257,10 +2312,10 @@ decorateType (ast * tree) computeType (LTYPE (tree), RTYPE (tree))); -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* division */ -/*----------------------------*/ + /*----------------------------*/ case '/': if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree))) { @@ -2285,10 +2340,10 @@ decorateType (ast * tree) RTYPE (tree))); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* modulus */ -/*----------------------------*/ + /*----------------------------*/ case '%': if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) { @@ -2318,10 +2373,10 @@ decorateType (ast * tree) RTYPE (tree))); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ -/* address dereference */ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* address dereference */ + /*----------------------------*/ case '*': /* can be unary : if right is null then unary operation */ if (!tree->right) { @@ -2336,17 +2391,16 @@ 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); + TTYPE (tree) = copyLinkChain (LTYPE (tree)->next); TETYPE (tree) = getSpec (TTYPE (tree)); SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree)); return tree; } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* multiplication */ -/*----------------------------*/ + /*----------------------------*/ if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree))) { werror (E_INVALID_OP, "multiplication"); @@ -2375,24 +2429,22 @@ decorateType (ast * tree) } LRVAL (tree) = RRVAL (tree) = 1; + TETYPE (tree) = getSpec (TTYPE (tree) = + computeType (LTYPE (tree), + RTYPE (tree))); + /* promote result to int if left & right are char this will facilitate hardware multiplies 8bit x 8bit = 16bit */ 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))); } + return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* unary '+' operator */ -/*----------------------------*/ + /*----------------------------*/ case '+': /* if unary plus */ if (!tree->right) @@ -2417,10 +2469,10 @@ decorateType (ast * tree) return tree; } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* addition */ -/*----------------------------*/ + /*----------------------------*/ /* this is not a unary operation */ /* if both pointers then problem */ @@ -2470,7 +2522,7 @@ decorateType (ast * tree) LRVAL (tree) = RRVAL (tree) = 1; /* if the left is a pointer */ - if (IS_PTR (LTYPE (tree))) + if (IS_PTR (LTYPE (tree)) || IS_AGGREGATE (LTYPE (tree)) ) TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)); else @@ -2479,10 +2531,10 @@ decorateType (ast * tree) RTYPE (tree))); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* unary '-' */ -/*----------------------------*/ + /*----------------------------*/ case '-': /* can be unary */ /* if right is null then unary */ if (!tree->right) @@ -2505,14 +2557,14 @@ decorateType (ast * tree) return tree; } LRVAL (tree) = 1; - TTYPE (tree) = LTYPE (tree); + TETYPE(tree) = getSpec (TTYPE (tree) = LTYPE (tree)); return tree; } -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* subtraction */ -/*----------------------------*/ + /*----------------------------*/ if (!(IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree)) || @@ -2579,10 +2631,10 @@ decorateType (ast * tree) LRVAL (tree) = RRVAL (tree) = 1; return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* compliment */ -/*----------------------------*/ + /*----------------------------*/ case '~': /* can be only integral type */ if (!IS_INTEGRAL (LTYPE (tree))) @@ -2604,10 +2656,10 @@ decorateType (ast * tree) COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* not */ -/*----------------------------*/ + /*----------------------------*/ case '!': /* can be pointer */ if (!IS_ARITHMETIC (LTYPE (tree)) && @@ -2631,10 +2683,10 @@ decorateType (ast * tree) TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* shift */ -/*----------------------------*/ + /*----------------------------*/ case RRC: case RLC: TTYPE (tree) = LTYPE (tree); @@ -2671,19 +2723,24 @@ decorateType (ast * tree) tree->opval.val->type); return tree; } + /* if only the right side is a literal & we are shifting more than size of the left operand then zero */ if (IS_LITERAL (RTYPE (tree)) && ((unsigned) floatFromVal (valFromType (RETYPE (tree)))) >= (getSize (LTYPE (tree)) * 8)) { - werror (W_SHIFT_CHANGED, - (tree->opval.op == LEFT_OP ? "left" : "right")); - tree->type = EX_VALUE; - tree->left = tree->right = NULL; - tree->opval.val = constVal ("0"); - TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; - return tree; + if (tree->opval.op==LEFT_OP || + (tree->opval.op==RIGHT_OP && SPEC_USIGN(LETYPE(tree)))) { + lineno=tree->lineno; + werror (W_SHIFT_CHANGED, + (tree->opval.op == LEFT_OP ? "left" : "right")); + tree->type = EX_VALUE; + tree->left = tree->right = NULL; + tree->opval.val = constVal ("0"); + TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; + return tree; + } } LRVAL (tree) = RRVAL (tree) = 1; if (IS_LITERAL (LTYPE (tree)) && !IS_LITERAL (RTYPE (tree))) @@ -2727,7 +2784,7 @@ decorateType (ast * tree) ((int)floatFromVal(valFromType(RETYPE(tree)))) !=0 ) /* special case of NULL */ { sym_link *rest = LTYPE(tree)->next; werror(W_LITERAL_GENERIC); - TTYPE(tree) = newLink(); + TTYPE(tree) = newLink(DECLARATOR); DCL_TYPE(TTYPE(tree)) = FPOINTER; TTYPE(tree)->next = rest; tree->left->opval.lnk = TTYPE(tree); @@ -2741,12 +2798,16 @@ decorateType (ast * tree) LRVAL (tree) = 1; } #else +#if 0 // this is already checked, now this could be explicit /* 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); - } + 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; @@ -2766,10 +2827,10 @@ decorateType (ast * tree) return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* logical &&, || */ -/*----------------------------*/ + /*----------------------------*/ case AND_OP: case OR_OP: /* each must me arithmetic type or be a pointer */ @@ -2806,10 +2867,10 @@ decorateType (ast * tree) TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* comparison operators */ -/*----------------------------*/ + /*----------------------------*/ case '>': case '<': case LE_OP: @@ -2826,10 +2887,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); @@ -2854,7 +2922,18 @@ decorateType (ast * tree) goto errorTreeReturn; } } + /* if unsigned value < 0 then always false */ + /* if (unsigned value) > 0 then (unsigned value) */ + if (SPEC_USIGN(LETYPE(tree)) && IS_LITERAL(RTYPE(tree)) && + ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) { + if (tree->opval.op == '<') { + return tree->right; + } + if (tree->opval.op == '>') { + return tree->left; + } + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && @@ -2873,14 +2952,14 @@ decorateType (ast * tree) TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* sizeof */ -/*----------------------------*/ + /*----------------------------*/ case SIZEOF: /* evaluate wihout code generation */ /* change the type to a integer */ tree->type = EX_VALUE; - sprintf (buffer, "%d", (getSize (tree->right->ftype))); + SNPRINTF(buffer, sizeof(buffer), "%d", (getSize (tree->right->ftype))); tree->opval.val = constVal (buffer); tree->right = tree->left = NULL; TETYPE (tree) = getSpec (TTYPE (tree) = @@ -2953,7 +3032,7 @@ decorateType (ast * tree) break; } } - sprintf (buffer, "%d", typeofv); + SNPRINTF (buffer, sizeof(buffer), "%d", typeofv); tree->opval.val = constVal (buffer); tree->right = tree->left = NULL; TETYPE (tree) = getSpec (TTYPE (tree) = @@ -2995,10 +3074,11 @@ decorateType (ast * tree) return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ +#if 0 // assignment operators are converted by the parser + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* assignment operators */ -/*----------------------------*/ + /*----------------------------*/ case MUL_ASSIGN: case DIV_ASSIGN: /* for these it must be both must be integral */ @@ -3011,12 +3091,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; @@ -3039,7 +3119,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)) { @@ -3050,10 +3130,10 @@ decorateType (ast * tree) return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* -= operator */ -/*----------------------------*/ + /*----------------------------*/ case SUB_ASSIGN: if (!(IS_PTR (LTYPE (tree)) || IS_ARITHMETIC (LTYPE (tree)))) @@ -3074,7 +3154,7 @@ decorateType (ast * tree) RTYPE (tree))); if (!tree->initMode && IS_CONSTANT (LETYPE (tree))) - werror (E_CODE_WRITE, " "); + werror (E_CODE_WRITE, "-="); if (LRVAL (tree)) { @@ -3085,10 +3165,10 @@ decorateType (ast * tree) return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* += operator */ -/*----------------------------*/ + /*----------------------------*/ case ADD_ASSIGN: /* this is not a unary operation */ /* if both pointers then problem */ @@ -3115,7 +3195,7 @@ decorateType (ast * tree) RTYPE (tree))); if (!tree->initMode && IS_CONSTANT (LETYPE (tree))) - werror (E_CODE_WRITE, " "); + werror (E_CODE_WRITE, "+="); if (LRVAL (tree)) { @@ -3127,11 +3207,12 @@ decorateType (ast * tree) tree->opval.op = '='; return tree; +#endif -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* straight assignemnt */ -/*----------------------------*/ + /*----------------------------*/ case '=': /* cannot be an aggregate */ if (IS_AGGREGATE (LTYPE (tree))) @@ -3144,13 +3225,7 @@ decorateType (ast * tree) if (compareType (LTYPE (tree), RTYPE (tree)) == 0) { werror (E_TYPE_MISMATCH, "assignment", " "); - fprintf (stderr, "type --> '"); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "' "); - fprintf (stderr, "assigned to type --> '"); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, "'\n"); - goto errorTreeReturn; + printFromToType(RTYPE(tree),LTYPE(tree)); } /* if the left side of the tree is of type void @@ -3167,7 +3242,7 @@ decorateType (ast * tree) LLVAL (tree) = 1; if (!tree->initMode ) { if ((IS_SPEC(LETYPE(tree)) && IS_CONSTANT (LETYPE (tree)))) - werror (E_CODE_WRITE, " "); + werror (E_CODE_WRITE, "="); } if (LRVAL (tree)) { @@ -3177,18 +3252,18 @@ decorateType (ast * tree) return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* comma operator */ -/*----------------------------*/ + /*----------------------------*/ case ',': TETYPE (tree) = getSpec (TTYPE (tree) = RTYPE (tree)); return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* function call */ -/*----------------------------*/ + /*----------------------------*/ case CALL: parmNumber = 1; @@ -3201,18 +3276,21 @@ 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; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* return statement */ -/*----------------------------*/ + /*----------------------------*/ case RETURN: if (!tree->right) goto voidcheck; @@ -3248,17 +3326,17 @@ 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; } TTYPE (tree) = TETYPE (tree) = NULL; return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* switch statement */ -/*----------------------------*/ + /*----------------------------*/ case SWITCH: /* the switch value must be an integer */ if (!IS_INTEGRAL (LTYPE (tree))) @@ -3270,10 +3348,10 @@ decorateType (ast * tree) TTYPE (tree) = TETYPE (tree) = NULL; return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* ifx Statement */ -/*----------------------------*/ + /*----------------------------*/ case IFX: tree->left = backPatchLabels (tree->left, tree->trueLabel, @@ -3281,10 +3359,10 @@ decorateType (ast * tree) TTYPE (tree) = TETYPE (tree) = NULL; return tree; -/*------------------------------------------------------------------*/ -/*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ /* for Statement */ -/*----------------------------*/ + /*----------------------------*/ case FOR: decorateType (resolveSymbols (AST_FOR (tree, initExpr))); @@ -3336,7 +3414,7 @@ sizeofOp (sym_link * type) checkTypeSanity(type, "(sizeof)"); /* get the size and convert it to character */ - sprintf (buff, "%d", getSize (type)); + SNPRINTF (buff, sizeof(buff), "%d", getSize (type)); /* now convert into value */ return constVal (buff); @@ -3370,7 +3448,7 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel) static int localLbl = 0; symbol *localLabel; - sprintf (buffer, "_and_%d", localLbl++); + SNPRINTF(buffer, sizeof(buffer), "_andif_%d", localLbl++); localLabel = newSymbol (buffer, NestLevel); tree->left = backPatchLabels (tree->left, localLabel, falseLabel); @@ -3396,7 +3474,7 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel) static int localLbl = 0; symbol *localLabel; - sprintf (buffer, "_or_%d", localLbl++); + SNPRINTF(buffer, sizeof(buffer), "_orif_%d", localLbl++); localLabel = newSymbol (buffer, NestLevel); tree->left = backPatchLabels (tree->left, trueLabel, localLabel); @@ -3458,12 +3536,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; @@ -3488,7 +3566,7 @@ createLabel (symbol * label, ast * stmnt) label = newSymbol (label->name, label->level); /* change the name before putting it in add _ */ - sprintf (name, "%s", label->name); + SNPRINTF(name, sizeof(name), "%s", label->name); /* put the label in the LabelSymbol table */ /* but first check if a label of the same */ @@ -3576,7 +3654,8 @@ createCase (ast * swStat, ast * caseVal, ast * stmnt) } /* create the case label */ - sprintf (caseLbl, "_case_%d_%d", + SNPRINTF(caseLbl, sizeof(caseLbl), + "_case_%d_%d", swStat->values.switchVals.swNum, (int) floatFromVal (caseVal->opval.val)); @@ -3605,7 +3684,8 @@ createDefault (ast * swStat, ast * stmnt) swStat->values.switchVals.swDefault = 1; /* create the label */ - sprintf (defLbl, "_default_%d", swStat->values.switchVals.swNum); + SNPRINTF (defLbl, sizeof(defLbl), + "_default_%d", swStat->values.switchVals.swNum); return createLabel (newSymbol (defLbl, 0), stmnt); } @@ -3628,18 +3708,18 @@ createIf (ast * condAst, ast * ifBody, ast * elseBody) } /* create the labels */ - sprintf (buffer, "_iffalse_%d", Lblnum); + SNPRINTF (buffer, sizeof(buffer), "_iffalse_%d", Lblnum); ifFalse = newSymbol (buffer, NestLevel); /* if no else body then end == false */ if (!elseBody) ifEnd = ifFalse; else { - sprintf (buffer, "_ifend_%d", Lblnum); + SNPRINTF(buffer, sizeof(buffer), "_ifend_%d", Lblnum); ifEnd = newSymbol (buffer, NestLevel); } - sprintf (buffer, "_iftrue_%d", Lblnum); + SNPRINTF (buffer, sizeof(buffer), "_iftrue_%d", Lblnum); ifTrue = newSymbol (buffer, NestLevel); Lblnum++; @@ -4016,7 +4096,7 @@ tryNext2: /*-----------------------------------------------------------------*/ /* optimizeCompare - otimizes compares for bit variables */ /*-----------------------------------------------------------------*/ -ast * +static ast * optimizeCompare (ast * root) { ast *optExpr = NULL; @@ -4063,63 +4143,6 @@ optimizeCompare (ast * root) vright = (root->right->type == EX_VALUE ? root->right->opval.val : NULL); - //#define EXPERIMENTAL -#ifdef EXPERIMENTAL - /* if left is unsigned and right is literal */ - if (vleft && vright && - IS_UNSIGNED(vleft->etype) && - IS_LITERAL(vright->etype)) { - double dval=floatFromVal(vright); - int op=root->opval.op; - - fprintf (stderr,"op: '"); - switch (op) { - case LE_OP: fprintf (stderr, "<= '"); break; - case EQ_OP: fprintf (stderr, "== '"); break; - case GE_OP: fprintf (stderr, ">= '"); break; - default: fprintf (stderr, "%c '", op); break; - } - fprintf (stderr, "%f\n", dval); - - switch (op) - { - case EQ_OP: - case LE_OP: - case '<': - if (dval<0 || (op=='<' && dval==0)) { - // unsigned is never < 0 - werror (W_IF_NEVER_TRUE); - optExpr = newAst_VALUE (constVal("0")); - return decorateType (optExpr); - } - if (dval==0) { - if (op==LE_OP) { - // change this into a cheaper EQ_OP - fprintf (stderr, "warning *** changed '<=' to '==' because of unsigned\n"); - root->opval.op=EQ_OP; - return root; - } - } - break; - case GE_OP: - case '>': - if (dval>0 || (op==GE_OP && dval==0)) { - // unsigned is never < 0 - werror (W_IF_ALWAYS_TRUE); - optExpr = newAst_VALUE (constVal("1")); - return decorateType (optExpr); - } - if (dval==0) { - if (op=='>') { - // change this into a cheaper reversed EQ_OP - fprintf (stderr, "warning *** changed '>' to '!=' because of unsigned\n"); - root->opval.op=EQ_OP; - } - } - } - } -#endif - /* if left is a BITVAR in BITSPACE */ /* and right is a LITERAL then opt- */ /* imize else do nothing */ @@ -4294,10 +4317,6 @@ createFunction (symbol * name, ast * body) name->lastLine = yylineno; currFunc = name; -#if 0 // jwk: this is now done in addDecl() - processFuncArgs (currFunc); -#endif - /* set the stack pointer */ /* PENDING: check this for the mcs51 */ stackPtr = -port->stack.direction * port->stack.call_overhead; @@ -4332,7 +4351,7 @@ createFunction (symbol * name, ast * body) name->stack = SPEC_STAK (fetype) = stack; /* name needs to be mangled */ - sprintf (name->rname, "%s%s", port->fun_prefix, name->name); + SNPRINTF (name->rname, sizeof(name->rname), "%s%s", port->fun_prefix, name->name); body = resolveSymbols (body); /* resolve the symbols */ body = decorateType (body); /* propagateType & do semantic checks */ @@ -4374,6 +4393,7 @@ skipall: /* dealloc the block variables */ processBlockVars (body, &stack, DEALLOCATE); + outputDebugStackSymbols(); /* deallocate paramaters */ deallocParms (FUNC_ARGS(name->type)); @@ -4382,14 +4402,14 @@ skipall: /* we are done freeup memory & cleanup */ noLineno--; - labelKey = 1; + if (port->reset_labelKey) labelKey = 1; name->key = 0; FUNC_HASBODY(name->type) = 1; addSet (&operKeyReset, name); applyToSet (operKeyReset, resetParmKey); - if (options.debug) - cdbStructBlock (1, cdbFile); + if (options.debug) + cdbStructBlock(1); cleanUpLevel (LabelTab, 0); cleanUpBlock (StructTab, 1); @@ -4401,7 +4421,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) */ /*-----------------------------------------------------------------*/ @@ -4435,7 +4455,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) { @@ -4469,9 +4489,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 ; } @@ -4893,14 +4911,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); @@ -4914,7 +4932,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); @@ -4989,7 +5007,9 @@ void ast_print (ast * tree, FILE *outfile, int indent) /*----------------------------*/ case RETURN: fprintf(outfile,"RETURN (%p) type (",tree); - printTypeChain(tree->right->ftype,outfile); + if (tree->right) { + printTypeChain(tree->right->ftype,outfile); + } fprintf(outfile,")\n"); ast_print(tree->right,outfile,indent+2); return ; @@ -5029,15 +5049,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 */