From 3b687e0be417621a93fd39d2e5fbd9a58a27e9b9 Mon Sep 17 00:00:00 2001 From: maartenbrock Date: Mon, 31 May 2004 16:22:41 +0000 Subject: [PATCH] * src/SDCCast.c (createIvalArray): fixed bug 770487 SIGSEGV * src/SDCCglue.c (emitRegularMap): fixed bug 770484 allocation problem * src/SDCCglue.c (initPointer, printIvalType, printIvalStruct, printIvalArray, printIvalFuncPtr, printIvalPtr, printIval): fixed bugs 928906 and 954082 half-empty initializers * src/SDCCsymt.h, * src/SDCCsymt.c (getAllocSize): added for above fix * src/z80/gen.c (genArrayInit): fixed bug 741044 * support/regression/tests/zeropad.c: added tests git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@3333 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- src/SDCCast.c | 5039 ++++++++++++++-------------- src/SDCCglue.c | 1615 ++++----- src/SDCCsymt.c | 2231 ++++++------ src/SDCCsymt.h | 1 + src/z80/gen.c | 30 +- support/regression/tests/zeropad.c | 64 +- 6 files changed, 4549 insertions(+), 4431 deletions(-) diff --git a/src/SDCCast.c b/src/SDCCast.c index ef2f29a7..3b568f43 100644 --- a/src/SDCCast.c +++ b/src/SDCCast.c @@ -142,13 +142,13 @@ newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel) { /* then depending on the expression value */ if (floatFromVal (condAst->opval.val)) - ifxNode = newNode (GOTO, - newAst_VALUE (symbolVal (trueLabel)), - NULL); + ifxNode = newNode (GOTO, + newAst_VALUE (symbolVal (trueLabel)), + NULL); else - ifxNode = newNode (GOTO, - newAst_VALUE (symbolVal (falseLabel)), - NULL); + ifxNode = newNode (GOTO, + newAst_VALUE (symbolVal (falseLabel)), + NULL); } else { @@ -174,11 +174,11 @@ copyAstValues (ast * dest, ast * src) case SWITCH: dest->values.switchVals.swVals = - copyValue (src->values.switchVals.swVals); + copyValue (src->values.switchVals.swVals); dest->values.switchVals.swDefault = - src->values.switchVals.swDefault; + src->values.switchVals.swDefault; dest->values.switchVals.swNum = - src->values.switchVals.swNum; + src->values.switchVals.swNum; break; case INLINEASM: @@ -186,8 +186,8 @@ copyAstValues (ast * dest, ast * src) break; case ARRAYINIT: - dest->values.constlist = copyLiteralList(src->values.constlist); - break; + dest->values.constlist = copyLiteralList(src->values.constlist); + break; case FOR: AST_FOR (dest, trueLabel) = copySymbol (AST_FOR (src, trueLabel)); @@ -340,7 +340,7 @@ hasSEFcalls (ast * tree) return TRUE; return (hasSEFcalls (tree->left) | - hasSEFcalls (tree->right)); + hasSEFcalls (tree->right)); } /*-----------------------------------------------------------------*/ @@ -363,28 +363,28 @@ isAstEqual (ast * t1, ast * t2) { case EX_OP: if (t1->opval.op != t2->opval.op) - return 0; + return 0; return (isAstEqual (t1->left, t2->left) && - isAstEqual (t1->right, t2->right)); + isAstEqual (t1->right, t2->right)); break; case EX_VALUE: if (t1->opval.val->sym) - { - if (!t2->opval.val->sym) - return 0; - else - return isSymbolEqual (t1->opval.val->sym, - t2->opval.val->sym); - } + { + if (!t2->opval.val->sym) + return 0; + else + return isSymbolEqual (t1->opval.val->sym, + t2->opval.val->sym); + } else - { - if (t2->opval.val->sym) - return 0; - else - return (floatFromVal (t1->opval.val) == - floatFromVal (t2->opval.val)); - } + { + if (t2->opval.val->sym) + return 0; + else + return (floatFromVal (t1->opval.val) == + floatFromVal (t2->opval.val)); + } break; /* only compare these two types */ @@ -427,25 +427,25 @@ resolveSymbols (ast * tree) symbol *csym; if (tree->trueLabel) - { - if ((csym = findSym (LabelTab, tree->trueLabel, - tree->trueLabel->name))) - tree->trueLabel = csym; - else - werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, - tree->trueLabel->name); - } + { + if ((csym = findSym (LabelTab, tree->trueLabel, + tree->trueLabel->name))) + tree->trueLabel = csym; + else + werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, + tree->trueLabel->name); + } if (tree->falseLabel) - { - if ((csym = findSym (LabelTab, - tree->falseLabel, - tree->falseLabel->name))) - tree->falseLabel = csym; - else - werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, - tree->falseLabel->name); - } + { + if ((csym = findSym (LabelTab, + tree->falseLabel, + tree->falseLabel->name))) + tree->falseLabel = csym; + else + werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, + tree->falseLabel->name); + } } @@ -456,13 +456,13 @@ resolveSymbols (ast * tree) { symbol *csym = findSym (LabelTab, tree->opval.val->sym, - tree->opval.val->sym->name); + tree->opval.val->sym->name); if (!csym) - werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, - tree->opval.val->sym->name); + werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF, + tree->opval.val->sym->name); else - tree->opval.val->sym = csym; + tree->opval.val->sym = csym; goto resolveChildren; } @@ -477,42 +477,42 @@ resolveSymbols (ast * tree) /* if found in the symbol table & they r not the same */ if (csym && tree->opval.val->sym != csym) - { - tree->opval.val->sym = csym; - tree->opval.val->type = csym->type; - tree->opval.val->etype = csym->etype; - } + { + tree->opval.val->sym = csym; + tree->opval.val->type = csym->type; + tree->opval.val->etype = csym->etype; + } /* if not found in the symbol table */ /* mark it as undefined assume it is */ /* an integer in data space */ if (!csym && !tree->opval.val->sym->implicit) - { - - /* if this is a function name then */ - /* mark it as returning an int */ - if (tree->funcName) - { - 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 (); - tree->opval.val->etype = tree->opval.val->etype; - tree->opval.val->type = tree->opval.val->sym->type; - werrorfl (tree->filename, tree->lineno, W_IMPLICIT_FUNC, - tree->opval.val->sym->name); - //tree->opval.val->sym->undefined = 1; - allocVariables (tree->opval.val->sym); - } - else - { - tree->opval.val->sym->undefined = 1; - tree->opval.val->type = - tree->opval.val->etype = newIntLink (); - tree->opval.val->sym->type = - tree->opval.val->sym->etype = newIntLink (); - } - } + { + + /* if this is a function name then */ + /* mark it as returning an int */ + if (tree->funcName) + { + 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 (); + tree->opval.val->etype = tree->opval.val->etype; + tree->opval.val->type = tree->opval.val->sym->type; + werrorfl (tree->filename, tree->lineno, W_IMPLICIT_FUNC, + tree->opval.val->sym->name); + //tree->opval.val->sym->undefined = 1; + allocVariables (tree->opval.val->sym); + } + else + { + tree->opval.val->sym->undefined = 1; + tree->opval.val->type = + tree->opval.val->etype = newIntLink (); + tree->opval.val->sym->type = + tree->opval.val->sym->etype = newIntLink (); + } + } } resolveChildren: @@ -541,7 +541,7 @@ int setAstLineno (ast * tree, int lineno) /*-----------------------------------------------------------------*/ symbol * funcOfType (char *name, sym_link * type, sym_link * argType, - int nArgs, int rent) + int nArgs, int rent) { symbol *sym; /* create the symbol */ @@ -561,14 +561,14 @@ funcOfType (char *name, sym_link * type, sym_link * argType, args = FUNC_ARGS(sym->type) = newValue (); while (nArgs--) - { - args->type = copyLinkChain (argType); - args->etype = getSpec (args->type); - SPEC_EXTR(args->etype)=1; - if (!nArgs) - break; - args = args->next = newValue (); - } + { + args->type = copyLinkChain (argType); + args->etype = getSpec (args->type); + SPEC_EXTR(args->etype)=1; + if (!nArgs) + break; + args = args->next = newValue (); + } } /* save it */ @@ -599,16 +599,16 @@ funcOfTypeVarg (char *name, char * rtype, int nArgs , char **atypes) /* if arguments required */ if (nArgs) { - value *args; - args = FUNC_ARGS(sym->type) = newValue (); - - for ( i = 0 ; i < nArgs ; i++ ) { - args->type = typeFromStr(atypes[i]); - args->etype = getSpec (args->type); - SPEC_EXTR(args->etype)=1; - if ((i + 1) == nArgs) break; - args = args->next = newValue (); - } + value *args; + args = FUNC_ARGS(sym->type) = newValue (); + + for ( i = 0 ; i < nArgs ; i++ ) { + args->type = typeFromStr(atypes[i]); + args->etype = getSpec (args->type); + SPEC_EXTR(args->etype)=1; + if ((i + 1) == nArgs) break; + args = args->next = newValue (); + } } /* save it */ @@ -648,10 +648,10 @@ reverseParms (ast * ptree) /*-----------------------------------------------------------------*/ static int processParms (ast *func, - value *defParm, - ast **actParm, - int *parmNumber, /* unused, although updated */ - bool rightmost) + value *defParm, + ast **actParm, + int *parmNumber, /* unused, although updated */ + bool rightmost) { RESULT_TYPE resultType; sym_link *functype; @@ -705,9 +705,9 @@ processParms (ast *func, { (*actParm)->decorated = 1; return (processParms (func, defParm, - &(*actParm)->left, parmNumber, FALSE) || - processParms (func, defParm ? defParm->next : NULL, - &(*actParm)->right, parmNumber, rightmost)); + &(*actParm)->left, parmNumber, FALSE) || + processParms (func, defParm ? defParm->next : NULL, + &(*actParm)->right, parmNumber, rightmost)); } else if (defParm) /* not vararg */ { @@ -718,10 +718,10 @@ processParms (ast *func, * supply enough. */ if (rightmost && defParm->next) - { - werror (E_TOO_FEW_PARMS); - return 1; - } + { + werror (E_TOO_FEW_PARMS); + return 1; + } } /* decorate parameter */ @@ -742,32 +742,32 @@ processParms (ast *func, sym_link *ftype; if (IS_CAST_OP (*actParm) - || (IS_AST_LIT_VALUE (*actParm) && (*actParm)->values.literalFromCast)) - { - /* Parameter was explicitly typecast; don't touch it. */ - return 0; - } + || (IS_AST_LIT_VALUE (*actParm) && (*actParm)->values.literalFromCast)) + { + /* Parameter was explicitly typecast; don't touch it. */ + return 0; + } ftype = (*actParm)->ftype; /* If it's a char, upcast to int. */ if (IS_INTEGRAL (ftype) - && (getSize (ftype) < (unsigned) INTSIZE)) - { - newType = newAst_LINK(INTTYPE); - } + && (getSize (ftype) < (unsigned) INTSIZE)) + { + newType = newAst_LINK(INTTYPE); + } if (IS_PTR(ftype) && !IS_GENPTR(ftype)) - { - newType = newAst_LINK (copyLinkChain(ftype)); - DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; - } + { + newType = newAst_LINK (copyLinkChain(ftype)); + DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; + } if (IS_AGGREGATE (ftype)) - { - newType = newAst_LINK (copyLinkChain (ftype)); - DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; - } + { + newType = newAst_LINK (copyLinkChain (ftype)); + DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer; + } if (newType) { @@ -862,7 +862,7 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist) { /* if we have come to end */ if (!iloop) - break; + break; sflds->implicit = 1; lAst = newNode (PTR_OP, newNode ('&', sym, NULL), newAst_VALUE (symbolVal (sflds))); lAst = decorateType (resolveSymbols (lAst), RESULT_CHECK); @@ -871,8 +871,8 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist) if (iloop) { werrorfl (sym->opval.val->sym->fileDef, sym->opval.val->sym->lineDef, - W_EXCESS_INITIALIZERS, "struct", - sym->opval.val->sym->name); + W_EXCESS_INITIALIZERS, "struct", + sym->opval.val->sym->name); } return rast; @@ -895,16 +895,16 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist) /* by a string */ if (IS_CHAR (type->next)) if ((rast = createIvalCharPtr (sym, - type, - decorateType (resolveSymbols (list2expr (ilist)), RESULT_CHECK)))) + type, + decorateType (resolveSymbols (list2expr (ilist)), RESULT_CHECK)))) return decorateType (resolveSymbols (rast), RESULT_CHECK); /* 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; @@ -912,64 +912,65 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist) if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL)) { - ast *aSym; - - aSym = decorateType (resolveSymbols(sym), RESULT_CHECK); - - 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; - char *filename=sym->opval.val->sym->fileDef; - - werrorfl (filename, lineno, W_EXCESS_INITIALIZERS, "array", name); - } + ast *aSym; + + aSym = decorateType (resolveSymbols(sym), RESULT_CHECK); + + 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; + char *filename=sym->opval.val->sym->fileDef; + + werrorfl (filename, lineno, W_EXCESS_INITIALIZERS, "array", name); + } } else { - for (;;) - { - ast *aSym; - - aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++)))); - aSym = decorateType (resolveSymbols (aSym), RESULT_CHECK); - 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; - char *filename=sym->opval.val->sym->fileDef; - werrorfl (filename, lineno, W_EXCESS_INITIALIZERS, "array", name); - - break; - } - } + for (;;) + { + ast *aSym; + + aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++)))); + aSym = decorateType (resolveSymbols (aSym), RESULT_CHECK); + 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) + { + // is this a better way? at least it won't crash + char *name = (IS_AST_SYM_VALUE(sym)) ? AST_SYMBOL(sym)->name : ""; + int lineno = iloop->lineno; + char *filename = iloop->filename; + werrorfl (filename, lineno, W_EXCESS_INITIALIZERS, "array", name); + + break; + } + } } /* if we have not been given a size */ if (!DCL_ELEM (type)) { - DCL_ELEM (type) = size; + /* but this still updates the typedef instead of the instance ! see bug 770487 */ + DCL_ELEM (type) = size; } return decorateType (resolveSymbols (rast), RESULT_CHECK); @@ -987,8 +988,8 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr) /* if this is a pointer & right is a literal array then */ /* just assignment will do */ if (IS_PTR (type) && ((IS_LITERAL (iexpr->etype) || - SPEC_SCLS (iexpr->etype) == S_CODE) - && IS_ARRAY (iexpr->ftype))) + SPEC_SCLS (iexpr->etype) == S_CODE) + && IS_ARRAY (iexpr->ftype))) return newNode ('=', sym, iexpr); /* left side is an array so we have to assign each */ @@ -1006,22 +1007,22 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr) if (size>symsize) { - if (size>(symsize+1)) - werrorfl (iexpr->filename, iexpr->lineno, W_EXCESS_INITIALIZERS, - "string", sym->opval.val->sym->name); - size = symsize; - } + if (size>(symsize+1)) + werrorfl (iexpr->filename, iexpr->lineno, W_EXCESS_INITIALIZERS, + "string", sym->opval.val->sym->name); + size = symsize; + } for (i=0;iival) - resolveIvalSym (sym->ival, sym->type); + resolveIvalSym (sym->ival, sym->type); /* if this is a static variable & has an */ /* initial value the code needs to be lifted */ /* here to the main portion since they can be */ /* initialised only once at the start */ if (IS_STATIC (sym->etype) && sym->ival && - SPEC_SCLS (sym->etype) != S_CODE) - { - symbol *newSym; - - /* insert the symbol into the symbol table */ - /* with level = 0 & name = rname */ - newSym = copySymbol (sym); - addSym (SymbolTab, newSym, newSym->rname, 0, 0, 1); - - /* now lift the code to main */ - if (IS_AGGREGATE (sym->type)) { - work = initAggregates (sym, sym->ival, NULL); - } else { - if (getNelements(sym->type, sym->ival)>1) { - werrorfl (sym->fileDef, sym->lineDef, - W_EXCESS_INITIALIZERS, "scalar", - sym->name); - } - work = newNode ('=', newAst_VALUE (symbolVal (newSym)), - list2expr (sym->ival)); - } - - setAstLineno (work, sym->lineDef); - - sym->ival = NULL; - if (staticAutos) - staticAutos = newNode (NULLOP, staticAutos, work); - else - staticAutos = work; - - continue; - } + SPEC_SCLS (sym->etype) != S_CODE) + { + symbol *newSym; + + /* insert the symbol into the symbol table */ + /* with level = 0 & name = rname */ + newSym = copySymbol (sym); + addSym (SymbolTab, newSym, newSym->rname, 0, 0, 1); + + /* now lift the code to main */ + if (IS_AGGREGATE (sym->type)) { + work = initAggregates (sym, sym->ival, NULL); + } else { + if (getNelements(sym->type, sym->ival)>1) { + werrorfl (sym->fileDef, sym->lineDef, + W_EXCESS_INITIALIZERS, "scalar", + sym->name); + } + work = newNode ('=', newAst_VALUE (symbolVal (newSym)), + list2expr (sym->ival)); + } + + setAstLineno (work, sym->lineDef); + + sym->ival = NULL; + if (staticAutos) + staticAutos = newNode (NULLOP, staticAutos, work); + else + staticAutos = work; + + continue; + } /* 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 { - if (getNelements(sym->type, sym->ival)>1) { - werrorfl (sym->fileDef, sym->lineDef, - W_EXCESS_INITIALIZERS, "scalar", - sym->name); - } - 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); - else - init = work; - } + { + 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 { + if (getNelements(sym->type, sym->ival)>1) { + werrorfl (sym->fileDef, sym->lineDef, + W_EXCESS_INITIALIZERS, "scalar", + sym->name); + } + 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); + else + init = work; + } } inInitMode = 0; return init; @@ -1222,7 +1223,7 @@ stringToSymbol (value * val) sym=sp->item; size = getSize (sym->type); if (sym->isstrlit && size == getSize (val->type) && - !memcmp(SPEC_CVAL(sym->etype).v_char, SPEC_CVAL(val->etype).v_char, size)) { + !memcmp(SPEC_CVAL(sym->etype).v_char, SPEC_CVAL(val->etype).v_char, size)) { // yes, this is old news. Don't publish it again. sym->isstrlit++; // but raise the usage count return symbolVal(sym); @@ -1230,7 +1231,7 @@ stringToSymbol (value * val) } SNPRINTF (name, sizeof(name), "_str_%d", charLbl++); - sym = newSymbol (name, 0); /* make it @ level 0 */ + sym = newSymbol (name, 0); /* make it @ level 0 */ strncpyz (sym->rname, name, SDCC_NAME_MAX); /* copy the type from the value passed */ @@ -1274,15 +1275,15 @@ processBlockVars (ast * tree, int *stack, int action) 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); + *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); + else /* action is deallocate */ + deallocLocal (tree->values.sym); } processBlockVars (tree->left, stack, action); @@ -1307,49 +1308,49 @@ bool constExprTree (ast *cexpr) { { case EX_VALUE: if (IS_AST_LIT_VALUE(cexpr)) { - // this is a literal - return TRUE; + // 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; + // 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; + // 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 + IN_CODESPACE(SPEC_OCLS(AST_SYMBOL(cexpr)->etype))) { + // a symbol in code space will never change + // This is only for the 'char *s="hallo"' case and will have to leave //printf(" code space symbol"); - return TRUE; + return TRUE; } return FALSE; case EX_LINK: werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "unexpected link in expression tree\n"); + "unexpected link in expression tree\n"); return FALSE; case EX_OP: if (cexpr->opval.op==ARRAYINIT) { - // this is a list of literals - return TRUE; + // this is a list of literals + return TRUE; } if (cexpr->opval.op=='=') { - return constExprTree(cexpr->right); + return constExprTree(cexpr->right); } if (cexpr->opval.op==CAST) { - // cast ignored, maybe we should throw a warning here? - return constExprTree(cexpr->right); + // cast ignored, maybe we should throw a warning here? + return constExprTree(cexpr->right); } if (cexpr->opval.op=='&') { - return TRUE; + return TRUE; } if (cexpr->opval.op==CALL || cexpr->opval.op==PCALL) { - return FALSE; + return FALSE; } if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) { - return TRUE; + return TRUE; } return FALSE; case EX_OPERAND: @@ -1373,34 +1374,34 @@ constExprValue (ast * cexpr, int check) /* then check if this is a literal array in code segment */ if (SPEC_SCLS (cexpr->etype) == S_CODE && - SPEC_CVAL (cexpr->etype).v_char && - IS_ARRAY (cexpr->ftype)) - { - value *val = valFromType (cexpr->ftype); - SPEC_SCLS (val->etype) = S_LITERAL; - val->sym = cexpr->opval.val->sym; - val->sym->type = copyLinkChain (cexpr->ftype); - val->sym->etype = getSpec (val->sym->type); - strncpyz (val->name, cexpr->opval.val->sym->rname, SDCC_NAME_MAX); - return val; - } + SPEC_CVAL (cexpr->etype).v_char && + IS_ARRAY (cexpr->ftype)) + { + value *val = valFromType (cexpr->ftype); + SPEC_SCLS (val->etype) = S_LITERAL; + val->sym = cexpr->opval.val->sym; + val->sym->type = copyLinkChain (cexpr->ftype); + val->sym->etype = getSpec (val->sym->type); + 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->right->ftype)) + cexpr->opval.op == CAST && + IS_LITERAL (cexpr->right->ftype)) { - return valCastLiteral (cexpr->ftype, - floatFromVal (cexpr->right->opval.val)); + return valCastLiteral (cexpr->ftype, + floatFromVal (cexpr->right->opval.val)); } if (IS_AST_VALUE (cexpr)) { - return cexpr->opval.val; + return cexpr->opval.val; } if (check) - werror (E_CONST_EXPECTED, "found expression"); + werror (E_CONST_EXPECTED, "found expression"); return NULL; } @@ -1435,7 +1436,7 @@ isLabelInAst (symbol * label, ast * tree) /*-----------------------------------------------------------------*/ bool isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr, - symbol ** sym, ast ** init, ast ** end) + symbol ** sym, ast ** init, ast ** end) { /* the loop is considered countable if the following @@ -1448,9 +1449,9 @@ isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr, /* first check the initExpr */ if (IS_AST_OP (initExpr) && - initExpr->opval.op == '=' && /* is assignment */ + initExpr->opval.op == '=' && /* is assignment */ IS_AST_SYM_VALUE (initExpr->left)) - { /* left is a symbol */ + { /* left is a symbol */ *sym = AST_SYMBOL (initExpr->left); *init = initExpr->right; @@ -1468,34 +1469,34 @@ isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr, { switch (condExpr->opval.op) - { - case '<': - if (IS_AST_SYM_VALUE (condExpr->left) && - isSymbolEqual (*sym, AST_SYMBOL (condExpr->left)) && - IS_AST_LIT_VALUE (condExpr->right)) - { - *end = condExpr->right; - break; - } - return FALSE; - - case '!': - if (IS_AST_OP (condExpr->left) && - condExpr->left->opval.op == '>' && - IS_AST_LIT_VALUE (condExpr->left->right) && - IS_AST_SYM_VALUE (condExpr->left->left) && - isSymbolEqual (*sym, AST_SYMBOL (condExpr->left->left))) - { - - *end = newNode ('+', condExpr->left->right, - newAst_VALUE (constVal ("1"))); - break; - } - return FALSE; - - default: - return FALSE; - } + { + case '<': + if (IS_AST_SYM_VALUE (condExpr->left) && + isSymbolEqual (*sym, AST_SYMBOL (condExpr->left)) && + IS_AST_LIT_VALUE (condExpr->right)) + { + *end = condExpr->right; + break; + } + return FALSE; + + case '!': + if (IS_AST_OP (condExpr->left) && + condExpr->left->opval.op == '>' && + IS_AST_LIT_VALUE (condExpr->left->right) && + IS_AST_SYM_VALUE (condExpr->left->left) && + isSymbolEqual (*sym, AST_SYMBOL (condExpr->left->left))) + { + + *end = newNode ('+', condExpr->left->right, + newAst_VALUE (constVal ("1"))); + break; + } + return FALSE; + + default: + return FALSE; + } } @@ -1508,34 +1509,34 @@ isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr, { if (loopExpr->left) - { - /* pre */ - if (IS_AST_SYM_VALUE (loopExpr->left) && - isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left))) - return TRUE; + { + /* pre */ + if (IS_AST_SYM_VALUE (loopExpr->left) && + isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left))) + return TRUE; - } + } else - { - /* post */ - if (IS_AST_SYM_VALUE (loopExpr->right) && - isSymbolEqual (*sym, AST_SYMBOL (loopExpr->right))) - return TRUE; - } + { + /* post */ + if (IS_AST_SYM_VALUE (loopExpr->right) && + isSymbolEqual (*sym, AST_SYMBOL (loopExpr->right))) + return TRUE; + } } else { /* check for += */ if (loopExpr->opval.op == ADD_ASSIGN) - { - - if (IS_AST_SYM_VALUE (loopExpr->left) && - isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) && - IS_AST_LIT_VALUE (loopExpr->right) && - (int) AST_LIT_VALUE (loopExpr->right) != 1) - return TRUE; - } + { + + if (IS_AST_SYM_VALUE (loopExpr->left) && + isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) && + IS_AST_LIT_VALUE (loopExpr->right) && + (int) AST_LIT_VALUE (loopExpr->right) != 1) + return TRUE; + } } return FALSE; @@ -1597,9 +1598,9 @@ astHasSymbol (ast * tree, symbol * sym) if (IS_AST_VALUE (tree)) { if (IS_AST_SYM_VALUE (tree)) - return isSymbolEqual (AST_SYMBOL (tree), sym); + return isSymbolEqual (AST_SYMBOL (tree), sym); else - return FALSE; + return FALSE; } return astHasSymbol (tree->left, sym) || @@ -1657,7 +1658,7 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) // if the loopvar is used as an index /* array op is commutative -- must check both left & right */ if (astHasSymbol(pbody->right, sym) || astHasSymbol(pbody->left, sym)) { - return FALSE; + return FALSE; } return isConformingBody (pbody->right, sym, body) && isConformingBody (pbody->left, sym, body); @@ -1673,20 +1674,20 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /* sure we are not sym is not modified */ if (pbody->left && - IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; + IS_AST_SYM_VALUE (pbody->left) && + isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; if (pbody->right && - IS_AST_SYM_VALUE (pbody->right) && - isSymbolEqual (AST_SYMBOL (pbody->right), sym)) - return FALSE; + IS_AST_SYM_VALUE (pbody->right) && + isSymbolEqual (AST_SYMBOL (pbody->right), sym)) + return FALSE; return TRUE; /*------------------------------------------------------------------*/ - case '*': /* can be unary : if right is null then unary operation */ + case '*': /* can be unary : if right is null then unary operation */ case '+': case '-': case '&': @@ -1697,19 +1698,19 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /* address of */ /*----------------------------*/ if (!pbody->right) - { - if (IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; - else - return isConformingBody (pbody->left, sym, body); - } + { + if (IS_AST_SYM_VALUE (pbody->left) && + isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; + else + return isConformingBody (pbody->left, sym, body); + } else - { - if (astHasSymbol (pbody->left, sym) || - astHasSymbol (pbody->right, sym)) - return FALSE; - } + { + if (astHasSymbol (pbody->left, sym) || + astHasSymbol (pbody->right, sym)) + return FALSE; + } /*------------------------------------------------------------------*/ @@ -1721,15 +1722,15 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) case RIGHT_OP: if (IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; + isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; if (IS_AST_SYM_VALUE (pbody->right) && - isSymbolEqual (AST_SYMBOL (pbody->right), sym)) - return FALSE; + isSymbolEqual (AST_SYMBOL (pbody->right), sym)) + return FALSE; return isConformingBody (pbody->left, sym, body) && - isConformingBody (pbody->right, sym, body); + isConformingBody (pbody->right, sym, body); case '~': case '!': @@ -1738,8 +1739,8 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) case GETHBIT: case SWAP: if (IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; + isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; return isConformingBody (pbody->left, sym, body); /*------------------------------------------------------------------*/ @@ -1754,18 +1755,18 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) case NE_OP: case '?': case ':': - case SIZEOF: /* evaluate wihout code generation */ + case SIZEOF: /* evaluate wihout code generation */ if (IS_AST_SYM_VALUE (pbody->left) && - isSymbolEqual (AST_SYMBOL (pbody->left), sym)) - return FALSE; + isSymbolEqual (AST_SYMBOL (pbody->left), sym)) + return FALSE; if (IS_AST_SYM_VALUE (pbody->right) && - isSymbolEqual (AST_SYMBOL (pbody->right), sym)) - return FALSE; + isSymbolEqual (AST_SYMBOL (pbody->right), sym)) + return FALSE; return isConformingBody (pbody->left, sym, body) && - isConformingBody (pbody->right, sym, body); + isConformingBody (pbody->right, sym, body); /*------------------------------------------------------------------*/ case '=': @@ -1773,29 +1774,29 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /* if left has a pointer & right has loop control variable then we cannot */ if (astHasPointer (pbody->left) && - astHasSymbol (pbody->right, sym)) - return FALSE; + astHasSymbol (pbody->right, sym)) + return FALSE; if (astHasVolatile (pbody->left)) - return FALSE; + 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 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; + return FALSE; if (astHasDeref(pbody->right)) return FALSE; return isConformingBody (pbody->left, sym, body) && - isConformingBody (pbody->right, sym, body); + isConformingBody (pbody->right, sym, body); case MUL_ASSIGN: case DIV_ASSIGN: @@ -1814,16 +1815,16 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /*----------------------------*/ case ',': return isConformingBody (pbody->left, sym, body) && - isConformingBody (pbody->right, sym, body); + isConformingBody (pbody->right, sym, body); /*------------------------------------------------------------------*/ /*----------------------------*/ /* function call */ /*----------------------------*/ case CALL: - /* if local & not passed as paramater then ok */ - if (sym->level && !astHasSymbol(pbody->right,sym)) - return TRUE; + /* if local & not passed as paramater then ok */ + if (sym->level && !astHasSymbol(pbody->right,sym)) + return TRUE; return FALSE; /*------------------------------------------------------------------*/ @@ -1835,12 +1836,12 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) case GOTO: if (isLabelInAst (AST_SYMBOL (pbody->left), body)) - return TRUE; + return TRUE; else - return FALSE; + return FALSE; case SWITCH: if (astHasSymbol (pbody->left, sym)) - return FALSE; + return FALSE; default: break; @@ -1860,7 +1861,7 @@ isConformingBody (ast * pbody, symbol * sym, ast * body) /*-----------------------------------------------------------------*/ bool isLoopReversible (ast * loop, symbol ** loopCntrl, - ast ** init, ast ** end) + ast ** init, ast ** end) { /* if option says don't do it then don't */ if (optimize.noLoopReverse) @@ -1873,9 +1874,9 @@ isLoopReversible (ast * loop, symbol ** loopCntrl, [++] | [ += 1] | [ = + 1] ) forBody */ if (!isLoopCountable (AST_FOR (loop, initExpr), - AST_FOR (loop, condExpr), - AST_FOR (loop, loopExpr), - loopCntrl, init, end)) + AST_FOR (loop, condExpr), + AST_FOR (loop, loopExpr), + loopCntrl, init, end)) return 0; /* now do some serious checking on the body of the loop @@ -1899,14 +1900,14 @@ replLoopSym (ast * body, symbol * sym) { if (isSymbolEqual (AST_SYMBOL (body), sym)) - { + { - body->type = EX_OP; - body->opval.op = '-'; - body->left = newAst_VALUE (symbolVal (sym)); - body->right = newAst_VALUE (constVal ("1")); + body->type = EX_OP; + body->opval.op = '-'; + body->left = newAst_VALUE (symbolVal (sym)); + body->right = newAst_VALUE (constVal ("1")); - } + } return; @@ -1935,29 +1936,29 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end) /* put it together piece by piece */ rloop = newNode (NULLOP, - createIf (newAst_VALUE (symbolVal (sym)), - newNode (GOTO, - newAst_VALUE (symbolVal (AST_FOR (loop, continueLabel))), - NULL), NULL), - newNode ('=', - newAst_VALUE (symbolVal (sym)), - end)); + createIf (newAst_VALUE (symbolVal (sym)), + newNode (GOTO, + 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)), - newNode ('-', end, init)), - createLabel (AST_FOR (loop, continueLabel), - newNode (NULLOP, - loop->left, - newNode (NULLOP, - newNode (SUB_ASSIGN, - newAst_VALUE (symbolVal (sym)), - newAst_VALUE (constVal ("1"))), - rloop)))); + newNode ('=', + newAst_VALUE (symbolVal (sym)), + newNode ('-', end, init)), + createLabel (AST_FOR (loop, continueLabel), + newNode (NULLOP, + loop->left, + newNode (NULLOP, + newNode (SUB_ASSIGN, + newAst_VALUE (symbolVal (sym)), + newAst_VALUE (constVal ("1"))), + rloop)))); rloop->lineno=init->lineno; return decorateType (rloop, RESULT_CHECK); @@ -1979,36 +1980,36 @@ searchLitOp (ast *tree, ast **parent, const char *ops) IS_AST_OP(tree->right) && tree->right->right && (tree->right->opval.op == ops[0] || tree->right->opval.op == ops[1])) - { - if (IS_LITERAL (RTYPE (tree->right)) != - IS_LITERAL (LTYPE (tree->right))) - { - tree->right->decorated = 0; - tree->decorated = 0; - *parent = tree; - return tree->right; - } - ret = searchLitOp (tree->right, parent, ops); - if (ret) - return ret; + { + if (IS_LITERAL (RTYPE (tree->right)) != + IS_LITERAL (LTYPE (tree->right))) + { + tree->right->decorated = 0; + tree->decorated = 0; + *parent = tree; + return tree->right; + } + ret = searchLitOp (tree->right, parent, ops); + if (ret) + return ret; } if (tree->left && IS_AST_OP(tree->left) && tree->left->right && - (tree->left->opval.op == ops[0] || tree->left->opval.op == ops[1])) - { - if (IS_LITERAL (RTYPE (tree->left)) != - IS_LITERAL (LTYPE (tree->left))) - { - tree->left->decorated = 0; - tree->decorated = 0; - *parent = tree; - return tree->left; - } - ret = searchLitOp (tree->left, parent, ops); - if (ret) - return ret; - } + (tree->left->opval.op == ops[0] || tree->left->opval.op == ops[1])) + { + if (IS_LITERAL (RTYPE (tree->left)) != + IS_LITERAL (LTYPE (tree->left))) + { + tree->left->decorated = 0; + tree->decorated = 0; + *parent = tree; + return tree->left; + } + ret = searchLitOp (tree->left, parent, ops); + if (ret) + return ret; + } } return NULL; } @@ -2052,45 +2053,45 @@ addCast (ast *tree, RESULT_TYPE resultType, bool upcast) switch (resultType) { case RESULT_TYPE_NONE: - /* char: promote to int */ - if (!upcast || - getSize (tree->etype) >= INTSIZE) - return tree; - newLink = newIntLink(); - upCasted = TRUE; - break; + /* char: promote to int */ + if (!upcast || + getSize (tree->etype) >= INTSIZE) + return tree; + newLink = newIntLink(); + upCasted = TRUE; + break; case RESULT_TYPE_CHAR: - if (IS_CHAR (tree->etype) || - IS_FLOAT(tree->etype)) - return tree; - newLink = newCharLink(); - break; + if (IS_CHAR (tree->etype) || + IS_FLOAT(tree->etype)) + return tree; + newLink = newCharLink(); + break; case RESULT_TYPE_INT: #if 0 - if (getSize (tree->etype) > INTSIZE) + if (getSize (tree->etype) > INTSIZE) { /* warn ("Loosing significant digits"); */ - return; - } + return; + } #endif - /* char: promote to int */ - if (!upcast || - getSize (tree->etype) >= INTSIZE) - return tree; - newLink = newIntLink(); - upCasted = TRUE; - break; + /* char: promote to int */ + if (!upcast || + getSize (tree->etype) >= INTSIZE) + return tree; + newLink = newIntLink(); + upCasted = TRUE; + break; case RESULT_TYPE_OTHER: - if (!upcast) - return tree; + if (!upcast) + return tree; /* return type is long, float: promote char to int */ - if (getSize (tree->etype) >= INTSIZE) - return tree; - newLink = newIntLink(); - upCasted = TRUE; - break; + if (getSize (tree->etype) >= INTSIZE) + return tree; + newLink = newIntLink(); + upCasted = TRUE; + break; default: - return tree; + return tree; } tree->decorated = 0; tree = newNode (CAST, newAst_LINK (newLink), tree); @@ -2120,17 +2121,17 @@ resultTypePropagate (ast *tree, RESULT_TYPE resultType) case '+': case '-': case LABEL: - return resultType; + return resultType; case '&': - if (!tree->right) - /* can be unary */ - return RESULT_TYPE_NONE; - else - return resultType; + if (!tree->right) + /* can be unary */ + return RESULT_TYPE_NONE; + else + return resultType; case IFX: - return RESULT_TYPE_IFX; + return RESULT_TYPE_IFX; default: - return RESULT_TYPE_NONE; + return RESULT_TYPE_NONE; } } @@ -2144,23 +2145,23 @@ getLeftResultType (ast *tree, RESULT_TYPE resultType) { case '=': case CAST: - if (IS_PTR (LTYPE (tree))) - return RESULT_TYPE_NONE; - else - return getResultTypeFromType (LETYPE (tree)); + if (IS_PTR (LTYPE (tree))) + return RESULT_TYPE_NONE; + else + return getResultTypeFromType (LETYPE (tree)); case RETURN: - if (IS_PTR (currFunc->type->next)) - return RESULT_TYPE_NONE; - else - return getResultTypeFromType (currFunc->type->next); + if (IS_PTR (currFunc->type->next)) + return RESULT_TYPE_NONE; + else + return getResultTypeFromType (currFunc->type->next); case '[': - if (!IS_ARRAY (LTYPE (tree))) - return resultType; - if (DCL_ELEM (LTYPE (tree)) > 0 && DCL_ELEM (LTYPE (tree)) <= 256) - return RESULT_TYPE_CHAR; - return resultType; + if (!IS_ARRAY (LTYPE (tree))) + return resultType; + if (DCL_ELEM (LTYPE (tree)) > 0 && DCL_ELEM (LTYPE (tree)) <= 256) + return RESULT_TYPE_CHAR; + return resultType; default: - return resultType; + return resultType; } } @@ -2217,47 +2218,47 @@ decorateType (ast * tree, RESULT_TYPE resultType) { if (IS_LITERAL (tree->opval.val->etype)) - { + { - /* if this is a character array then declare it */ - if (IS_ARRAY (tree->opval.val->type)) - tree->opval.val = stringToSymbol (tree->opval.val); + /* if this is a character array then declare it */ + if (IS_ARRAY (tree->opval.val->type)) + tree->opval.val = stringToSymbol (tree->opval.val); - /* otherwise just copy the type information */ - COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type); - return tree; - } + /* otherwise just copy the type information */ + COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type); + return tree; + } if (tree->opval.val->sym) - { - /* if the undefined flag is set then give error message */ - if (tree->opval.val->sym->undefined) - { - werror (E_ID_UNDEF, tree->opval.val->sym->name); - /* assume int */ - TTYPE (tree) = TETYPE (tree) = - tree->opval.val->type = tree->opval.val->sym->type = - tree->opval.val->etype = tree->opval.val->sym->etype = - copyLinkChain (INTTYPE); - } - else - { - - /* if impilicit i.e. struct/union member then no type */ - if (tree->opval.val->sym->implicit) - TTYPE (tree) = TETYPE (tree) = NULL; - - else - { - - /* else copy the type */ - COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type); - - /* and mark it as referenced */ - tree->opval.val->sym->isref = 1; - } - } - } + { + /* if the undefined flag is set then give error message */ + if (tree->opval.val->sym->undefined) + { + werror (E_ID_UNDEF, tree->opval.val->sym->name); + /* assume int */ + TTYPE (tree) = TETYPE (tree) = + tree->opval.val->type = tree->opval.val->sym->type = + tree->opval.val->etype = tree->opval.val->sym->etype = + copyLinkChain (INTTYPE); + } + else + { + + /* if impilicit i.e. struct/union member then no type */ + if (tree->opval.val->sym->implicit) + TTYPE (tree) = TETYPE (tree) = NULL; + + else + { + + /* else copy the type */ + COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type); + + /* and mark it as referenced */ + tree->opval.val->sym->isref = 1; + } + } + } return tree; } @@ -2276,21 +2277,21 @@ decorateType (ast * tree, RESULT_TYPE resultType) if (tree->opval.op == NULLOP || tree->opval.op == BLOCK) { if (tree->left && tree->left->type == EX_OPERAND - && (tree->left->opval.op == INC_OP - || tree->left->opval.op == DEC_OP) - && tree->left->left) - { - tree->left->right = tree->left->left; - tree->left->left = NULL; - } + && (tree->left->opval.op == INC_OP + || tree->left->opval.op == DEC_OP) + && tree->left->left) + { + tree->left->right = tree->left->left; + tree->left->left = NULL; + } if (tree->right && tree->right->type == EX_OPERAND - && (tree->right->opval.op == INC_OP - || tree->right->opval.op == DEC_OP) - && tree->right->left) - { - tree->right->right = tree->right->left; - tree->right->left = NULL; - } + && (tree->right->opval.op == INC_OP + || tree->right->opval.op == DEC_OP) + && tree->right->left) + { + tree->right->right = tree->right->left; + tree->right->left = NULL; + } } #endif @@ -2308,12 +2309,12 @@ decorateType (ast * tree, RESULT_TYPE resultType) { /* determine which is the array & which the index */ if ((IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree))) && - IS_INTEGRAL (LTYPE (tree))) - { - ast *tempTree = tree->left; - tree->left = tree->right; - tree->right = tempTree; - } + IS_INTEGRAL (LTYPE (tree))) + { + ast *tempTree = tree->left; + tree->left = tree->right; + tree->right = tempTree; + } } /* After decorating the left branch there's type information available @@ -2324,18 +2325,18 @@ decorateType (ast * tree, RESULT_TYPE resultType) switch (tree->opval.op) { case '?': - /* delay right side for '?' operator since conditional macro - expansions might rely on this */ - dtr = tree->right; - break; - case CALL: - /* decorate right side for CALL (parameter list) in processParms(); - there is resultType available */ - dtr = tree->right; - break; - default: - dtr = decorateType (tree->right, resultTypeProp); - break; + /* delay right side for '?' operator since conditional macro + expansions might rely on this */ + dtr = tree->right; + break; + case CALL: + /* decorate right side for CALL (parameter list) in processParms(); + there is resultType available */ + dtr = tree->right; + break; + default: + dtr = decorateType (tree->right, resultTypeProp); + break; } /* this is to take care of situations @@ -2352,42 +2353,42 @@ decorateType (ast * tree, RESULT_TYPE resultType) switch (tree->opval.op) { - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* array node */ - /*----------------------------*/ + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* array node */ + /*----------------------------*/ case '[': /* first check if this is a array or a pointer */ if ((!IS_ARRAY (LTYPE (tree))) && (!IS_PTR (LTYPE (tree)))) - { - werror (E_NEED_ARRAY_PTR, "[]"); - goto errorTreeReturn; - } + { + werror (E_NEED_ARRAY_PTR, "[]"); + goto errorTreeReturn; + } /* check if the type of the idx */ if (!IS_INTEGRAL (RTYPE (tree))) - { - werror (E_IDX_NOT_INT); - goto errorTreeReturn; - } + { + werror (E_IDX_NOT_INT); + goto errorTreeReturn; + } /* if the left is an rvalue then error */ if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "array access"); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "array access"); + goto errorTreeReturn; + } if (IS_LITERAL (RTYPE (tree))) - { - int arrayIndex = (int) floatFromVal (valFromType (RETYPE (tree))); - int arraySize = DCL_ELEM (LTYPE (tree)); - if (arraySize && arrayIndex >= arraySize) - { - werror (W_IDX_OUT_OF_BOUNDS, arrayIndex, arraySize); - } - } + { + int arrayIndex = (int) floatFromVal (valFromType (RETYPE (tree))); + int arraySize = DCL_ELEM (LTYPE (tree)); + if (arraySize && arrayIndex >= arraySize) + { + werror (W_IDX_OUT_OF_BOUNDS, arrayIndex, arraySize); + } + } RRVAL (tree) = 1; COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)->next); @@ -2400,13 +2401,13 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '.': /* if this is not a structure */ if (!IS_STRUCT (LTYPE (tree))) - { - werror (E_STRUCT_UNION, "."); - goto errorTreeReturn; - } + { + werror (E_STRUCT_UNION, "."); + goto errorTreeReturn; + } TTYPE (tree) = structElemType (LTYPE (tree), - (tree->right->type == EX_VALUE ? - tree->right->opval.val : NULL)); + (tree->right->type == EX_VALUE ? + tree->right->opval.val : NULL)); TETYPE (tree) = getSpec (TTYPE (tree)); return tree; @@ -2417,51 +2418,51 @@ decorateType (ast * tree, RESULT_TYPE resultType) case PTR_OP: /* if not pointer to a structure */ if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE(tree))) - { - werror (E_PTR_REQD); - goto errorTreeReturn; - } + { + werror (E_PTR_REQD); + goto errorTreeReturn; + } if (!IS_STRUCT (LTYPE (tree)->next)) - { - werror (E_STRUCT_UNION, "->"); - goto errorTreeReturn; - } + { + werror (E_STRUCT_UNION, "->"); + goto errorTreeReturn; + } TTYPE (tree) = structElemType (LTYPE (tree)->next, - (tree->right->type == EX_VALUE ? - tree->right->opval.val : NULL)); + (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: - SPEC_SCLS(TETYPE(tree)) = S_DATA; - break; + SPEC_SCLS(TETYPE(tree)) = S_DATA; + break; case FPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_XDATA; - break; + SPEC_SCLS(TETYPE(tree)) = S_XDATA; + break; case CPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_CODE; - break; + SPEC_SCLS(TETYPE(tree)) = S_CODE; + break; case GPOINTER: - SPEC_SCLS (TETYPE (tree)) = 0; - break; + SPEC_SCLS (TETYPE (tree)) = 0; + break; case PPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_XSTACK; - break; + SPEC_SCLS(TETYPE(tree)) = S_XSTACK; + break; case IPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_IDATA; - break; + SPEC_SCLS(TETYPE(tree)) = S_IDATA; + break; case EEPPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_EEPROM; - break; + SPEC_SCLS(TETYPE(tree)) = S_EEPROM; + break; case UPOINTER: - SPEC_SCLS (TETYPE (tree)) = 0; - break; + SPEC_SCLS (TETYPE (tree)) = 0; + break; case ARRAY: case FUNCTION: - break; + break; } /* This breaks with extern declarations, bitfields, and perhaps other */ @@ -2478,7 +2479,7 @@ decorateType (ast * tree, RESULT_TYPE resultType) */ symbol *sym; symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree)), - AST_SYMBOL(tree->right)); + AST_SYMBOL(tree->right)); sym = newSymbol(genSymName (0), 0); sym->type = TTYPE (tree); @@ -2511,96 +2512,96 @@ decorateType (ast * tree, RESULT_TYPE resultType) case INC_OP: case DEC_OP: { - sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree)); - COPYTYPE (TTYPE (tree), TETYPE (tree), ltc); + sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree)); + COPYTYPE (TTYPE (tree), TETYPE (tree), ltc); if (!tree->initMode && IS_CONSTANT(TTYPE(tree))) - werror (E_CODE_WRITE, tree->opval.op==INC_OP ? "++" : "--"); + werror (E_CODE_WRITE, tree->opval.op==INC_OP ? "++" : "--"); - if (tree->right) - RLVAL (tree) = 1; - else - LLVAL (tree) = 1; - return tree; + if (tree->right) + RLVAL (tree) = 1; + else + LLVAL (tree) = 1; + return tree; } /*------------------------------------------------------------------*/ /*----------------------------*/ /* bitwise and */ /*----------------------------*/ - case '&': /* can be unary */ + case '&': /* can be unary */ /* if right is NULL then unary operation */ - if (tree->right) /* not an unary operation */ - { - - if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) - { - werror (E_BITWISE_OP); - werror (W_CONTINUE, "left & right types are "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, ","); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } - - /* if they are both literal */ - if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valBitwise (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree)), '&'); - - tree->right = tree->left = NULL; - TETYPE (tree) = tree->opval.val->etype; - TTYPE (tree) = tree->opval.val->type; - return tree; - } - - /* see if this is a GETHBIT operation if yes - then return that */ - { - ast *otree = optimizeGetHbit (tree); - - if (otree != tree) - return decorateType (otree, RESULT_CHECK); - } - - TTYPE (tree) = computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op); - TETYPE (tree) = getSpec (TTYPE (tree)); + if (tree->right) /* not an unary operation */ + { + + if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) + { + werror (E_BITWISE_OP); + werror (W_CONTINUE, "left & right types are "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, ","); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } + + /* if they are both literal */ + if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) + { + tree->type = EX_VALUE; + tree->opval.val = valBitwise (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree)), '&'); + + tree->right = tree->left = NULL; + TETYPE (tree) = tree->opval.val->etype; + TTYPE (tree) = tree->opval.val->type; + return tree; + } + + /* see if this is a GETHBIT operation if yes + then return that */ + { + ast *otree = optimizeGetHbit (tree); + + if (otree != tree) + return decorateType (otree, RESULT_CHECK); + } + + TTYPE (tree) = computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op); + TETYPE (tree) = getSpec (TTYPE (tree)); /* if left is a literal exchange left & right */ if (IS_LITERAL (LTYPE (tree))) - { - ast *tTree = tree->left; - tree->left = tree->right; - tree->right = tTree; - } - - /* if right is a literal and */ - /* we can find a 2nd literal in a and-tree then */ - /* rearrange the tree */ - if (IS_LITERAL (RTYPE (tree))) - { - ast *parent; - ast *litTree = searchLitOp (tree, &parent, "&"); - if (litTree) - { - DEBUG_CF("&") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tTree; - /* both operands in tTree are literal now */ - decorateType (parent, resultType); - } - } - - LRVAL (tree) = RRVAL (tree) = 1; - - return tree; - } + { + ast *tTree = tree->left; + tree->left = tree->right; + tree->right = tTree; + } + + /* if right is a literal and */ + /* we can find a 2nd literal in a and-tree then */ + /* rearrange the tree */ + if (IS_LITERAL (RTYPE (tree))) + { + ast *parent; + ast *litTree = searchLitOp (tree, &parent, "&"); + if (litTree) + { + DEBUG_CF("&") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tTree; + /* both operands in tTree are literal now */ + decorateType (parent, resultType); + } + } + + LRVAL (tree) = RRVAL (tree) = 1; + + return tree; + } /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -2609,56 +2610,56 @@ decorateType (ast * tree, RESULT_TYPE resultType) p = newLink (DECLARATOR); /* if bit field then error */ if (IS_BITVAR (tree->left->etype)) - { - werror (E_ILLEGAL_ADDR, "address of bit variable"); - goto errorTreeReturn; - } + { + werror (E_ILLEGAL_ADDR, "address of bit variable"); + goto errorTreeReturn; + } if (LETYPE(tree) && SPEC_SCLS (tree->left->etype) == S_REGISTER) - { - werror (E_ILLEGAL_ADDR, "address of register variable"); - goto errorTreeReturn; - } + { + werror (E_ILLEGAL_ADDR, "address of register variable"); + goto errorTreeReturn; + } if (IS_FUNC (LTYPE (tree))) - { - // this ought to be ignored - return (tree->left); - } + { + // this ought to be ignored + return (tree->left); + } if (IS_LITERAL(LTYPE(tree))) - { - werror (E_ILLEGAL_ADDR, "address of literal"); - goto errorTreeReturn; - } + { + werror (E_ILLEGAL_ADDR, "address of literal"); + goto errorTreeReturn; + } if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "address of"); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "address of"); + goto errorTreeReturn; + } if (!LETYPE (tree)) DCL_TYPE (p) = POINTER; else if (SPEC_SCLS (tree->left->etype) == S_CODE) - DCL_TYPE (p) = CPOINTER; + DCL_TYPE (p) = CPOINTER; else if (SPEC_SCLS (tree->left->etype) == S_XDATA) - DCL_TYPE (p) = FPOINTER; + DCL_TYPE (p) = FPOINTER; else if (SPEC_SCLS (tree->left->etype) == S_XSTACK) - DCL_TYPE (p) = PPOINTER; + DCL_TYPE (p) = PPOINTER; else if (SPEC_SCLS (tree->left->etype) == S_IDATA) - DCL_TYPE (p) = IPOINTER; + DCL_TYPE (p) = IPOINTER; else if (SPEC_SCLS (tree->left->etype) == S_EEPROM) - DCL_TYPE (p) = EEPPOINTER; + DCL_TYPE (p) = EEPPOINTER; else if (SPEC_OCLS(tree->left->etype)) - DCL_TYPE (p) = PTR_TYPE(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)) - { - AST_SYMBOL (tree->left)->addrtaken = 1; - AST_SYMBOL (tree->left)->allocreq = 1; - } + { + AST_SYMBOL (tree->left)->addrtaken = 1; + AST_SYMBOL (tree->left)->allocreq = 1; + } p->next = LTYPE (tree); TTYPE (tree) = p; @@ -2671,13 +2672,13 @@ decorateType (ast * tree, RESULT_TYPE resultType) && IS_AST_VALUE (tree->left->left) && !IS_AST_SYM_VALUE (tree->left->left)) { symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree->left)), - AST_SYMBOL(tree->left->right)); - AST_VALUE(tree) = valPlus(AST_VALUE(tree->left->left), + AST_SYMBOL(tree->left->right)); + AST_VALUE(tree) = valPlus(AST_VALUE(tree->left->left), valueFromLit(element->offset)); - tree->left = NULL; - tree->right = NULL; - tree->type = EX_VALUE; - tree->values.literalFromCast = 1; + tree->left = NULL; + tree->right = NULL; + tree->type = EX_VALUE; + tree->values.literalFromCast = 1; } #endif @@ -2690,39 +2691,39 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '|': /* if the rewrite succeeds then don't go any furthur */ { - ast *wtree = optimizeRRCRLC (tree); - if (wtree != tree) - return decorateType (wtree, RESULT_CHECK); - - wtree = optimizeSWAP (tree); - if (wtree != tree) - return decorateType (wtree, RESULT_CHECK); + ast *wtree = optimizeRRCRLC (tree); + if (wtree != tree) + return decorateType (wtree, RESULT_CHECK); + + wtree = optimizeSWAP (tree); + if (wtree != tree) + return decorateType (wtree, RESULT_CHECK); } /* if left is a literal exchange left & right */ if (IS_LITERAL (LTYPE (tree))) - { - ast *tTree = tree->left; - tree->left = tree->right; - tree->right = tTree; - } + { + ast *tTree = tree->left; + tree->left = tree->right; + tree->right = tTree; + } /* if right is a literal and */ /* we can find a 2nd literal in a or-tree then */ /* rearrange the tree */ if (IS_LITERAL (RTYPE (tree))) - { - ast *parent; - ast *litTree = searchLitOp (tree, &parent, "|"); - if (litTree) - { - DEBUG_CF("|") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tTree; - /* both operands in tTree are literal now */ - decorateType (parent, resultType); - } + { + ast *parent; + ast *litTree = searchLitOp (tree, &parent, "|"); + if (litTree) + { + DEBUG_CF("|") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tTree; + /* both operands in tTree are literal now */ + decorateType (parent, resultType); + } } /* fall through */ @@ -2732,63 +2733,63 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case '^': if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) - { - werror (E_BITWISE_OP); - werror (W_CONTINUE, "left & right types are "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, ","); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } + { + werror (E_BITWISE_OP); + werror (W_CONTINUE, "left & right types are "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, ","); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valBitwise (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree)), - tree->opval.op); - tree->right = tree->left = NULL; - TETYPE (tree) = tree->opval.val->etype; - TTYPE (tree) = tree->opval.val->type; - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valBitwise (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree)), + tree->opval.op); + tree->right = tree->left = NULL; + TETYPE (tree) = tree->opval.val->etype; + TTYPE (tree) = tree->opval.val->type; + return tree; + } /* if left is a literal exchange left & right */ if (IS_LITERAL (LTYPE (tree))) - { - ast *tTree = tree->left; - tree->left = tree->right; - tree->right = tTree; - } + { + ast *tTree = tree->left; + tree->left = tree->right; + tree->right = tTree; + } /* if right is a literal and */ /* we can find a 2nd literal in a xor-tree then */ /* rearrange the tree */ if (IS_LITERAL (RTYPE (tree)) && tree->opval.op == '^') /* the same source is used by 'bitwise or' */ - { - ast *parent; - ast *litTree = searchLitOp (tree, &parent, "^"); - if (litTree) - { - DEBUG_CF("^") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tTree; - /* both operands in litTree are literal now */ - decorateType (parent, resultType); - } + { + ast *parent; + ast *litTree = searchLitOp (tree, &parent, "^"); + if (litTree) + { + DEBUG_CF("^") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tTree; + /* both operands in litTree are literal now */ + decorateType (parent, resultType); + } } LRVAL (tree) = RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); return tree; @@ -2798,30 +2799,30 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case '/': if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree))) - { - werror (E_INVALID_OP, "divide"); - goto errorTreeReturn; - } + { + werror (E_INVALID_OP, "divide"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valDiv (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree))); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valDiv (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree))); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } LRVAL (tree) = RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); /* if right is a literal and */ /* left is also a division by a literal then */ @@ -2829,33 +2830,33 @@ decorateType (ast * tree, RESULT_TYPE resultType) if (IS_LITERAL (RTYPE (tree)) /* avoid infinite loop */ && (TYPE_UDWORD) floatFromVal (tree->right->opval.val) != 1) - { - ast *parent; - ast *litTree = searchLitOp (tree, &parent, "/"); - if (litTree) - { - if (IS_LITERAL (RTYPE (litTree))) - { - /* foo_div */ - DEBUG_CF("div r") - litTree->right = newNode ('*', - litTree->right, - copyAst (tree->right)); - litTree->right->lineno = tree->lineno; - - tree->right->opval.val = constVal ("1"); - decorateType (parent, resultType); - } - else - { - /* litTree->left is literal: no gcse possible. - We can't call decorateType(parent, RESULT_CHECK), because - this would cause an infinit loop. */ - parent->decorated = 1; - decorateType (litTree, resultType); - } - } - } + { + ast *parent; + ast *litTree = searchLitOp (tree, &parent, "/"); + if (litTree) + { + if (IS_LITERAL (RTYPE (litTree))) + { + /* foo_div */ + DEBUG_CF("div r") + litTree->right = newNode ('*', + litTree->right, + copyAst (tree->right)); + litTree->right->lineno = tree->lineno; + + tree->right->opval.val = constVal ("1"); + decorateType (parent, resultType); + } + else + { + /* litTree->left is literal: no gcse possible. + We can't call decorateType(parent, RESULT_CHECK), because + this would cause an infinit loop. */ + parent->decorated = 1; + decorateType (litTree, resultType); + } + } + } return tree; @@ -2865,150 +2866,150 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case '%': if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree))) - { - werror (E_BITWISE_OP); - werror (W_CONTINUE, "left & right types are "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, ","); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } + { + werror (E_BITWISE_OP); + werror (W_CONTINUE, "left & right types are "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, ","); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valMod (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree))); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valMod (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree))); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } LRVAL (tree) = RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); return tree; /*------------------------------------------------------------------*/ /*----------------------------*/ /* address dereference */ /*----------------------------*/ - case '*': /* can be unary : if right is null then unary operation */ + case '*': /* can be unary : if right is null then unary operation */ if (!tree->right) - { - if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree))) - { - werror (E_PTR_REQD); - goto errorTreeReturn; - } - - if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "pointer deref"); - goto errorTreeReturn; - } - if (IS_ADDRESS_OF_OP(tree->left)) + { + if (!IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree))) + { + werror (E_PTR_REQD); + goto errorTreeReturn; + } + + if (LRVAL (tree)) + { + werror (E_LVALUE_REQUIRED, "pointer deref"); + goto errorTreeReturn; + } + if (IS_ADDRESS_OF_OP(tree->left)) { /* replace *&obj with obj */ return tree->left->left; } TTYPE (tree) = copyLinkChain (LTYPE (tree)->next); - TETYPE (tree) = getSpec (TTYPE (tree)); - /* adjust the storage class */ - switch (DCL_TYPE(tree->left->ftype)) { - case POINTER: - SPEC_SCLS(TETYPE(tree)) = S_DATA; - break; - case FPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_XDATA; - break; - case CPOINTER: - SPEC_SCLS(TETYPE(tree)) = S_CODE; - break; - case GPOINTER: - SPEC_SCLS (TETYPE (tree)) = 0; - 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: - SPEC_SCLS (TETYPE (tree)) = 0; + TETYPE (tree) = getSpec (TTYPE (tree)); + /* adjust the storage class */ + switch (DCL_TYPE(tree->left->ftype)) { + case POINTER: + SPEC_SCLS(TETYPE(tree)) = S_DATA; + break; + case FPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_XDATA; + break; + case CPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_CODE; + break; + case GPOINTER: + SPEC_SCLS (TETYPE (tree)) = 0; + break; + case PPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_XSTACK; break; - case ARRAY: - case FUNCTION: - break; - } - return tree; - } + case IPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_IDATA; + break; + case EEPPOINTER: + SPEC_SCLS(TETYPE(tree)) = S_EEPROM; + break; + case UPOINTER: + SPEC_SCLS (TETYPE (tree)) = 0; + break; + case ARRAY: + case FUNCTION: + break; + } + return tree; + } /*------------------------------------------------------------------*/ /*----------------------------*/ /* multiplication */ /*----------------------------*/ if (!IS_ARITHMETIC (LTYPE (tree)) || !IS_ARITHMETIC (RTYPE (tree))) - { - werror (E_INVALID_OP, "multiplication"); - goto errorTreeReturn; - } + { + werror (E_INVALID_OP, "multiplication"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valMult (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree))); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valMult (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree))); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } /* if left is a literal exchange left & right */ if (IS_LITERAL (LTYPE (tree))) - { - ast *tTree = tree->left; - tree->left = tree->right; - tree->right = tTree; - } + { + ast *tTree = tree->left; + tree->left = tree->right; + tree->right = tTree; + } /* if right is a literal and */ /* we can find a 2nd literal in a mul-tree then */ /* rearrange the tree */ if (IS_LITERAL (RTYPE (tree))) - { - ast *parent; - ast *litTree = searchLitOp (tree, &parent, "*"); - if (litTree) - { - DEBUG_CF("mul") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tTree; - /* both operands in litTree are literal now */ - decorateType (parent, resultType); - } + { + ast *parent; + ast *litTree = searchLitOp (tree, &parent, "*"); + if (litTree) + { + DEBUG_CF("mul") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tTree; + /* both operands in litTree are literal now */ + decorateType (parent, resultType); + } } LRVAL (tree) = RRVAL (tree) = 1; tree->left = addCast (tree->left, resultType, FALSE); tree->right = addCast (tree->right, resultType, FALSE); TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); return tree; @@ -3019,26 +3020,26 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '+': /* if unary plus */ if (!tree->right) - { - if (!IS_ARITHMETIC (LTYPE (tree))) - { - werror (E_UNARY_OP, '+'); - goto errorTreeReturn; - } - - /* if left is a literal then do it */ - if (IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valFromType (LETYPE (tree)); - tree->left = NULL; - TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; - return tree; - } - LRVAL (tree) = 1; - COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)); - return tree; - } + { + if (!IS_ARITHMETIC (LTYPE (tree))) + { + werror (E_UNARY_OP, '+'); + goto errorTreeReturn; + } + + /* if left is a literal then do it */ + if (IS_LITERAL (LTYPE (tree))) + { + tree->type = EX_VALUE; + tree->opval.val = valFromType (LETYPE (tree)); + tree->left = NULL; + TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; + return tree; + } + LRVAL (tree) = 1; + COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)); + return tree; + } /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -3048,141 +3049,141 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* this is not a unary operation */ /* if both pointers then problem */ if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) && - (IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)))) - { - werror (E_PTR_PLUS_PTR); - goto errorTreeReturn; - } + (IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)))) + { + werror (E_PTR_PLUS_PTR); + goto errorTreeReturn; + } if (!IS_ARITHMETIC (LTYPE (tree)) && - !IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree))) - { - werror (E_PLUS_INVALID, "+"); - goto errorTreeReturn; - } + !IS_PTR (LTYPE (tree)) && !IS_ARRAY (LTYPE (tree))) + { + werror (E_PLUS_INVALID, "+"); + goto errorTreeReturn; + } if (!IS_ARITHMETIC (RTYPE (tree)) && - !IS_PTR (RTYPE (tree)) && !IS_ARRAY (RTYPE (tree))) - { - werror (E_PLUS_INVALID, "+"); - goto errorTreeReturn; - } + !IS_PTR (RTYPE (tree)) && !IS_ARRAY (RTYPE (tree))) + { + werror (E_PLUS_INVALID, "+"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->left = addCast (tree->left, resultType, TRUE); + { + tree->type = EX_VALUE; + tree->left = addCast (tree->left, resultType, TRUE); tree->right = addCast (tree->right, resultType, TRUE); - tree->opval.val = valPlus (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree))); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + tree->opval.val = valPlus (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree))); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } /* if the right is a pointer or left is a literal xchange left & right */ if (IS_ARRAY (RTYPE (tree)) || - IS_PTR (RTYPE (tree)) || - IS_LITERAL (LTYPE (tree))) - { - ast *tTree = tree->left; - tree->left = tree->right; - tree->right = tTree; - } + IS_PTR (RTYPE (tree)) || + IS_LITERAL (LTYPE (tree))) + { + ast *tTree = tree->left; + tree->left = tree->right; + tree->right = tTree; + } /* if right is a literal and */ /* left is also an addition/subtraction with a literal then */ /* rearrange the tree */ if (IS_LITERAL (RTYPE (tree))) - { - ast *litTree, *parent; - litTree = searchLitOp (tree, &parent, "+-"); - if (litTree) - { - if (litTree->opval.op == '+') - { - /* foo_aa */ - DEBUG_CF("+ 1 AA") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tree->left; - tree->left = tTree; - } - else if (litTree->opval.op == '-') - { - if (IS_LITERAL (RTYPE (litTree))) - { - DEBUG_CF("+ 2 ASR") - /* foo_asr */ - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = tTree; - } - else - { - DEBUG_CF("+ 3 ASL") - /* foo_asl */ - ast *tTree = litTree->right; - litTree->right = tree->right; - tree->right = tTree; - litTree->opval.op = '+'; - tree->opval.op = '-'; - } - } - decorateType (parent, resultType); - } - } + { + ast *litTree, *parent; + litTree = searchLitOp (tree, &parent, "+-"); + if (litTree) + { + if (litTree->opval.op == '+') + { + /* foo_aa */ + DEBUG_CF("+ 1 AA") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tree->left; + tree->left = tTree; + } + else if (litTree->opval.op == '-') + { + if (IS_LITERAL (RTYPE (litTree))) + { + DEBUG_CF("+ 2 ASR") + /* foo_asr */ + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = tTree; + } + else + { + DEBUG_CF("+ 3 ASL") + /* foo_asl */ + ast *tTree = litTree->right; + litTree->right = tree->right; + tree->right = tTree; + litTree->opval.op = '+'; + tree->opval.op = '-'; + } + } + decorateType (parent, resultType); + } + } LRVAL (tree) = RRVAL (tree) = 1; /* if the left is a pointer */ if (IS_PTR (LTYPE (tree)) || IS_AGGREGATE (LTYPE (tree)) ) - TETYPE (tree) = getSpec (TTYPE (tree) = - LTYPE (tree)); + TETYPE (tree) = getSpec (TTYPE (tree) = + LTYPE (tree)); else - { - tree->left = addCast (tree->left, resultType, TRUE); + { + tree->left = addCast (tree->left, resultType, TRUE); tree->right = addCast (tree->right, resultType, TRUE); TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); - } - + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); + } + return tree; /*------------------------------------------------------------------*/ /*----------------------------*/ /* unary '-' */ /*----------------------------*/ - case '-': /* can be unary */ + case '-': /* can be unary */ /* if right is null then unary */ if (!tree->right) - { - - if (!IS_ARITHMETIC (LTYPE (tree))) - { - werror (E_UNARY_OP, tree->opval.op); - goto errorTreeReturn; - } - - /* if left is a literal then do it */ - if (IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valUnaryPM (valFromType (LETYPE (tree))); - tree->left = NULL; - TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; - SPEC_USIGN(TETYPE(tree)) = 0; - return tree; - } - LRVAL (tree) = 1; - TETYPE(tree) = getSpec (TTYPE (tree) = LTYPE (tree)); - return tree; - } + { + + if (!IS_ARITHMETIC (LTYPE (tree))) + { + werror (E_UNARY_OP, tree->opval.op); + goto errorTreeReturn; + } + + /* if left is a literal then do it */ + if (IS_LITERAL (LTYPE (tree))) + { + tree->type = EX_VALUE; + tree->opval.val = valUnaryPM (valFromType (LETYPE (tree))); + tree->left = NULL; + TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; + SPEC_USIGN(TETYPE(tree)) = 0; + return tree; + } + LRVAL (tree) = 1; + TETYPE(tree) = getSpec (TTYPE (tree) = LTYPE (tree)); + return tree; + } /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -3190,76 +3191,76 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ if (!(IS_PTR (LTYPE (tree)) || - IS_ARRAY (LTYPE (tree)) || - IS_ARITHMETIC (LTYPE (tree)))) - { - werror (E_PLUS_INVALID, "-"); - goto errorTreeReturn; - } + IS_ARRAY (LTYPE (tree)) || + IS_ARITHMETIC (LTYPE (tree)))) + { + werror (E_PLUS_INVALID, "-"); + goto errorTreeReturn; + } if (!(IS_PTR (RTYPE (tree)) || - IS_ARRAY (RTYPE (tree)) || - IS_ARITHMETIC (RTYPE (tree)))) - { - werror (E_PLUS_INVALID, "-"); - goto errorTreeReturn; - } + IS_ARRAY (RTYPE (tree)) || + IS_ARITHMETIC (RTYPE (tree)))) + { + werror (E_PLUS_INVALID, "-"); + goto errorTreeReturn; + } if ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) && - !(IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)) || - IS_INTEGRAL (RTYPE (tree)))) - { - werror (E_PLUS_INVALID, "-"); - goto errorTreeReturn; - } + !(IS_PTR (RTYPE (tree)) || IS_ARRAY (RTYPE (tree)) || + IS_INTEGRAL (RTYPE (tree)))) + { + werror (E_PLUS_INVALID, "-"); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->left = addCast (tree->left, resultType, TRUE); - tree->right = addCast (tree->right, resultType, TRUE); - tree->opval.val = valMinus (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree))); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + { + tree->type = EX_VALUE; + tree->left = addCast (tree->left, resultType, TRUE); + tree->right = addCast (tree->right, resultType, TRUE); + tree->opval.val = valMinus (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree))); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } /* if the left & right are equal then zero */ if (isAstEqual (tree->left, tree->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; - } + { + 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 both of them are pointers or arrays then */ /* the result is going to be an integer */ if ((IS_ARRAY (LTYPE (tree)) || IS_PTR (LTYPE (tree))) && - (IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree)))) - TETYPE (tree) = TTYPE (tree) = newIntLink (); + (IS_ARRAY (RTYPE (tree)) || IS_PTR (RTYPE (tree)))) + TETYPE (tree) = TTYPE (tree) = newIntLink (); else - /* if only the left is a pointer */ - /* then result is a pointer */ + /* if only the left is a pointer */ + /* then result is a pointer */ if (IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) - TETYPE (tree) = getSpec (TTYPE (tree) = - LTYPE (tree)); + TETYPE (tree) = getSpec (TTYPE (tree) = + LTYPE (tree)); else - { - tree->left = addCast (tree->left, resultType, TRUE); - tree->right = addCast (tree->right, resultType, TRUE); + { + tree->left = addCast (tree->left, resultType, TRUE); + tree->right = addCast (tree->right, resultType, TRUE); - TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - resultType, - tree->opval.op)); - } + TETYPE (tree) = getSpec (TTYPE (tree) = + computeType (LTYPE (tree), + RTYPE (tree), + resultType, + tree->opval.op)); + } LRVAL (tree) = RRVAL (tree) = 1; @@ -3269,49 +3270,49 @@ decorateType (ast * tree, RESULT_TYPE resultType) if (IS_LITERAL (RTYPE (tree)) /* avoid infinite loop */ && (TYPE_UDWORD) floatFromVal (tree->right->opval.val) != 0) - { - ast *litTree, *litParent; - litTree = searchLitOp (tree, &litParent, "+-"); - if (litTree) - { - if (litTree->opval.op == '+') - { - /* foo_sa */ - DEBUG_CF("- 1 SA") - ast *tTree = litTree->left; - litTree->left = litTree->right; - litTree->right = tree->right; - tree->right = tTree; - tree->opval.op = '+'; - litTree->opval.op = '-'; - } - else if (litTree->opval.op == '-') - { - if (IS_LITERAL (RTYPE (litTree))) - { - /* foo_ssr */ - DEBUG_CF("- 2 SSR") - ast *tTree = litTree->left; - litTree->left = tree->right; - tree->right = litParent->left; - litParent->left = tTree; - litTree->opval.op = '+'; - - tree->decorated = 0; - decorateType (tree, resultType); - } - else - { - /* foo_ssl */ - DEBUG_CF("- 3 SSL") - ast *tTree = litTree->right; - litTree->right = tree->right; - tree->right = tTree; - } - } - decorateType (litParent, resultType); - } - } + { + ast *litTree, *litParent; + litTree = searchLitOp (tree, &litParent, "+-"); + if (litTree) + { + if (litTree->opval.op == '+') + { + /* foo_sa */ + DEBUG_CF("- 1 SA") + ast *tTree = litTree->left; + litTree->left = litTree->right; + litTree->right = tree->right; + tree->right = tTree; + tree->opval.op = '+'; + litTree->opval.op = '-'; + } + else if (litTree->opval.op == '-') + { + if (IS_LITERAL (RTYPE (litTree))) + { + /* foo_ssr */ + DEBUG_CF("- 2 SSR") + ast *tTree = litTree->left; + litTree->left = tree->right; + tree->right = litParent->left; + litParent->left = tTree; + litTree->opval.op = '+'; + + tree->decorated = 0; + decorateType (tree, resultType); + } + else + { + /* foo_ssl */ + DEBUG_CF("- 3 SSL") + ast *tTree = litTree->right; + litTree->right = tree->right; + tree->right = tTree; + } + } + decorateType (litParent, resultType); + } + } return tree; /*------------------------------------------------------------------*/ @@ -3321,10 +3322,10 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '~': /* can be only integral type */ if (!IS_INTEGRAL (LTYPE (tree))) - { - werror (E_UNARY_OP, tree->opval.op); - goto errorTreeReturn; - } + { + werror (E_UNARY_OP, tree->opval.op); + goto errorTreeReturn; + } /* if left is a literal then do it */ if (IS_LITERAL (LTYPE (tree))) @@ -3347,22 +3348,22 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '!': /* can be pointer */ if (!IS_ARITHMETIC (LTYPE (tree)) && - !IS_PTR (LTYPE (tree)) && - !IS_ARRAY (LTYPE (tree))) - { - werror (E_UNARY_OP, tree->opval.op); - goto errorTreeReturn; - } + !IS_PTR (LTYPE (tree)) && + !IS_ARRAY (LTYPE (tree))) + { + werror (E_UNARY_OP, tree->opval.op); + goto errorTreeReturn; + } /* if left is a literal then do it */ if (IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valNot (valFromType (LETYPE (tree))); - tree->left = NULL; - TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valNot (valFromType (LETYPE (tree))); + tree->left = NULL; + TETYPE (tree) = TTYPE (tree) = tree->opval.val->type; + return tree; + } LRVAL (tree) = 1; TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; @@ -3385,15 +3386,15 @@ decorateType (ast * tree, RESULT_TYPE resultType) case LEFT_OP: case RIGHT_OP: if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (tree->left->etype)) - { - werror (E_SHIFT_OP_INVALID); - werror (W_CONTINUE, "left & right types are "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, ","); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } + { + werror (E_SHIFT_OP_INVALID); + werror (W_CONTINUE, "left & right types are "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, ","); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } /* make smaller type only if it's a LEFT_OP */ if (tree->opval.op == LEFT_OP) @@ -3402,53 +3403,53 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valShift (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree)), - (tree->opval.op == LEFT_OP ? 1 : 0)); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + { + tree->type = EX_VALUE; + tree->opval.val = valShift (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree)), + (tree->opval.op == LEFT_OP ? 1 : 0)); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } LRVAL (tree) = RRVAL (tree) = 1; if (tree->opval.op == LEFT_OP) - { - TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - NULL, - resultType, - tree->opval.op)); - } + { + TETYPE (tree) = getSpec (TTYPE (tree) = + computeType (LTYPE (tree), + NULL, + resultType, + tree->opval.op)); + } else /* RIGHT_OP */ - { - /* no promotion necessary */ - TTYPE (tree) = TETYPE (tree) = copyLinkChain (LTYPE (tree)); - if (IS_LITERAL (TTYPE (tree))) - SPEC_SCLS (TTYPE (tree)) &= ~S_LITERAL; - } + { + /* no promotion necessary */ + TTYPE (tree) = TETYPE (tree) = copyLinkChain (LTYPE (tree)); + if (IS_LITERAL (TTYPE (tree))) + SPEC_SCLS (TTYPE (tree)) &= ~S_LITERAL; + } /* 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)) && - ((TYPE_UDWORD) floatFromVal (valFromType (RETYPE (tree)))) >= - (getSize (TETYPE (tree)) * 8)) - { - 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; - } - } + ((TYPE_UDWORD) floatFromVal (valFromType (RETYPE (tree)))) >= + (getSize (TETYPE (tree)) * 8)) + { + 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; + } + } return tree; @@ -3456,13 +3457,13 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ /* casting */ /*----------------------------*/ - case CAST: /* change the type */ + case CAST: /* change the type */ /* cannot cast to an aggregate type */ if (IS_AGGREGATE (LTYPE (tree))) - { - werror (E_CAST_ILLEGAL); - goto errorTreeReturn; - } + { + werror (E_CAST_ILLEGAL); + goto errorTreeReturn; + } /* make sure the type is complete and sane */ checkTypeSanity(LETYPE(tree), "(cast)"); @@ -3470,73 +3471,73 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* If code memory is read only, then pointers to code memory */ /* implicitly point to constants -- make this explicit */ { - sym_link *t = LTYPE(tree); - while (t && t->next) - { - if (IS_CODEPTR(t) && port->mem.code_ro) - { - if (IS_SPEC(t->next)) - SPEC_CONST (t->next) = 1; - else - DCL_PTR_CONST (t->next) = 1; - } - t = t->next; + sym_link *t = LTYPE(tree); + while (t && t->next) + { + if (IS_CODEPTR(t) && port->mem.code_ro) + { + if (IS_SPEC(t->next)) + SPEC_CONST (t->next) = 1; + else + DCL_PTR_CONST (t->next) = 1; + } + t = t->next; } } #if 0 /* if the right is a literal replace the tree */ 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(DECLARATOR); - 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; - } + 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(DECLARATOR); + 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; + TTYPE (tree) = LTYPE (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); - } + 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); + } #endif if (IS_ADDRESS_OF_OP(tree->right) && IS_AST_SYM_VALUE (tree->right->left) && SPEC_ABSA (AST_SYMBOL (tree->right->left)->etype)) { tree->type = EX_VALUE; - tree->opval.val = - valCastLiteral (LTYPE (tree), - SPEC_ADDR (AST_SYMBOL (tree->right->left)->etype)); - TTYPE (tree) = tree->opval.val->type; + tree->opval.val = + valCastLiteral (LTYPE (tree), + SPEC_ADDR (AST_SYMBOL (tree->right->left)->etype)); + TTYPE (tree) = tree->opval.val->type; TETYPE (tree) = getSpec (TTYPE (tree)); - tree->left = NULL; - tree->right = NULL; - tree->values.literalFromCast = 1; + tree->left = NULL; + tree->right = NULL; + tree->values.literalFromCast = 1; return tree; } @@ -3552,21 +3553,21 @@ decorateType (ast * tree, RESULT_TYPE resultType) symbol *element = getStructElement ( SPEC_STRUCT (LETYPE(tree->right->left)), - AST_SYMBOL(tree->right->left->right) + AST_SYMBOL(tree->right->left->right) ); if (element) { tree->type = EX_VALUE; - tree->opval.val = valCastLiteral ( - LTYPE (tree), - element->offset + tree->opval.val = valCastLiteral ( + LTYPE (tree), + element->offset + floatFromVal (valFromType (RTYPE (tree->right->left->left))) ); - TTYPE (tree) = tree->opval.val->type; + TTYPE (tree) = tree->opval.val->type; TETYPE (tree) = getSpec (TTYPE (tree)); - tree->left = NULL; - tree->right = NULL; + tree->left = NULL; + tree->right = NULL; return tree; } } @@ -3574,7 +3575,7 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* if the right is a literal replace the tree */ if (IS_LITERAL (RETYPE (tree))) { #if 0 - if (IS_PTR (LTYPE (tree)) && !IS_GENPTR (LTYPE (tree)) ) { + if (IS_PTR (LTYPE (tree)) && !IS_GENPTR (LTYPE (tree)) ) { /* rewrite (type *)litaddr as &temp and define type at litaddr temp @@ -3606,22 +3607,22 @@ decorateType (ast * tree, RESULT_TYPE resultType) newTree->left->lineno = tree->lineno; LTYPE (newTree) = sym->type; LETYPE (newTree) = sym->etype; - LLVAL (newTree) = 1; + LLVAL (newTree) = 1; LRVAL (newTree) = 0; TLVAL (newTree) = 1; return newTree; } - #endif + #endif if (!IS_PTR (LTYPE (tree))) { - tree->type = EX_VALUE; - tree->opval.val = - valCastLiteral (LTYPE (tree), - floatFromVal (valFromType (RTYPE (tree)))); - TTYPE (tree) = tree->opval.val->type; - tree->left = NULL; - tree->right = NULL; - tree->values.literalFromCast = 1; - TETYPE (tree) = getSpec (TTYPE (tree)); + tree->type = EX_VALUE; + tree->opval.val = + valCastLiteral (LTYPE (tree), + floatFromVal (valFromType (RTYPE (tree)))); + TTYPE (tree) = tree->opval.val->type; + tree->left = NULL; + tree->right = NULL; + tree->values.literalFromCast = 1; + TETYPE (tree) = getSpec (TTYPE (tree)); return tree; } } @@ -3641,34 +3642,34 @@ decorateType (ast * tree, RESULT_TYPE resultType) case OR_OP: /* each must be arithmetic type or be a pointer */ if (!IS_PTR (LTYPE (tree)) && - !IS_ARRAY (LTYPE (tree)) && - !IS_INTEGRAL (LTYPE (tree))) - { - werror (E_COMPARE_OP); - goto errorTreeReturn; - } + !IS_ARRAY (LTYPE (tree)) && + !IS_INTEGRAL (LTYPE (tree))) + { + werror (E_COMPARE_OP); + goto errorTreeReturn; + } if (!IS_PTR (RTYPE (tree)) && - !IS_ARRAY (RTYPE (tree)) && - !IS_INTEGRAL (RTYPE (tree))) - { - werror (E_COMPARE_OP); - goto errorTreeReturn; - } + !IS_ARRAY (RTYPE (tree)) && + !IS_INTEGRAL (RTYPE (tree))) + { + werror (E_COMPARE_OP); + goto errorTreeReturn; + } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && - IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valLogicAndOr (valFromType (LTYPE (tree)), - valFromType (RTYPE (tree)), - tree->opval.op); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + IS_LITERAL (LTYPE (tree))) + { + tree->type = EX_VALUE; + tree->opval.val = valLogicAndOr (valFromType (LTYPE (tree)), + valFromType (RTYPE (tree)), + tree->opval.op); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } LRVAL (tree) = RRVAL (tree) = 1; TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; @@ -3684,94 +3685,94 @@ decorateType (ast * tree, RESULT_TYPE resultType) case EQ_OP: case NE_OP: { - ast *lt = optimizeCompare (tree); + ast *lt = optimizeCompare (tree); - if (tree != lt) - return lt; + if (tree != lt) + return lt; } /* 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 "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, "to type "); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } - } + { + 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 "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, "to type "); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } + } /* else they should be promotable to one another */ else - { - if (!((IS_PTR (LTYPE (tree)) && IS_LITERAL (RTYPE (tree))) || - (IS_PTR (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))))) - - if (compareType (LTYPE (tree), RTYPE (tree)) == 0) - { - werror (E_COMPARE_OP); - fprintf (stderr, "comparing type "); - printTypeChain (LTYPE (tree), stderr); - fprintf (stderr, "to type "); - printTypeChain (RTYPE (tree), stderr); - fprintf (stderr, "\n"); - goto errorTreeReturn; - } - } + { + if (!((IS_PTR (LTYPE (tree)) && IS_LITERAL (RTYPE (tree))) || + (IS_PTR (RTYPE (tree)) && IS_LITERAL (LTYPE (tree))))) + + if (compareType (LTYPE (tree), RTYPE (tree)) == 0) + { + werror (E_COMPARE_OP); + fprintf (stderr, "comparing type "); + printTypeChain (LTYPE (tree), stderr); + fprintf (stderr, "to type "); + printTypeChain (RTYPE (tree), stderr); + fprintf (stderr, "\n"); + goto errorTreeReturn; + } + } /* if unsigned value < 0 then always false */ /* if (unsigned value) > 0 then '(unsigned value) ? 1 : 0' */ if (SPEC_USIGN(LETYPE(tree)) && !IS_CHAR(LETYPE(tree)) && /* promotion to signed int */ IS_LITERAL(RTYPE(tree)) && - ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) - { - if (tree->opval.op == '<') - { - return tree->right; - } - if (tree->opval.op == '>') - { - if (resultType == RESULT_TYPE_IFX) - { - /* the parent is an ifx: */ - /* if (unsigned value) */ - return tree->left; - } - - /* (unsigned value) ? 1 : 0 */ - tree->opval.op = '?'; - tree->right = newNode (':', - newAst_VALUE (constVal ("1")), - tree->right); /* val 0 */ - tree->right->lineno = tree->lineno; - tree->right->left->lineno = tree->lineno; - decorateType (tree->right, RESULT_CHECK); - } + ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0) + { + if (tree->opval.op == '<') + { + return tree->right; + } + if (tree->opval.op == '>') + { + if (resultType == RESULT_TYPE_IFX) + { + /* the parent is an ifx: */ + /* if (unsigned value) */ + return tree->left; + } + + /* (unsigned value) ? 1 : 0 */ + tree->opval.op = '?'; + tree->right = newNode (':', + newAst_VALUE (constVal ("1")), + tree->right); /* val 0 */ + tree->right->lineno = tree->lineno; + tree->right->left->lineno = tree->lineno; + decorateType (tree->right, RESULT_CHECK); + } } /* if they are both literal then */ /* rewrite the tree */ if (IS_LITERAL (RTYPE (tree)) && - IS_LITERAL (LTYPE (tree))) - { - tree->type = EX_VALUE; - tree->opval.val = valCompare (valFromType (LETYPE (tree)), - valFromType (RETYPE (tree)), - tree->opval.op); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - return tree; - } + IS_LITERAL (LTYPE (tree))) + { + tree->type = EX_VALUE; + tree->opval.val = valCompare (valFromType (LETYPE (tree)), + valFromType (RETYPE (tree)), + tree->opval.op); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + return tree; + } LRVAL (tree) = RRVAL (tree) = 1; TTYPE (tree) = TETYPE (tree) = newCharLink (); return tree; @@ -3780,19 +3781,19 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ /* sizeof */ /*----------------------------*/ - case SIZEOF: /* evaluate wihout code generation */ + case SIZEOF: /* evaluate wihout code generation */ /* change the type to a integer */ { - int size = getSize (tree->right->ftype); - SNPRINTF(buffer, sizeof(buffer), "%d", size); - if (!size && !IS_VOID(tree->right->ftype)) - werrorfl (tree->filename, tree->lineno, E_SIZEOF_INCOMPLETE_TYPE); + int size = getSize (tree->right->ftype); + SNPRINTF(buffer, sizeof(buffer), "%d", size); + if (!size && !IS_VOID(tree->right->ftype)) + werrorfl (tree->filename, tree->lineno, E_SIZEOF_INCOMPLETE_TYPE); } tree->type = EX_VALUE; tree->opval.val = constVal (buffer); tree->right = tree->left = NULL; TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); + tree->opval.val->type); return tree; /*------------------------------------------------------------------*/ @@ -3800,77 +3801,77 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* typeof */ /*----------------------------*/ case TYPEOF: - /* return typeof enum value */ - tree->type = EX_VALUE; - { - int typeofv = 0; - if (IS_SPEC(tree->right->ftype)) { - switch (SPEC_NOUN(tree->right->ftype)) { - case V_INT: - if (SPEC_LONG(tree->right->ftype)) typeofv = TYPEOF_LONG; - else typeofv = TYPEOF_INT; - break; - case V_FLOAT: - typeofv = TYPEOF_FLOAT; - break; - case V_CHAR: - typeofv = TYPEOF_CHAR; - break; - case V_VOID: - typeofv = TYPEOF_VOID; - break; - case V_STRUCT: - typeofv = TYPEOF_STRUCT; - break; - case V_BITFIELD: - typeofv = TYPEOF_BITFIELD; - break; - case V_BIT: - typeofv = TYPEOF_BIT; - break; - case V_SBIT: - typeofv = TYPEOF_SBIT; - break; - default: - break; - } - } else { - switch (DCL_TYPE(tree->right->ftype)) { - case POINTER: - typeofv = TYPEOF_POINTER; - break; - case FPOINTER: - typeofv = TYPEOF_FPOINTER; - break; - case CPOINTER: - typeofv = TYPEOF_CPOINTER; - break; - case GPOINTER: - typeofv = TYPEOF_GPOINTER; - break; - case PPOINTER: - typeofv = TYPEOF_PPOINTER; - break; - case IPOINTER: - typeofv = TYPEOF_IPOINTER; - break; - case ARRAY: - typeofv = TYPEOF_ARRAY; - break; - case FUNCTION: - typeofv = TYPEOF_FUNCTION; - break; - default: - break; - } - } - SNPRINTF (buffer, sizeof(buffer), "%d", typeofv); - tree->opval.val = constVal (buffer); - tree->right = tree->left = NULL; - TETYPE (tree) = getSpec (TTYPE (tree) = - tree->opval.val->type); - } - return tree; + /* return typeof enum value */ + tree->type = EX_VALUE; + { + int typeofv = 0; + if (IS_SPEC(tree->right->ftype)) { + switch (SPEC_NOUN(tree->right->ftype)) { + case V_INT: + if (SPEC_LONG(tree->right->ftype)) typeofv = TYPEOF_LONG; + else typeofv = TYPEOF_INT; + break; + case V_FLOAT: + typeofv = TYPEOF_FLOAT; + break; + case V_CHAR: + typeofv = TYPEOF_CHAR; + break; + case V_VOID: + typeofv = TYPEOF_VOID; + break; + case V_STRUCT: + typeofv = TYPEOF_STRUCT; + break; + case V_BITFIELD: + typeofv = TYPEOF_BITFIELD; + break; + case V_BIT: + typeofv = TYPEOF_BIT; + break; + case V_SBIT: + typeofv = TYPEOF_SBIT; + break; + default: + break; + } + } else { + switch (DCL_TYPE(tree->right->ftype)) { + case POINTER: + typeofv = TYPEOF_POINTER; + break; + case FPOINTER: + typeofv = TYPEOF_FPOINTER; + break; + case CPOINTER: + typeofv = TYPEOF_CPOINTER; + break; + case GPOINTER: + typeofv = TYPEOF_GPOINTER; + break; + case PPOINTER: + typeofv = TYPEOF_PPOINTER; + break; + case IPOINTER: + typeofv = TYPEOF_IPOINTER; + break; + case ARRAY: + typeofv = TYPEOF_ARRAY; + break; + case FUNCTION: + typeofv = TYPEOF_FUNCTION; + break; + default: + break; + } + } + SNPRINTF (buffer, sizeof(buffer), "%d", typeofv); + tree->opval.val = constVal (buffer); + tree->right = tree->left = NULL; + TETYPE (tree) = getSpec (TTYPE (tree) = + tree->opval.val->type); + } + return tree; /*------------------------------------------------------------------*/ /*----------------------------*/ /* conditional operator '?' */ @@ -3879,29 +3880,29 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* 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 */ + but faster to do it here */ if (IS_LITERAL (LTYPE (tree))) - { - if (((int) floatFromVal (valFromType (LETYPE (tree)))) != 0) + { + if (((int) floatFromVal (valFromType (LETYPE (tree)))) != 0) return decorateType (tree->right->left, resultTypeProp); - else - return decorateType (tree->right->right, resultTypeProp); - } + else + return decorateType (tree->right->right, resultTypeProp); + } else - { - tree->right = decorateType (tree->right, resultTypeProp); - TTYPE (tree) = RTYPE (tree); - TETYPE (tree) = getSpec (TTYPE (tree)); - } + { + tree->right = decorateType (tree->right, resultTypeProp); + TTYPE (tree) = RTYPE (tree); + TETYPE (tree) = getSpec (TTYPE (tree)); + } return tree; case ':': /* if they don't match we have a problem */ if (compareType (LTYPE (tree), RTYPE (tree)) == 0) - { - werror (E_TYPE_MISMATCH, "conditional operator", " "); - goto errorTreeReturn; - } + { + werror (E_TYPE_MISMATCH, "conditional operator", " "); + goto errorTreeReturn; + } TTYPE (tree) = computeType (LTYPE (tree), RTYPE (tree), resultType, tree->opval.op); @@ -3918,22 +3919,22 @@ decorateType (ast * tree, RESULT_TYPE resultType) case DIV_ASSIGN: /* for these it must be both must be integral */ if (!IS_ARITHMETIC (LTYPE (tree)) || - !IS_ARITHMETIC (RTYPE (tree))) - { - werror (E_OPS_INTEGRAL); - goto errorTreeReturn; - } + !IS_ARITHMETIC (RTYPE (tree))) + { + werror (E_OPS_INTEGRAL); + goto errorTreeReturn; + } RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)); if (!tree->initMode && IS_CONSTANT (LTYPE (tree))) - werror (E_CODE_WRITE, tree->opval.op==MUL_ASSIGN ? "*=" : "/="); + werror (E_CODE_WRITE, tree->opval.op==MUL_ASSIGN ? "*=" : "/="); if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, tree->opval.op==MUL_ASSIGN ? "*=" : "/="); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, tree->opval.op==MUL_ASSIGN ? "*=" : "/="); + goto errorTreeReturn; + } LLVAL (tree) = 1; return tree; @@ -3945,22 +3946,22 @@ decorateType (ast * tree, RESULT_TYPE resultType) case LEFT_ASSIGN: /* for these it must be both must be integral */ if (!IS_INTEGRAL (LTYPE (tree)) || - !IS_INTEGRAL (RTYPE (tree))) - { - werror (E_OPS_INTEGRAL); - goto errorTreeReturn; - } + !IS_INTEGRAL (RTYPE (tree))) + { + werror (E_OPS_INTEGRAL); + goto errorTreeReturn; + } RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)); if (!tree->initMode && IS_CONSTANT (LETYPE (tree))) - werror (E_CODE_WRITE, "&= or |= or ^= or >>= or <<="); + werror (E_CODE_WRITE, "&= or |= or ^= or >>= or <<="); if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "&= or |= or ^= or >>= or <<="); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "&= or |= or ^= or >>= or <<="); + goto errorTreeReturn; + } LLVAL (tree) = 1; return tree; @@ -3971,33 +3972,33 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case SUB_ASSIGN: if (!(IS_PTR (LTYPE (tree)) || - IS_ARITHMETIC (LTYPE (tree)))) - { - werror (E_PLUS_INVALID, "-="); - goto errorTreeReturn; - } + IS_ARITHMETIC (LTYPE (tree)))) + { + werror (E_PLUS_INVALID, "-="); + goto errorTreeReturn; + } if (!(IS_PTR (RTYPE (tree)) || - IS_ARITHMETIC (RTYPE (tree)))) - { - werror (E_PLUS_INVALID, "-="); - goto errorTreeReturn; - } + IS_ARITHMETIC (RTYPE (tree)))) + { + werror (E_PLUS_INVALID, "-="); + goto errorTreeReturn; + } RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - RESULT_TYPE_NOPROM, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + RESULT_TYPE_NOPROM, + tree->opval.op)); if (!tree->initMode && IS_CONSTANT (LETYPE (tree))) - werror (E_CODE_WRITE, "-="); + werror (E_CODE_WRITE, "-="); if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "-="); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "-="); + goto errorTreeReturn; + } LLVAL (tree) = 1; return tree; @@ -4010,37 +4011,37 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* this is not a unary operation */ /* if both pointers then problem */ if (IS_PTR (LTYPE (tree)) && IS_PTR (RTYPE (tree))) - { - werror (E_PTR_PLUS_PTR); - goto errorTreeReturn; - } + { + werror (E_PTR_PLUS_PTR); + goto errorTreeReturn; + } if (!IS_ARITHMETIC (LTYPE (tree)) && !IS_PTR (LTYPE (tree))) - { - werror (E_PLUS_INVALID, "+="); - goto errorTreeReturn; - } + { + werror (E_PLUS_INVALID, "+="); + goto errorTreeReturn; + } if (!IS_ARITHMETIC (RTYPE (tree)) && !IS_PTR (RTYPE (tree))) - { - werror (E_PLUS_INVALID, "+="); - goto errorTreeReturn; - } + { + werror (E_PLUS_INVALID, "+="); + goto errorTreeReturn; + } RRVAL (tree) = 1; TETYPE (tree) = getSpec (TTYPE (tree) = - computeType (LTYPE (tree), - RTYPE (tree), - RESULT_TYPE_NOPROM, - tree->opval.op)); + computeType (LTYPE (tree), + RTYPE (tree), + RESULT_TYPE_NOPROM, + tree->opval.op)); if (!tree->initMode && IS_CONSTANT (LETYPE (tree))) - werror (E_CODE_WRITE, "+="); + werror (E_CODE_WRITE, "+="); if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "+="); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "+="); + goto errorTreeReturn; + } tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right), RESULT_CHECK); tree->opval.op = '='; @@ -4055,39 +4056,39 @@ decorateType (ast * tree, RESULT_TYPE resultType) case '=': /* cannot be an aggregate */ if (IS_AGGREGATE (LTYPE (tree))) - { - werror (E_AGGR_ASSIGN); - goto errorTreeReturn; - } + { + werror (E_AGGR_ASSIGN); + goto errorTreeReturn; + } /* they should either match or be castable */ if (compareType (LTYPE (tree), RTYPE (tree)) == 0) - { - werror (E_TYPE_MISMATCH, "assignment", " "); - printFromToType(RTYPE(tree),LTYPE(tree)); - } + { + werror (E_TYPE_MISMATCH, "assignment", " "); + printFromToType(RTYPE(tree),LTYPE(tree)); + } /* if the left side of the tree is of type void then report error */ if (IS_VOID (LTYPE (tree))) - { - werror (E_CAST_ZERO); - printFromToType(RTYPE(tree), LTYPE(tree)); - } + { + werror (E_CAST_ZERO); + printFromToType(RTYPE(tree), LTYPE(tree)); + } TETYPE (tree) = getSpec (TTYPE (tree) = - LTYPE (tree)); + LTYPE (tree)); RRVAL (tree) = 1; LLVAL (tree) = 1; if (!tree->initMode ) { if (IS_CONSTANT(LTYPE(tree))) - werror (E_CODE_WRITE, "="); + werror (E_CODE_WRITE, "="); } if (LRVAL (tree)) - { - werror (E_LVALUE_REQUIRED, "="); - goto errorTreeReturn; - } + { + werror (E_LVALUE_REQUIRED, "="); + goto errorTreeReturn; + } return tree; @@ -4108,17 +4109,17 @@ decorateType (ast * tree, RESULT_TYPE resultType) /* undo any explicit pointer derefernce; PCALL will handle it instead */ if (IS_FUNC (LTYPE (tree)) && tree->left->type == EX_OP) { - if (tree->left->opval.op == '*' && !tree->left->right) - tree->left = tree->left->left; - } + if (tree->left->opval.op == '*' && !tree->left->right) + tree->left = tree->left->left; + } /* require a function or pointer to function */ if (!IS_FUNC (LTYPE (tree)) && !(IS_CODEPTR (LTYPE (tree)) && IS_FUNC (LTYPE (tree)->next))) - { - werrorfl (tree->filename, tree->lineno, E_FUNCTION_EXPECTED); - goto errorTreeReturn; - } + { + werrorfl (tree->filename, tree->lineno, E_FUNCTION_EXPECTED); + goto errorTreeReturn; + } /* if there are parms, make sure that parms are decorate / process / reverse only once */ @@ -4156,32 +4157,32 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case RETURN: if (!tree->right) - goto voidcheck; + goto voidcheck; if (compareType (currFunc->type->next, RTYPE (tree)) == 0) - { - werrorfl (tree->filename, tree->lineno, W_RETURN_MISMATCH); - printFromToType (RTYPE(tree), currFunc->type->next); - goto errorTreeReturn; - } + { + werrorfl (tree->filename, tree->lineno, W_RETURN_MISMATCH); + printFromToType (RTYPE(tree), currFunc->type->next); + goto errorTreeReturn; + } if (IS_VOID (currFunc->type->next) - && tree->right && - !IS_VOID (RTYPE (tree))) - { - werrorfl (tree->filename, tree->lineno, E_FUNC_VOID); - goto errorTreeReturn; - } + && tree->right && + !IS_VOID (RTYPE (tree))) + { + werrorfl (tree->filename, tree->lineno, E_FUNC_VOID); + goto errorTreeReturn; + } /* if there is going to be a casting required then add it */ if (compareType (currFunc->type->next, RTYPE (tree)) < 0) - { - tree->right = - decorateType (newNode (CAST, - newAst_LINK (copyLinkChain (currFunc->type->next)), - tree->right), - RESULT_CHECK); - } + { + tree->right = + decorateType (newNode (CAST, + newAst_LINK (copyLinkChain (currFunc->type->next)), + tree->right), + RESULT_CHECK); + } RRVAL (tree) = 1; return tree; @@ -4189,10 +4190,10 @@ decorateType (ast * tree, RESULT_TYPE resultType) voidcheck: if (!IS_VOID (currFunc->type->next) && tree->right == NULL) - { - werror (W_VOID_FUNC, currFunc->name); - goto errorTreeReturn; - } + { + werror (W_VOID_FUNC, currFunc->name); + goto errorTreeReturn; + } TTYPE (tree) = TETYPE (tree) = NULL; return tree; @@ -4204,10 +4205,10 @@ decorateType (ast * tree, RESULT_TYPE resultType) case SWITCH: /* the switch value must be an integer */ if (!IS_INTEGRAL (LTYPE (tree))) - { - werrorfl (tree->filename, tree->lineno, E_SWITCH_NON_INTEGER); - goto errorTreeReturn; - } + { + werrorfl (tree->filename, tree->lineno, E_SWITCH_NON_INTEGER); + goto errorTreeReturn; + } LRVAL (tree) = 1; TTYPE (tree) = TETYPE (tree) = NULL; return tree; @@ -4218,8 +4219,8 @@ decorateType (ast * tree, RESULT_TYPE resultType) /*----------------------------*/ case IFX: tree->left = backPatchLabels (tree->left, - tree->trueLabel, - tree->falseLabel); + tree->trueLabel, + tree->falseLabel); TTYPE (tree) = TETYPE (tree) = NULL; return tree; @@ -4237,25 +4238,25 @@ decorateType (ast * tree, RESULT_TYPE resultType) reverse it otherwise do what we normally do */ { - symbol *sym; - ast *init, *end; - - if (isLoopReversible (tree, &sym, &init, &end)) - return reverseLoop (tree, sym, init, end); - else - return decorateType (createFor (AST_FOR (tree, trueLabel), - AST_FOR (tree, continueLabel), - AST_FOR (tree, falseLabel), - AST_FOR (tree, condLabel), - AST_FOR (tree, initExpr), - AST_FOR (tree, condExpr), - AST_FOR (tree, loopExpr), - tree->left), RESULT_CHECK); + symbol *sym; + ast *init, *end; + + if (isLoopReversible (tree, &sym, &init, &end)) + return reverseLoop (tree, sym, init, end); + else + return decorateType (createFor (AST_FOR (tree, trueLabel), + AST_FOR (tree, continueLabel), + AST_FOR (tree, falseLabel), + AST_FOR (tree, condLabel), + AST_FOR (tree, initExpr), + AST_FOR (tree, condExpr), + AST_FOR (tree, loopExpr), + tree->left), RESULT_CHECK); } case PARAM: werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "node PARAM shouldn't be processed here"); - /* but in processParams() */ + "node PARAM shouldn't be processed here"); + /* but in processParams() */ return tree; default: TTYPE (tree) = TETYPE (tree) = NULL; @@ -4327,12 +4328,12 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel) /* if left is already a IFX then just change the if true label in that */ if (!IS_IFX (tree->left)) - tree->left = newIfxNode (tree->left, localLabel, falseLabel); + tree->left = newIfxNode (tree->left, localLabel, falseLabel); tree->right = backPatchLabels (tree->right, trueLabel, falseLabel); /* right is a IFX then just join */ if (IS_IFX (tree->right)) - return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right)); + return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right)); tree->right = createLabel (localLabel, tree->right); tree->right = newIfxNode (tree->right, trueLabel, falseLabel); @@ -4353,12 +4354,12 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel) /* if left is already a IFX then just change the if true label in that */ if (!IS_IFX (tree->left)) - tree->left = newIfxNode (tree->left, trueLabel, localLabel); + tree->left = newIfxNode (tree->left, trueLabel, localLabel); tree->right = backPatchLabels (tree->right, trueLabel, falseLabel); /* right is a IFX then just join */ if (IS_IFX (tree->right)) - return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right)); + return newNode (NULLOP, tree->left, createLabel (localLabel, tree->right)); tree->right = createLabel (localLabel, tree->right); tree->right = newIfxNode (tree->right, trueLabel, falseLabel); @@ -4374,18 +4375,18 @@ backPatchLabels (ast * tree, symbol * trueLabel, symbol * falseLabel) /* if the left is already a IFX */ if (!IS_IFX (tree->left)) - tree->left = newNode (IFX, tree->left, NULL); + tree->left = newNode (IFX, tree->left, NULL); if (wasnot) - { - tree->left->trueLabel = trueLabel; - tree->left->falseLabel = falseLabel; - } + { + tree->left->trueLabel = trueLabel; + tree->left->falseLabel = falseLabel; + } else - { - tree->left->trueLabel = falseLabel; - tree->left->falseLabel = trueLabel; - } + { + tree->left->trueLabel = falseLabel; + tree->left->falseLabel = trueLabel; + } return tree->left; } @@ -4499,44 +4500,44 @@ createCase (ast * swStat, ast * caseVal, ast * stmnt) value *pval = NULL; int cVal = (int) floatFromVal (caseVal->opval.val); while (val && (int) floatFromVal (val) < cVal) - { - pval = val; - val = val->next; - } + { + pval = val; + val = val->next; + } /* if we reached the end then */ if (!val) - { - pval->next = caseVal->opval.val; - } + { + pval->next = caseVal->opval.val; + } else if ((int) floatFromVal (val) == cVal) - { - werrorfl (caseVal->filename, caseVal->lineno, E_DUPLICATE_LABEL, - "case"); - return NULL; - } + { + werrorfl (caseVal->filename, caseVal->lineno, E_DUPLICATE_LABEL, + "case"); + return NULL; + } else - { - /* we found a value greater than */ - /* the current value we must add this */ - /* before the value */ - caseVal->opval.val->next = val; - - /* if this was the first in chain */ - if (swStat->values.switchVals.swVals == val) - swStat->values.switchVals.swVals = - caseVal->opval.val; - else - pval->next = caseVal->opval.val; - } + { + /* we found a value greater than */ + /* the current value we must add this */ + /* before the value */ + caseVal->opval.val->next = val; + + /* if this was the first in chain */ + if (swStat->values.switchVals.swVals == val) + swStat->values.switchVals.swVals = + caseVal->opval.val; + else + pval->next = caseVal->opval.val; + } } /* create the case label */ SNPRINTF(caseLbl, sizeof(caseLbl), - "_case_%d_%d", - swStat->values.switchVals.swNum, - (int) floatFromVal (caseVal->opval.val)); + "_case_%d_%d", + swStat->values.switchVals.swNum, + (int) floatFromVal (caseVal->opval.val)); rexpr = createLabel (newSymbol (caseLbl, 0), stmnt); rexpr->lineno = 0; @@ -4562,7 +4563,7 @@ createDefault (ast * swStat, ast * defaultVal, ast * stmnt) if (swStat->values.switchVals.swDefault) { werrorfl (defaultVal->filename, defaultVal->lineno, E_DUPLICATE_LABEL, - "default"); + "default"); return NULL; } @@ -4571,7 +4572,7 @@ createDefault (ast * swStat, ast * defaultVal, ast * stmnt) /* create the label */ SNPRINTF (defLbl, sizeof(defLbl), - "_default_%d", swStat->values.switchVals.swNum); + "_default_%d", swStat->values.switchVals.swNum); return createLabel (newSymbol (defLbl, 0), stmnt); } @@ -4616,20 +4617,20 @@ createIf (ast * condAst, ast * ifBody, ast * elseBody) if (elseBody) { ifBody = newNode (NULLOP, ifBody, - newNode (GOTO, - newAst_VALUE (symbolVal (ifEnd)), - NULL)); + newNode (GOTO, + newAst_VALUE (symbolVal (ifEnd)), + NULL)); /* put the elseLabel on the else body */ elseBody = createLabel (ifFalse, elseBody); /* out the end at the end of the body */ elseBody = newNode (NULLOP, - elseBody, - createLabel (ifEnd, NULL)); + elseBody, + createLabel (ifEnd, NULL)); } else { ifBody = newNode (NULLOP, ifBody, - createLabel (ifFalse, NULL)); + createLabel (ifFalse, NULL)); } condAst = backPatchLabels (condAst, ifTrue, ifFalse); if (IS_IFX (condAst)) @@ -4638,7 +4639,7 @@ createIf (ast * condAst, ast * ifBody, ast * elseBody) ifTree = newIfxNode (condAst, ifTrue, ifFalse); return newNode (NULLOP, ifTree, - newNode (NULLOP, ifBody, elseBody)); + newNode (NULLOP, ifBody, elseBody)); } @@ -4654,7 +4655,7 @@ createIf (ast * condAst, ast * ifBody, ast * elseBody) /*-----------------------------------------------------------------*/ ast * createDo (symbol * trueLabel, symbol * continueLabel, - symbol * falseLabel, ast * condAst, ast * doBody) + symbol * falseLabel, ast * condAst, ast * doBody) { ast *doTree; @@ -4664,7 +4665,7 @@ createDo (symbol * trueLabel, symbol * continueLabel, { condAst = backPatchLabels (condAst, continueLabel, NULL); doTree = (IS_IFX (condAst) ? createLabel (continueLabel, condAst) - : newNode (IFX, createLabel (continueLabel, condAst), NULL)); + : newNode (IFX, createLabel (continueLabel, condAst), NULL)); doTree->trueLabel = continueLabel; doTree->falseLabel = NULL; return doTree; @@ -4677,7 +4678,7 @@ createDo (symbol * trueLabel, symbol * continueLabel, doBody = createLabel (trueLabel, doBody); /* attach the continue label to end of body */ doBody = newNode (NULLOP, doBody, - createLabel (continueLabel, NULL)); + createLabel (continueLabel, NULL)); /* now put the break label at the end */ if (IS_IFX (condAst)) @@ -4707,9 +4708,9 @@ createDo (symbol * trueLabel, symbol * continueLabel, /*-----------------------------------------------------------------*/ ast * createFor (symbol * trueLabel, symbol * continueLabel, - symbol * falseLabel, symbol * condLabel, - ast * initExpr, ast * condExpr, ast * loopExpr, - ast * forBody) + symbol * falseLabel, symbol * condLabel, + ast * initExpr, ast * condExpr, ast * loopExpr, + ast * forBody) { ast *forTree; @@ -4717,8 +4718,8 @@ createFor (symbol * trueLabel, symbol * continueLabel, /* the same way as a while */ if (!loopExpr) return newNode (NULLOP, initExpr, - createWhile (trueLabel, continueLabel, - falseLabel, condExpr, forBody)); + createWhile (trueLabel, continueLabel, + falseLabel, condExpr, forBody)); /* vanilla for statement */ condExpr = backPatchLabels (condExpr, trueLabel, falseLabel); @@ -4735,18 +4736,18 @@ createFor (symbol * trueLabel, symbol * continueLabel, /* attach continue to forLoop expression & attach */ /* goto the forcond @ and of loopExpression */ loopExpr = createLabel (continueLabel, - newNode (NULLOP, - loopExpr, - newNode (GOTO, - newAst_VALUE (symbolVal (condLabel)), - NULL))); + newNode (NULLOP, + loopExpr, + newNode (GOTO, + newAst_VALUE (symbolVal (condLabel)), + NULL))); /* now start putting them together */ forTree = newNode (NULLOP, initExpr, condExpr); forTree = newNode (NULLOP, forTree, forBody); forTree = newNode (NULLOP, forTree, loopExpr); /* finally add the break label */ forTree = newNode (NULLOP, forTree, - createLabel (falseLabel, NULL)); + createLabel (falseLabel, NULL)); return forTree; } @@ -4765,7 +4766,7 @@ createFor (symbol * trueLabel, symbol * continueLabel, /*-----------------------------------------------------------------*/ ast * createWhile (symbol * trueLabel, symbol * continueLabel, - symbol * falseLabel, ast * condExpr, ast * whileBody) + symbol * falseLabel, ast * condExpr, ast * whileBody) { ast *whileTree; @@ -4780,10 +4781,10 @@ createWhile (symbol * trueLabel, symbol * continueLabel, /* put a jump to continue at the end of the body */ /* and put break label at the end of the body */ whileBody = newNode (NULLOP, - whileBody, - newNode (GOTO, - newAst_VALUE (symbolVal (continueLabel)), - createLabel (falseLabel, NULL))); + whileBody, + newNode (GOTO, + newAst_VALUE (symbolVal (continueLabel)), + createLabel (falseLabel, NULL))); /* put it all together */ if (IS_IFX (condExpr)) @@ -4866,23 +4867,23 @@ optimizeRRCRLC (ast * root) { if (!SPEC_USIGN (TETYPE (root->left->left))) - return root; + return root; if (!IS_AST_LIT_VALUE (root->left->right) || - !IS_AST_LIT_VALUE (root->right->right)) - goto tryNext0; + !IS_AST_LIT_VALUE (root->right->right)) + goto tryNext0; /* make sure it is the same expression */ if (!isAstEqual (root->left->left, - root->right->left)) - goto tryNext0; + root->right->left)) + goto tryNext0; if (AST_LIT_VALUE (root->left->right) != 1) - goto tryNext0; + goto tryNext0; if (AST_LIT_VALUE (root->right->right) != - (getSize (TTYPE (root->left->left)) * 8 - 1)) - goto tryNext0; + (getSize (TTYPE (root->left->left)) * 8 - 1)) + goto tryNext0; /* make sure the port supports RLC */ if (port->hasExtBitOp @@ -4901,23 +4902,23 @@ tryNext0: { if (!SPEC_USIGN (TETYPE (root->left->left))) - return root; + return root; if (!IS_AST_LIT_VALUE (root->left->right) || - !IS_AST_LIT_VALUE (root->right->right)) - goto tryNext1; + !IS_AST_LIT_VALUE (root->right->right)) + goto tryNext1; /* make sure it is the same symbol */ if (!isAstEqual (root->left->left, - root->right->left)) - goto tryNext1; + root->right->left)) + goto tryNext1; if (AST_LIT_VALUE (root->right->right) != 1) - goto tryNext1; + goto tryNext1; if (AST_LIT_VALUE (root->left->right) != - (getSize (TTYPE (root->left->left)) * 8 - 1)) - goto tryNext1; + (getSize (TTYPE (root->left->left)) * 8 - 1)) + goto tryNext1; /* make sure the port supports RLC */ if (port->hasExtBitOp @@ -4937,23 +4938,23 @@ tryNext1: { if (!SPEC_USIGN (TETYPE (root->left->left))) - return root; + return root; if (!IS_AST_LIT_VALUE (root->left->right) || - !IS_AST_LIT_VALUE (root->right->right)) - goto tryNext2; + !IS_AST_LIT_VALUE (root->right->right)) + goto tryNext2; /* make sure it is the same symbol */ if (!isAstEqual (root->left->left, - root->right->left)) - goto tryNext2; + root->right->left)) + goto tryNext2; if (AST_LIT_VALUE (root->left->right) != 1) - goto tryNext2; + goto tryNext2; if (AST_LIT_VALUE (root->right->right) != - (getSize (TTYPE (root->left->left)) * 8 - 1)) - goto tryNext2; + (getSize (TTYPE (root->left->left)) * 8 - 1)) + goto tryNext2; /* make sure the port supports RRC */ if (port->hasExtBitOp @@ -4972,23 +4973,23 @@ tryNext2: { if (!SPEC_USIGN (TETYPE (root->left->left))) - return root; + return root; if (!IS_AST_LIT_VALUE (root->left->right) || - !IS_AST_LIT_VALUE (root->right->right)) - return root; + !IS_AST_LIT_VALUE (root->right->right)) + return root; /* make sure it is the same symbol */ if (!isAstEqual (root->left->left, - root->right->left)) - return root; + root->right->left)) + return root; if (AST_LIT_VALUE (root->right->right) != 1) - return root; + return root; if (AST_LIT_VALUE (root->left->right) != - (getSize (TTYPE (root->left->left)) * 8 - 1)) - return root; + (getSize (TTYPE (root->left->left)) * 8 - 1)) + return root; /* make sure the port supports RRC */ if (port->hasExtBitOp @@ -5026,24 +5027,24 @@ optimizeSWAP (ast * root) { if (!SPEC_USIGN (TETYPE (root->left->left))) - return root; + return root; if (!IS_AST_LIT_VALUE (root->left->right) || - !IS_AST_LIT_VALUE (root->right->right)) - return root; + !IS_AST_LIT_VALUE (root->right->right)) + return root; /* make sure it is the same expression */ if (!isAstEqual (root->left->left, - root->right->left)) - return root; + root->right->left)) + return root; if (AST_LIT_VALUE (root->left->right) != - (getSize (TTYPE (root->left->left)) * 4)) - return root; + (getSize (TTYPE (root->left->left)) * 4)) + return root; if (AST_LIT_VALUE (root->right->right) != - (getSize (TTYPE (root->left->left)) * 4)) - return root; + (getSize (TTYPE (root->left->left)) * 4)) + return root; /* make sure the port supports SWAP */ if (port->hasExtBitOp @@ -5087,27 +5088,27 @@ optimizeCompare (ast * root) if (isAstEqual (root->left, root->right)) { switch (root->opval.op) - { - case '>': - case '<': - case NE_OP: - optExpr = newAst_VALUE (constVal ("0")); - break; - case GE_OP: - case LE_OP: - case EQ_OP: - optExpr = newAst_VALUE (constVal ("1")); - break; - } + { + case '>': + case '<': + case NE_OP: + optExpr = newAst_VALUE (constVal ("0")); + break; + case GE_OP: + case LE_OP: + case EQ_OP: + optExpr = newAst_VALUE (constVal ("1")); + break; + } return decorateType (optExpr, RESULT_CHECK); } vleft = (root->left->type == EX_VALUE ? - root->left->opval.val : NULL); + root->left->opval.val : NULL); vright = (root->right->type == EX_VALUE ? - root->right->opval.val : NULL); + root->right->opval.val : NULL); /* if left is a BITVAR in BITSPACE */ /* and right is a LITERAL then opt- */ @@ -5120,62 +5121,62 @@ optimizeCompare (ast * root) /* if right side > 1 then comparison may never succeed */ if ((litValue = (int) floatFromVal (vright)) > 1) - { - werror (W_BAD_COMPARE); - goto noOptimize; - } + { + werror (W_BAD_COMPARE); + goto noOptimize; + } if (litValue) - { - switch (root->opval.op) - { - case '>': /* bit value greater than 1 cannot be */ - werror (W_BAD_COMPARE); - goto noOptimize; - break; - - case '<': /* bit value < 1 means 0 */ - case NE_OP: - optExpr = newNode ('!', newAst_VALUE (vleft), NULL); - break; - - case LE_OP: /* bit value <= 1 means no check */ - optExpr = newAst_VALUE (vright); - break; - - case GE_OP: /* bit value >= 1 means only check for = */ - case EQ_OP: - optExpr = newAst_VALUE (vleft); - break; - } - } + { + switch (root->opval.op) + { + case '>': /* bit value greater than 1 cannot be */ + werror (W_BAD_COMPARE); + goto noOptimize; + break; + + case '<': /* bit value < 1 means 0 */ + case NE_OP: + optExpr = newNode ('!', newAst_VALUE (vleft), NULL); + break; + + case LE_OP: /* bit value <= 1 means no check */ + optExpr = newAst_VALUE (vright); + break; + + case GE_OP: /* bit value >= 1 means only check for = */ + case EQ_OP: + optExpr = newAst_VALUE (vleft); + break; + } + } else - { /* literal is zero */ - switch (root->opval.op) - { - case '<': /* bit value < 0 cannot be */ - werror (W_BAD_COMPARE); - goto noOptimize; - break; - - case '>': /* bit value > 0 means 1 */ - case NE_OP: - optExpr = newAst_VALUE (vleft); - break; - - case LE_OP: /* bit value <= 0 means no check */ - case GE_OP: /* bit value >= 0 means no check */ - werror (W_BAD_COMPARE); - goto noOptimize; - break; - - case EQ_OP: /* bit == 0 means ! of bit */ - optExpr = newNode ('!', newAst_VALUE (vleft), NULL); - break; - } - } + { /* literal is zero */ + switch (root->opval.op) + { + case '<': /* bit value < 0 cannot be */ + werror (W_BAD_COMPARE); + goto noOptimize; + break; + + case '>': /* bit value > 0 means 1 */ + case NE_OP: + optExpr = newAst_VALUE (vleft); + break; + + case LE_OP: /* bit value <= 0 means no check */ + case GE_OP: /* bit value >= 0 means no check */ + werror (W_BAD_COMPARE); + goto noOptimize; + break; + + case EQ_OP: /* bit == 0 means ! of bit */ + optExpr = newNode ('!', newAst_VALUE (vleft), NULL); + break; + } + } return decorateType (resolveSymbols (optExpr), RESULT_CHECK); - } /* end-of-if of BITVAR */ + } /* end-of-if of BITVAR */ noOptimize: return root; @@ -5215,7 +5216,7 @@ processRegParms (value * args, ast * body) while (args) { if (IS_REGPARM (args->etype)) - addSymToBlock (args->sym, body); + addSymToBlock (args->sym, body); args = args->next; } } @@ -5271,9 +5272,9 @@ createFunction (symbol * name, ast * body) actually means we are now compiling the compiler support routine */ if (name->cdef) - { - addSet (&publics, name); - } + { + addSet (&publics, name); + } } else { @@ -5293,12 +5294,12 @@ createFunction (symbol * name, ast * body) xstackPtr = -port->stack.direction * port->stack.call_overhead; - fetype = getSpec (name->type); /* get the specifier for the function */ + fetype = getSpec (name->type); /* get the specifier for the function */ /* if this is a reentrant function then */ if (IFFUNC_ISREENT (name->type)) reentrant++; - allocParms (FUNC_ARGS(name->type)); /* allocate the parameters */ + allocParms (FUNC_ARGS(name->type)); /* allocate the parameters */ /* do processing for parameters that are passed in registers */ processRegParms (FUNC_ARGS(name->type), body); @@ -5319,11 +5320,11 @@ createFunction (symbol * name, ast * body) /* name needs to be mangled */ SNPRINTF (name->rname, sizeof(name->rname), "%s%s", port->fun_prefix, name->name); - body = resolveSymbols (body); /* resolve the symbols */ - body = decorateType (body, RESULT_TYPE_NONE); /* propagateType & do semantic checks */ - + body = resolveSymbols (body); /* resolve the symbols */ + body = decorateType (body, RESULT_TYPE_NONE); /* 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; @@ -5396,697 +5397,697 @@ skipall: void ast_print (ast * tree, FILE *outfile, int indent) { - if (!tree) return ; - - /* can print only decorated trees */ - if (!tree->decorated) return; - - /* if any child is an error | this one is an error do nothing */ - if (tree->isError || - (tree->left && tree->left->isError) || - (tree->right && tree->right->isError)) { - fprintf(outfile,"ERROR_NODE(%p)\n",tree); - } - - - /* print the line */ - /* if not block & function */ - if (tree->type == EX_OP && - (tree->opval.op != FUNCTION && - tree->opval.op != BLOCK && - tree->opval.op != NULLOP)) { - } - - if (tree->opval.op == FUNCTION) { - 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->left->opval.val->type->next,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); - ast_print(tree->right,outfile,indent); - return ; - } - if (tree->opval.op == BLOCK) { - symbol *decls = tree->values.sym; - INDENT(indent,outfile); - fprintf(outfile,"{\n"); - while (decls) { - INDENT(indent+2,outfile); - 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+2); - INDENT(indent,outfile); - fprintf(outfile,"}\n"); - return; - } - if (tree->opval.op == NULLOP) { - ast_print(tree->left,outfile,indent); - ast_print(tree->right,outfile,indent); - return ; - } - INDENT(indent,outfile); - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* leaf has been reached */ - /*----------------------------*/ - /* if this is of type value */ - /* just get the type */ - if (tree->type == EX_VALUE) { - - if (IS_LITERAL (tree->opval.val->etype)) { - fprintf(outfile,"CONSTANT (%p) value = ", tree); - if (SPEC_USIGN (tree->opval.val->etype)) - fprintf(outfile,"%u", (TYPE_UDWORD) floatFromVal(tree->opval.val)); - else - fprintf(outfile,"%d", (TYPE_DWORD) floatFromVal(tree->opval.val)); - fprintf(outfile,", 0x%x, %f", (TYPE_UDWORD) floatFromVal(tree->opval.val), - floatFromVal(tree->opval.val)); - } else if (tree->opval.val->sym) { - /* if the undefined flag is set then give error message */ - if (tree->opval.val->sym->undefined) { - fprintf(outfile,"UNDEFINED SYMBOL "); - } else { - fprintf(outfile,"SYMBOL "); - } - fprintf(outfile,"(%s=%p)", - tree->opval.val->sym->name,tree); - } - if (tree->ftype) { - fprintf(outfile," type ("); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - } else { - fprintf(outfile,"\n"); - } - return ; - } - - /* if type link for the case of cast */ - if (tree->type == EX_LINK) { - fprintf(outfile,"TYPENODE (%p) type = (",tree); - printTypeChain(tree->opval.lnk,outfile); - fprintf(outfile,")\n"); - return ; - } - - - /* depending on type of operator do */ - - switch (tree->opval.op) { - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* array node */ - /*----------------------------*/ - case '[': - fprintf(outfile,"ARRAY_OP (%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; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* struct/union */ - /*----------------------------*/ - case '.': - fprintf(outfile,"STRUCT_ACCESS (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* struct/union pointer */ - /*----------------------------*/ - case PTR_OP: - fprintf(outfile,"PTR_ACCESS (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* ++/-- operation */ - /*----------------------------*/ - case INC_OP: - if (tree->left) - fprintf(outfile,"post-"); - else - fprintf(outfile,"pre-"); - fprintf(outfile,"INC_OP (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); /* postincrement case */ - ast_print(tree->right,outfile,indent+2); /* preincrement case */ - return ; - - case DEC_OP: - if (tree->left) - fprintf(outfile,"post-"); - else - fprintf(outfile,"pre-"); - fprintf(outfile,"DEC_OP (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); /* postdecrement case */ - ast_print(tree->right,outfile,indent+2); /* predecrement case */ - return ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* bitwise and */ - /*----------------------------*/ - case '&': - if (tree->right) { - fprintf(outfile,"& (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - ast_print(tree->right,outfile,indent+2); - } else { - fprintf(outfile,"ADDRESS_OF (%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 ; - /*----------------------------*/ - /* bitwise or */ - /*----------------------------*/ - case '|': - fprintf(outfile,"OR (%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 ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* bitwise xor */ - /*----------------------------*/ - case '^': - fprintf(outfile,"XOR (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* division */ - /*----------------------------*/ - case '/': - fprintf(outfile,"DIV (%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 ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* modulus */ - /*----------------------------*/ - case '%': - fprintf(outfile,"MOD (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* address dereference */ - /*----------------------------*/ - case '*': /* can be unary : if right is null then unary operation */ - if (!tree->right) { - fprintf(outfile,"DEREF (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - } - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* multiplication */ - /*----------------------------*/ - fprintf(outfile,"MULT (%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 ; - - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* unary '+' operator */ - /*----------------------------*/ - case '+': - /* if unary plus */ - if (!tree->right) { - fprintf(outfile,"UPLUS (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - } else { - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* addition */ - /*----------------------------*/ - fprintf(outfile,"ADD (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* unary '-' */ - /*----------------------------*/ - case '-': /* can be unary */ - if (!tree->right) { - fprintf(outfile,"UMINUS (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - } else { - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* subtraction */ - /*----------------------------*/ - fprintf(outfile,"SUB (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* compliment */ - /*----------------------------*/ - case '~': - fprintf(outfile,"COMPL (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* not */ - /*----------------------------*/ - case '!': - fprintf(outfile,"NOT (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* shift */ - /*----------------------------*/ - case RRC: - fprintf(outfile,"RRC (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - - case RLC: - fprintf(outfile,"RLC (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - case SWAP: - fprintf(outfile,"SWAP (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - case GETHBIT: - fprintf(outfile,"GETHBIT (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - return ; - case LEFT_OP: - fprintf(outfile,"LEFT_SHIFT (%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 RIGHT_OP: - fprintf(outfile,"RIGHT_SHIFT (%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 ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* casting */ - /*----------------------------*/ - case CAST: /* change the type */ - 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+2); - return ; - - case AND_OP: - fprintf(outfile,"ANDAND (%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 OR_OP: - fprintf(outfile,"OROR (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* comparison operators */ - /*----------------------------*/ - case '>': - fprintf(outfile,"GT(>) (%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 '<': - fprintf(outfile,"LT(<) (%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 LE_OP: - fprintf(outfile,"LE(<=) (%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 GE_OP: - fprintf(outfile,"GE(>=) (%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 EQ_OP: - fprintf(outfile,"EQ(==) (%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 NE_OP: - fprintf(outfile,"NE(!=) (%p) type (",tree); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - ast_print(tree->right,outfile,indent+2); - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* sizeof */ - /*----------------------------*/ - case SIZEOF: /* evaluate wihout code generation */ - fprintf(outfile,"SIZEOF %d\n",(getSize (tree->right->ftype))); - return ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* conditional operator '?' */ - /*----------------------------*/ - case '?': - fprintf(outfile,"QUEST(?) (%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 ':': - fprintf(outfile,"COLON(:) (%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 ; - - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* assignment operators */ - /*----------------------------*/ - case MUL_ASSIGN: - fprintf(outfile,"MULASS(*=) (%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 DIV_ASSIGN: - fprintf(outfile,"DIVASS(/=) (%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 AND_ASSIGN: - fprintf(outfile,"ANDASS(&=) (%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 OR_ASSIGN: - 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); - printTypeChain(tree->ftype,outfile); - fprintf(outfile,")\n"); - ast_print(tree->left,outfile,indent+2); - ast_print(tree->right,outfile,indent+2); - return; - case RIGHT_ASSIGN: - fprintf(outfile,"RSHFTASS(>>=) (%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 LEFT_ASSIGN: - fprintf(outfile,"LSHFTASS(<<=) (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* -= operator */ - /*----------------------------*/ - case SUB_ASSIGN: - fprintf(outfile,"SUBASS(-=) (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* += operator */ - /*----------------------------*/ - case ADD_ASSIGN: - fprintf(outfile,"ADDASS(+=) (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* straight assignemnt */ - /*----------------------------*/ - case '=': - fprintf(outfile,"ASSIGN(=) (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* comma operator */ - /*----------------------------*/ - case ',': - fprintf(outfile,"COMMA(,) (%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; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* function call */ - /*----------------------------*/ - case CALL: - case PCALL: - fprintf(outfile,"CALL (%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 PARAM: - fprintf(outfile,"PARMS\n"); - ast_print(tree->left,outfile,indent+2); - if (tree->right /*&& !IS_AST_PARAM(tree->right)*/) { - ast_print(tree->right,outfile,indent+2); - } - return ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* return statement */ - /*----------------------------*/ - case RETURN: - fprintf(outfile,"RETURN (%p) type (",tree); - if (tree->right) { - printTypeChain(tree->right->ftype,outfile); - } - fprintf(outfile,")\n"); - ast_print(tree->right,outfile,indent+2); - return ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* label statement */ - /*----------------------------*/ - case LABEL : - fprintf(outfile,"LABEL (%p)\n",tree); - ast_print(tree->left,outfile,indent+2); - ast_print(tree->right,outfile,indent); - return; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* switch statement */ - /*----------------------------*/ - case SWITCH: - { - value *val; - fprintf(outfile,"SWITCH (%p) ",tree); - ast_print(tree->left,outfile,0); - for (val = tree->values.switchVals.swVals; val ; val = val->next) { - INDENT(indent+2,outfile); - fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n", - (int) floatFromVal(val), - tree->values.switchVals.swNum, - (int) floatFromVal(val)); - } - ast_print(tree->right,outfile,indent); - } - return ; - /*------------------------------------------------------------------*/ - /*----------------------------*/ - /* ifx Statement */ - /*----------------------------*/ - case IFX: - fprintf(outfile,"IF (%p) \n",tree); - ast_print(tree->left,outfile,indent+2); - if (tree->trueLabel) { - INDENT(indent+2,outfile); - fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name); - } - if (tree->falseLabel) { - 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 */ - /*----------------------------*/ - case FOR: - fprintf(outfile,"FOR (%p) \n",tree); - if (AST_FOR( tree, initExpr)) { - INDENT(indent+2,outfile); - fprintf(outfile,"INIT EXPR "); - ast_print(AST_FOR(tree, initExpr),outfile,indent+2); - } - if (AST_FOR( tree, condExpr)) { - INDENT(indent+2,outfile); - fprintf(outfile,"COND EXPR "); - ast_print(AST_FOR(tree, condExpr),outfile,indent+2); - } - if (AST_FOR( tree, loopExpr)) { - INDENT(indent+2,outfile); - fprintf(outfile,"LOOP EXPR "); - ast_print(AST_FOR(tree, loopExpr),outfile,indent+2); - } - fprintf(outfile,"FOR LOOP BODY \n"); - ast_print(tree->left,outfile,indent+2); - return ; - case CRITICAL: - fprintf(outfile,"CRITICAL (%p) \n",tree); - ast_print(tree->left,outfile,indent+2); - default: - return ; - } + if (!tree) return ; + + /* can print only decorated trees */ + if (!tree->decorated) return; + + /* if any child is an error | this one is an error do nothing */ + if (tree->isError || + (tree->left && tree->left->isError) || + (tree->right && tree->right->isError)) { + fprintf(outfile,"ERROR_NODE(%p)\n",tree); + } + + + /* print the line */ + /* if not block & function */ + if (tree->type == EX_OP && + (tree->opval.op != FUNCTION && + tree->opval.op != BLOCK && + tree->opval.op != NULLOP)) { + } + + if (tree->opval.op == FUNCTION) { + 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->left->opval.val->type->next,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); + ast_print(tree->right,outfile,indent); + return ; + } + if (tree->opval.op == BLOCK) { + symbol *decls = tree->values.sym; + INDENT(indent,outfile); + fprintf(outfile,"{\n"); + while (decls) { + INDENT(indent+2,outfile); + 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+2); + INDENT(indent,outfile); + fprintf(outfile,"}\n"); + return; + } + if (tree->opval.op == NULLOP) { + ast_print(tree->left,outfile,indent); + ast_print(tree->right,outfile,indent); + return ; + } + INDENT(indent,outfile); + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* leaf has been reached */ + /*----------------------------*/ + /* if this is of type value */ + /* just get the type */ + if (tree->type == EX_VALUE) { + + if (IS_LITERAL (tree->opval.val->etype)) { + fprintf(outfile,"CONSTANT (%p) value = ", tree); + if (SPEC_USIGN (tree->opval.val->etype)) + fprintf(outfile,"%u", (TYPE_UDWORD) floatFromVal(tree->opval.val)); + else + fprintf(outfile,"%d", (TYPE_DWORD) floatFromVal(tree->opval.val)); + fprintf(outfile,", 0x%x, %f", (TYPE_UDWORD) floatFromVal(tree->opval.val), + floatFromVal(tree->opval.val)); + } else if (tree->opval.val->sym) { + /* if the undefined flag is set then give error message */ + if (tree->opval.val->sym->undefined) { + fprintf(outfile,"UNDEFINED SYMBOL "); + } else { + fprintf(outfile,"SYMBOL "); + } + fprintf(outfile,"(%s=%p)", + tree->opval.val->sym->name,tree); + } + if (tree->ftype) { + fprintf(outfile," type ("); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + } else { + fprintf(outfile,"\n"); + } + return ; + } + + /* if type link for the case of cast */ + if (tree->type == EX_LINK) { + fprintf(outfile,"TYPENODE (%p) type = (",tree); + printTypeChain(tree->opval.lnk,outfile); + fprintf(outfile,")\n"); + return ; + } + + + /* depending on type of operator do */ + + switch (tree->opval.op) { + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* array node */ + /*----------------------------*/ + case '[': + fprintf(outfile,"ARRAY_OP (%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; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* struct/union */ + /*----------------------------*/ + case '.': + fprintf(outfile,"STRUCT_ACCESS (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* struct/union pointer */ + /*----------------------------*/ + case PTR_OP: + fprintf(outfile,"PTR_ACCESS (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* ++/-- operation */ + /*----------------------------*/ + case INC_OP: + if (tree->left) + fprintf(outfile,"post-"); + else + fprintf(outfile,"pre-"); + fprintf(outfile,"INC_OP (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); /* postincrement case */ + ast_print(tree->right,outfile,indent+2); /* preincrement case */ + return ; + + case DEC_OP: + if (tree->left) + fprintf(outfile,"post-"); + else + fprintf(outfile,"pre-"); + fprintf(outfile,"DEC_OP (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); /* postdecrement case */ + ast_print(tree->right,outfile,indent+2); /* predecrement case */ + return ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* bitwise and */ + /*----------------------------*/ + case '&': + if (tree->right) { + fprintf(outfile,"& (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + ast_print(tree->right,outfile,indent+2); + } else { + fprintf(outfile,"ADDRESS_OF (%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 ; + /*----------------------------*/ + /* bitwise or */ + /*----------------------------*/ + case '|': + fprintf(outfile,"OR (%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 ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* bitwise xor */ + /*----------------------------*/ + case '^': + fprintf(outfile,"XOR (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* division */ + /*----------------------------*/ + case '/': + fprintf(outfile,"DIV (%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 ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* modulus */ + /*----------------------------*/ + case '%': + fprintf(outfile,"MOD (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* address dereference */ + /*----------------------------*/ + case '*': /* can be unary : if right is null then unary operation */ + if (!tree->right) { + fprintf(outfile,"DEREF (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + } + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* multiplication */ + /*----------------------------*/ + fprintf(outfile,"MULT (%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 ; + + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* unary '+' operator */ + /*----------------------------*/ + case '+': + /* if unary plus */ + if (!tree->right) { + fprintf(outfile,"UPLUS (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + } else { + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* addition */ + /*----------------------------*/ + fprintf(outfile,"ADD (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* unary '-' */ + /*----------------------------*/ + case '-': /* can be unary */ + if (!tree->right) { + fprintf(outfile,"UMINUS (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + } else { + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* subtraction */ + /*----------------------------*/ + fprintf(outfile,"SUB (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* compliment */ + /*----------------------------*/ + case '~': + fprintf(outfile,"COMPL (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* not */ + /*----------------------------*/ + case '!': + fprintf(outfile,"NOT (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* shift */ + /*----------------------------*/ + case RRC: + fprintf(outfile,"RRC (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + + case RLC: + fprintf(outfile,"RLC (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + case SWAP: + fprintf(outfile,"SWAP (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + case GETHBIT: + fprintf(outfile,"GETHBIT (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + return ; + case LEFT_OP: + fprintf(outfile,"LEFT_SHIFT (%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 RIGHT_OP: + fprintf(outfile,"RIGHT_SHIFT (%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 ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* casting */ + /*----------------------------*/ + case CAST: /* change the type */ + 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+2); + return ; + + case AND_OP: + fprintf(outfile,"ANDAND (%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 OR_OP: + fprintf(outfile,"OROR (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* comparison operators */ + /*----------------------------*/ + case '>': + fprintf(outfile,"GT(>) (%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 '<': + fprintf(outfile,"LT(<) (%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 LE_OP: + fprintf(outfile,"LE(<=) (%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 GE_OP: + fprintf(outfile,"GE(>=) (%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 EQ_OP: + fprintf(outfile,"EQ(==) (%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 NE_OP: + fprintf(outfile,"NE(!=) (%p) type (",tree); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + ast_print(tree->right,outfile,indent+2); + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* sizeof */ + /*----------------------------*/ + case SIZEOF: /* evaluate wihout code generation */ + fprintf(outfile,"SIZEOF %d\n",(getSize (tree->right->ftype))); + return ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* conditional operator '?' */ + /*----------------------------*/ + case '?': + fprintf(outfile,"QUEST(?) (%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 ':': + fprintf(outfile,"COLON(:) (%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 ; + + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* assignment operators */ + /*----------------------------*/ + case MUL_ASSIGN: + fprintf(outfile,"MULASS(*=) (%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 DIV_ASSIGN: + fprintf(outfile,"DIVASS(/=) (%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 AND_ASSIGN: + fprintf(outfile,"ANDASS(&=) (%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 OR_ASSIGN: + 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); + printTypeChain(tree->ftype,outfile); + fprintf(outfile,")\n"); + ast_print(tree->left,outfile,indent+2); + ast_print(tree->right,outfile,indent+2); + return; + case RIGHT_ASSIGN: + fprintf(outfile,"RSHFTASS(>>=) (%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 LEFT_ASSIGN: + fprintf(outfile,"LSHFTASS(<<=) (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* -= operator */ + /*----------------------------*/ + case SUB_ASSIGN: + fprintf(outfile,"SUBASS(-=) (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* += operator */ + /*----------------------------*/ + case ADD_ASSIGN: + fprintf(outfile,"ADDASS(+=) (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* straight assignemnt */ + /*----------------------------*/ + case '=': + fprintf(outfile,"ASSIGN(=) (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* comma operator */ + /*----------------------------*/ + case ',': + fprintf(outfile,"COMMA(,) (%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; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* function call */ + /*----------------------------*/ + case CALL: + case PCALL: + fprintf(outfile,"CALL (%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 PARAM: + fprintf(outfile,"PARMS\n"); + ast_print(tree->left,outfile,indent+2); + if (tree->right /*&& !IS_AST_PARAM(tree->right)*/) { + ast_print(tree->right,outfile,indent+2); + } + return ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* return statement */ + /*----------------------------*/ + case RETURN: + fprintf(outfile,"RETURN (%p) type (",tree); + if (tree->right) { + printTypeChain(tree->right->ftype,outfile); + } + fprintf(outfile,")\n"); + ast_print(tree->right,outfile,indent+2); + return ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* label statement */ + /*----------------------------*/ + case LABEL : + fprintf(outfile,"LABEL (%p)\n",tree); + ast_print(tree->left,outfile,indent+2); + ast_print(tree->right,outfile,indent); + return; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* switch statement */ + /*----------------------------*/ + case SWITCH: + { + value *val; + fprintf(outfile,"SWITCH (%p) ",tree); + ast_print(tree->left,outfile,0); + for (val = tree->values.switchVals.swVals; val ; val = val->next) { + INDENT(indent+2,outfile); + fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n", + (int) floatFromVal(val), + tree->values.switchVals.swNum, + (int) floatFromVal(val)); + } + ast_print(tree->right,outfile,indent); + } + return ; + /*------------------------------------------------------------------*/ + /*----------------------------*/ + /* ifx Statement */ + /*----------------------------*/ + case IFX: + fprintf(outfile,"IF (%p) \n",tree); + ast_print(tree->left,outfile,indent+2); + if (tree->trueLabel) { + INDENT(indent+2,outfile); + fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name); + } + if (tree->falseLabel) { + 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 */ + /*----------------------------*/ + case FOR: + fprintf(outfile,"FOR (%p) \n",tree); + if (AST_FOR( tree, initExpr)) { + INDENT(indent+2,outfile); + fprintf(outfile,"INIT EXPR "); + ast_print(AST_FOR(tree, initExpr),outfile,indent+2); + } + if (AST_FOR( tree, condExpr)) { + INDENT(indent+2,outfile); + fprintf(outfile,"COND EXPR "); + ast_print(AST_FOR(tree, condExpr),outfile,indent+2); + } + if (AST_FOR( tree, loopExpr)) { + INDENT(indent+2,outfile); + fprintf(outfile,"LOOP EXPR "); + ast_print(AST_FOR(tree, loopExpr),outfile,indent+2); + } + fprintf(outfile,"FOR LOOP BODY \n"); + ast_print(tree->left,outfile,indent+2); + return ; + case CRITICAL: + fprintf(outfile,"CRITICAL (%p) \n",tree); + ast_print(tree->left,outfile,indent+2); + default: + return ; + } } void PA(ast *t) { - ast_print(t,stdout,0); + ast_print(t,stdout,0); } diff --git a/src/SDCCglue.c b/src/SDCCglue.c index 9b3b509f..d76ca14f 100644 --- a/src/SDCCglue.c +++ b/src/SDCCglue.c @@ -38,16 +38,16 @@ symbol *interrupts[INTNO_MAX+1]; void printIval (symbol *, sym_link *, initList *, FILE *); -set *publics = NULL; /* public variables */ -set *externs = NULL; /* Varibles that are declared as extern */ +set *publics = NULL; /* public variables */ +set *externs = NULL; /* Varibles that are declared as extern */ /* TODO: this should be configurable (DS803C90 uses more than 6) */ unsigned maxInterrupts = 6; int allocInfo = 1; symbol *mainf; set *pipeSet = NULL; /* set of pipes */ -set *tmpfileSet = NULL; /* set of tmp file created by the compiler */ -set *tmpfileNameSet = NULL; /* All are unlinked at close. */ +set *tmpfileSet = NULL; /* set of tmp file created by the compiler */ +set *tmpfileNameSet = NULL; /* All are unlinked at close. */ /*-----------------------------------------------------------------*/ /* closePipes - closes all pipes created by the compiler */ @@ -136,52 +136,52 @@ copyFile (FILE * dest, FILE * src) char * aopLiteralLong (value * val, int offset, int size) { - union { - float f; - unsigned char c[4]; - } - fl; - - if (!val) { - // assuming we have been warned before - val=constVal("0"); - } - - /* if it is a float then it gets tricky */ - /* otherwise it is fairly simple */ - if (!IS_FLOAT (val->type)) { - unsigned long v = (unsigned long) floatFromVal (val); - - v >>= (offset * 8); - switch (size) { - case 1: - tsprintf (buffer, sizeof(buffer), - "!immedbyte", (unsigned int) v & 0xff); - break; - case 2: - tsprintf (buffer, sizeof(buffer), - "!immedword", (unsigned int) v & 0xffff); - break; - default: - /* Hmm. Too big for now. */ - assert (0); - } - return Safe_strdup (buffer); - } - - /* PENDING: For now size must be 1 */ - assert (size == 1); - - /* it is type float */ - fl.f = (float) floatFromVal (val); + union { + float f; + unsigned char c[4]; + } + fl; + + if (!val) { + // assuming we have been warned before + val=constVal("0"); + } + + /* if it is a float then it gets tricky */ + /* otherwise it is fairly simple */ + if (!IS_FLOAT (val->type)) { + unsigned long v = (unsigned long) floatFromVal (val); + + v >>= (offset * 8); + switch (size) { + case 1: + tsprintf (buffer, sizeof(buffer), + "!immedbyte", (unsigned int) v & 0xff); + break; + case 2: + tsprintf (buffer, sizeof(buffer), + "!immedword", (unsigned int) v & 0xffff); + break; + default: + /* Hmm. Too big for now. */ + assert (0); + } + return Safe_strdup (buffer); + } + + /* PENDING: For now size must be 1 */ + assert (size == 1); + + /* it is type float */ + fl.f = (float) floatFromVal (val); #ifdef WORDS_BIGENDIAN - tsprintf (buffer, sizeof(buffer), - "!immedbyte", fl.c[3 - offset]); + tsprintf (buffer, sizeof(buffer), + "!immedbyte", fl.c[3 - offset]); #else - tsprintf (buffer, sizeof(buffer), - "!immedbyte", fl.c[offset]); + tsprintf (buffer, sizeof(buffer), + "!immedbyte", fl.c[offset]); #endif - return Safe_strdup (buffer); + return Safe_strdup (buffer); } /*-----------------------------------------------------------------*/ @@ -190,7 +190,7 @@ aopLiteralLong (value * val, int offset, int size) char * aopLiteral (value * val, int offset) { - return aopLiteralLong (val, offset, 1); + return aopLiteralLong (val, offset, 1); } /*-----------------------------------------------------------------*/ @@ -209,13 +209,13 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) { /* PENDING: special case here - should remove */ if (!strcmp (map->sname, CODE_NAME)) - tfprintf (map->oFile, "\t!areacode\n", map->sname); + tfprintf (map->oFile, "\t!areacode\n", map->sname); else if (!strcmp (map->sname, DATA_NAME)) - tfprintf (map->oFile, "\t!areadata\n", map->sname); + tfprintf (map->oFile, "\t!areadata\n", map->sname); else if (!strcmp (map->sname, HOME_NAME)) - tfprintf (map->oFile, "\t!areahome\n", map->sname); + tfprintf (map->oFile, "\t!areahome\n", map->sname); else - tfprintf (map->oFile, "\t!area\n", map->sname); + tfprintf (map->oFile, "\t!area\n", map->sname); } for (sym = setFirstItem (map->syms); sym; @@ -225,144 +225,157 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) /* if extern then add it into the extern list */ if (IS_EXTERN (sym->etype)) - { + { addSetHead (&externs, sym); - continue; - } + continue; + } /* if allocation required check is needed then check if the symbol really requires allocation only for local variables */ if (arFlag && !IS_AGGREGATE (sym->type) && - !(sym->_isparm && !IS_REGPARM (sym->etype)) && - !sym->allocreq && sym->level) - continue; + !(sym->_isparm && !IS_REGPARM (sym->etype)) && + !sym->allocreq && sym->level) + continue; /* for bitvar locals and parameters */ if (!arFlag && !sym->allocreq && sym->level - && !SPEC_ABSA (sym->etype)) { - continue; + && !SPEC_ABSA (sym->etype)) { + continue; } /* if global variable & not static or extern and addPublics allowed then add it to the public set */ if ((sym->level == 0 || - (sym->_isparm && !IS_REGPARM (sym->etype))) && - addPublics && - !IS_STATIC (sym->etype) && + (sym->_isparm && !IS_REGPARM (sym->etype))) && + addPublics && + !IS_STATIC (sym->etype) && (IS_FUNC(sym->type) ? (sym->used || IFFUNC_HASBODY(sym->type)) : 1)) - { - addSetHead (&publics, sym); - } + { + addSetHead (&publics, sym); + } /* if extern then do nothing or is a function then do nothing */ if (IS_FUNC (sym->type) && !(sym->isitmp)) - continue; + continue; /* print extra debug info if required */ if (options.debug) - { - if (!sym->level) /* global */ - { - if (IS_STATIC (sym->etype)) - fprintf (map->oFile, "F%s$", moduleName); /* scope is file */ - else - fprintf (map->oFile, "G$"); /* scope is global */ - } - else - { - /* symbol is local */ - fprintf (map->oFile, "L%s$", (sym->localof ? sym->localof->name : "-null-")); - } - fprintf (map->oFile, "%s$%d$%d", sym->name, sym->level, sym->block); - } + { + if (!sym->level) /* global */ + { + if (IS_STATIC (sym->etype)) + fprintf (map->oFile, "F%s$", moduleName); /* scope is file */ + else + fprintf (map->oFile, "G$"); /* scope is global */ + } + else + { + /* symbol is local */ + fprintf (map->oFile, "L%s$", (sym->localof ? sym->localof->name : "-null-")); + } + fprintf (map->oFile, "%s$%d$%d", sym->name, sym->level, sym->block); + } /* if it has an initial value then do it only if it is a global variable */ if (sym->ival && sym->level == 0) { - if (SPEC_OCLS(sym->etype)==xidata) { - /* create a new "XINIT (CODE)" symbol, that will be emitted later - in the static seg */ - newSym=copySymbol (sym); - SPEC_OCLS(newSym->etype)=xinit; - SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name); - SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname); - if (IS_SPEC (newSym->type)) + if (SPEC_OCLS(sym->etype)==xidata) { + /* create a new "XINIT (CODE)" symbol, that will be emitted later + in the static seg */ + newSym=copySymbol (sym); + SPEC_OCLS(newSym->etype)=xinit; + SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name); + SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname); + if (IS_SPEC (newSym->type)) SPEC_CONST (newSym->type) = 1; else DCL_PTR_CONST (newSym->type) = 1; - SPEC_STAT(newSym->etype)=1; - resolveIvalSym(newSym->ival, newSym->type); - - // add it to the "XINIT (CODE)" segment - addSet(&xinit->syms, newSym); - sym->ival=NULL; - } else { - if (IS_AGGREGATE (sym->type)) { - ival = initAggregates (sym, sym->ival, NULL); - } else { - if (getNelements(sym->type, sym->ival)>1) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", - sym->name); - } - ival = newNode ('=', newAst_VALUE (symbolVal (sym)), - decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK)); - } - codeOutFile = statsg->oFile; - - if (ival) { - // set ival's lineno to where the symbol was defined - setAstLineno (ival, lineno=sym->lineDef); - // check if this is not a constant expression - if (!constExprTree(ival)) { - werror (E_CONST_EXPECTED, "found expression"); - // but try to do it anyway - } - allocInfo = 0; + SPEC_STAT(newSym->etype)=1; + resolveIvalSym(newSym->ival, newSym->type); + + // add it to the "XINIT (CODE)" segment + addSet(&xinit->syms, newSym); + + if (!SPEC_ABSA (sym->etype)) + { + FILE *tmpFile = tempfile (); + addSetHead (&tmpfileSet, tmpFile); + // before allocation we must parse the sym->ival tree + // but without actually generating initialization code + noAlloc++; + resolveIvalSym (sym->ival, sym->type); + printIval (sym, sym->type, sym->ival, tmpFile); + noAlloc--; + } + + sym->ival=NULL; + } else { + if (IS_AGGREGATE (sym->type)) { + ival = initAggregates (sym, sym->ival, NULL); + } else { + if (getNelements(sym->type, sym->ival)>1) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", + sym->name); + } + ival = newNode ('=', newAst_VALUE (symbolVal (sym)), + decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK)); + } + codeOutFile = statsg->oFile; + + if (ival) { + // set ival's lineno to where the symbol was defined + setAstLineno (ival, lineno=sym->lineDef); + // check if this is not a constant expression + if (!constExprTree(ival)) { + werror (E_CONST_EXPECTED, "found expression"); + // but try to do it anyway + } + allocInfo = 0; if (!astErrors(ival)) - eBBlockFromiCode (iCodeFromAst (ival)); - allocInfo = 1; - } - } - sym->ival = NULL; + eBBlockFromiCode (iCodeFromAst (ival)); + allocInfo = 1; + } + } + sym->ival = NULL; } - /* if is has an absolute address then generate + /* if it has an absolute address then generate an equate for this no need to allocate space */ if (SPEC_ABSA (sym->etype)) - { - char *equ="="; - if (options.debug) { - fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - } - if (TARGET_IS_XA51) { - if (map==sfr) { - equ="sfr"; - } else if (map==bit || map==sfrbit) { - equ="bit"; - } - } - fprintf (map->oFile, "%s\t%s\t0x%04x\n", - sym->rname, equ, - SPEC_ADDR (sym->etype)); - } + { + char *equ="="; + if (options.debug) { + fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + } + if (TARGET_IS_XA51) { + if (map==sfr) { + equ="sfr"; + } else if (map==bit || map==sfrbit) { + equ="bit"; + } + } + fprintf (map->oFile, "%s\t%s\t0x%04x\n", + sym->rname, equ, + SPEC_ADDR (sym->etype)); + } else { - int size = getSize (sym->type); - if (size==0) { - werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE, sym->name); - } - /* allocate space */ - if (options.debug) { - fprintf (map->oFile, "==.\n"); - } - if (IS_STATIC (sym->etype)) - tfprintf (map->oFile, "!slabeldef\n", sym->rname); - else - tfprintf (map->oFile, "!labeldef\n", sym->rname); - tfprintf (map->oFile, "\t!ds\n", - (unsigned int) size & 0xffff); + int size = getAllocSize (sym->type); + if (size==0) { + werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE, sym->name); + } + /* allocate space */ + if (options.debug) { + fprintf (map->oFile, "==.\n"); + } + if (IS_STATIC (sym->etype)) + tfprintf (map->oFile, "!slabeldef\n", sym->rname); + else + tfprintf (map->oFile, "!labeldef\n", sym->rname); + tfprintf (map->oFile, "\t!ds\n", + (unsigned int) size & 0xffff); } } } @@ -373,130 +386,136 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) value * initPointer (initList * ilist, sym_link *toType) { - value *val; - ast *expr = list2expr (ilist); - - if (!expr) - goto wrong; - - /* try it the oldway first */ - if ((val = constExprValue (expr, FALSE))) - return val; - - /* ( ptr + constant ) */ - if (IS_AST_OP (expr) && - (expr->opval.op == '+' || expr->opval.op == '-') && - IS_AST_SYM_VALUE (expr->left) && - (IS_ARRAY(expr->left->ftype) || IS_PTR(expr->left->ftype)) && - compareType(toType, expr->left->ftype) && - IS_AST_LIT_VALUE (expr->right)) { - return valForCastAggr (expr->left, expr->left->ftype, - expr->right, - expr->opval.op); - } - - /* (char *)&a */ - if (IS_AST_OP(expr) && expr->opval.op==CAST && - IS_AST_OP(expr->right) && expr->right->opval.op=='&') { - if (compareType(toType, expr->left->ftype)!=1) { - werror (W_INIT_WRONG); - printFromToType(expr->left->ftype, toType); - } - // skip the cast ??? - expr=expr->right; - } - - /* no then we have to do these cludgy checks */ - /* pointers can be initialized with address of - a variable or address of an array element */ - if (IS_AST_OP (expr) && expr->opval.op == '&') { - /* address of symbol */ - if (IS_AST_SYM_VALUE (expr->left)) { - val = copyValue (AST_VALUE (expr->left)); - val->type = newLink (DECLARATOR); - if (SPEC_SCLS (expr->left->etype) == S_CODE) { - DCL_TYPE (val->type) = CPOINTER; - DCL_PTR_CONST (val->type) = port->mem.code_ro; - } - else if (SPEC_SCLS (expr->left->etype) == S_XDATA) - DCL_TYPE (val->type) = FPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_XSTACK) - DCL_TYPE (val->type) = PPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_IDATA) - DCL_TYPE (val->type) = IPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_EEPROM) - DCL_TYPE (val->type) = EEPPOINTER; - else - DCL_TYPE (val->type) = POINTER; - val->type->next = expr->left->ftype; - val->etype = getSpec (val->type); - return val; - } - - /* if address of indexed array */ - if (IS_AST_OP (expr->left) && expr->left->opval.op == '[') - return valForArray (expr->left); - - /* if address of structure element then - case 1. a.b ; */ - if (IS_AST_OP (expr->left) && - expr->left->opval.op == '.') { - return valForStructElem (expr->left->left, - expr->left->right); - } - - /* case 2. (&a)->b ; - (&some_struct)->element */ - if (IS_AST_OP (expr->left) && - expr->left->opval.op == PTR_OP && - IS_ADDRESS_OF_OP (expr->left->left)) { - return valForStructElem (expr->left->left->left, - expr->left->right); - } - } - /* case 3. (((char *) &a) +/- constant) */ - if (IS_AST_OP (expr) && - (expr->opval.op == '+' || expr->opval.op == '-') && - IS_AST_OP (expr->left) && expr->left->opval.op == CAST && - IS_AST_OP (expr->left->right) && - expr->left->right->opval.op == '&' && - IS_AST_LIT_VALUE (expr->right)) { - - return valForCastAggr (expr->left->right->left, - expr->left->left->opval.lnk, - expr->right, expr->opval.op); - - } - /* case 4. (char *)(array type) */ - if (IS_CAST_OP(expr) && IS_AST_SYM_VALUE (expr->right) && - IS_ARRAY(expr->right->ftype)) { - - val = copyValue (AST_VALUE (expr->right)); - val->type = newLink (DECLARATOR); - if (SPEC_SCLS (expr->right->etype) == S_CODE) { - DCL_TYPE (val->type) = CPOINTER; - DCL_PTR_CONST (val->type) = port->mem.code_ro; - } - else if (SPEC_SCLS (expr->right->etype) == S_XDATA) - DCL_TYPE (val->type) = FPOINTER; - else if (SPEC_SCLS (expr->right->etype) == S_XSTACK) - DCL_TYPE (val->type) = PPOINTER; - else if (SPEC_SCLS (expr->right->etype) == S_IDATA) - DCL_TYPE (val->type) = IPOINTER; - else if (SPEC_SCLS (expr->right->etype) == S_EEPROM) - DCL_TYPE (val->type) = EEPPOINTER; - else - DCL_TYPE (val->type) = POINTER; - val->type->next = expr->right->ftype->next; - val->etype = getSpec (val->type); - return val; - } + value *val; + ast *expr; + + if (!ilist) { + return valCastLiteral(toType, 0.0); + } + + expr = list2expr (ilist); + + if (!expr) + goto wrong; + + /* try it the old way first */ + if ((val = constExprValue (expr, FALSE))) + return val; + + /* ( ptr + constant ) */ + if (IS_AST_OP (expr) && + (expr->opval.op == '+' || expr->opval.op == '-') && + IS_AST_SYM_VALUE (expr->left) && + (IS_ARRAY(expr->left->ftype) || IS_PTR(expr->left->ftype)) && + compareType(toType, expr->left->ftype) && + IS_AST_LIT_VALUE (expr->right)) { + return valForCastAggr (expr->left, expr->left->ftype, + expr->right, + expr->opval.op); + } + + /* (char *)&a */ + if (IS_AST_OP(expr) && expr->opval.op==CAST && + IS_AST_OP(expr->right) && expr->right->opval.op=='&') { + if (compareType(toType, expr->left->ftype)!=1) { + werror (W_INIT_WRONG); + printFromToType(expr->left->ftype, toType); + } + // skip the cast ??? + expr=expr->right; + } + + /* no then we have to do these cludgy checks */ + /* pointers can be initialized with address of + a variable or address of an array element */ + if (IS_AST_OP (expr) && expr->opval.op == '&') { + /* address of symbol */ + if (IS_AST_SYM_VALUE (expr->left)) { + val = copyValue (AST_VALUE (expr->left)); + val->type = newLink (DECLARATOR); + if (SPEC_SCLS (expr->left->etype) == S_CODE) { + DCL_TYPE (val->type) = CPOINTER; + DCL_PTR_CONST (val->type) = port->mem.code_ro; + } + else if (SPEC_SCLS (expr->left->etype) == S_XDATA) + DCL_TYPE (val->type) = FPOINTER; + else if (SPEC_SCLS (expr->left->etype) == S_XSTACK) + DCL_TYPE (val->type) = PPOINTER; + else if (SPEC_SCLS (expr->left->etype) == S_IDATA) + DCL_TYPE (val->type) = IPOINTER; + else if (SPEC_SCLS (expr->left->etype) == S_EEPROM) + DCL_TYPE (val->type) = EEPPOINTER; + else + DCL_TYPE (val->type) = POINTER; + val->type->next = expr->left->ftype; + val->etype = getSpec (val->type); + return val; + } + + /* if address of indexed array */ + if (IS_AST_OP (expr->left) && expr->left->opval.op == '[') + return valForArray (expr->left); + + /* if address of structure element then + case 1. a.b ; */ + if (IS_AST_OP (expr->left) && + expr->left->opval.op == '.') { + return valForStructElem (expr->left->left, + expr->left->right); + } + + /* case 2. (&a)->b ; + (&some_struct)->element */ + if (IS_AST_OP (expr->left) && + expr->left->opval.op == PTR_OP && + IS_ADDRESS_OF_OP (expr->left->left)) { + return valForStructElem (expr->left->left->left, + expr->left->right); + } + } + /* case 3. (((char *) &a) +/- constant) */ + if (IS_AST_OP (expr) && + (expr->opval.op == '+' || expr->opval.op == '-') && + IS_AST_OP (expr->left) && expr->left->opval.op == CAST && + IS_AST_OP (expr->left->right) && + expr->left->right->opval.op == '&' && + IS_AST_LIT_VALUE (expr->right)) { + + return valForCastAggr (expr->left->right->left, + expr->left->left->opval.lnk, + expr->right, expr->opval.op); + + } + /* case 4. (char *)(array type) */ + if (IS_CAST_OP(expr) && IS_AST_SYM_VALUE (expr->right) && + IS_ARRAY(expr->right->ftype)) { + + val = copyValue (AST_VALUE (expr->right)); + val->type = newLink (DECLARATOR); + if (SPEC_SCLS (expr->right->etype) == S_CODE) { + DCL_TYPE (val->type) = CPOINTER; + DCL_PTR_CONST (val->type) = port->mem.code_ro; + } + else if (SPEC_SCLS (expr->right->etype) == S_XDATA) + DCL_TYPE (val->type) = FPOINTER; + else if (SPEC_SCLS (expr->right->etype) == S_XSTACK) + DCL_TYPE (val->type) = PPOINTER; + else if (SPEC_SCLS (expr->right->etype) == S_IDATA) + DCL_TYPE (val->type) = IPOINTER; + else if (SPEC_SCLS (expr->right->etype) == S_EEPROM) + DCL_TYPE (val->type) = EEPPOINTER; + else + DCL_TYPE (val->type) = POINTER; + val->type->next = expr->right->ftype->next; + val->etype = getSpec (val->type); + return val; + } wrong: - if (expr) - werrorfl (expr->filename, expr->lineno, E_INCOMPAT_PTYPES); - else - werror (E_INCOMPAT_PTYPES); - return NULL; + if (expr) + werrorfl (expr->filename, expr->lineno, E_INCOMPAT_PTYPES); + else + werror (E_INCOMPAT_PTYPES); + return NULL; } @@ -516,35 +535,35 @@ printChar (FILE * ofile, char *s, int plen) { i = 60; while (i && pplen < plen) - { - if (*s < ' ' || *s == '\"' || *s=='\\') - { - *p = '\0'; - if (p != buf) - tfprintf (ofile, "\t!ascii\n", buf); - tfprintf (ofile, "\t!db !constbyte\n", (unsigned char)*s); - p = buf; - } - else - { - *p = *s; - p++; - } - s++; - pplen++; - i--; - } + { + if (*s < ' ' || *s == '\"' || *s=='\\') + { + *p = '\0'; + if (p != buf) + tfprintf (ofile, "\t!ascii\n", buf); + tfprintf (ofile, "\t!db !constbyte\n", (unsigned char)*s); + p = buf; + } + else + { + *p = *s; + p++; + } + s++; + pplen++; + i--; + } if (p != buf) - { - *p = '\0'; - tfprintf (ofile, "\t!ascii\n", buf); - p = buf; - } + { + *p = '\0'; + tfprintf (ofile, "\t!ascii\n", buf); + p = buf; + } if (len > 60) - len -= 60; + len -= 60; else - len = 0; + len = 0; } while (pplen < plen) { @@ -565,9 +584,9 @@ pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) case POINTER: return GPTYPE_NEAR; case GPOINTER: - werror (E_CANNOT_USE_GENERIC_POINTER, - iname ? iname : "", - oname ? oname : ""); + werror (E_CANNOT_USE_GENERIC_POINTER, + iname ? iname : "", + oname ? oname : ""); exit (1); case FPOINTER: return GPTYPE_FAR; @@ -577,7 +596,7 @@ pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) return GPTYPE_XSTACK; default: fprintf (stderr, "*** internal error: unknown pointer type %d in GPByte.\n", - p_type); + p_type); break; } return -1; @@ -621,7 +640,7 @@ printPointerType (FILE * oFile, const char *name) /*-----------------------------------------------------------------*/ void printGPointerType (FILE * oFile, const char *iname, const char *oname, - const unsigned int type) + const unsigned int type) { _printPointerType (oFile, iname); fprintf (oFile, ",#0x%02x\n", pointerTypeToGPByte (type, iname, oname)); @@ -633,55 +652,55 @@ printGPointerType (FILE * oFile, const char *iname, const char *oname, void printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) { - value *val; - - /* if initList is deep */ - if (ilist->type == INIT_DEEP) - ilist = ilist->init.deep; - - if (!(val = list2val (ilist))) { - // assuming a warning has been thrown - val=constVal("0"); - } - - if (val->type != type) { - val = valCastLiteral(type, floatFromVal(val)); - } - - switch (getSize (type)) { - case 1: - if (!val) - tfprintf (oFile, "\t!db !constbyte\n", 0); - else - tfprintf (oFile, "\t!dbs\n", - aopLiteral (val, 0)); - break; - - case 2: - if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); - else if (port->little_endian) - fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); - else - fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); - break; - case 4: - if (!val) { - tfprintf (oFile, "\t!dw !constword\n", 0); - tfprintf (oFile, "\t!dw !constword\n", 0); - } - else if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1), - aopLiteral (val, 2), aopLiteral (val, 3)); - } - else { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 3), aopLiteral (val, 2), - aopLiteral (val, 1), aopLiteral (val, 0)); - } - break; - } + value *val; + + /* if initList is deep */ + if (ilist && (ilist->type == INIT_DEEP)) + ilist = ilist->init.deep; + + if (!(val = list2val (ilist))) { + // assuming a warning has been thrown + val=constVal("0"); + } + + if (val->type != type) { + val = valCastLiteral(type, floatFromVal(val)); + } + + switch (getSize (type)) { + case 1: + if (!val) + tfprintf (oFile, "\t!db !constbyte\n", 0); + else + tfprintf (oFile, "\t!dbs\n", + aopLiteral (val, 0)); + break; + + case 2: + if (port->use_dw_for_init) + tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); + else if (port->little_endian) + fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); + else + fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); + break; + case 4: + if (!val) { + tfprintf (oFile, "\t!dw !constword\n", 0); + tfprintf (oFile, "\t!dw !constword\n", 0); + } + else if (port->little_endian) { + fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 0), aopLiteral (val, 1), + aopLiteral (val, 2), aopLiteral (val, 3)); + } + else { + fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 3), aopLiteral (val, 2), + aopLiteral (val, 1), aopLiteral (val, 0)); + } + break; + } } /*-----------------------------------------------------------------*/ @@ -689,49 +708,49 @@ printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ void printIvalBitFields(symbol **sym, initList **ilist, FILE * oFile) { - value *val ; - symbol *lsym = *sym; - initList *lilist = *ilist ; - unsigned long ival = 0; - int size =0; - - - do { - unsigned long i; - val = list2val(lilist); - if (size) { - if (SPEC_BLEN(lsym->etype) > 8) { - size += ((SPEC_BLEN (lsym->etype) / 8) + - (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); - } - } else { - size = ((SPEC_BLEN (lsym->etype) / 8) + - (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); - } - i = (unsigned long)floatFromVal(val); - i <<= SPEC_BSTR (lsym->etype); - ival |= i; - if (! ( lsym->next && - (IS_BITFIELD(lsym->next->type)) && - (SPEC_BSTR(lsym->next->etype)))) break; - lsym = lsym->next; - lilist = lilist->next; - } while (1); - switch (size) { - case 1: - tfprintf (oFile, "\t!db !constbyte\n",ival); - break; - - case 2: - tfprintf (oFile, "\t!dw !constword\n",ival); - break; - case 4: /* EEP: why is this db and not dw? */ - tfprintf (oFile, "\t!db !constword,!constword\n", - (ival >> 8) & 0xffff, (ival & 0xffff)); - break; - } - *sym = lsym; - *ilist = lilist; + value *val ; + symbol *lsym = *sym; + initList *lilist = *ilist ; + unsigned long ival = 0; + int size =0; + + + do { + unsigned long i; + val = list2val(lilist); + if (size) { + if (SPEC_BLEN(lsym->etype) > 8) { + size += ((SPEC_BLEN (lsym->etype) / 8) + + (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); + } + } else { + size = ((SPEC_BLEN (lsym->etype) / 8) + + (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); + } + i = (unsigned long)floatFromVal(val); + i <<= SPEC_BSTR (lsym->etype); + ival |= i; + if (! ( lsym->next && + (IS_BITFIELD(lsym->next->type)) && + (SPEC_BSTR(lsym->next->etype)))) break; + lsym = lsym->next; + lilist = lilist->next; + } while (1); + switch (size) { + case 1: + tfprintf (oFile, "\t!db !constbyte\n",ival); + break; + + case 2: + tfprintf (oFile, "\t!dw !constword\n",ival); + break; + case 4: /* EEP: why is this db and not dw? */ + tfprintf (oFile, "\t!db !constword,!constword\n", + (ival >> 8) & 0xffff, (ival & 0xffff)); + break; + } + *sym = lsym; + *ilist = lilist; } /*-----------------------------------------------------------------*/ @@ -739,30 +758,33 @@ void printIvalBitFields(symbol **sym, initList **ilist, FILE * oFile) /*-----------------------------------------------------------------*/ void printIvalStruct (symbol * sym, sym_link * type, - initList * ilist, FILE * oFile) + initList * ilist, FILE * oFile) { - symbol *sflds; - initList *iloop; - - sflds = SPEC_STRUCT (type)->fields; - if (ilist->type != INIT_DEEP) { - werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name); - return; - } - - iloop = ilist->init.deep; - - for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL)) { - if (IS_BITFIELD(sflds->type)) { - printIvalBitFields(&sflds,&iloop,oFile); - } else { - printIval (sym, sflds->type, iloop, oFile); - } - } - if (iloop) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "struct", sym->name); - } - return; + symbol *sflds; + initList *iloop = NULL; + + sflds = SPEC_STRUCT (type)->fields; + + if (ilist) { + if (ilist->type != INIT_DEEP) { + werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name); + return; + } + + iloop = ilist->init.deep; + } + + for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL)) { + if (IS_BITFIELD(sflds->type)) { + printIvalBitFields(&sflds,&iloop,oFile); + } else { + printIval (sym, sflds->type, iloop, oFile); + } + } + if (iloop) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "struct", sym->name); + } + return; } /*-----------------------------------------------------------------*/ @@ -779,16 +801,16 @@ printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) val = list2val (ilist); /* if the value is a character string */ if (IS_ARRAY (val->type) && IS_CHAR (val->etype)) - { - if (!DCL_ELEM (type)) - DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1; + { + if (!DCL_ELEM (type)) + DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1; - printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type)); + printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type)); - return 1; - } + return 1; + } else - return 0; + return 0; } else printChar (oFile, s, strlen (s) + 1); @@ -800,47 +822,47 @@ printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) /*-----------------------------------------------------------------*/ void printIvalArray (symbol * sym, sym_link * type, initList * ilist, - FILE * oFile) + FILE * oFile) { initList *iloop; int size = 0; - /* take care of the special case */ - /* array of characters can be init */ - /* by a string */ - if (IS_CHAR (type->next)) { - if (!IS_LITERAL(list2val(ilist)->etype)) { - werrorfl (ilist->filename, ilist->lineno, E_CONST_EXPECTED); - return; + if (ilist) { + /* take care of the special case */ + /* array of characters can be init */ + /* by a string */ + if (IS_CHAR (type->next)) { + if (!IS_LITERAL(list2val(ilist)->etype)) { + werrorfl (ilist->filename, ilist->lineno, E_CONST_EXPECTED); + return; + } + if (printIvalChar (type, + (ilist->type == INIT_DEEP ? ilist->init.deep : ilist), + oFile, SPEC_CVAL (sym->etype).v_char)) + return; } - if (printIvalChar (type, - (ilist->type == INIT_DEEP ? ilist->init.deep : ilist), - oFile, SPEC_CVAL (sym->etype).v_char)) - return; - } - /* not the special case */ - if (ilist->type != INIT_DEEP) - { + /* not the special case */ + if (ilist->type != INIT_DEEP) { werrorfl (ilist->filename, ilist->lineno, E_INIT_STRUCT, sym->name); return; } - for (iloop=ilist->init.deep; iloop; iloop=iloop->next) - { + for (iloop=ilist->init.deep; iloop; iloop=iloop->next) { printIval (sym, type->next, iloop, oFile); - if (++size > DCL_ELEM(type)) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "array", sym->name); - break; + if ((++size > DCL_ELEM(type)) && DCL_ELEM(type)) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "array", sym->name); + break; } } + } if (DCL_ELEM(type)) { // pad with zeros if needed if (sizenext); while (size--) { - tfprintf (oFile, "\t!db !constbyte\n", 0); + tfprintf (oFile, "\t!db !constbyte\n", 0); } } } else { @@ -860,15 +882,18 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) value *val; int dLvl = 0; - val = list2val (ilist); + if (ilist) + val = list2val (ilist); + else + val = valCastLiteral(type, 0.0); if (!val) { - // an error has been thrown allready + // an error has been thrown already val=constVal("0"); } if (IS_LITERAL(val->etype)) { - if (compareType(type,val->etype)==0) { + if (compareType(type, val->etype) == 0) { werrorfl (ilist->filename, ilist->lineno, E_INCOMPAT_TYPES); printFromToType (val->type, type); } @@ -887,13 +912,13 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) if (!val->sym) { if (port->use_dw_for_init) - { - tfprintf (oFile, "\t!dws\n", val->name); - } + { + tfprintf (oFile, "\t!dws\n", val->name); + } else - { - printPointerType (oFile, val->name); - } + { + printPointerType (oFile, val->name); + } } else if (port->use_dw_for_init) { @@ -923,99 +948,99 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) if (val->name && strlen (val->name)) { - if (size == 1) /* This appears to be Z80 specific?? */ - { - tfprintf (oFile, - "\t!dbs\n", val->name); - } + if (size == 1) /* This appears to be Z80 specific?? */ + { + tfprintf (oFile, + "\t!dbs\n", val->name); + } else if (size == FPTRSIZE) - { - if (port->use_dw_for_init) - { - tfprintf (oFile, "\t!dws\n", val->name); - } - else - { - printPointerType (oFile, val->name); - } - } + { + if (port->use_dw_for_init) + { + tfprintf (oFile, "\t!dws\n", val->name); + } + else + { + printPointerType (oFile, val->name); + } + } else if (size == GPTRSIZE) - { - int type; - if (IS_PTR (val->type)) { - type = DCL_TYPE (val->type); - } else { - type = PTR_TYPE (SPEC_OCLS (val->etype)); - } - if (val->sym && val->sym->isstrlit) { - // this is a literal string - type=CPOINTER; - } - printGPointerType (oFile, val->name, sym->name, type); - } + { + int type; + if (IS_PTR (val->type)) { + type = DCL_TYPE (val->type); + } else { + type = PTR_TYPE (SPEC_OCLS (val->etype)); + } + if (val->sym && val->sym->isstrlit) { + // this is a literal string + type=CPOINTER; + } + printGPointerType (oFile, val->name, sym->name, type); + } else - { - fprintf (stderr, "*** internal error: unknown size in " - "printIvalCharPtr.\n"); - } + { + fprintf (stderr, "*** internal error: unknown size in " + "printIvalCharPtr.\n"); + } } else { // these are literals assigned to pointers switch (size) - { - case 1: - tfprintf (oFile, "\t!dbs\n", aopLiteral (val, 0)); - break; - case 2: - if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, size)); - else if (port->little_endian) - tfprintf (oFile, "\t.byte %s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1)); - else - tfprintf (oFile, "\t.byte %s,%s\n", - aopLiteral (val, 1), aopLiteral (val, 0)); - break; - case 3: - if (IS_GENPTR(type) && floatFromVal(val)!=0) { - // non-zero mcs51 generic pointer - werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); - } - if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s\n", - aopLiteral (val, 0), - aopLiteral (val, 1), - aopLiteral (val, 2)); - } else { - fprintf (oFile, "\t.byte %s,%s,%s\n", - aopLiteral (val, 2), - aopLiteral (val, 1), - aopLiteral (val, 0)); - } - break; - case 4: - if (IS_GENPTR(type) && floatFromVal(val)!=0) { - // non-zero ds390 generic pointer - werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); - } - if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 0), - aopLiteral (val, 1), - aopLiteral (val, 2), - aopLiteral (val, 3)); - } else { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 3), - aopLiteral (val, 2), - aopLiteral (val, 1), - aopLiteral (val, 0)); - } - break; - default: - assert (0); - } + { + case 1: + tfprintf (oFile, "\t!dbs\n", aopLiteral (val, 0)); + break; + case 2: + if (port->use_dw_for_init) + tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, size)); + else if (port->little_endian) + tfprintf (oFile, "\t.byte %s,%s\n", + aopLiteral (val, 0), aopLiteral (val, 1)); + else + tfprintf (oFile, "\t.byte %s,%s\n", + aopLiteral (val, 1), aopLiteral (val, 0)); + break; + case 3: + if (IS_GENPTR(type) && floatFromVal(val)!=0) { + // non-zero mcs51 generic pointer + werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); + } + if (port->little_endian) { + fprintf (oFile, "\t.byte %s,%s,%s\n", + aopLiteral (val, 0), + aopLiteral (val, 1), + aopLiteral (val, 2)); + } else { + fprintf (oFile, "\t.byte %s,%s,%s\n", + aopLiteral (val, 2), + aopLiteral (val, 1), + aopLiteral (val, 0)); + } + break; + case 4: + if (IS_GENPTR(type) && floatFromVal(val)!=0) { + // non-zero ds390 generic pointer + werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); + } + if (port->little_endian) { + fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 0), + aopLiteral (val, 1), + aopLiteral (val, 2), + aopLiteral (val, 3)); + } else { + fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 3), + aopLiteral (val, 2), + aopLiteral (val, 1), + aopLiteral (val, 0)); + } + break; + default: + assert (0); + } } if (val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) { @@ -1035,7 +1060,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) int size; /* if deep then */ - if (ilist->type == INIT_DEEP) + if (ilist && (ilist->type == INIT_DEEP)) ilist = ilist->init.deep; /* function pointer */ @@ -1063,60 +1088,60 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) if (IS_LITERAL (val->etype)) { switch (getSize (type)) - { - case 1: - tfprintf (oFile, "\t!db !constbyte\n", (unsigned int) floatFromVal (val) & 0xff); - break; - case 2: - if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); - else if (port->little_endian) - tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); - else - tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); - break; - case 3: // how about '390?? - fprintf (oFile, "; generic printIvalPtr\n"); - if (port->little_endian) - { - fprintf (oFile, "\t.byte %s,%s", - aopLiteral (val, 0), aopLiteral (val, 1)); - } - else - { - fprintf (oFile, "\t.byte %s,%s", - aopLiteral (val, 1), aopLiteral (val, 0)); - } - if (IS_GENPTR (val->type)) - fprintf (oFile, ",%s\n", aopLiteral (val, 2)); - else if (IS_PTR (val->type)) - fprintf (oFile, ",#%x\n", pointerTypeToGPByte (DCL_TYPE (val->type), NULL, NULL)); - else - fprintf (oFile, ",%s\n", aopLiteral (val, 2)); - } + { + case 1: + tfprintf (oFile, "\t!db !constbyte\n", (unsigned int) floatFromVal (val) & 0xff); + break; + case 2: + if (port->use_dw_for_init) + tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); + else if (port->little_endian) + tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); + else + tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); + break; + case 3: // how about '390?? + fprintf (oFile, "; generic printIvalPtr\n"); + if (port->little_endian) + { + fprintf (oFile, "\t.byte %s,%s", + aopLiteral (val, 0), aopLiteral (val, 1)); + } + else + { + fprintf (oFile, "\t.byte %s,%s", + aopLiteral (val, 1), aopLiteral (val, 0)); + } + if (IS_GENPTR (val->type)) + fprintf (oFile, ",%s\n", aopLiteral (val, 2)); + else if (IS_PTR (val->type)) + fprintf (oFile, ",#%x\n", pointerTypeToGPByte (DCL_TYPE (val->type), NULL, NULL)); + else + fprintf (oFile, ",%s\n", aopLiteral (val, 2)); + } return; } size = getSize (type); - if (size == 1) /* Z80 specific?? */ + if (size == 1) /* Z80 specific?? */ { tfprintf (oFile, "\t!dbs\n", val->name); } else if (size == FPTRSIZE) { if (port->use_dw_for_init) { - tfprintf (oFile, "\t!dws\n", val->name); + tfprintf (oFile, "\t!dws\n", val->name); } else { - printPointerType (oFile, val->name); + printPointerType (oFile, val->name); } } else if (size == GPTRSIZE) { printGPointerType (oFile, val->name, sym->name, - (IS_PTR (val->type) ? DCL_TYPE (val->type) : - PTR_TYPE (SPEC_OCLS (val->etype)))); + (IS_PTR (val->type) ? DCL_TYPE (val->type) : + PTR_TYPE (SPEC_OCLS (val->etype)))); } return; } @@ -1129,9 +1154,6 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { sym_link *itype; - if (!ilist) - return; - /* if structure then */ if (IS_STRUCT (type)) { @@ -1146,31 +1168,34 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) return; } - // not an aggregate, ilist must be a node - if (ilist->type!=INIT_NODE) { - // or a 1-element list - if (ilist->init.deep->next) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", - sym->name); - } else { - ilist=ilist->init.deep; - } - } - - // and the type must match - itype=ilist->init.node->ftype; + if (ilist) + { + // not an aggregate, ilist must be a node + if (ilist->type!=INIT_NODE) { + // or a 1-element list + if (ilist->init.deep->next) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", + sym->name); + } else { + ilist=ilist->init.deep; + } + } - if (compareType(type, itype)==0) { - // special case for literal strings - if (IS_ARRAY (itype) && IS_CHAR (getSpec(itype)) && - // which are really code pointers - IS_PTR(type) && DCL_TYPE(type)==CPOINTER) { - // no sweat - } else { - werrorfl (ilist->filename, ilist->lineno, E_TYPE_MISMATCH, "assignment", " "); - printFromToType(itype, type); + // and the type must match + itype=ilist->init.node->ftype; + + if (compareType(type, itype)==0) { + // special case for literal strings + if (IS_ARRAY (itype) && IS_CHAR (getSpec(itype)) && + // which are really code pointers + IS_PTR(type) && DCL_TYPE(type)==CPOINTER) { + // no sweat + } else { + werrorfl (ilist->filename, ilist->lineno, E_TYPE_MISMATCH, "assignment", " "); + printFromToType(itype, type); + } + } } - } /* if this is a pointer */ if (IS_PTR (type)) @@ -1204,7 +1229,7 @@ emitStaticSeg (memmap * map, FILE * out) /* if it is "extern" then do nothing */ if (IS_EXTERN (sym->etype)) - continue; + continue; /* if it is not static add it to the public table */ @@ -1216,69 +1241,69 @@ emitStaticSeg (memmap * map, FILE * out) /* print extra debug info if required */ if (options.debug) { - if (!sym->level) - { /* global */ - if (IS_STATIC (sym->etype)) - fprintf (out, "F%s$", moduleName); /* scope is file */ - else - fprintf (out, "G$"); /* scope is global */ - } - else - /* symbol is local */ - fprintf (out, "L%s$", - (sym->localof ? sym->localof->name : "-null-")); - fprintf (out, "%s$%d$%d", sym->name, sym->level, sym->block); + if (!sym->level) + { /* global */ + if (IS_STATIC (sym->etype)) + fprintf (out, "F%s$", moduleName); /* scope is file */ + else + fprintf (out, "G$"); /* scope is global */ + } + else + /* symbol is local */ + fprintf (out, "L%s$", + (sym->localof ? sym->localof->name : "-null-")); + fprintf (out, "%s$%d$%d", sym->name, sym->level, sym->block); } /* if it has an absolute address */ if (SPEC_ABSA (sym->etype)) - { - if (options.debug) - fprintf (out, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - - fprintf (out, "%s\t=\t0x%04x\n", - sym->rname, - SPEC_ADDR (sym->etype)); - } + { + if (options.debug) + fprintf (out, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + + fprintf (out, "%s\t=\t0x%04x\n", + sym->rname, + SPEC_ADDR (sym->etype)); + } else - { - if (options.debug) - fprintf (out, " == .\n"); - - /* if it has an initial value */ - if (sym->ival) - { - fprintf (out, "%s:\n", sym->rname); - noAlloc++; - resolveIvalSym (sym->ival, sym->type); - printIval (sym, sym->type, sym->ival, out); - noAlloc--; - /* if sym is a simple string and sym->ival is a string, - WE don't need it anymore */ - if (IS_ARRAY(sym->type) && IS_CHAR(sym->type->next) && - IS_AST_SYM_VALUE(list2expr(sym->ival)) && - list2val(sym->ival)->sym->isstrlit) { - freeStringSymbol(list2val(sym->ival)->sym); - } - } - else { - /* allocate space */ - int size = getSize (sym->type); - - if (size==0) { - werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE,sym->name); - } - fprintf (out, "%s:\n", sym->rname); - /* special case for character strings */ - if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) && - SPEC_CVAL (sym->etype).v_char) - printChar (out, - SPEC_CVAL (sym->etype).v_char, - size); - else - tfprintf (out, "\t!ds\n", (unsigned int) size & 0xffff); - } - } + { + if (options.debug) + fprintf (out, " == .\n"); + + /* if it has an initial value */ + if (sym->ival) + { + fprintf (out, "%s:\n", sym->rname); + noAlloc++; + resolveIvalSym (sym->ival, sym->type); + printIval (sym, sym->type, sym->ival, out); + noAlloc--; + /* if sym is a simple string and sym->ival is a string, + WE don't need it anymore */ + if (IS_ARRAY(sym->type) && IS_CHAR(sym->type->next) && + IS_AST_SYM_VALUE(list2expr(sym->ival)) && + list2val(sym->ival)->sym->isstrlit) { + freeStringSymbol(list2val(sym->ival)->sym); + } + } + else { + /* allocate space */ + int size = getSize (sym->type); + + if (size==0) { + werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE,sym->name); + } + fprintf (out, "%s:\n", sym->rname); + /* special case for character strings */ + if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) && + SPEC_CVAL (sym->etype).v_char) + printChar (out, + SPEC_CVAL (sym->etype).v_char, + size); + else + tfprintf (out, "\t!ds\n", (unsigned int) size & 0xffff); + } + } } } @@ -1339,7 +1364,7 @@ createInterruptVect (FILE * vFile) if (!(mainf = findSymWithLevel (SymbolTab, mainf))) { if (!options.cc_only && !noAssemble && !options.c1mode) - werror (E_NO_MAIN); + werror (E_NO_MAIN); return; } @@ -1348,7 +1373,7 @@ createInterruptVect (FILE * vFile) { /* if ! compile only then main function should be present */ if (!options.cc_only && !noAssemble) - werror (E_NO_MAIN); + werror (E_NO_MAIN); return; } @@ -1366,20 +1391,20 @@ createInterruptVect (FILE * vFile) /* now for the other interrupts */ for (; i < maxInterrupts; i++) - { - if (interrupts[i]) - { - fprintf (vFile, "\tljmp\t%s\n", interrupts[i]->rname); - if ( i != maxInterrupts - 1 ) - fprintf (vFile, "\t.ds\t5\n"); - } - else - { - fprintf (vFile, "\treti\n"); - if ( i != maxInterrupts - 1 ) - fprintf (vFile, "\t.ds\t7\n"); - } - } + { + if (interrupts[i]) + { + fprintf (vFile, "\tljmp\t%s\n", interrupts[i]->rname); + if ( i != maxInterrupts - 1 ) + fprintf (vFile, "\t.ds\t5\n"); + } + else + { + fprintf (vFile, "\treti\n"); + if ( i != maxInterrupts - 1 ) + fprintf (vFile, "\t.ds\t7\n"); + } + } } } @@ -1460,83 +1485,83 @@ emitOverlay (FILE * afile) symbol *sym; if (elementsInSet (ovrset)) - { - /* output the area informtion */ - fprintf (afile, "\t.area\t%s\n", port->mem.overlay_name); /* MOF */ - } + { + /* output the area informtion */ + fprintf (afile, "\t.area\t%s\n", port->mem.overlay_name); /* MOF */ + } for (sym = setFirstItem (ovrset); sym; - sym = setNextItem (ovrset)) - { - /* if extern then it is in the publics table: do nothing */ - if (IS_EXTERN (sym->etype)) - continue; - - /* if allocation required check is needed - then check if the symbol really requires - allocation only for local variables */ - if (!IS_AGGREGATE (sym->type) && - !(sym->_isparm && !IS_REGPARM (sym->etype)) - && !sym->allocreq && sym->level) - continue; - - /* if global variable & not static or extern - and addPublics allowed then add it to the public set */ - if ((sym->_isparm && !IS_REGPARM (sym->etype)) - && !IS_STATIC (sym->etype)) + sym = setNextItem (ovrset)) + { + /* if extern then it is in the publics table: do nothing */ + if (IS_EXTERN (sym->etype)) + continue; + + /* if allocation required check is needed + then check if the symbol really requires + allocation only for local variables */ + if (!IS_AGGREGATE (sym->type) && + !(sym->_isparm && !IS_REGPARM (sym->etype)) + && !sym->allocreq && sym->level) + continue; + + /* if global variable & not static or extern + and addPublics allowed then add it to the public set */ + if ((sym->_isparm && !IS_REGPARM (sym->etype)) + && !IS_STATIC (sym->etype)) { addSetHead (&publics, sym); } - /* if extern then do nothing or is a function - then do nothing */ - if (IS_FUNC (sym->type)) - continue; - - /* print extra debug info if required */ - if (options.debug) - { - if (!sym->level) - { /* global */ - if (IS_STATIC (sym->etype)) - fprintf (afile, "F%s$", moduleName); /* scope is file */ - else - fprintf (afile, "G$"); /* scope is global */ - } - else - /* symbol is local */ - fprintf (afile, "L%s$", - (sym->localof ? sym->localof->name : "-null-")); - fprintf (afile, "%s$%d$%d", sym->name, sym->level, sym->block); - } - - /* if is has an absolute address then generate - an equate for this no need to allocate space */ - if (SPEC_ABSA (sym->etype)) - { - - if (options.debug) - fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - - fprintf (afile, "%s\t=\t0x%04x\n", - sym->rname, - SPEC_ADDR (sym->etype)); - } - else { - int size = getSize(sym->type); - - if (size==0) { - werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE); - } - if (options.debug) - fprintf (afile, "==.\n"); - - /* allocate space */ - tfprintf (afile, "!labeldef\n", sym->rname); - tfprintf (afile, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); - } - - } + /* if extern then do nothing or is a function + then do nothing */ + if (IS_FUNC (sym->type)) + continue; + + /* print extra debug info if required */ + if (options.debug) + { + if (!sym->level) + { /* global */ + if (IS_STATIC (sym->etype)) + fprintf (afile, "F%s$", moduleName); /* scope is file */ + else + fprintf (afile, "G$"); /* scope is global */ + } + else + /* symbol is local */ + fprintf (afile, "L%s$", + (sym->localof ? sym->localof->name : "-null-")); + fprintf (afile, "%s$%d$%d", sym->name, sym->level, sym->block); + } + + /* if is has an absolute address then generate + an equate for this no need to allocate space */ + if (SPEC_ABSA (sym->etype)) + { + + if (options.debug) + fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + + fprintf (afile, "%s\t=\t0x%04x\n", + sym->rname, + SPEC_ADDR (sym->etype)); + } + else { + int size = getSize(sym->type); + + if (size==0) { + werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE); + } + if (options.debug) + fprintf (afile, "==.\n"); + + /* allocate space */ + tfprintf (afile, "!labeldef\n", sym->rname); + tfprintf (afile, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); + } + + } } } @@ -1685,7 +1710,7 @@ glue (void) } if(mcs51_like) - { + { /* copy the sbit segment */ fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; special function bits \n"); @@ -1693,21 +1718,21 @@ glue (void) copyFile (asmFile, sfrbit->oFile); /*JCF: Create the areas for the register banks*/ - if(RegBankUsed[0]||RegBankUsed[1]||RegBankUsed[2]||RegBankUsed[3]) - { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; overlayable register banks \n"); - fprintf (asmFile, "%s", iComments2); - if(RegBankUsed[0]) - fprintf (asmFile, "\t.area REG_BANK_0\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[1]||options.parms_in_bank1) - fprintf (asmFile, "\t.area REG_BANK_1\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[2]) - fprintf (asmFile, "\t.area REG_BANK_2\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[3]) - fprintf (asmFile, "\t.area REG_BANK_3\t(REL,OVR,DATA)\n\t.ds 8\n"); - } - } + if(RegBankUsed[0]||RegBankUsed[1]||RegBankUsed[2]||RegBankUsed[3]) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable register banks \n"); + fprintf (asmFile, "%s", iComments2); + if(RegBankUsed[0]) + fprintf (asmFile, "\t.area REG_BANK_0\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[1]||options.parms_in_bank1) + fprintf (asmFile, "\t.area REG_BANK_1\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[2]) + fprintf (asmFile, "\t.area REG_BANK_2\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[3]) + fprintf (asmFile, "\t.area REG_BANK_3\t(REL,OVR,DATA)\n\t.ds 8\n"); + } + } /* copy the data segment */ fprintf (asmFile, "%s", iComments2); @@ -1731,7 +1756,7 @@ glue (void) fprintf (asmFile, "; Stack segment in internal ram \n"); fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "\t.area\tSSEG\t(DATA)\n" - "__start__stack:\n\t.ds\t1\n\n"); + "__start__stack:\n\t.ds\t1\n\n"); } /* create the idata segment */ @@ -1756,7 +1781,7 @@ glue (void) fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; external stack \n"); fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "\t.area XSEG (XDATA)\n"); /* MOF */ + fprintf (asmFile, "\t.area XSEG (XDATA)\n"); /* MOF */ fprintf (asmFile, "\t.ds 256\n"); } @@ -1779,7 +1804,7 @@ glue (void) if (port->extraAreas.genExtraAreaDeclaration) { port->extraAreas.genExtraAreaDeclaration(asmFile, - mainf && IFFUNC_HASBODY(mainf->type)); + mainf && IFFUNC_HASBODY(mainf->type)); } /* copy the interrupt vector table */ @@ -1802,7 +1827,7 @@ glue (void) * the post_static_name area will immediately follow the static_name * area. */ - tfprintf (asmFile, "\t!area\n", port->mem.static_name); /* MOF */ + tfprintf (asmFile, "\t!area\n", port->mem.static_name); /* MOF */ tfprintf (asmFile, "\t!area\n", port->mem.post_static_name); tfprintf (asmFile, "\t!area\n", port->mem.static_name); @@ -1810,8 +1835,8 @@ glue (void) { if (port->genInitStartup) { - port->genInitStartup(asmFile); - } + port->genInitStartup(asmFile); + } else { fprintf (asmFile, "__sdcc_gsinit_startup:\n"); @@ -1820,21 +1845,21 @@ glue (void) going into P2 and the lower order going into spx */ if (options.useXstack) - { - fprintf (asmFile, "\tmov\tP2,#0x%02x\n", - (((unsigned int) options.xdata_loc) >> 8) & 0xff); - fprintf (asmFile, "\tmov\t_spx,#0x%02x\n", - (unsigned int) options.xdata_loc & 0xff); - } + { + fprintf (asmFile, "\tmov\tP2,#0x%02x\n", + (((unsigned int) options.xdata_loc) >> 8) & 0xff); + fprintf (asmFile, "\tmov\t_spx,#0x%02x\n", + (unsigned int) options.xdata_loc & 0xff); + } // This should probably be a port option, but I'm being lazy. // on the 400, the firmware boot loader gives us a valid stack // (see '400 data sheet pg. 85 (TINI400 ROM Initialization code) if (!TARGET_IS_DS400) - { - /* initialise the stack pointer. JCF: aslink takes care of the location */ - fprintf (asmFile, "\tmov\tsp,#__start__stack - 1\n"); /* MOF */ - } + { + /* initialise the stack pointer. JCF: aslink takes care of the location */ + fprintf (asmFile, "\tmov\tsp,#__start__stack - 1\n"); /* MOF */ + } fprintf (asmFile, "\tlcall\t__sdcc_external_startup\n"); fprintf (asmFile, "\tmov\ta,dpl\n"); @@ -1844,10 +1869,10 @@ glue (void) // if the port can copy the XINIT segment to XISEG if (port->genXINIT) - { - port->genXINIT(asmFile); + { + port->genXINIT(asmFile); } - } + } } copyFile (asmFile, statsg->oFile); @@ -1863,9 +1888,9 @@ glue (void) } fprintf (asmFile, - "%s" - "; Home\n" - "%s", iComments2, iComments2); + "%s" + "; Home\n" + "%s", iComments2, iComments2); tfprintf (asmFile, "\t!areahome\n", HOME_NAME); copyFile (asmFile, home->oFile); @@ -1904,7 +1929,7 @@ glue (void) } -/** Creates a temporary file with unoque file name +/** Creates a temporary file with unique file name Scans, in order: - TMP, TEMP, TMPDIR env. varibles - if Un*x system: /usr/tmp and /tmp @@ -1934,8 +1959,8 @@ tempfileandname(char *fname, size_t len) if (!warning_emitted) { fprintf (stderr, "TMP not defined in environment, using %s for temporary files\n.", tmpdir); - warning_emitted = 1; - } + warning_emitted = 1; + } } } #else diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index dcce5fcc..e9b76c7d 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -59,11 +59,11 @@ char *nounName(sym_link *sl) { return "unknown"; }; -bucket *SymbolTab[256]; /* the symbol table */ -bucket *StructTab[256]; /* the structure table */ -bucket *TypedefTab[256]; /* the typedef table */ -bucket *LabelTab[256]; /* the Label table */ -bucket *enumTab[256]; /* enumerated table */ +bucket *SymbolTab[256]; /* the symbol table */ +bucket *StructTab[256]; /* the structure table */ +bucket *TypedefTab[256]; /* the typedef table */ +bucket *LabelTab[256]; /* the Label table */ +bucket *enumTab[256]; /* enumerated table */ /*------------------------------------------------------------------*/ /* initSymt () - initialises symbol table related stuff */ @@ -109,14 +109,14 @@ hashKey (const char *s) /*-----------------------------------------------------------------*/ void addSym (bucket ** stab, - void *sym, - char *sname, - int level, - int block, - int checkType) + void *sym, + char *sname, + int level, + int block, + int checkType) { - int i; /* index into the hash Table */ - bucket *bp; /* temp bucket * */ + int i; /* index into the hash Table */ + bucket *bp; /* temp bucket * */ if (checkType) { symbol *csym = (symbol *)sym; @@ -139,15 +139,15 @@ addSym (bucket ** stab, /* get a free entry */ bp = Safe_alloc ( sizeof (bucket)); - bp->sym = sym; /* update the symbol pointer */ - bp->level = level; /* update the nest level */ + bp->sym = sym; /* update the symbol pointer */ + bp->level = level; /* update the nest level */ bp->block = block; - strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */ + strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */ /* if this is the first entry */ if (stab[i] == NULL) { - bp->prev = bp->next = (void *) NULL; /* point to nothing */ + bp->prev = bp->next = (void *) NULL; /* point to nothing */ stab[i] = bp; } /* not first entry then add @ head of list */ @@ -175,25 +175,25 @@ deleteSym (bucket ** stab, void *sym, char *sname) /* find the symbol */ while (bp) { - if (bp->sym == sym) /* found it then break out */ - break; /* of the loop */ + if (bp->sym == sym) /* found it then break out */ + break; /* of the loop */ bp = bp->next; } - if (!bp) /* did not find it */ + if (!bp) /* did not find it */ return; /* if this is the first one in the chain */ if (!bp->prev) { stab[i] = bp->next; - if (stab[i]) /* if chain ! empty */ - stab[i]->prev = (void *) NULL; + if (stab[i]) /* if chain ! empty */ + stab[i]->prev = (void *) NULL; } /* middle || end of chain */ else { - if (bp->next) /* if not end of chain */ - bp->next->prev = bp->prev; + if (bp->next) /* if not end of chain */ + bp->next->prev = bp->prev; bp->prev->next = bp->next; } @@ -212,7 +212,7 @@ findSym (bucket ** stab, void *sym, const char *sname) while (bp) { if (bp->sym == sym || strcmp (bp->name, sname) == 0) - break; + break; bp = bp->next; } @@ -240,20 +240,20 @@ findSymWithLevel (bucket ** stab, symbol * sym) while (bp) { if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level) - { - /* if this is parameter then nothing else need to be checked */ - if (((symbol *) (bp->sym))->_isparm) - return (bp->sym); - /* if levels match then block numbers should also match */ - if (bp->level && bp->level == sym->level && bp->block == sym->block) - return (bp->sym); - /* if levels don't match then we are okay */ - if (bp->level && bp->level != sym->level && bp->block <= sym->block) - return (bp->sym); - /* if this is a global variable then we are ok too */ - if (bp->level == 0) - return (bp->sym); - } + { + /* if this is parameter then nothing else need to be checked */ + if (((symbol *) (bp->sym))->_isparm) + return (bp->sym); + /* if levels match then block numbers should also match */ + if (bp->level && bp->level == sym->level && bp->block == sym->block) + return (bp->sym); + /* if levels don't match then we are okay */ + if (bp->level && bp->level != sym->level && bp->block <= sym->block) + return (bp->sym); + /* if this is a global variable then we are ok too */ + if (bp->level == 0) + return (bp->sym); + } bp = bp->next; } @@ -273,8 +273,8 @@ findSymWithBlock (bucket ** stab, symbol * sym, int block) while (bp) { if (strcmp (bp->name, sym->name) == 0 && - bp->block <= block) - break; + bp->block <= block) + break; bp = bp->next; } @@ -291,10 +291,10 @@ newSymbol (char *name, int scope) sym = Safe_alloc ( sizeof (symbol)); - strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */ - sym->level = scope; /* set the level */ + strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */ + sym->level = scope; /* set the level */ sym->block = currBlockno; - sym->lineDef = mylineno; /* set the line number */ + sym->lineDef = mylineno; /* set the line number */ sym->fileDef = currFname; return sym; } @@ -323,7 +323,7 @@ newStruct (char *tag) s = Safe_alloc ( sizeof (structdef)); - strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */ + strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */ return s; } @@ -385,29 +385,29 @@ pointerTypes (sym_link * ptr, sym_link * type) if (IS_SPEC (type)) { switch (SPEC_SCLS (type)) - { - case S_XDATA: - DCL_TYPE (ptr) = FPOINTER; - break; - case S_IDATA: - DCL_TYPE (ptr) = IPOINTER; - break; - case S_PDATA: - DCL_TYPE (ptr) = PPOINTER; - break; - case S_DATA: - DCL_TYPE (ptr) = POINTER; - break; - case S_CODE: - DCL_TYPE (ptr) = CPOINTER; - break; - case S_EEPROM: - DCL_TYPE (ptr) = EEPPOINTER; - break; - default: - DCL_TYPE (ptr) = port->unqualified_pointer; - break; - } + { + case S_XDATA: + DCL_TYPE (ptr) = FPOINTER; + break; + case S_IDATA: + DCL_TYPE (ptr) = IPOINTER; + break; + case S_PDATA: + DCL_TYPE (ptr) = PPOINTER; + break; + case S_DATA: + DCL_TYPE (ptr) = POINTER; + break; + case S_CODE: + DCL_TYPE (ptr) = CPOINTER; + break; + case S_EEPROM: + DCL_TYPE (ptr) = EEPPOINTER; + break; + default: + DCL_TYPE (ptr) = port->unqualified_pointer; + break; + } /* the storage class of type ends here */ SPEC_SCLS (type) = 0; } @@ -417,7 +417,7 @@ pointerTypes (sym_link * ptr, sym_link * type) while (ptr) { if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER) - DCL_TYPE (ptr) = port->unqualified_pointer; + DCL_TYPE (ptr) = port->unqualified_pointer; ptr = ptr->next; } @@ -426,7 +426,7 @@ pointerTypes (sym_link * ptr, sym_link * type) while (type) { if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER) - DCL_TYPE (type) = port->unqualified_pointer; + DCL_TYPE (type) = port->unqualified_pointer; type = type->next; } } @@ -449,7 +449,7 @@ addDecl (symbol * sym, int type, sym_link * p) { tail = head = p; while (tail->next) - tail = tail->next; + tail = tail->next; } else { @@ -466,25 +466,25 @@ addDecl (symbol * sym, int type, sym_link * p) else { if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail) - { - sym->etype = mergeSpec (sym->etype, head, sym->name); - } + { + sym->etype = mergeSpec (sym->etype, head, sym->name); + } else - { - if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail) - { - t = sym->type; - while (t->next != sym->etype) - t = t->next; - t->next = head; - tail->next = sym->etype; - } - else - { - sym->etype->next = head; - sym->etype = tail; - } - } + { + if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail) + { + t = sym->type; + while (t->next != sym->etype) + t = t->next; + t->next = head; + tail->next = sym->etype; + } + else + { + sym->etype->next = head; + sym->etype = tail; + } + } } /* if the type is an unknown pointer and has @@ -497,9 +497,9 @@ addDecl (symbol * sym, int type, sym_link * p) DCL_TSPEC (p)) { if (!IS_SPEC (sym->etype)) - { - sym->etype = sym->etype->next = newLink (SPECIFIER); - } + { + sym->etype = sym->etype->next = newLink (SPECIFIER); + } SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p)); DCL_TSPEC (p) = NULL; } @@ -610,7 +610,7 @@ mergeSpec (sym_link * dest, sym_link * src, char *name) } else { /* we shouldn't redeclare the type */ if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "mergeSpec: "); + fprintf (stderr, "mergeSpec: "); } werror(E_TWO_OR_MORE_DATA_TYPES, name); } @@ -622,7 +622,7 @@ mergeSpec (sym_link * dest, sym_link * src, char *name) SPEC_SCLS (dest) = SPEC_SCLS (src); } else { if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "mergeSpec: "); + fprintf (stderr, "mergeSpec: "); } werror(E_TWO_OR_MORE_STORAGE_CLASSES, name); } @@ -774,41 +774,41 @@ getSize (sym_link * p) if (!p) return 0; if (IS_SPEC (p)) - { /* if this is the specifier then */ + { /* if this is the specifier then */ switch (SPEC_NOUN (p)) - { /* depending on the specifier type */ - case V_INT: - return (IS_LONG (p) ? LONGSIZE : INTSIZE); - case V_FLOAT: - return FLOATSIZE; - case V_CHAR: - return CHARSIZE; - case V_VOID: - return 0; - case V_STRUCT: - return SPEC_STRUCT (p)->size; - case V_LABEL: - return 0; - case V_SBIT: - case V_BIT: - return BITSIZE; - case V_BITFIELD: - return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0)); - default: - return 0; - } + { /* depending on the specifier type */ + case V_INT: + return (IS_LONG (p) ? LONGSIZE : INTSIZE); + case V_FLOAT: + return FLOATSIZE; + case V_CHAR: + return CHARSIZE; + case V_VOID: + return 0; + case V_STRUCT: + return SPEC_STRUCT (p)->size; + case V_LABEL: + return 0; + case V_SBIT: + case V_BIT: + return BITSIZE; + case V_BITFIELD: + return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0)); + default: + return 0; + } } - /* this is a specifier */ + /* this is a declarator */ switch (DCL_TYPE (p)) { case ARRAY: if (DCL_ELEM(p)) { - return DCL_ELEM (p) * getSize (p->next); + return DCL_ELEM (p) * getSize (p->next); } else { - // werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - // "can not tell the size of an array[]"); - return 0; + // werror (E_INTERNAL_ERROR, __FILE__, __LINE__, + // "can not tell the size of an array[]"); + return 0; } case IPOINTER: case PPOINTER: @@ -827,6 +827,31 @@ getSize (sym_link * p) } } +/*---------------------------------------------------------------------*/ +/* getAllocSize - returns size of a type chain in bytes for allocation */ +/*---------------------------------------------------------------------*/ +unsigned int +getAllocSize (sym_link *p) +{ + if (IS_STRUCT (p) && SPEC_STRUCT (p)->type == STRUCT) + { + /* if this is a struct specifier then */ + /* calculate the size as it could end */ + /* with an array of unspecified length */ + symbol *sflds = SPEC_STRUCT (p)->fields; + + while (sflds && sflds->next) + sflds = sflds->next; + + if (sflds && !IS_BITFIELD (sflds->type)) + return sflds->offset + getAllocSize (sflds->type); + else + return SPEC_STRUCT (p)->size; + } + else + return getSize (p); +} + /*------------------------------------------------------------------*/ /* bitsForType - returns # of bits required to store this type */ /*------------------------------------------------------------------*/ @@ -838,30 +863,30 @@ bitsForType (sym_link * p) return 0; if (IS_SPEC (p)) - { /* if this is the specifier then */ + { /* if this is the specifier then */ switch (SPEC_NOUN (p)) - { /* depending on the specifier type */ - case V_INT: - return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8); - case V_FLOAT: - return FLOATSIZE * 8; - case V_CHAR: - return CHARSIZE * 8; - case V_VOID: - return 0; - case V_STRUCT: - return SPEC_STRUCT (p)->size * 8; - case V_LABEL: - return 0; - case V_SBIT: - case V_BIT: - return 1; - case V_BITFIELD: - return SPEC_BLEN (p); - default: - return 0; - } + { /* depending on the specifier type */ + case V_INT: + return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8); + case V_FLOAT: + return FLOATSIZE * 8; + case V_CHAR: + return CHARSIZE * 8; + case V_VOID: + return 0; + case V_STRUCT: + return SPEC_STRUCT (p)->size * 8; + case V_LABEL: + return 0; + case V_SBIT: + case V_BIT: + return 1; + case V_BITFIELD: + return SPEC_BLEN (p); + default: + return 0; + } } /* this is a specifier */ @@ -999,68 +1024,68 @@ addSymChain (symbol * symHead) then check if the type match, if the types match then delete the current entry and add the new entry */ if ((csym = findSymWithLevel (SymbolTab, sym)) && - csym->level == sym->level) { - - /* If the previous definition was for an array with incomplete */ - /* type, and the new definition has completed the type, update */ - /* the original type to match */ - if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY - && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY) - { - if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type)) - DCL_ELEM(csym->type) = DCL_ELEM(sym->type); - } - - #if 0 - /* If only one of the definitions used the "at" keyword, copy */ - /* the address to the other. */ - if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype) - && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype)) - { - SPEC_ABSA (sym->etype) = 1; - SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype); - } - if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype) - && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype)) - { - SPEC_ABSA (csym->etype) = 1; - SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype); - } - #endif + csym->level == sym->level) { + + /* If the previous definition was for an array with incomplete */ + /* type, and the new definition has completed the type, update */ + /* the original type to match */ + if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY + && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY) + { + if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type)) + DCL_ELEM(csym->type) = DCL_ELEM(sym->type); + } + + #if 0 + /* If only one of the definitions used the "at" keyword, copy */ + /* the address to the other. */ + if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype) + && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype)) + { + SPEC_ABSA (sym->etype) = 1; + SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype); + } + if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype) + && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype)) + { + SPEC_ABSA (csym->etype) = 1; + SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype); + } + #endif error = 0; if (csym->ival && sym->ival) error = 1; - if (compareTypeExact (csym->type, sym->type, sym->level) != 1) + if (compareTypeExact (csym->type, sym->type, sym->level) != 1) error = 1; if (error) { /* one definition extern ? */ - if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) - werror (E_EXTERN_MISMATCH, sym->name); + if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) + werror (E_EXTERN_MISMATCH, sym->name); else - werror (E_DUPLICATE, sym->name); - werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF); - #if 0 - fprintf (stderr, "from type '"); - printTypeChain (csym->type, stderr); - if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype)) - fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype)); - fprintf (stderr, "'\nto type '"); - printTypeChain (sym->type, stderr); - if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype)) - fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype)); - fprintf (stderr, "'\n"); - #endif - continue; - } - - if (csym->ival && !sym->ival) - sym->ival = csym->ival; - - /* delete current entry */ - deleteSym (SymbolTab, csym, csym->name); - deleteFromSeg(csym); + werror (E_DUPLICATE, sym->name); + werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF); + #if 0 + fprintf (stderr, "from type '"); + printTypeChain (csym->type, stderr); + if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype)) + fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype)); + fprintf (stderr, "'\nto type '"); + printTypeChain (sym->type, stderr); + if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype)) + fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype)); + fprintf (stderr, "'\n"); + #endif + continue; + } + + if (csym->ival && !sym->ival) + sym->ival = csym->ival; + + /* delete current entry */ + deleteSym (SymbolTab, csym, csym->name); + deleteFromSeg(csym); } /* add new entry */ @@ -1078,7 +1103,7 @@ funcInChain (sym_link * lnk) while (lnk) { if (IS_FUNC (lnk)) - return 1; + return 1; lnk = lnk->next; } return 0; @@ -1099,19 +1124,19 @@ structElemType (sym_link * stype, value * id) /* look for the id */ while (fields) { - if (strcmp (fields->rname, id->name) == 0) - { - type = copyLinkChain (fields->type); - etype = getSpec (type); - SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ? - SPEC_SCLS (etype) : SPEC_SCLS (petype)); + if (strcmp (fields->rname, id->name) == 0) + { + type = copyLinkChain (fields->type); + etype = getSpec (type); + SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ? + SPEC_SCLS (etype) : SPEC_SCLS (petype)); if (IS_SPEC (type)) SPEC_CONST (type) |= SPEC_CONST (stype); else DCL_PTR_CONST (type) |= SPEC_CONST (stype); - return type; - } - fields = fields->next; + return type; + } + fields = fields->next; } } @@ -1152,90 +1177,90 @@ compStructSize (int su, structdef * sdef) loop = sdef->fields; while (loop) { - /* create the internal name for this variable */ - SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name); - if (su == UNION) { - sum = 0; - bitOffset = 0; - } - SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0); - - /* if this is a bit field */ - if (loop->bitVar) { - - /* change it to a unsigned bit */ - SPEC_NOUN (loop->etype) = V_BITFIELD; - SPEC_USIGN (loop->etype) = 1; - SPEC_BLEN (loop->etype) = loop->bitVar; - - if (loop->bitVar == BITVAR_PAD) { - /* A zero length bitfield forces padding */ - SPEC_BSTR (loop->etype) = bitOffset; - SPEC_BLEN (loop->etype) = 0; - bitOffset = 8; - loop->offset = sum; - } - else { - if (bitOffset == 8) { - bitOffset = 0; - sum++; - } - /* check if this fit into the remaining */ - /* bits of this byte else align it to the */ - /* next byte boundary */ - if (loop->bitVar <= (8 - bitOffset)) { - /* fits into current byte */ - loop->offset = sum; - SPEC_BSTR (loop->etype) = bitOffset; - bitOffset += loop->bitVar; - } - else if (!bitOffset) { - /* does not fit, but is already byte aligned */ - loop->offset = sum; - SPEC_BSTR (loop->etype) = bitOffset; - bitOffset += loop->bitVar; - } - else { - /* does not fit; need to realign first */ - sum++; - loop->offset = (su == UNION ? sum = 0 : sum); - bitOffset = 0; - SPEC_BSTR (loop->etype) = bitOffset; - bitOffset += loop->bitVar; - } - while (bitOffset>8) { - bitOffset -= 8; - sum++; - } - } - } - else { - /* This is a non-bit field. Make sure we are */ - /* byte aligned first */ - if (bitOffset) { - sum++; - loop->offset = (su == UNION ? sum = 0 : sum); - bitOffset = 0; - } - loop->offset = sum; - checkDecl (loop, 1); - sum += getSize (loop->type); - } - - loop = loop->next; - - /* if union then size = sizeof larget field */ - if (su == UNION) { - /* For UNION, round up after each field */ - sum += ((bitOffset+7)/8); - usum = max (usum, sum); - } + /* create the internal name for this variable */ + SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name); + if (su == UNION) { + sum = 0; + bitOffset = 0; + } + SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0); + + /* if this is a bit field */ + if (loop->bitVar) { + + /* change it to a unsigned bit */ + SPEC_NOUN (loop->etype) = V_BITFIELD; + SPEC_USIGN (loop->etype) = 1; + SPEC_BLEN (loop->etype) = loop->bitVar; + + if (loop->bitVar == BITVAR_PAD) { + /* A zero length bitfield forces padding */ + SPEC_BSTR (loop->etype) = bitOffset; + SPEC_BLEN (loop->etype) = 0; + bitOffset = 8; + loop->offset = sum; + } + else { + if (bitOffset == 8) { + bitOffset = 0; + sum++; + } + /* check if this fit into the remaining */ + /* bits of this byte else align it to the */ + /* next byte boundary */ + if (loop->bitVar <= (8 - bitOffset)) { + /* fits into current byte */ + loop->offset = sum; + SPEC_BSTR (loop->etype) = bitOffset; + bitOffset += loop->bitVar; + } + else if (!bitOffset) { + /* does not fit, but is already byte aligned */ + loop->offset = sum; + SPEC_BSTR (loop->etype) = bitOffset; + bitOffset += loop->bitVar; + } + else { + /* does not fit; need to realign first */ + sum++; + loop->offset = (su == UNION ? sum = 0 : sum); + bitOffset = 0; + SPEC_BSTR (loop->etype) = bitOffset; + bitOffset += loop->bitVar; + } + while (bitOffset>8) { + bitOffset -= 8; + sum++; + } + } + } + else { + /* This is a non-bit field. Make sure we are */ + /* byte aligned first */ + if (bitOffset) { + sum++; + loop->offset = (su == UNION ? sum = 0 : sum); + bitOffset = 0; + } + loop->offset = sum; + checkDecl (loop, 1); + sum += getSize (loop->type); + } + + loop = loop->next; + + /* if union then size = sizeof larget field */ + if (su == UNION) { + /* For UNION, round up after each field */ + sum += ((bitOffset+7)/8); + usum = max (usum, sum); + } } /* For STRUCT, round up after all fields processed */ if (su != UNION) - sum += ((bitOffset+7)/8); + sum += ((bitOffset+7)/8); return (su == UNION ? usum : sum); } @@ -1260,46 +1285,46 @@ promoteAnonStructs (int su, structdef * sdef) { nextfield = field->next; if (!*field->name && IS_STRUCT (field->type)) - { - /* Found an anonymous struct/union. Replace it */ - /* with the fields it contains and adjust all */ - /* the offsets */ - - base = field->offset; - subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields); - if (!subfield) - continue; /* just in case it's empty */ - - *tofield = subfield; - for (;;) - { - /* check for field name conflicts resulting from promotion */ - dupfield = sdef->fields; - while (dupfield && dupfield != subfield) - { - if (*subfield->name && !strcmp (dupfield->name, subfield->name)) - { - werrorfl (subfield->fileDef, subfield->lineDef, - E_DUPLICATE_MEMBER, - su==STRUCT ? "struct" : "union", - subfield->name); - werrorfl (dupfield->fileDef, dupfield->lineDef, - E_PREVIOUS_DEF); - } - dupfield = dupfield->next; - } - - subfield->offset += base; - if (subfield->next) - subfield = subfield->next; - else - break; - } - subfield->next = nextfield; - tofield = &subfield->next; - } + { + /* Found an anonymous struct/union. Replace it */ + /* with the fields it contains and adjust all */ + /* the offsets */ + + base = field->offset; + subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields); + if (!subfield) + continue; /* just in case it's empty */ + + *tofield = subfield; + for (;;) + { + /* check for field name conflicts resulting from promotion */ + dupfield = sdef->fields; + while (dupfield && dupfield != subfield) + { + if (*subfield->name && !strcmp (dupfield->name, subfield->name)) + { + werrorfl (subfield->fileDef, subfield->lineDef, + E_DUPLICATE_MEMBER, + su==STRUCT ? "struct" : "union", + subfield->name); + werrorfl (dupfield->fileDef, dupfield->lineDef, + E_PREVIOUS_DEF); + } + dupfield = dupfield->next; + } + + subfield->offset += base; + if (subfield->next) + subfield = subfield->next; + else + break; + } + subfield->next = nextfield; + tofield = &subfield->next; + } else - tofield = &field->next; + tofield = &field->next; field = nextfield; } } @@ -1405,15 +1430,15 @@ checkSClass (symbol * sym, int isProto) /* if this is an automatic symbol */ if (sym->level && (options.stackAuto || reentrant)) { if ((SPEC_SCLS (sym->etype) == S_AUTO || - SPEC_SCLS (sym->etype) == S_FIXED || - SPEC_SCLS (sym->etype) == S_REGISTER || - SPEC_SCLS (sym->etype) == S_STACK || - SPEC_SCLS (sym->etype) == S_XSTACK)) { + SPEC_SCLS (sym->etype) == S_FIXED || + SPEC_SCLS (sym->etype) == S_REGISTER || + SPEC_SCLS (sym->etype) == S_STACK || + SPEC_SCLS (sym->etype) == S_XSTACK)) { SPEC_SCLS (sym->etype) = S_AUTO; } else { /* storage class may only be specified for statics */ if (!IS_STATIC(sym->etype)) { - werror (E_AUTO_ASSUMED, sym->name); + werror (E_AUTO_ASSUMED, sym->name); } } } @@ -1449,11 +1474,11 @@ checkSClass (symbol * sym, int isProto) /* variables declared in CODE space must have */ /* initializers if not an extern */ if (SPEC_SCLS (sym->etype) == S_CODE && - sym->ival == NULL && - //!sym->level && - port->mem.code_ro && - !IS_EXTERN (sym->etype) && - !funcInChain (sym->type)) + sym->ival == NULL && + //!sym->level && + port->mem.code_ro && + !IS_EXTERN (sym->etype) && + !funcInChain (sym->type)) werror (E_CODE_NO_INIT, sym->name); } @@ -1463,21 +1488,21 @@ checkSClass (symbol * sym, int isProto) !IS_STATIC(sym->etype)) { if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type))) - { - SPEC_SCLS (sym->etype) = (options.useXstack ? - S_XSTACK : S_STACK); - } + { + SPEC_SCLS (sym->etype) = (options.useXstack ? + S_XSTACK : S_STACK); + } else - { - /* hack-o-matic! I see no reason why the useXstack option should ever - * control this allcoation, but the code was originally that way, and - * changing it for non-390 ports breaks the compiler badly. - */ - bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ? - 1 : options.useXstack; - SPEC_SCLS (sym->etype) = (useXdata ? - S_XDATA : S_FIXED); - } + { + /* hack-o-matic! I see no reason why the useXstack option should ever + * control this allcoation, but the code was originally that way, and + * changing it for non-390 ports breaks the compiler badly. + */ + bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ? + 1 : options.useXstack; + SPEC_SCLS (sym->etype) = (useXdata ? + S_XDATA : S_FIXED); + } } } @@ -1496,9 +1521,9 @@ changePointer (symbol * sym) for (p = sym->type; p; p = p->next) { if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER) - DCL_TYPE (p) = port->unqualified_pointer; + DCL_TYPE (p) = port->unqualified_pointer; if (IS_PTR (p) && IS_FUNC (p->next)) - DCL_TYPE (p) = CPOINTER; + DCL_TYPE (p) = CPOINTER; } } @@ -1509,8 +1534,8 @@ int checkDecl (symbol * sym, int isProto) { - checkSClass (sym, isProto); /* check the storage class */ - changePointer (sym); /* change pointers if required */ + checkSClass (sym, isProto); /* check the storage class */ + changePointer (sym); /* change pointers if required */ /* if this is an array without any dimension then update the dimension from the initial value */ @@ -1532,7 +1557,7 @@ copyLinkChain (sym_link * p) head = loop = (curr ? newLink (p->class) : (void *) NULL); while (curr) { - memcpy (loop, curr, sizeof (sym_link)); /* copy it */ + memcpy (loop, curr, sizeof (sym_link)); /* copy it */ loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL); loop = loop->next; curr = curr->next; @@ -1556,12 +1581,12 @@ cleanUpBlock (bucket ** table, int block) for (i = 0; i < 256; i++) { for (chain = table[i]; chain; chain = chain->next) - { - if (chain->block >= block) - { - deleteSym (table, chain->sym, chain->name); - } - } + { + if (chain->block >= block) + { + deleteSym (table, chain->sym, chain->name); + } + } } } @@ -1579,12 +1604,12 @@ cleanUpLevel (bucket ** table, int level) for (i = 0; i < 256; i++) { for (chain = table[i]; chain; chain = chain->next) - { - if (chain->level >= level) - { - deleteSym (table, chain->sym, chain->name); - } - } + { + if (chain->level >= level) + { + deleteSym (table, chain->sym, chain->name); + } + } } } @@ -1607,51 +1632,51 @@ computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType) if (SPEC_USIGN (etype1)) { if ( IS_LITERAL (etype2) - && floatFromVal (valFromType (etype2)) >= 0) - SPEC_USIGN (reType) = 1; + && floatFromVal (valFromType (etype2)) >= 0) + SPEC_USIGN (reType) = 1; else - { - /* promote to int */ - SPEC_USIGN (reType) = 0; - SPEC_NOUN (reType) = V_INT; - } + { + /* promote to int */ + SPEC_USIGN (reType) = 0; + SPEC_NOUN (reType) = V_INT; + } } else /* etype1 signed */ { if ( IS_LITERAL (etype2) - && floatFromVal (valFromType (etype2)) <= 127) - SPEC_USIGN (reType) = 0; + && floatFromVal (valFromType (etype2)) <= 127) + SPEC_USIGN (reType) = 0; else - { - /* promote to int */ - SPEC_USIGN (reType) = 0; - SPEC_NOUN (reType) = V_INT; - } + { + /* promote to int */ + SPEC_USIGN (reType) = 0; + SPEC_NOUN (reType) = V_INT; + } } if (SPEC_USIGN (etype2)) { if ( IS_LITERAL (etype1) - && floatFromVal (valFromType (etype1)) >= 0) - SPEC_USIGN (reType) = 1; + && floatFromVal (valFromType (etype1)) >= 0) + SPEC_USIGN (reType) = 1; else - { - /* promote to int */ - SPEC_USIGN (reType) = 0; - SPEC_NOUN (reType) = V_INT; - } + { + /* promote to int */ + SPEC_USIGN (reType) = 0; + SPEC_NOUN (reType) = V_INT; + } } else /* etype2 signed */ { if ( IS_LITERAL (etype1) - && floatFromVal (valFromType (etype1)) <= 127) - SPEC_USIGN (reType) = 0; + && floatFromVal (valFromType (etype1)) <= 127) + SPEC_USIGN (reType) = 0; else - { - /* promote to int */ - SPEC_USIGN (reType) = 0; - SPEC_NOUN (reType) = V_INT; - } + { + /* promote to int */ + SPEC_USIGN (reType) = 0; + SPEC_NOUN (reType) = V_INT; + } } return reType; } @@ -1681,7 +1706,7 @@ computeType (sym_link * type1, sym_link * type2, if (IS_BITVAR (etype1) && IS_BITVAR (etype2)) { rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ? - copyLinkChain (type1) : copyLinkChain (type1); + copyLinkChain (type1) : copyLinkChain (type1); } /* if only one of them is a bit variable then the other one prevails */ @@ -1723,62 +1748,62 @@ computeType (sym_link * type1, sym_link * type2, switch (resultType) { case RESULT_TYPE_CHAR: - if (IS_BITVAR (reType)) - { - SPEC_NOUN (reType) = V_CHAR; - SPEC_SCLS (reType) = 0; - SPEC_USIGN (reType) = 0; - return rType; - } - break; + if (IS_BITVAR (reType)) + { + SPEC_NOUN (reType) = V_CHAR; + SPEC_SCLS (reType) = 0; + SPEC_USIGN (reType) = 0; + return rType; + } + break; case RESULT_TYPE_INT: case RESULT_TYPE_NONE: case RESULT_TYPE_OTHER: - if (IS_BIT (reType)) - { - SPEC_NOUN (reType) = V_CHAR; - SPEC_SCLS (reType) = 0; - SPEC_USIGN (reType) = 0; - return rType; - } - else if (IS_BITFIELD (reType)) - { - /* could be smarter, but it depends on the op */ - /* this is for the worst case: a multiplication of 4 * 4 bit */ - SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT; - SPEC_SCLS (reType) = 0; - SPEC_USIGN (reType) = 0; - return rType; - } - else if (IS_CHAR (reType)) - { - if (op == '|' || op == '^') - return computeTypeOr (etype1, etype2, reType); - else if ( op == '&' - && SPEC_USIGN (etype1) != SPEC_USIGN (etype2)) - { - SPEC_USIGN (reType) = 1; - return rType; - } - else if (op == '*') - { - SPEC_NOUN (reType) = V_INT; - SPEC_USIGN (reType) = 0; - return rType; - } - /* TODO: should be in SDCCast.c */ - else if ( op == '/' - && ( !SPEC_USIGN (etype1) - || !SPEC_USIGN (etype2))) - { - SPEC_NOUN (reType) = V_INT; - SPEC_USIGN (reType) = 0; - return rType; - } - } - break; + if (IS_BIT (reType)) + { + SPEC_NOUN (reType) = V_CHAR; + SPEC_SCLS (reType) = 0; + SPEC_USIGN (reType) = 0; + return rType; + } + else if (IS_BITFIELD (reType)) + { + /* could be smarter, but it depends on the op */ + /* this is for the worst case: a multiplication of 4 * 4 bit */ + SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT; + SPEC_SCLS (reType) = 0; + SPEC_USIGN (reType) = 0; + return rType; + } + else if (IS_CHAR (reType)) + { + if (op == '|' || op == '^') + return computeTypeOr (etype1, etype2, reType); + else if ( op == '&' + && SPEC_USIGN (etype1) != SPEC_USIGN (etype2)) + { + SPEC_USIGN (reType) = 1; + return rType; + } + else if (op == '*') + { + SPEC_NOUN (reType) = V_INT; + SPEC_USIGN (reType) = 0; + return rType; + } + /* TODO: should be in SDCCast.c */ + else if ( op == '/' + && ( !SPEC_USIGN (etype1) + || !SPEC_USIGN (etype2))) + { + SPEC_NOUN (reType) = V_INT; + SPEC_USIGN (reType) = 0; + return rType; + } + } + break; default: - break; + break; } /* SDCC's sign promotion: @@ -1803,37 +1828,37 @@ computeType (sym_link * type1, sym_link * type2, This seems to be contradictionary to the first two rules, but it makes real sense (all types are char's): - A signed char can be negative; this must be preserved in the result - -1 * 100 = -100; + A signed char can be negative; this must be preserved in the result + -1 * 100 = -100; - Only if both operands are unsigned it's safe to make the result - unsigned; this helps to avoid overflow: - 2 * 100 = 200; + Only if both operands are unsigned it's safe to make the result + unsigned; this helps to avoid overflow: + 2 * 100 = 200; - ToDo: document '|', '^' and '&' Homework: - why is (200 * 200 < 0) true? - - why is { char l = 200, r = 200; (r * l > 0) } true? + - why is { char l = 200, r = 200; (r * l > 0) } true? */ if (!IS_FLOAT (reType) && ( (SPEC_USIGN (etype1) /* if this operand is promoted to a larger type, - then it will be promoted to a signed type */ - && !(getSize (etype1) < getSize (reType)) + then it will be promoted to a signed type */ + && !(getSize (etype1) < getSize (reType)) /* char require special handling */ - && !IS_CHAR (etype1)) - || /* same for 2nd operand */ - (SPEC_USIGN (etype2) - && !(getSize (etype2) < getSize (reType)) - && !IS_CHAR (etype2)) - || /* if both are 'unsigned char' and not promoted - let the result be unsigned too */ - ( SPEC_USIGN (etype1) - && SPEC_USIGN (etype2) - && IS_CHAR (etype1) - && IS_CHAR (etype2) - && IS_CHAR (reType)))) + && !IS_CHAR (etype1)) + || /* same for 2nd operand */ + (SPEC_USIGN (etype2) + && !(getSize (etype2) < getSize (reType)) + && !IS_CHAR (etype2)) + || /* if both are 'unsigned char' and not promoted + let the result be unsigned too */ + ( SPEC_USIGN (etype1) + && SPEC_USIGN (etype2) + && IS_CHAR (etype1) + && IS_CHAR (etype2) + && IS_CHAR (reType)))) SPEC_USIGN (reType) = 1; else SPEC_USIGN (reType) = 0; @@ -1860,33 +1885,33 @@ compareType (sym_link * dest, sym_link * src) if (IS_DECL (dest)) { if (IS_DECL (src)) - { - if (DCL_TYPE (src) == DCL_TYPE (dest)) { - if (IS_FUNC(src)) { - //checkFunction(src,dest); - } - return compareType (dest->next, src->next); - } - if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) { - return 1; - } - if (IS_PTR (src) && IS_GENPTR (dest)) - return -1; - if (IS_PTR (dest) && IS_ARRAY (src)) { - value *val=aggregateToPointer (valFromType(src)); - int res=compareType (dest, val->type); - Safe_free(val->type); - Safe_free(val); - return res; - } - if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src)) - return compareType (dest->next, src); - return 0; - } + { + if (DCL_TYPE (src) == DCL_TYPE (dest)) { + if (IS_FUNC(src)) { + //checkFunction(src,dest); + } + return compareType (dest->next, src->next); + } + if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) { + return 1; + } + if (IS_PTR (src) && IS_GENPTR (dest)) + return -1; + if (IS_PTR (dest) && IS_ARRAY (src)) { + value *val=aggregateToPointer (valFromType(src)); + int res=compareType (dest, val->type); + Safe_free(val->type); + Safe_free(val); + return res; + } + if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src)) + return compareType (dest->next, src); + return 0; + } else if (IS_PTR (dest) && IS_INTEGRAL (src)) - return -1; + return -1; else - return 0; + return 0; } /* if one is a specifier and the other is not */ @@ -1914,25 +1939,25 @@ compareType (sym_link * dest, sym_link * src) if (SPEC_NOUN (dest) != SPEC_NOUN (src)) { if (SPEC_USIGN (dest) == SPEC_USIGN (src) && - IS_INTEGRAL (dest) && IS_INTEGRAL (src) && - /* I would prefer - bitsForType (dest) == bitsForType (src)) - instead of the next two lines, but the regression tests fail with - them; I guess it's a problem with replaceCheaperOp */ - getSize (dest) == getSize (src) && - !(!IS_BIT (dest) && IS_BIT (src))) - return 1; + IS_INTEGRAL (dest) && IS_INTEGRAL (src) && + /* I would prefer + bitsForType (dest) == bitsForType (src)) + instead of the next two lines, but the regression tests fail with + them; I guess it's a problem with replaceCheaperOp */ + getSize (dest) == getSize (src) && + !(!IS_BIT (dest) && IS_BIT (src))) + return 1; else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src)) - return -1; + return -1; else - return 0; + return 0; } else if (IS_STRUCT (dest)) { if (SPEC_STRUCT (dest) != SPEC_STRUCT (src)) - return 0; + return 0; else - return 1; + return 1; } if (SPEC_LONG (dest) != SPEC_LONG (src)) return -1; @@ -1964,65 +1989,65 @@ compareTypeExact (sym_link * dest, sym_link * src, int level) if (IS_DECL (dest)) { if (IS_DECL (src)) - { - if (DCL_TYPE (src) == DCL_TYPE (dest)) { - if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest))) - return 0; - if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest)) - return 0; - if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest)) - return 0; - if (IS_FUNC(src)) + { + if (DCL_TYPE (src) == DCL_TYPE (dest)) { + if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest))) + return 0; + if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest)) + return 0; + if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest)) + return 0; + if (IS_FUNC(src)) { - value *exargs, *acargs, *checkValue; + value *exargs, *acargs, *checkValue; /* verify function return type */ - if (!compareTypeExact (dest->next, src->next, -1)) - return 0; - if (FUNC_ISISR (dest) != FUNC_ISISR (src)) - return 0; - if (FUNC_REGBANK (dest) != FUNC_REGBANK (src)) - return 0; - if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src)) - return 0; - #if 0 + if (!compareTypeExact (dest->next, src->next, -1)) + return 0; + if (FUNC_ISISR (dest) != FUNC_ISISR (src)) + return 0; + if (FUNC_REGBANK (dest) != FUNC_REGBANK (src)) + return 0; + if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src)) + return 0; + #if 0 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1) - return 0; + return 0; #endif - /* compare expected args with actual args */ - exargs = FUNC_ARGS(dest); - acargs = FUNC_ARGS(src); + /* compare expected args with actual args */ + exargs = FUNC_ARGS(dest); + acargs = FUNC_ARGS(src); - /* for all the expected args do */ - for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next) - { - //checkTypeSanity(acargs->etype, acargs->name); + /* for all the expected args do */ + for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next) + { + //checkTypeSanity(acargs->etype, acargs->name); - if (IS_AGGREGATE (acargs->type)) - { - checkValue = copyValue (acargs); - aggregateToPointer (checkValue); - } - else - checkValue = acargs; + if (IS_AGGREGATE (acargs->type)) + { + checkValue = copyValue (acargs); + aggregateToPointer (checkValue); + } + else + checkValue = acargs; #if 0 - if (!compareTypeExact (exargs->type, checkValue->type, -1)) + if (!compareTypeExact (exargs->type, checkValue->type, -1)) return 0; #endif - } + } - /* if one them ended we have a problem */ - if ((exargs && !acargs && !IS_VOID (exargs->type)) || - (!exargs && acargs && !IS_VOID (acargs->type))) - return 0; + /* if one them ended we have a problem */ + if ((exargs && !acargs && !IS_VOID (exargs->type)) || + (!exargs && acargs && !IS_VOID (acargs->type))) + return 0; return 1; } - return compareTypeExact (dest->next, src->next, level); - } + return compareTypeExact (dest->next, src->next, level); + } return 0; - } + } return 0; } @@ -2046,18 +2071,18 @@ compareTypeExact (sym_link * dest, sym_link * src, int level) { /* signedness must match */ if (SPEC_USIGN (dest) != SPEC_USIGN (src)) - return 0; + return 0; /* size must match */ if (SPEC_LONG (dest) != SPEC_LONG (src)) - return 0; + return 0; if (SPEC_SHORT (dest) != SPEC_SHORT (src)) - return 0; + return 0; } if (IS_STRUCT (dest)) { if (SPEC_STRUCT (dest) != SPEC_STRUCT (src)) - return 0; + return 0; } if (SPEC_CONST (dest) != SPEC_CONST (src)) @@ -2078,9 +2103,9 @@ compareTypeExact (sym_link * dest, sym_link * src, int level) if (!level & port->mem.code_ro && SPEC_CONST (dest)) { if (srcScls == S_CODE && destScls == S_FIXED) - destScls = S_CODE; + destScls = S_CODE; if (destScls == S_CODE && srcScls == S_FIXED) - srcScls = S_CODE; + srcScls = S_CODE; } /* compensate for allocGlobal() */ @@ -2093,19 +2118,19 @@ compareTypeExact (sym_link * dest, sym_link * src, int level) { /* Compensate for hack-o-matic in checkSClass() */ if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type))) - { - if (destScls == S_FIXED) - destScls = (options.useXstack ? S_XSTACK : S_STACK); - if (srcScls == S_FIXED) - srcScls = (options.useXstack ? S_XSTACK : S_STACK); - } + { + if (destScls == S_FIXED) + destScls = (options.useXstack ? S_XSTACK : S_STACK); + if (srcScls == S_FIXED) + srcScls = (options.useXstack ? S_XSTACK : S_STACK); + } else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack) - { - if (destScls == S_FIXED) - destScls = S_XDATA; - if (srcScls == S_FIXED) - srcScls = S_XDATA; - } + { + if (destScls == S_FIXED) + destScls = S_XDATA; + if (srcScls == S_FIXED) + srcScls = S_XDATA; + } } if (srcScls != destScls) @@ -2113,7 +2138,7 @@ compareTypeExact (sym_link * dest, sym_link * src, int level) #if 0 printf ("level = %d\n", level); printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n", - SPEC_SCLS (src), SPEC_SCLS (dest)); + SPEC_SCLS (src), SPEC_SCLS (dest)); printf ("srcScls = %d, destScls = %d\n",srcScls, destScls); #endif return 0; @@ -2151,58 +2176,58 @@ aggregateToPointer (value * val) /* if this is a structure */ /* then we need to add a new link */ if (IS_STRUCT (val->type)) - { - /* first lets add DECLARATOR type */ - sym_link *p = val->type; + { + /* first lets add DECLARATOR type */ + sym_link *p = val->type; - werror (W_STRUCT_AS_ARG, val->name); - val->type = newLink (DECLARATOR); - val->type->next = p; - } + werror (W_STRUCT_AS_ARG, val->name); + val->type = newLink (DECLARATOR); + val->type->next = p; + } /* change to a pointer depending on the */ /* storage class specified */ switch (SPEC_SCLS (val->etype)) - { - case S_IDATA: - DCL_TYPE (val->type) = IPOINTER; - break; - case S_PDATA: - DCL_TYPE (val->type) = PPOINTER; - break; - case S_FIXED: - if (SPEC_OCLS(val->etype)) { - DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype)); - } else { - // this happens for (external) function parameters - DCL_TYPE (val->type) = port->unqualified_pointer; - } - break; - case S_AUTO: - case S_DATA: - case S_REGISTER: - DCL_TYPE (val->type) = POINTER; - break; - case S_CODE: - DCL_TYPE (val->type) = CPOINTER; - break; - case S_XDATA: - DCL_TYPE (val->type) = FPOINTER; - break; - case S_EEPROM: - DCL_TYPE (val->type) = EEPPOINTER; - break; - default: - DCL_TYPE (val->type) = port->unqualified_pointer; - } + { + case S_IDATA: + DCL_TYPE (val->type) = IPOINTER; + break; + case S_PDATA: + DCL_TYPE (val->type) = PPOINTER; + break; + case S_FIXED: + if (SPEC_OCLS(val->etype)) { + DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype)); + } else { + // this happens for (external) function parameters + DCL_TYPE (val->type) = port->unqualified_pointer; + } + break; + case S_AUTO: + case S_DATA: + case S_REGISTER: + DCL_TYPE (val->type) = POINTER; + break; + case S_CODE: + DCL_TYPE (val->type) = CPOINTER; + break; + case S_XDATA: + DCL_TYPE (val->type) = FPOINTER; + break; + case S_EEPROM: + DCL_TYPE (val->type) = EEPPOINTER; + break; + default: + DCL_TYPE (val->type) = port->unqualified_pointer; + } /* is there is a symbol associated then */ /* change the type of the symbol as well */ if (val->sym) - { - val->sym->type = copyLinkChain (val->type); - val->sym->etype = getSpec (val->sym->type); - } + { + val->sym->type = copyLinkChain (val->type); + val->sym->etype = getSpec (val->sym->type); + } } return val; } @@ -2260,8 +2285,8 @@ checkFunction (symbol * sym, symbol *csym) if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type)) { if (!IS_VOID(FUNC_ARGS(sym->type)->type)) { - werror (E_INT_ARGS, sym->name); - FUNC_ARGS(sym->type)=NULL; + werror (E_INT_ARGS, sym->name); + FUNC_ARGS(sym->type)=NULL; } } @@ -2287,7 +2312,7 @@ checkFunction (symbol * sym, symbol *csym) argCnt--; if (!csym && !(csym = findSym (SymbolTab, sym, sym->name))) - return 1; /* not defined nothing more to check */ + return 1; /* not defined nothing more to check */ /* check if body already present */ if (csym && IFFUNC_HASBODY(csym->type)) @@ -2340,7 +2365,7 @@ checkFunction (symbol * sym, symbol *csym) exargs = exargs->next, acargs = acargs->next, argCnt++) { if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "checkFunction: %s ", exargs->name); + fprintf (stderr, "checkFunction: %s ", exargs->name); } /* make sure the type is complete and sane */ checkTypeSanity(exargs->etype, exargs->name); @@ -2350,21 +2375,21 @@ checkFunction (symbol * sym, symbol *csym) * change here. */ if (IS_AGGREGATE (acargs->type)) - { - checkValue = copyValue (acargs); - aggregateToPointer (checkValue); - } + { + checkValue = copyValue (acargs); + aggregateToPointer (checkValue); + } else - { - checkValue = acargs; - } + { + checkValue = acargs; + } if (compareType (exargs->type, checkValue->type) <= 0) - { - werror (E_ARG_TYPE, argCnt); - printFromToType(exargs->type, checkValue->type); - return 0; - } + { + werror (E_ARG_TYPE, argCnt); + printFromToType(exargs->type, checkValue->type); + return 0; + } } /* if one them ended we have a problem */ @@ -2398,13 +2423,13 @@ void cdbStructBlock (int block) for (i = 0; i < 256; i++) { for (chain = table[i]; chain; chain = chain->next) - { - if (chain->block >= block) - { - if(debugFile) - debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL); - } - } + { + if (chain->block >= block) + { + if(debugFile) + debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL); + } + } } } @@ -2450,23 +2475,23 @@ processFuncArgs (symbol * func) /* change it to pointer to the same type */ while (val) { - int argreg = 0; + int argreg = 0; /* mark it as a register parameter if the function does not have VA_ARG and as port dictates */ if (!IFFUNC_HASVARARGS(funcType) && - (argreg = (*port->reg_parm) (val->type))) - { - SPEC_REGPARM (val->etype) = 1; - SPEC_ARGREG(val->etype) = argreg; - } else if (IFFUNC_ISREENT(funcType)) { - FUNC_HASSTACKPARM(funcType) = 1; - } + (argreg = (*port->reg_parm) (val->type))) + { + SPEC_REGPARM (val->etype) = 1; + SPEC_ARGREG(val->etype) = argreg; + } else if (IFFUNC_ISREENT(funcType)) { + FUNC_HASSTACKPARM(funcType) = 1; + } if (IS_AGGREGATE (val->type)) - { - aggregateToPointer (val); - } + { + aggregateToPointer (val); + } val = val->next; pNum++; @@ -2494,45 +2519,45 @@ processFuncArgs (symbol * func) /* if a symbolname is not given */ /* synthesize a variable name */ if (!val->sym) - { - SNPRINTF (val->name, sizeof(val->name), - "_%s_PARM_%d", func->name, pNum++); - val->sym = newSymbol (val->name, 1); - SPEC_OCLS (val->etype) = port->mem.default_local_map; - val->sym->type = copyLinkChain (val->type); - val->sym->etype = getSpec (val->sym->type); - val->sym->_isparm = 1; - strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); - #if 0 - /* ?? static functions shouldn't imply static parameters - EEP */ - if (IS_SPEC(func->etype)) { - SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = - SPEC_STAT (func->etype); - } - #endif - addSymChain (val->sym); - - } - else /* symbol name given create synth name */ - { - - SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++); - strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); - val->sym->_isparm = 1; - SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = - (options.model != MODEL_SMALL ? xdata : data); - - #if 0 - /* ?? static functions shouldn't imply static parameters - EEP */ - if (IS_SPEC(func->etype)) { - SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = - SPEC_STAT (func->etype); - } - #endif - } + { + SNPRINTF (val->name, sizeof(val->name), + "_%s_PARM_%d", func->name, pNum++); + val->sym = newSymbol (val->name, 1); + SPEC_OCLS (val->etype) = port->mem.default_local_map; + val->sym->type = copyLinkChain (val->type); + val->sym->etype = getSpec (val->sym->type); + val->sym->_isparm = 1; + strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); + #if 0 + /* ?? static functions shouldn't imply static parameters - EEP */ + if (IS_SPEC(func->etype)) { + SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = + SPEC_STAT (func->etype); + } + #endif + addSymChain (val->sym); + + } + else /* symbol name given create synth name */ + { + + SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++); + strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); + val->sym->_isparm = 1; + SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = + (options.model != MODEL_SMALL ? xdata : data); + + #if 0 + /* ?? static functions shouldn't imply static parameters - EEP */ + if (IS_SPEC(func->etype)) { + SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = + SPEC_STAT (func->etype); + } + #endif + } if (!isinSet(operKeyReset, val->sym)) { - addSet (&operKeyReset, val->sym); - applyToSet (operKeyReset, resetParmKey); + addSet (&operKeyReset, val->sym); + applyToSet (operKeyReset, resetParmKey); } val = val->next; } @@ -2562,7 +2587,7 @@ isSymbolEqual (symbol * dest, symbol * src) void PT(sym_link *type) { - printTypeChain(type,0); + printTypeChain(type,0); } /*-----------------------------------------------------------------*/ /* printTypeChain - prints the type chain in human readable form */ @@ -2600,142 +2625,142 @@ printTypeChain (sym_link * start, FILE * of) while (type) { if (type==start) { - switch (scls) - { - case S_DATA: fprintf (of, "data-"); break; - case S_XDATA: fprintf (of, "xdata-"); break; - case S_SFR: fprintf (of, "sfr-"); break; - case S_SBIT: fprintf (of, "sbit-"); break; - case S_CODE: fprintf (of, "code-"); break; - case S_IDATA: fprintf (of, "idata-"); break; - case S_PDATA: fprintf (of, "pdata-"); break; - case S_LITERAL: fprintf (of, "literal-"); break; - case S_STACK: fprintf (of, "stack-"); break; - case S_XSTACK: fprintf (of, "xstack-"); break; - case S_BIT: fprintf (of, "bit-"); break; - case S_EEPROM: fprintf (of, "eeprom-"); break; - default: break; - } + switch (scls) + { + case S_DATA: fprintf (of, "data-"); break; + case S_XDATA: fprintf (of, "xdata-"); break; + case S_SFR: fprintf (of, "sfr-"); break; + case S_SBIT: fprintf (of, "sbit-"); break; + case S_CODE: fprintf (of, "code-"); break; + case S_IDATA: fprintf (of, "idata-"); break; + case S_PDATA: fprintf (of, "pdata-"); break; + case S_LITERAL: fprintf (of, "literal-"); break; + case S_STACK: fprintf (of, "stack-"); break; + case S_XSTACK: fprintf (of, "xstack-"); break; + case S_BIT: fprintf (of, "bit-"); break; + case S_EEPROM: fprintf (of, "eeprom-"); break; + default: break; + } } if (IS_DECL (type)) - { - if (!IS_FUNC(type)) { - if (DCL_PTR_VOLATILE (type)) { - fprintf (of, "volatile-"); - } - if (DCL_PTR_CONST (type)) { - fprintf (of, "const-"); - } - } - switch (DCL_TYPE (type)) - { - case FUNCTION: - fprintf (of, "function %s %s", - (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "), - (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " ")); - fprintf (of, "( "); - for (args = FUNC_ARGS(type); - args; - args=args->next) { - printTypeChain(args->type, of); - if (args->next) - fprintf(of, ", "); - } - fprintf (of, ") "); - break; - case GPOINTER: - fprintf (of, "generic* "); - break; - case CPOINTER: - fprintf (of, "code* "); - break; - case FPOINTER: - fprintf (of, "xdata* "); - break; - case EEPPOINTER: - fprintf (of, "eeprom* "); - break; - case POINTER: - fprintf (of, "near* "); - break; - case IPOINTER: - fprintf (of, "idata* "); - break; - case PPOINTER: - fprintf (of, "pdata* "); - break; - case UPOINTER: - fprintf (of, "unknown* "); - break; - case ARRAY: - if (DCL_ELEM(type)) { - fprintf (of, "[%d] ", DCL_ELEM(type)); - } else { - fprintf (of, "[] "); - } - break; - } - } + { + if (!IS_FUNC(type)) { + if (DCL_PTR_VOLATILE (type)) { + fprintf (of, "volatile-"); + } + if (DCL_PTR_CONST (type)) { + fprintf (of, "const-"); + } + } + switch (DCL_TYPE (type)) + { + case FUNCTION: + fprintf (of, "function %s %s", + (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "), + (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " ")); + fprintf (of, "( "); + for (args = FUNC_ARGS(type); + args; + args=args->next) { + printTypeChain(args->type, of); + if (args->next) + fprintf(of, ", "); + } + fprintf (of, ") "); + break; + case GPOINTER: + fprintf (of, "generic* "); + break; + case CPOINTER: + fprintf (of, "code* "); + break; + case FPOINTER: + fprintf (of, "xdata* "); + break; + case EEPPOINTER: + fprintf (of, "eeprom* "); + break; + case POINTER: + fprintf (of, "near* "); + break; + case IPOINTER: + fprintf (of, "idata* "); + break; + case PPOINTER: + fprintf (of, "pdata* "); + break; + case UPOINTER: + fprintf (of, "unknown* "); + break; + case ARRAY: + if (DCL_ELEM(type)) { + fprintf (of, "[%d] ", DCL_ELEM(type)); + } else { + fprintf (of, "[] "); + } + break; + } + } else - { - if (SPEC_VOLATILE (type)) - fprintf (of, "volatile-"); - if (SPEC_CONST (type)) - fprintf (of, "const-"); - if (SPEC_USIGN (type)) - fprintf (of, "unsigned-"); - switch (SPEC_NOUN (type)) - { - case V_INT: - if (IS_LONG (type)) - fprintf (of, "long-"); - fprintf (of, "int"); - break; - - case V_CHAR: - fprintf (of, "char"); - break; - - case V_VOID: - fprintf (of, "void"); - break; - - case V_FLOAT: - fprintf (of, "float"); - break; - - case V_STRUCT: - fprintf (of, "struct %s", SPEC_STRUCT (type)->tag); - break; - - case V_SBIT: - fprintf (of, "sbit"); - break; - - case V_BIT: - fprintf (of, "bit"); - break; - - case V_BITFIELD: - fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type)); - break; - - case V_DOUBLE: - fprintf (of, "double"); - break; - - default: - fprintf (of, "unknown type"); - break; - } - } + { + if (SPEC_VOLATILE (type)) + fprintf (of, "volatile-"); + if (SPEC_CONST (type)) + fprintf (of, "const-"); + if (SPEC_USIGN (type)) + fprintf (of, "unsigned-"); + switch (SPEC_NOUN (type)) + { + case V_INT: + if (IS_LONG (type)) + fprintf (of, "long-"); + fprintf (of, "int"); + break; + + case V_CHAR: + fprintf (of, "char"); + break; + + case V_VOID: + fprintf (of, "void"); + break; + + case V_FLOAT: + fprintf (of, "float"); + break; + + case V_STRUCT: + fprintf (of, "struct %s", SPEC_STRUCT (type)->tag); + break; + + case V_SBIT: + fprintf (of, "sbit"); + break; + + case V_BIT: + fprintf (of, "bit"); + break; + + case V_BITFIELD: + fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type)); + break; + + case V_DOUBLE: + fprintf (of, "double"); + break; + + default: + fprintf (of, "unknown type"); + break; + } + } /* search entry in list before "type" */ for (search = start; search && search->next != type;) - search = search->next; + search = search->next; type = search; if (type) - fputc (' ', of); + fputc (' ', of); } if (nlr) fprintf (of, "\n"); @@ -2768,144 +2793,144 @@ printTypeChainRaw (sym_link * start, FILE * of) while (type) { if (IS_DECL (type)) - { - if (!IS_FUNC(type)) { - if (DCL_PTR_VOLATILE (type)) { - fprintf (of, "volatile-"); - } - if (DCL_PTR_CONST (type)) { - fprintf (of, "const-"); - } - } - switch (DCL_TYPE (type)) - { - case FUNCTION: - fprintf (of, "function %s %s", - (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "), - (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " ")); - fprintf (of, "( "); - for (args = FUNC_ARGS(type); - args; - args=args->next) { - printTypeChain(args->type, of); - if (args->next) - fprintf(of, ", "); - } - fprintf (of, ") "); - break; - case GPOINTER: - fprintf (of, "generic* "); - break; - case CPOINTER: - fprintf (of, "code* "); - break; - case FPOINTER: - fprintf (of, "xdata* "); - break; - case EEPPOINTER: - fprintf (of, "eeprom* "); - break; - case POINTER: - fprintf (of, "near* "); - break; - case IPOINTER: - fprintf (of, "idata* "); - break; - case PPOINTER: - fprintf (of, "pdata* "); - break; - case UPOINTER: - fprintf (of, "unknown* "); - break; - case ARRAY: - if (DCL_ELEM(type)) { - fprintf (of, "[%d] ", DCL_ELEM(type)); - } else { - fprintf (of, "[] "); - } - break; - } + { + if (!IS_FUNC(type)) { + if (DCL_PTR_VOLATILE (type)) { + fprintf (of, "volatile-"); + } + if (DCL_PTR_CONST (type)) { + fprintf (of, "const-"); + } + } + switch (DCL_TYPE (type)) + { + case FUNCTION: + fprintf (of, "function %s %s", + (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "), + (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " ")); + fprintf (of, "( "); + for (args = FUNC_ARGS(type); + args; + args=args->next) { + printTypeChain(args->type, of); + if (args->next) + fprintf(of, ", "); + } + fprintf (of, ") "); + break; + case GPOINTER: + fprintf (of, "generic* "); + break; + case CPOINTER: + fprintf (of, "code* "); + break; + case FPOINTER: + fprintf (of, "xdata* "); + break; + case EEPPOINTER: + fprintf (of, "eeprom* "); + break; + case POINTER: + fprintf (of, "near* "); + break; + case IPOINTER: + fprintf (of, "idata* "); + break; + case PPOINTER: + fprintf (of, "pdata* "); + break; + case UPOINTER: + fprintf (of, "unknown* "); + break; + case ARRAY: + if (DCL_ELEM(type)) { + fprintf (of, "[%d] ", DCL_ELEM(type)); + } else { + fprintf (of, "[] "); + } + break; + } if (DCL_TSPEC(type)) { fprintf (of, "{"); printTypeChainRaw(DCL_TSPEC(type), of); fprintf (of, "}"); } - } + } else if (IS_SPEC (type)) - { - switch (SPEC_SCLS (type)) - { - case S_DATA: fprintf (of, "data-"); break; - case S_XDATA: fprintf (of, "xdata-"); break; - case S_SFR: fprintf (of, "sfr-"); break; - case S_SBIT: fprintf (of, "sbit-"); break; - case S_CODE: fprintf (of, "code-"); break; - case S_IDATA: fprintf (of, "idata-"); break; - case S_PDATA: fprintf (of, "pdata-"); break; - case S_LITERAL: fprintf (of, "literal-"); break; - case S_STACK: fprintf (of, "stack-"); break; - case S_XSTACK: fprintf (of, "xstack-"); break; - case S_BIT: fprintf (of, "bit-"); break; - case S_EEPROM: fprintf (of, "eeprom-"); break; - default: break; - } - if (SPEC_VOLATILE (type)) - fprintf (of, "volatile-"); - if (SPEC_CONST (type)) - fprintf (of, "const-"); - if (SPEC_USIGN (type)) - fprintf (of, "unsigned-"); - switch (SPEC_NOUN (type)) - { - case V_INT: - if (IS_LONG (type)) - fprintf (of, "long-"); - fprintf (of, "int"); - break; - - case V_CHAR: - fprintf (of, "char"); - break; - - case V_VOID: - fprintf (of, "void"); - break; - - case V_FLOAT: - fprintf (of, "float"); - break; - - case V_STRUCT: - fprintf (of, "struct %s", SPEC_STRUCT (type)->tag); - break; - - case V_SBIT: - fprintf (of, "sbit"); - break; - - case V_BIT: - fprintf (of, "bit"); - break; - - case V_BITFIELD: - fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type)); - break; - - case V_DOUBLE: - fprintf (of, "double"); - break; - - default: - fprintf (of, "unknown type"); - break; - } - } + { + switch (SPEC_SCLS (type)) + { + case S_DATA: fprintf (of, "data-"); break; + case S_XDATA: fprintf (of, "xdata-"); break; + case S_SFR: fprintf (of, "sfr-"); break; + case S_SBIT: fprintf (of, "sbit-"); break; + case S_CODE: fprintf (of, "code-"); break; + case S_IDATA: fprintf (of, "idata-"); break; + case S_PDATA: fprintf (of, "pdata-"); break; + case S_LITERAL: fprintf (of, "literal-"); break; + case S_STACK: fprintf (of, "stack-"); break; + case S_XSTACK: fprintf (of, "xstack-"); break; + case S_BIT: fprintf (of, "bit-"); break; + case S_EEPROM: fprintf (of, "eeprom-"); break; + default: break; + } + if (SPEC_VOLATILE (type)) + fprintf (of, "volatile-"); + if (SPEC_CONST (type)) + fprintf (of, "const-"); + if (SPEC_USIGN (type)) + fprintf (of, "unsigned-"); + switch (SPEC_NOUN (type)) + { + case V_INT: + if (IS_LONG (type)) + fprintf (of, "long-"); + fprintf (of, "int"); + break; + + case V_CHAR: + fprintf (of, "char"); + break; + + case V_VOID: + fprintf (of, "void"); + break; + + case V_FLOAT: + fprintf (of, "float"); + break; + + case V_STRUCT: + fprintf (of, "struct %s", SPEC_STRUCT (type)->tag); + break; + + case V_SBIT: + fprintf (of, "sbit"); + break; + + case V_BIT: + fprintf (of, "bit"); + break; + + case V_BITFIELD: + fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type)); + break; + + case V_DOUBLE: + fprintf (of, "double"); + break; + + default: + fprintf (of, "unknown type"); + break; + } + } else fprintf (of, "NOT_SPEC_OR_DECL"); type = type->next; if (type) - fputc (' ', of); + fputc (' ', of); } if (nlr) fprintf (of, "\n"); @@ -2924,7 +2949,7 @@ powof2 (TYPE_UDWORD num) while (num) { if (num & 1) - n1s++; + n1s++; num >>= 1; nshifts++; } @@ -2971,20 +2996,20 @@ _mangleFunctionName(char *in) /*-----------------------------------------------------------------*/ /* typeFromStr - create a typechain from an encoded string */ -/* basic types - 'c' - char */ -/* 's' - short */ -/* 'i' - int */ -/* 'l' - long */ -/* 'f' - float */ -/* 'v' - void */ -/* '*' - pointer - default (GPOINTER) */ +/* basic types - 'c' - char */ +/* 's' - short */ +/* 'i' - int */ +/* 'l' - long */ +/* 'f' - float */ +/* 'v' - void */ +/* '*' - pointer - default (GPOINTER) */ /* modifiers - 'u' - unsigned */ /* pointer modifiers - 'g' - generic */ /* 'x' - xdata */ /* 'p' - code */ /* 'd' - data */ /* 'F' - function */ -/* examples : "ig*" - generic int * */ +/* examples : "ig*" - generic int * */ /* "cx*" - char xdata * */ /* "ui" - unsigned int */ /*-----------------------------------------------------------------*/ @@ -2994,80 +3019,80 @@ sym_link *typeFromStr (char *s) int usign = 0; do { - sym_link *nr; - switch (*s) { - case 'u' : - usign = 1; - s++; - continue ; - break ; - case 'c': - r->class = SPECIFIER; - SPEC_NOUN(r) = V_CHAR; - break; - case 's': - case 'i': - r->class = SPECIFIER; - SPEC_NOUN(r) = V_INT; - break; - case 'l': - r->class = SPECIFIER; - SPEC_NOUN(r) = V_INT; - SPEC_LONG(r) = 1; - break; - case 'f': - r->class = SPECIFIER; - SPEC_NOUN(r) = V_FLOAT; - break; - case 'v': - r->class = SPECIFIER; - SPEC_NOUN(r) = V_VOID; - break; - case '*': - DCL_TYPE(r) = port->unqualified_pointer; - break; - case 'g': - case 'x': - case 'p': - case 'd': - case 'F': - assert(*(s+1)=='*'); - nr = newLink(DECLARATOR); - nr->next = r; - r = nr; - switch (*s) { - case 'g': - DCL_TYPE(r) = GPOINTER; - break; - case 'x': - DCL_TYPE(r) = FPOINTER; - break; - case 'p': - DCL_TYPE(r) = CPOINTER; - break; - case 'd': - DCL_TYPE(r) = POINTER; - break; - case 'F': - DCL_TYPE(r) = FUNCTION; - nr = newLink(DECLARATOR); - nr->next = r; - r = nr; - DCL_TYPE(r) = CPOINTER; - break; - } - s++; - break; - default: - werror(E_INTERNAL_ERROR, __FILE__, __LINE__, - "typeFromStr: unknown type"); - break; - } - if (IS_SPEC(r) && usign) { - SPEC_USIGN(r) = 1; - usign = 0; - } - s++; + sym_link *nr; + switch (*s) { + case 'u' : + usign = 1; + s++; + continue ; + break ; + case 'c': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_CHAR; + break; + case 's': + case 'i': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_INT; + break; + case 'l': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_INT; + SPEC_LONG(r) = 1; + break; + case 'f': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_FLOAT; + break; + case 'v': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_VOID; + break; + case '*': + DCL_TYPE(r) = port->unqualified_pointer; + break; + case 'g': + case 'x': + case 'p': + case 'd': + case 'F': + assert(*(s+1)=='*'); + nr = newLink(DECLARATOR); + nr->next = r; + r = nr; + switch (*s) { + case 'g': + DCL_TYPE(r) = GPOINTER; + break; + case 'x': + DCL_TYPE(r) = FPOINTER; + break; + case 'p': + DCL_TYPE(r) = CPOINTER; + break; + case 'd': + DCL_TYPE(r) = POINTER; + break; + case 'F': + DCL_TYPE(r) = FUNCTION; + nr = newLink(DECLARATOR); + nr->next = r; + r = nr; + DCL_TYPE(r) = CPOINTER; + break; + } + s++; + break; + default: + werror(E_INTERNAL_ERROR, __FILE__, __LINE__, + "typeFromStr: unknown type"); + break; + } + if (IS_SPEC(r) && usign) { + SPEC_USIGN(r) = 1; + usign = 0; + } + s++; } while (*s); return r; } @@ -3108,19 +3133,19 @@ initCSupport () { sym_link *l = NULL; switch (bwd) - { - case 0: - l = newCharLink (); - break; - case 1: - l = newIntLink (); - break; - case 2: - l = newLongLink (); - break; - default: - assert (0); - } + { + case 0: + l = newCharLink (); + break; + case 1: + l = newIntLink (); + break; + case 2: + l = newLongLink (); + break; + default: + assert (0); + } __multypes[bwd][0] = l; __multypes[bwd][1] = copyLinkChain (l); SPEC_USIGN (__multypes[bwd][1]) = 1; @@ -3140,39 +3165,39 @@ initCSupport () for (tofrom = 0; tofrom < 2; tofrom++) { for (bwd = 0; bwd < 3; bwd++) - { - for (su = 0; su < 2; su++) - { - if (tofrom) - { - SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent); - } - else - { - SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent); - } - } - } + { + for (su = 0; su < 2; su++) + { + if (tofrom) + { + SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]); + __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent); + } + else + { + SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]); + __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent); + } + } + } } /* for (muldivmod = 0; muldivmod < 3; muldivmod++) { for (bwd = 0; bwd < 3; bwd++) - { - for (su = 0; su < 2; su++) - { - SNPRINTF (buffer, sizeof(buffer), - "_%s%s%s", - smuldivmod[muldivmod], - ssu[su], - sbwd[bwd]); + { + for (su = 0; su < 2; su++) + { + SNPRINTF (buffer, sizeof(buffer), + "_%s%s%s", + smuldivmod[muldivmod], + ssu[su], + sbwd[bwd]); __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); - FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; - } - } + FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; + } + } } muluint() and mulsint() resp. mululong() and mulslong() return the same result. @@ -3182,19 +3207,19 @@ initCSupport () for (bwd = 0; bwd < 3; bwd++) { for (su = 0; su < 2; su++) - { - for (muldivmod = 1; muldivmod < 3; muldivmod++) - { - /* div and mod */ - SNPRINTF (buffer, sizeof(buffer), - "_%s%s%s", - smuldivmod[muldivmod], - ssu[su], - sbwd[bwd]); - __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); - FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; - } - } + { + for (muldivmod = 1; muldivmod < 3; muldivmod++) + { + /* div and mod */ + SNPRINTF (buffer, sizeof(buffer), + "_%s%s%s", + smuldivmod[muldivmod], + ssu[su], + sbwd[bwd]); + __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); + FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; + } + } } /* mul only */ muldivmod = 0; @@ -3205,10 +3230,10 @@ initCSupport () /* muluchar and mulschar are still separate functions, because e.g. the z80 port is sign/zero-extending to int before calling mulint() */ SNPRINTF (buffer, sizeof(buffer), - "_%s%s%s", - smuldivmod[muldivmod], - ssu[su], - sbwd[bwd]); + "_%s%s%s", + smuldivmod[muldivmod], + ssu[su], + sbwd[bwd]); __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; } @@ -3219,9 +3244,9 @@ initCSupport () { /* mul, int/long */ SNPRINTF (buffer, sizeof(buffer), - "_%s%s", - smuldivmod[muldivmod], - sbwd[bwd]); + "_%s%s", + smuldivmod[muldivmod], + sbwd[bwd]); __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1; /* signed = unsigned */ @@ -3231,18 +3256,18 @@ initCSupport () for (rlrr = 0; rlrr < 2; rlrr++) { for (bwd = 0; bwd < 3; bwd++) - { - for (su = 0; su < 2; su++) - { - SNPRINTF (buffer, sizeof(buffer), - "_%s%s%s", - srlrr[rlrr], - ssu[su], - sbwd[bwd]); + { + for (su = 0; su < 2; su++) + { + SNPRINTF (buffer, sizeof(buffer), + "_%s%s%s", + srlrr[rlrr], + ssu[su], + sbwd[bwd]); __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent); - FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1; - } - } + FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1; + } + } } } @@ -3257,29 +3282,29 @@ void initBuiltIns() if (!port->builtintable) return ; for (i = 0 ; port->builtintable[i].name ; i++) { - sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype, - port->builtintable[i].nParms,port->builtintable[i].parm_types); - FUNC_ISBUILTIN(sym->type) = 1; - FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */ + sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype, + port->builtintable[i].nParms,port->builtintable[i].parm_types); + FUNC_ISBUILTIN(sym->type) = 1; + FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */ } } -sym_link *validateLink(sym_link *l, - const char *macro, - const char *args, - const char select, - const char *file, - unsigned line) +sym_link *validateLink(sym_link *l, + const char *macro, + const char *args, + const char select, + const char *file, + unsigned line) { if (l && l->class==select) { - return l; + return l; } fprintf(stderr, - "Internal error: validateLink failed in %s(%s) @ %s:%u:" - " expected %s, got %s\n", - macro, args, file, line, - DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link"); + "Internal error: validateLink failed in %s(%s) @ %s:%u:" + " expected %s, got %s\n", + macro, args, file, line, + DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link"); exit(-1); return l; // never reached, makes compiler happy. } diff --git a/src/SDCCsymt.h b/src/SDCCsymt.h index 259ad9d4..318c2efb 100644 --- a/src/SDCCsymt.h +++ b/src/SDCCsymt.h @@ -545,6 +545,7 @@ value *checkStructIval (symbol *, value *); value *checkArrayIval (sym_link *, value *); value *checkIval (sym_link *, value *); unsigned int getSize (sym_link *); +unsigned int getAllocSize (sym_link *); unsigned int bitsForType (sym_link *); sym_link *newIntLink (); sym_link *newCharLink (); diff --git a/src/z80/gen.c b/src/z80/gen.c index f61ad624..c474b6c2 100644 --- a/src/z80/gen.c +++ b/src/z80/gen.c @@ -6815,7 +6815,7 @@ genGenPointerSet (operand * right, { fetchPair (pairId, AOP (result)); } - /* so hl know contains the address */ + /* so hl now contains the address */ freeAsmop (result, NULL, ic); /* if bit then unpack */ @@ -7491,13 +7491,26 @@ genArrayInit (iCode * ic) if (type && type->next) { - elementSize = getSize(type->next); + if (IS_SPEC(type->next)) + { + elementSize = getSize(type->next); + } + else if (IS_ARRAY(type->next) && type->next->next) + { + elementSize = getSize(type->next->next); + } + else + { + wassertl (0, "Can't determine element size in genArrayInit."); + } } else { wassertl (0, "Can't determine element size in genArrayInit."); } + wassertl ((elementSize > 0) && (elementSize <= 4), "Illegal element size in genArrayInit."); + iLoop = IC_ARRAYILIST(ic); lastVal = (unsigned)-1; @@ -7510,17 +7523,14 @@ genArrayInit (iCode * ic) { ix = iLoop->count; - if (ix != 0) + for (i = 0; i < ix; i++) { - for (i = 0; i < ix; i++) + for (eIndex = 0; eIndex < elementSize; eIndex++) { - for (eIndex = 0; eIndex < elementSize; eIndex++) - { - val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff; - _rleAppend(&rle, val); - } + val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff; + _rleAppend(&rle, val); } - } + } iLoop = iLoop->next; } diff --git a/support/regression/tests/zeropad.c b/support/regression/tests/zeropad.c index 78851044..a3049bcf 100644 --- a/support/regression/tests/zeropad.c +++ b/support/regression/tests/zeropad.c @@ -2,36 +2,92 @@ storage: idata, xdata, code, */ +#ifndef STORAGE +#define STORAGE {storage} +#endif + #include +typedef unsigned int size_t; +#define offsetof(s,m) (size_t)&(((s *)0)->m) + #if defined(PORT_HOST) || defined(SDCC_z80) || defined(SDCC_gbz80) # define idata # define xdata # define code #endif +char array[5] = {'a', 'b', 'c'}; + +struct w { + char a; + int b; +} STORAGE g[3] = { + {'x', 1}, + {'y'}, + {'z', 3} +}; + struct x { short a; char b[10]; }; -struct x {storage} teststruct[6] = { +struct y { + short a; + char b[]; +}; + +struct z { + char c; + struct y s; +}; + +struct x STORAGE teststruct[5] = { { 10, { 1, 2, 3, 4, 5} }, { 20, { 11 } }, { 30, { 6, 7, 8} } }; +struct y STORAGE incompletestruct = { + 10, {1, 2, 3, 4, 5} +}; + +struct z STORAGE nestedstruct = { + 16, + {20, {6, 7, 8} } +}; + void testZeropad(void) { -#if ! (defined(SDCC_z80) || defined(SDCC_gbz80)) + ASSERT(array[2] == 'c'); + ASSERT(array[4] == 0); + + ASSERT(g[1].a == 'y'); + ASSERT(g[1].b == 0); + ASSERT(g[2].a == 'z'); + ASSERT(g[2].b == 3); + ASSERT(teststruct[0].b[1] == 2); -#endif ASSERT(teststruct[0].b[5] == 0); ASSERT(teststruct[1].b[0] == 11); + ASSERT(teststruct[4].b[9] == 0); ASSERT(sizeof(teststruct[2].a) == 2); ASSERT(sizeof(teststruct[1].b) == 10); ASSERT(sizeof(teststruct[1]) == 12); - ASSERT(sizeof(teststruct) == 72); + ASSERT(sizeof(teststruct) == 60); + + ASSERT(incompletestruct.a == 10); + ASSERT(incompletestruct.b[0] == 1); + ASSERT(incompletestruct.b[4] == 5); + + ASSERT(sizeof(incompletestruct) == sizeof(struct y)); + ASSERT(sizeof(incompletestruct) == offsetof(struct y, b)); + ASSERT(sizeof(incompletestruct) == offsetof(struct x, b)); + + ASSERT(nestedstruct.c == 16); + ASSERT(nestedstruct.s.a == 20); + ASSERT(nestedstruct.s.b[2] == 8); } -- 2.30.2