int noLineno = 0;
int noAlloc = 0;
symbol *currFunc;
-ast *createIval (ast *, sym_link *, initList *, ast *);
-ast *createIvalCharPtr (ast *, sym_link *, ast *);
+static ast *createIval (ast *, sym_link *, initList *, ast *);
+static ast *createIvalCharPtr (ast *, sym_link *, ast *);
ast *optimizeRRCRLC (ast *);
ast *optimizeGetHbit (ast *);
ast *backPatchLabels (ast *, symbol *, symbol *);
/*-----------------------------------------------------------------*/
-/* newAst - creates a fresh node for an expression tree */
+/* newAst - creates a fresh node for an expression tree */
/*-----------------------------------------------------------------*/
-#if 0
-ast *
-newAst (int type, void *op)
-{
- ast *ex;
- static int oldLineno = 0;
-
- ex = Safe_alloc ( sizeof (ast));
-
- ex->type = type;
- ex->lineno = (noLineno ? oldLineno : yylineno);
- ex->filename = currFname;
- ex->level = NestLevel;
- ex->block = currBlockno;
- ex->initMode = inInitMode;
-
- /* depending on the type */
- switch (type)
- {
- case EX_VALUE:
- ex->opval.val = (value *) op;
- break;
- case EX_OP:
- ex->opval.op = (long) op;
- break;
- case EX_LINK:
- ex->opval.lnk = (sym_link *) op;
- break;
- case EX_STMNT:
- ex->opval.stmnt = (unsigned) op;
- }
-
- return ex;
-}
-#endif
-
static ast *
newAst_ (unsigned type)
{
return 0;
}
-#if 0
-/* this functions seems to be superfluous?! kmh */
-
-/*-----------------------------------------------------------------*/
-/* resolveFromTable - will return the symbal table value */
-/*-----------------------------------------------------------------*/
-value *
-resolveFromTable (value * val)
-{
- symbol *csym;
-
- if (!val->sym)
- return val;
-
- csym = findSymWithLevel (SymbolTab, val->sym);
-
- /* if found in the symbol table & they r not the same */
- if (csym && val->sym != csym &&
- csym->level == val->sym->level &&
- csym->_isparm &&
- !csym->ismyparm)
- {
-
- val->sym = csym;
- val->type = csym->type;
- val->etype = csym->etype;
- }
-
- return val;
-}
-#endif
-
/*-----------------------------------------------------------------*/
/* funcOfType :- function of type with name */
/*-----------------------------------------------------------------*/
}
+/*-----------------------------------------------------------------*/
+/* funcOfTypeVarg :- function of type with name and argtype */
+/*-----------------------------------------------------------------*/
+symbol *
+funcOfTypeVarg (char *name, char * rtype, int nArgs , char **atypes)
+{
+
+ symbol *sym;
+ int i ;
+ /* create the symbol */
+ sym = newSymbol (name, 0);
+
+ /* setup return value */
+ sym->type = newLink ();
+ DCL_TYPE (sym->type) = FUNCTION;
+ sym->type->next = typeFromStr(rtype);
+ sym->etype = getSpec (sym->type);
+
+ /* 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 ();
+ }
+ }
+
+ /* save it */
+ addSymChain (sym);
+ sym->cdef = 1;
+ allocVariables (sym);
+ return sym;
+
+}
+
/*-----------------------------------------------------------------*/
/* reverseParms - will reverse a parameter tree */
/*-----------------------------------------------------------------*/
-void
+static void
reverseParms (ast * ptree)
{
ast *ttree;
if (IS_PTR(ftype) && !IS_GENPTR(ftype))
{
newType = newAst_LINK (copyLinkChain(ftype));
- DCL_TYPE (newType->opval.lnk) = GPOINTER;
+ DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
}
if (IS_AGGREGATE (ftype))
{
newType = newAst_LINK (copyLinkChain (ftype));
- DCL_TYPE (newType->opval.lnk) = GPOINTER;
+ DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
}
if (newType)
{
/*-----------------------------------------------------------------*/
/* createIvalType - generates ival for basic types */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIvalType (ast * sym, sym_link * type, initList * ilist)
{
ast *iExpr;
/*-----------------------------------------------------------------*/
/* createIvalStruct - generates initial value for structures */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIvalStruct (ast * sym, sym_link * type, initList * ilist)
{
ast *rast = NULL;
/*-----------------------------------------------------------------*/
/* createIvalArray - generates code for array initialization */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIvalArray (ast * sym, sym_link * type, initList * ilist)
{
ast *rast = NULL;
/*-----------------------------------------------------------------*/
/* createIvalCharPtr - generates initial values for char pointers */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr)
{
ast *rast = NULL;
/*-----------------------------------------------------------------*/
/* createIvalPtr - generates initial value for pointers */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIvalPtr (ast * sym, sym_link * type, initList * ilist)
{
ast *rast;
/*-----------------------------------------------------------------*/
/* createIval - generates code for initial value */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
createIval (ast * sym, sym_link * type, initList * ilist, ast * wid)
{
ast *rast = NULL;
/*-----------------------------------------------------------------*/
/* initAggregates - initialises aggregate variables with initv */
/*-----------------------------------------------------------------*/
-
-/* this has to go */ void printIval (symbol *, sym_link *, initList *, FILE *);
-
ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
- ast *ast;
- symbol *newSym;
-
- if (getenv("TRY_THE_NEW_INITIALIZER")) {
-
- if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
- fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
- "with -mmcs51 and --model-large\n");
- exit(404);
- }
-
- if (SPEC_OCLS(sym->etype)==xdata &&
- getSize(sym->type) > 16) { // else it isn't worth it: do it the old way
-
- // copy this symbol
- newSym=copySymbol (sym);
- SPEC_OCLS(newSym->etype)=code;
- sprintf (newSym->name, "%s_init__", sym->name);
- sprintf (newSym->rname,"%s_init__", sym->rname);
- addSym (SymbolTab, newSym, newSym->name, 0, 0, 1);
-
- // emit it in the static segment
- addSet(&statsg->syms, newSym);
-
- // now memcpy() the entire array from cseg
- ast=newNode (ARRAYINIT, // ASSIGN_AGGREGATE
- newAst_VALUE (symbolVal (sym)),
- newAst_VALUE (symbolVal (newSym)));
- return decorateType(resolveSymbols(ast));
- }
- }
-
return createIval (newAst_VALUE (symbolVal (sym)), sym->type, ival, wid);
}
/* gatherAutoInit - creates assignment expressions for initial */
/* values */
/*-----------------------------------------------------------------*/
-ast *
+static ast *
gatherAutoInit (symbol * autoChain)
{
ast *init = NULL;
{
symbol *newSym;
- // this can only be a constant
- if (!inInitMode && !IS_LITERAL(sym->ival->init.node->etype)) {
- werror (E_CONST_EXPECTED);
- }
-
/* insert the symbol into the symbol table */
/* with level = 0 & name = rname */
newSym = copySymbol (sym);
}
-//#define DEMAND_INTEGER_PROMOTION
-
-#ifdef DEMAND_INTEGER_PROMOTION
-
-/*-----------------------------------------------------------------*/
-/* walk a tree looking for the leaves. Add a typecast to the given */
-/* type to each value leaf node. */
-/*-----------------------------------------------------------------*/
-void
-pushTypeCastToLeaves (sym_link * type, ast * node, ast ** parentPtr)
-{
- if (!node || IS_CALLOP(node))
- {
- /* WTF? We should never get here. */
- return;
- }
-
- if (!node->left && !node->right)
- {
- /* We're at a leaf; if it's a value, apply the typecast */
- if (node->type == EX_VALUE && IS_INTEGRAL (TTYPE (node)))
- {
- *parentPtr = decorateType (newNode (CAST,
- newAst_LINK (copyLinkChain (type)),
- node));
- }
- }
- else
- {
- if (node->left)
- {
- pushTypeCastToLeaves (type, node->left, &(node->left));
- }
- if (node->right)
- {
- pushTypeCastToLeaves (type, node->right, &(node->right));
- }
- }
-}
-
-#endif
-
/*-----------------------------------------------------------------*/
/* decorateType - compute type for this tree also does type cheking */
/* this is done bottom up, since type have to flow upwards */
ast *dtl, *dtr;
dtl = decorateType (tree->left);
- dtr = decorateType (tree->right);
+ /* delay right side for '?' operator since conditional macro expansions might
+ rely on this */
+ dtr = (tree->opval.op == '?' ? tree->right : decorateType (tree->right));
/* this is to take care of situations
when the tree gets rewritten */
(tree->right->type == EX_VALUE ?
tree->right->opval.val : NULL));
TETYPE (tree) = getSpec (TTYPE (tree));
+
+ /* adjust the storage class */
+ switch (DCL_TYPE(tree->left->ftype)) {
+ case POINTER:
+ break;
+ case FPOINTER:
+ SPEC_SCLS(TETYPE(tree)) = S_XDATA;
+ break;
+ case CPOINTER:
+ SPEC_SCLS(TETYPE(tree)) = S_CODE;
+ break;
+ case GPOINTER:
+ break;
+ case PPOINTER:
+ SPEC_SCLS(TETYPE(tree)) = S_XSTACK;
+ break;
+ case IPOINTER:
+ SPEC_SCLS(TETYPE(tree)) = S_IDATA;
+ break;
+ case EEPPOINTER:
+ SPEC_SCLS(TETYPE(tree)) = S_EEPROM;
+ break;
+ case UPOINTER:
+ case ARRAY:
+ case FUNCTION:
+ }
+
return tree;
/*------------------------------------------------------------------*/
tree->opval.val->type);
return tree;
+ /*------------------------------------------------------------------*/
+ /*----------------------------*/
+ /* 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_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;
+ }
+ }
+ sprintf (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 '?' */
assert(IS_COLON_OP(tree->right));
/* if already known then replace the tree : optimizer will do it
but faster to do it here */
- if (IS_LITERAL (LTYPE(tree))) {
+ if (IS_LITERAL (LTYPE(tree))) {
if ( ((int) floatFromVal (valFromType (LETYPE (tree)))) != 0) {
- return tree->right->left ;
+ return decorateType(tree->right->left) ;
} else {
- return tree->right->right ;
+ return decorateType(tree->right->right) ;
}
} else {
+ tree->right = decorateType(tree->right);
TTYPE (tree) = RTYPE(tree);
TETYPE (tree) = getSpec (TTYPE (tree));
}
goto errorTreeReturn;
}
- if (options.stackAuto || IFFUNC_ISREENT (LTYPE (tree)))
+ if ((options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) &&
+ !IFFUNC_ISBUILTIN(LTYPE(tree)))
{
//FUNC_ARGS(tree->left->ftype) =
//reverseVal (FUNC_ARGS(tree->left->ftype));
vright = (root->right->type == EX_VALUE ?
root->right->opval.val : NULL);
+ //#define EXPERIMENTAL
+#ifdef EXPERIMENTAL
+ /* if left is unsigned and right is literal */
+ if (vleft && vright &&
+ IS_UNSIGNED(vleft->etype) &&
+ IS_LITERAL(vright->etype)) {
+ double dval=floatFromVal(vright);
+ int op=root->opval.op;
+
+ fprintf (stderr,"op: '");
+ switch (op) {
+ case LE_OP: fprintf (stderr, "<= '"); break;
+ case EQ_OP: fprintf (stderr, "== '"); break;
+ case GE_OP: fprintf (stderr, ">= '"); break;
+ default: fprintf (stderr, "%c '", op); break;
+ }
+ fprintf (stderr, "%f\n", dval);
+
+ switch (op)
+ {
+ case EQ_OP:
+ case LE_OP:
+ case '<':
+ if (dval<0 || (op=='<' && dval==0)) {
+ // unsigned is never < 0
+ werror (W_IF_NEVER_TRUE);
+ optExpr = newAst_VALUE (constVal("0"));
+ return decorateType (optExpr);
+ }
+ if (dval==0) {
+ if (op==LE_OP) {
+ // change this into a cheaper EQ_OP
+ fprintf (stderr, "warning *** changed '<=' to '==' because of unsigned\n");
+ root->opval.op=EQ_OP;
+ return root;
+ }
+ }
+ break;
+ case GE_OP:
+ case '>':
+ if (dval>0 || (op==GE_OP && dval==0)) {
+ // unsigned is never < 0
+ werror (W_IF_ALWAYS_TRUE);
+ optExpr = newAst_VALUE (constVal("1"));
+ return decorateType (optExpr);
+ }
+ if (dval==0) {
+ if (op=='>') {
+ // change this into a cheaper reversed EQ_OP
+ fprintf (stderr, "warning *** changed '>' to '!=' because of unsigned\n");
+ root->opval.op=EQ_OP;
+ }
+ }
+ }
+ }
+#endif
+
/* if left is a BITVAR in BITSPACE */
/* and right is a LITERAL then opt- */
/* imize else do nothing */
name->lastLine = yylineno;
currFunc = name;
-#if 0 // jwk: this is now done in addDecl()
- processFuncArgs (currFunc);
-#endif
-
/* set the stack pointer */
/* PENDING: check this for the mcs51 */
stackPtr = -port->stack.direction * port->stack.call_overhead;
/* we are done freeup memory & cleanup */
noLineno--;
- labelKey = 1;
+ if (port->reset_labelKey) labelKey = 1;
name->key = 0;
FUNC_HASBODY(name->type) = 1;
addSet (&operKeyReset, name);
projects / fw / sdcc / blobdiff