int currLineno = 0;
set *astList = NULL ;
set *operKeyReset = NULL;
-extern char *currFname ;
ast *staticAutos = NULL;
int labelKey = 1 ;
int noLineno = 0;
int noAlloc = 0 ;
symbol *currFunc ;
-extern int fatalError ;
-extern int lineno;
-extern char *filename ;
-extern set *publics;
-extern ast *createIval (ast *, link *, initList *, ast *);
-extern ast *createIvalCharPtr (ast *, link *, ast *);
+ast *createIval (ast *, sym_link *, initList *, ast *);
+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 */
/*-----------------------------------------------------------------*/
+#if 0
ast *newAst (int type, void *op )
{
ast *ex ;
ex->opval.val = (value *) op;
break ;
case EX_OP :
- ex->opval.op = (int) op ;
+ ex->opval.op = (long) op ;
break ;
case EX_LINK :
- ex->opval.lnk = (link *) op;
+ ex->opval.lnk = (sym_link *) op;
break ;
case EX_STMNT :
ex->opval.stmnt= (unsigned) op;
return ex;
}
+#endif
+
+static ast* newAst_(unsigned type)
+{
+ ast *ex ;
+ static int oldLineno = 0 ;
+
+ ALLOC(ex,sizeof(ast));
+
+ ex->type = type ;
+ ex->lineno = (noLineno ? oldLineno : yylineno);
+ ex->filename = currFname ;
+ ex->level = NestLevel ;
+ ex->block = currBlockno ;
+ ex->initMode = inInitMode;
+ return ex;
+}
+
+ast* newAst_VALUE(value*val)
+{
+ ast* ex = newAst_(EX_VALUE);
+ ex->opval.val = val;
+ return ex;
+}
+
+ast* newAst_OP(unsigned op)
+{
+ ast*ex = newAst_(EX_OP);
+ ex->opval.op = op;
+ return ex;
+}
+
+ast* newAst_LINK(sym_link*val)
+{
+ ast* ex = newAst_(EX_LINK);
+ ex->opval.lnk = val;
+ return ex;
+}
+
+ast* newAst_STMNT(unsigned val)
+{
+ ast* ex = newAst_(EX_STMNT);
+ ex->opval.stmnt = val;
+ return ex;
+}
/*-----------------------------------------------------------------*/
/* newNode - creates a new node */
/*-----------------------------------------------------------------*/
-ast *newNode ( int op, ast *left, ast *right )
+ast *newNode ( long op, ast *left, ast *right )
{
ast *ex ;
- ex = newAst (EX_OP,(void *) op) ;
+ ex = newAst_OP(op) ;
ex->left = left ;
ex->right = right;
/* then depending on the expression value */
if ( floatFromVal(condAst->opval.val) )
- ifxNode = newNode(GOTO, newAst(EX_VALUE,
- symbolVal (trueLabel )),NULL);
+ ifxNode = newNode(GOTO,
+ newAst_VALUE(symbolVal(trueLabel)),
+ NULL);
else
- ifxNode = newNode(GOTO, newAst(EX_VALUE,
- symbolVal (falseLabel )),NULL);
+ ifxNode = newNode(GOTO,
+ newAst_VALUE(symbolVal(falseLabel)),
+ NULL);
}
else {
ifxNode = newNode(IFX,condAst,NULL);
return 0;
}
+#if 0
+/* this functions seems to be superfluous?! kmh */
+
/*-----------------------------------------------------------------*/
/* resolveFromTable - will return the symbal table value */
/*-----------------------------------------------------------------*/
return val;
}
+#endif
/*-----------------------------------------------------------------*/
/* funcOfType :- function of type with name */
/*-----------------------------------------------------------------*/
-symbol *funcOfType (char *name, link *type, link *argType,
+symbol *funcOfType (char *name, sym_link *type, sym_link *argType,
int nArgs , int rent)
{
symbol *sym;
-
+ int argStack = 0;
/* create the symbol */
sym = newSymbol (name,0);
args = sym->args = newValue();
while (nArgs--) {
+ argStack += getSize(type);
args->type = copyLinkChain(argType);
args->etype = getSpec(args->type);
if (!nArgs)
/* save it */
addSymChain(sym);
sym->cdef = 1;
+ sym->argStack = (rent ? argStack : 0);
allocVariables (sym);
return sym;
ast *actParm,
int *parmNumber)
{
- link *fetype = func->etype;
+ sym_link *fetype = func->etype;
/* if none of them exist */
if ( !defParm && !actParm)
/* now change the current one to a cast */
actParm->type = EX_OP ;
actParm->opval.op = CAST ;
- actParm->left = newAst(EX_LINK,defParm->type);
+ actParm->left = newAst_LINK(defParm->type);
actParm->right= pTree ;
actParm->etype= defParm->etype;
actParm->ftype= defParm->type;
}
- actParm->argSym = resolveFromTable(defParm)->sym ;
+/* actParm->argSym = resolveFromTable(defParm)->sym ; */
+ actParm->argSym = defParm->sym;
/* make a copy and change the regparm type to the defined parm */
actParm->etype = getSpec(actParm->ftype = copyLinkChain(actParm->ftype));
SPEC_REGPARM(actParm->etype) = SPEC_REGPARM(defParm->etype);
+ (*parmNumber)++;
return 0;
}
/*-----------------------------------------------------------------*/
/* createIvalType - generates ival for basic types */
/*-----------------------------------------------------------------*/
-ast *createIvalType ( ast *sym,link *type, initList *ilist)
+ast *createIvalType ( ast *sym,sym_link *type, initList *ilist)
{
ast *iExpr;
ilist = ilist->init.deep ;
iExpr = decorateType(resolveSymbols(list2expr(ilist)));
- return newNode('=',sym,iExpr);
+ return decorateType(newNode('=',sym,iExpr));
}
/*-----------------------------------------------------------------*/
/* createIvalStruct - generates initial value for structures */
/*-----------------------------------------------------------------*/
-ast *createIvalStruct (ast *sym,link *type,initList *ilist)
+ast *createIvalStruct (ast *sym,sym_link *type,initList *ilist)
{
ast *rast = NULL ;
symbol *sflds ;
if (!iloop)
break;
sflds->implicit = 1;
- lAst = decorateType(resolveSymbols(newNode('.',sym,
- newAst(EX_VALUE,symbolVal(sflds)))));
- rast = createIval (lAst, sflds->type, iloop,rast);
+ lAst = newNode(PTR_OP,newNode('&',sym,NULL),newAst_VALUE(symbolVal(sflds)));
+ lAst = decorateType(resolveSymbols(lAst));
+ rast = decorateType(resolveSymbols(createIval (lAst, sflds->type, iloop,rast)));
}
return rast ;
}
/*-----------------------------------------------------------------*/
/* createIvalArray - generates code for array initialization */
/*-----------------------------------------------------------------*/
-ast *createIvalArray (ast *sym, link *type, initList *ilist)
+ast *createIvalArray (ast *sym, sym_link *type, initList *ilist)
{
ast *rast = NULL;
initList *iloop ;
type,
decorateType(resolveSymbols(list2expr(ilist))))))
- return rast;
+ return decorateType(resolveSymbols(rast));
/* not the special case */
if (ilist->type != INIT_DEEP) {
ast *aSym ;
size++ ;
- aSym = newNode('[',sym,newAst(EX_VALUE,valueFromLit(size-1)));
+ aSym = newNode('[',sym,newAst_VALUE(valueFromLit(size-1)));
aSym = decorateType(resolveSymbols(aSym));
rast = createIval (aSym,type->next,iloop,rast) ;
iloop = (iloop ? iloop->next : NULL) ;
if (!DCL_ELEM(type))
DCL_ELEM(type) = size;
- return rast;
+ return decorateType(resolveSymbols(rast));
}
/*-----------------------------------------------------------------*/
/* createIvalCharPtr - generates initial values for char pointers */
/*-----------------------------------------------------------------*/
-ast *createIvalCharPtr (ast *sym, link *type, ast *iexpr)
+ast *createIvalCharPtr (ast *sym, sym_link *type, ast *iexpr)
{
ast *rast = NULL ;
rast,
newNode('=',
newNode('[', sym,
- newAst(EX_VALUE,valueFromLit(i))),
- newAst(EX_VALUE,valueFromLit(*s))));
+ newAst_VALUE(valueFromLit(i))),
+ newAst_VALUE(valueFromLit(*s))));
i++;
s++;
}
rast,
newNode('=',
newNode('[', sym,
- newAst(EX_VALUE,valueFromLit(i))),
- newAst(EX_VALUE,valueFromLit(*s))));
- return rast;
+ newAst_VALUE(valueFromLit(i))),
+ newAst_VALUE(valueFromLit(*s))));
+ return decorateType(resolveSymbols(rast));
}
return NULL ;
/*-----------------------------------------------------------------*/
/* createIvalPtr - generates initial value for pointers */
/*-----------------------------------------------------------------*/
-ast *createIvalPtr (ast *sym,link *type,initList *ilist)
+ast *createIvalPtr (ast *sym,sym_link *type,initList *ilist)
{
ast *rast;
ast *iexpr ;
/*-----------------------------------------------------------------*/
/* createIval - generates code for initial value */
/*-----------------------------------------------------------------*/
-ast *createIval (ast *sym, link *type, initList *ilist, ast *wid)
+ast *createIval (ast *sym, sym_link *type, initList *ilist, ast *wid)
{
ast *rast = NULL;
if (IS_SPEC(type))
rast = createIvalType (sym,type,ilist);
if ( wid )
- return newNode(NULLOP,wid,rast);
+ return decorateType(resolveSymbols(newNode(NULLOP,wid,rast)));
else
- return rast ;
+ return decorateType(resolveSymbols(rast)) ;
}
/*-----------------------------------------------------------------*/
-/* initAggregates - initialises aggregate variables with initv */
+/* initAggregates - initialises aggregate variables with initv */
/*-----------------------------------------------------------------*/
ast *initAggregates ( symbol *sym, initList *ival, ast *wid)
{
- return createIval (newAst(EX_VALUE,symbolVal(sym)),sym->type,ival,wid);
+ return createIval (newAst_VALUE(symbolVal(sym)),sym->type,ival,wid);
}
/*-----------------------------------------------------------------*/
if (IS_AGGREGATE(sym->type))
work = initAggregates (sym, sym->ival,NULL);
else
- work = newNode('=' ,newAst(EX_VALUE,symbolVal(newSym)),
+ work = newNode('=' ,newAst_VALUE(symbolVal(newSym)),
list2expr(sym->ival));
setAstLineno(work,sym->lineDef);
if (IS_AGGREGATE(sym->type))
work = initAggregates (sym,sym->ival,NULL);
else
- work = newNode('=' ,newAst(EX_VALUE,symbolVal(sym)),
+ work = newNode('=' ,newAst_VALUE(symbolVal(sym)),
list2expr(sym->ival));
setAstLineno (work,sym->lineDef);
sym->block = sym->level = 0;
sym->isstrlit = 1;
/* create an ival */
- sym->ival = newiList(INIT_NODE,newAst(EX_VALUE,val));
+ sym->ival = newiList(INIT_NODE,newAst_VALUE(val));
if (noAlloc == 0) {
/* allocate it */
addSymChain(sym);
isSymbolEqual (*sym,AST_SYMBOL(condExpr->left->left))) {
*end = newNode('+', condExpr->left->right,
- newAst(EX_VALUE,constVal("1")));
+ newAst_VALUE(constVal("1")));
break;
}
return FALSE ;
return FALSE;
else
return isConformingBody(pbody->left,sym,body) ;
- }
+ } else {
+ if (astHasSymbol(pbody->left,sym) ||
+ astHasSymbol(pbody->right,sym))
+ return FALSE;
+ }
+
/*------------------------------------------------------------------*/
case '|':
body->type = EX_OP;
body->opval.op = '-';
- body->left = newAst(EX_VALUE,symbolVal(sym));
- body->right= newAst(EX_VALUE,constVal("1"));
+ body->left = newAst_VALUE(symbolVal(sym));
+ body->right= newAst_VALUE(constVal("1"));
}
forbody
<sym> -= 1;
if (sym) goto for_continue ;
- <sym> = end - 1; */
+ <sym> = end */
/* put it together piece by piece */
rloop = newNode (NULLOP,
- createIf(newAst(EX_VALUE,symbolVal(sym)),
+ createIf(newAst_VALUE(symbolVal(sym)),
newNode(GOTO,
- newAst(EX_VALUE,
- symbolVal(AST_FOR(loop,continueLabel))),
+ newAst_VALUE(symbolVal(AST_FOR(loop,continueLabel))),
NULL),NULL),
newNode('=',
- newAst(EX_VALUE,symbolVal(sym)),
- newNode('-', end,
- newAst(EX_VALUE,
- constVal("1")))));
+ newAst_VALUE(symbolVal(sym)),
+ end));
replLoopSym(loop->left, sym);
rloop = newNode(NULLOP,
newNode('=',
- newAst(EX_VALUE,symbolVal(sym)),
+ newAst_VALUE(symbolVal(sym)),
newNode('-',end,init)),
createLabel(AST_FOR(loop,continueLabel),
newNode(NULLOP,
loop->left,
newNode(NULLOP,
newNode(SUB_ASSIGN,
- newAst(EX_VALUE,symbolVal(sym)),
- newAst(EX_VALUE,constVal("1"))),
+ newAst_VALUE(symbolVal(sym)),
+ newAst_VALUE(constVal("1"))),
rloop ))));
return decorateType(rloop);
ast *decorateType (ast *tree)
{
int parmNumber ;
- link *p;
+ sym_link *p;
if ( ! tree )
return tree ;
/* otherwise just copy the type information */
COPYTYPE(TTYPE(tree),TETYPE(tree),tree->opval.val->type);
+ if (funcInChain(tree->opval.val->type)) {
+ tree->hasVargs = tree->opval.val->sym->hasVargs;
+ tree->args = copyValueChain(tree->opval.val->sym->args) ;
+ }
return tree ;
}
TTYPE(tree) = TETYPE(tree) =
tree->opval.val->type = tree->opval.val->sym->type =
tree->opval.val->etype = tree->opval.val->sym->etype =
- copyLinkChain(intType);
+ copyLinkChain(INTTYPE);
}
else {
case INC_OP: /* incerement operator unary so left only */
case DEC_OP:
{
- link *ltc = (tree->right ? RTYPE(tree) : LTYPE(tree) );
+ sym_link *ltc = (tree->right ? RTYPE(tree) : LTYPE(tree) );
COPYTYPE(TTYPE(tree),TETYPE(tree),ltc);
if (!tree->initMode && IS_CONSTANT(TETYPE(tree)))
werror(E_CODE_WRITE,"++/--");
}
if (SPEC_SCLS(tree->left->etype) == S_CODE) {
DCL_TYPE(p) = CPOINTER ;
- DCL_PTR_CONST(p) = 1;
+ DCL_PTR_CONST(p) = port->mem.code_ro;
}
else
if (SPEC_SCLS(tree->left->etype) == S_XDATA)
if (SPEC_SCLS(tree->left->etype) == S_IDATA)
DCL_TYPE(p) = IPOINTER ;
else
- DCL_TYPE(p) = POINTER ;
+ if (SPEC_SCLS(tree->left->etype) == S_EEPROM)
+ DCL_TYPE(p) = EEPPOINTER ;
+ else
+ DCL_TYPE(p) = POINTER ;
if (IS_AST_SYM_VALUE(tree->left)) {
AST_SYMBOL(tree->left)->addrtaken = 1;
return tree;
}
LRVAL(tree) = RRVAL(tree) = 1;
- COPYTYPE(TTYPE(tree),TETYPE(tree),LTYPE(tree));
+ if (IS_LITERAL(LTYPE(tree)) && !IS_LITERAL(RTYPE(tree))) {
+ COPYTYPE(TTYPE(tree),TETYPE(tree),RTYPE(tree));
+ } else {
+ COPYTYPE(TTYPE(tree),TETYPE(tree),LTYPE(tree));
+ }
return tree ;
/*------------------------------------------------------------------*/
/*----------------------------*/
/* 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);
/* logical &&, || */
/*----------------------------*/
case AND_OP:
- case OR_OP :
+ case OR_OP:
/* each must me arithmetic type or be a pointer */
if (!IS_PTR(LTYPE(tree)) &&
!IS_ARRAY(LTYPE(tree)) &&
if (checkType(currFunc->type->next,RTYPE(tree)) < 0 ) {
tree->right =
decorateType(newNode(CAST,
- newAst(EX_LINK,
- copyLinkChain(currFunc->type->next)),
+ newAst_LINK(copyLinkChain(currFunc->type->next)),
tree->right));
}
/*-----------------------------------------------------------------*/
/* sizeofOp - processes size of operation */
/*-----------------------------------------------------------------*/
-value *sizeofOp( link *type)
+value *sizeofOp( sym_link *type)
{
char buff[10];
/* change not */
if (IS_NOT(tree)) {
- tree->left = backPatchLabels (tree->left,trueLabel,falseLabel);
+ int wasnot = IS_NOT(tree->left);
+ tree->left = backPatchLabels (tree->left,falseLabel,trueLabel);
/* if the left is already a IFX */
if ( ! IS_IFX(tree->left) )
tree->left = newNode (IFX,tree->left,NULL);
- tree->left->trueLabel = falseLabel ;
- tree->left->falseLabel= trueLabel ;
+ if (wasnot) {
+ tree->left->trueLabel = trueLabel ;
+ tree->left->falseLabel= falseLabel ;
+ } else {
+ tree->left->trueLabel = falseLabel ;
+ tree->left->falseLabel= trueLabel ;
+ }
return tree->left ;
}
label->islbl = 1;
label->key = labelKey++ ;
- rValue = newNode (LABEL,newAst(EX_VALUE,symbolVal(label)),stmnt);
+ rValue = newNode (LABEL,newAst_VALUE(symbolVal(label)),stmnt);
rValue->lineno = 0;
return rValue ;
if ( elseBody ) {
ifBody = newNode(NULLOP,ifBody,
newNode(GOTO,
- newAst(EX_VALUE,symbolVal(ifEnd)),
+ newAst_VALUE(symbolVal(ifEnd)),
NULL));
/* put the elseLabel on the else body */
elseBody = createLabel (ifFalse,elseBody);
/* vanilla for statement */
condExpr = backPatchLabels(condExpr,trueLabel,falseLabel);
- if (!IS_IFX(condExpr))
+ if (condExpr && !IS_IFX(condExpr))
condExpr = newIfxNode(condExpr,trueLabel,falseLabel);
newNode(NULLOP,
loopExpr,
newNode(GOTO,
- newAst(EX_VALUE,symbolVal(condLabel)),
+ newAst_VALUE(symbolVal(condLabel)),
NULL)));
/* now start putting them together */
forTree = newNode(NULLOP,initExpr,condExpr);
whileBody = newNode(NULLOP,
whileBody,
newNode(GOTO,
- newAst(EX_VALUE,
- symbolVal(continueLabel)),
+ newAst_VALUE(symbolVal(continueLabel)),
createLabel(falseLabel,NULL)));
/* put it all together */
case '>' :
case '<' :
case NE_OP :
- optExpr = newAst(EX_VALUE,constVal("0"));
+ optExpr = newAst_VALUE(constVal("0"));
break;
case GE_OP :
case LE_OP :
case EQ_OP :
- optExpr = newAst(EX_VALUE,constVal("1"));
+ optExpr = newAst_VALUE(constVal("1"));
break;
}
case '<' : /* bit value < 1 means 0 */
case NE_OP :
- optExpr = newNode('!',newAst(EX_VALUE,vleft),NULL);
+ optExpr = newNode('!',newAst_VALUE(vleft),NULL);
break;
case LE_OP : /* bit value <= 1 means no check */
- optExpr = newAst(EX_VALUE,vright);
+ optExpr = newAst_VALUE(vright);
break;
case GE_OP : /* bit value >= 1 means only check for = */
case EQ_OP :
- optExpr = newAst(EX_VALUE,vleft);
+ optExpr = newAst_VALUE(vleft);
break;
}
} else { /* literal is zero */
case '>' : /* bit value > 0 means 1 */
case NE_OP :
- optExpr = newAst(EX_VALUE,vleft);
+ optExpr = newAst_VALUE(vleft);
break;
case LE_OP : /* bit value <= 0 means no check */
break;
case EQ_OP : /* bit == 0 means ! of bit */
- optExpr = newNode('!',newAst(EX_VALUE,vleft),NULL);
+ optExpr = newNode('!',newAst_VALUE(vleft),NULL);
break;
}
}
ast *ex ;
symbol *csym;
int stack = 0 ;
- link *fetype;
+ sym_link *fetype;
iCode *piCode = NULL;
/* if check function return 0 then some problem */
we need to add the name to the publics list : this
actually means we are now compiling the compiler
support routine */
- if (name->cdef)
+ if (name->cdef) {
addSet(&publics,name);
+ }
}
else {
addSymChain(name);
name->stack = SPEC_STAK(fetype) = stack;
/* name needs to be mangled */
- sprintf (name->rname,"_%s",name->name);
+ sprintf (name->rname,"%s%s", port->fun_prefix, name->name);
body = resolveSymbols(body); /* resolve the symbols */
body = decorateType (body); /* propagateType & do semantic checks */
- ex = newAst (EX_VALUE, symbolVal(name)); /* create name */
+ ex = newAst_VALUE(symbolVal(name)); /* create name */
ex = newNode (FUNCTION,ex,body);
ex->values.args = name->args ;
addSet(&operKeyReset,name);
applyToSet(operKeyReset,resetParmKey);
- if (options.debug)
+ if (options.debug && !options.nodebug)
cdbStructBlock(1,cdbFile);
cleanUpLevel(LabelTab,0);