ast *optimizeRRCRLC (ast *);
ast *optimizeGetHbit (ast *);
ast *backPatchLabels (ast *, symbol *, symbol *);
+void PA(ast *t);
int inInitMode = 0;
memmap *GcurMemmap=NULL; /* points to the memmap that's currently active */
FILE *codeOutFile;
dest->lineno = src->lineno;
dest->level = src->level;
dest->funcName = src->funcName;
- dest->argSym = src->argSym;
+
+ if (src->ftype)
+ dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
/* if this is a leaf */
/* if value */
/* if this is a node that has special values */
copyAstValues (dest, src);
- if (src->ftype)
- dest->etype = getSpec (dest->ftype = copyLinkChain (src->ftype));
-
dest->trueLabel = copySymbol (src->trueLabel);
dest->falseLabel = copySymbol (src->falseLabel);
dest->left = copyAst (src->left);
/* create the symbol */
sym = newSymbol (name, 0);
+ /* setup return value */
+ sym->type = newLink ();
+ DCL_TYPE (sym->type) = FUNCTION;
+ sym->type->next = copyLinkChain (type);
+ sym->etype = getSpec (sym->type);
+ FUNC_ISREENT(sym->type) = rent;
+
/* if arguments required */
if (nArgs)
{
-
value *args;
- args = sym->args = newValue ();
+ args = FUNC_ARGS(sym->type) = newValue ();
while (nArgs--)
{
args->type = copyLinkChain (argType);
args->etype = getSpec (args->type);
+ SPEC_EXTR(args->etype)=1;
if (!nArgs)
break;
args = args->next = newValue ();
}
}
- /* setup return value */
- sym->type = newLink ();
- DCL_TYPE (sym->type) = FUNCTION;
- sym->type->next = copyLinkChain (type);
- sym->etype = getSpec (sym->type);
- SPEC_RENT (sym->etype) = rent;
-
/* save it */
addSymChain (sym);
sym->cdef = 1;
}
+/*-----------------------------------------------------------------*/
+/* 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 */
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int
processParms (ast * func,
- value * defParm,
+ value *defParm,
ast * actParm,
- int *parmNumber,
+ int *parmNumber, // unused, although updated
bool rightmost)
{
- sym_link *fetype = func->etype;
-
/* if none of them exist */
if (!defParm && !actParm)
return 0;
if (defParm) {
if (getenv("DEBUG_SANITY")) {
- fprintf (stderr, "addSym: %s ", defParm->name);
+ fprintf (stderr, "processParms: %s ", defParm->name);
}
/* make sure the type is complete and sane */
checkTypeSanity(defParm->etype, defParm->name);
/* if the function is being called via a pointer & */
/* it has not been defined a reentrant then we cannot */
/* have parameters */
- if (func->type != EX_VALUE && !IS_RENT (fetype) && !options.stackAuto)
+ if (func->type != EX_VALUE && !IFFUNC_ISREENT (func->ftype) && !options.stackAuto)
{
werror (W_NONRENT_ARGS);
return 1;
/* if defined parameters ended but actual parameters */
/* exist and this is not defined as a variable arg */
- /* also check if statckAuto option is specified */ // jwk: WHY?
- if ((!defParm) && actParm && (!func->hasVargs)
- /* && !options.stackAuto && !IS_RENT (fetype) */)
+ if (!defParm && actParm && !IFFUNC_HASVARARGS(func->ftype))
{
werror (E_TOO_MANY_PARMS);
return 1;
return 1;
}
+ if (IS_VOID(actParm->ftype)) {
+ werror (E_VOID_VALUE_USED);
+ return 1;
+ }
+
/* If this is a varargs function... */
- if (!defParm && actParm && func->hasVargs)
+ if (!defParm && actParm && IFFUNC_HASVARARGS(func->ftype))
{
ast *newType = NULL;
sym_link *ftype;
return 0;
}
- /* The ternary ('?') operator is weird: the ftype of the
- * operator is the type of the condition, but it will return a
- * (possibly) different type.
- */
- if (IS_TERNARY_OP(actParm))
- {
- assert(IS_COLON_OP(actParm->right));
- assert(actParm->right->left);
- ftype = actParm->right->left->ftype;
- }
- else
- {
- ftype = actParm->ftype;
- }
+ ftype = actParm->ftype;
/* If it's a small integer, upcast to int. */
if (IS_INTEGRAL (ftype)
if (newType)
{
/* cast required; change this op to a cast. */
- ast *parmCopy = resolveSymbols (copyAst (actParm));
+ ast *parmCopy = decorateType(resolveSymbols (copyAst (actParm)));
actParm->type = EX_OP;
actParm->opval.op = CAST;
}
/* if defined parameters ended but actual has not & */
- /* stackAuto */
+ /* reentrant */
if (!defParm && actParm &&
- (options.stackAuto || IS_RENT (fetype)))
+ (options.stackAuto || IFFUNC_ISREENT (func->ftype)))
return 0;
resolveSymbols (actParm);
}
}
-
/* the parameter type must be at least castable */
if (compareType (defParm->type, actParm->ftype) == 0) {
werror (E_INCOMPAT_TYPES);
- fprintf (stderr, "type --> '");
- printTypeChain (actParm->ftype, stderr);
- fprintf (stderr, "' ");
- fprintf (stderr, "assigned to type --> '");
- printTypeChain (defParm->type, stderr);
- fprintf (stderr, "'\n");
+ printFromToType (actParm->ftype, defParm->type);
return 1;
}
/* if the parameter is castable then add the cast */
if (compareType (defParm->type, actParm->ftype) < 0)
{
- ast *pTree = resolveSymbols (copyAst (actParm));
+ ast *pTree = decorateType(resolveSymbols (copyAst (actParm)));
/* now change the current one to a cast */
actParm->type = EX_OP;
actParm->right = pTree;
actParm->etype = defParm->etype;
actParm->ftype = defParm->type;
+ actParm->decorated=0; /* force typechecking */
+ decorateType (actParm);
}
-/* 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);
createIvalStruct (ast * sym, sym_link * type, initList * ilist)
{
ast *rast = NULL;
+ ast *lAst;
symbol *sflds;
initList *iloop;
for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
{
- ast *lAst;
-
/* if we have come to end */
if (!iloop)
break;
lAst = decorateType (resolveSymbols (lAst));
rast = decorateType (resolveSymbols (createIval (lAst, sflds->type, iloop, rast)));
}
+
+ if (iloop) {
+ werror (W_EXCESS_INITIALIZERS, "struct",
+ sym->opval.val->sym->name, sym->opval.val->sym->lineDef);
+ }
+
return rast;
}
char *name=sym->opval.val->sym->name;
int lineno=sym->opval.val->sym->lineDef;
- werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+ werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
}
}
else
// there has to be a better way
char *name=sym->opval.val->sym->name;
int lineno=sym->opval.val->sym->lineDef;
- werror (W_EXESS_ARRAY_INITIALIZERS, name, lineno);
+ werror (W_EXCESS_INITIALIZERS, "array", name, lineno);
break;
}
if (!TARGET_IS_MCS51 || !(options.model==MODEL_LARGE)) {
fprintf (stderr, "Can't \"TRY_THE_NEW_INITIALIZER\" unless "
- "with -mmcs51 and --model-large");
+ "with -mmcs51 and --model-large\n");
exit(404);
}
addSym (SymbolTab, newSym, newSym->rname, 0, 0, 1);
/* now lift the code to main */
- if (IS_AGGREGATE (sym->type))
+ if (IS_AGGREGATE (sym->type)) {
work = initAggregates (sym, sym->ival, NULL);
- else
+ } else {
+ if (getNelements(sym->type, sym->ival)>1) {
+ werror (W_EXCESS_INITIALIZERS, "scalar",
+ sym->name, sym->lineDef);
+ }
work = newNode ('=', newAst_VALUE (symbolVal (newSym)),
list2expr (sym->ival));
+ }
setAstLineno (work, sym->lineDef);
/* if there is an initial value */
if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
{
- if (IS_AGGREGATE (sym->type))
+ if (IS_AGGREGATE (sym->type)) {
work = initAggregates (sym, sym->ival, NULL);
- else
+ } else {
+ if (getNelements(sym->type, sym->ival)>1) {
+ werror (W_EXCESS_INITIALIZERS, "scalar",
+ sym->name, sym->lineDef);
+ }
work = newNode ('=', newAst_VALUE (symbolVal (sym)),
list2expr (sym->ival));
+ }
setAstLineno (work, sym->lineDef);
sym->ival = NULL;
#endif
-/*-----------------------------------------------------------------*/
-/* Given an assignment operation in a tree, determine if the LHS */
-/* (the result) has a different (integer) type than the RHS. */
-/* If so, walk the RHS and add a typecast to the type of the LHS */
-/* to all leaf nodes. */
-/*-----------------------------------------------------------------*/
-void
-propAsgType (ast * tree)
-{
-#ifdef DEMAND_INTEGER_PROMOTION
- if (!IS_INTEGRAL (LTYPE (tree)) || !IS_INTEGRAL (RTYPE (tree)))
- {
- /* Nothing to do here... */
- return;
- }
-
- if (getSize (LTYPE (tree)) > getSize (RTYPE (tree)))
- {
- pushTypeCastToLeaves (LTYPE (tree), tree->right, &(tree->right));
- }
-#else
- (void) tree;
-#endif
-}
-
/*-----------------------------------------------------------------*/
/* decorateType - compute type for this tree also does type cheking */
/* this is done bottom up, since type have to flow upwards */
/* otherwise just copy the type information */
COPYTYPE (TTYPE (tree), TETYPE (tree), tree->opval.val->type);
- if (funcInChain (tree->opval.val->type))
- {
- tree->hasVargs = tree->opval.val->sym->hasVargs;
- tree->args = copyValueChain (tree->opval.val->sym->args);
- }
return tree;
}
/* and mark it as referenced */
tree->opval.val->sym->isref = 1;
- /* if this is of type function or function pointer */
- if (funcInChain (tree->opval.val->type))
- {
- tree->hasVargs = tree->opval.val->sym->hasVargs;
- tree->args = copyValueChain (tree->opval.val->sym->args);
-
- }
}
}
}
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 */
}
TTYPE (tree) = structElemType (LTYPE (tree),
(tree->right->type == EX_VALUE ?
- tree->right->opval.val : NULL), &tree->args);
+ tree->right->opval.val : NULL));
TETYPE (tree) = getSpec (TTYPE (tree));
return tree;
TTYPE (tree) = structElemType (LTYPE (tree)->next,
(tree->right->type == EX_VALUE ?
- tree->right->opval.val : NULL), &tree->args);
+ tree->right->opval.val : NULL));
TETYPE (tree) = getSpec (TTYPE (tree));
return tree;
return decorateType (otree);
}
-#if 0
- // we can't do this because of "(int & 0xff) << 3"
-
- /* if right or left is literal then result of that type */
- if (IS_LITERAL (RTYPE (tree)))
- {
-
- TTYPE (tree) = copyLinkChain (RTYPE (tree));
- TETYPE (tree) = getSpec (TTYPE (tree));
- SPEC_SCLS (TETYPE (tree)) = S_AUTO;
- }
- else
- {
- if (IS_LITERAL (LTYPE (tree)))
- {
- TTYPE (tree) = copyLinkChain (LTYPE (tree));
- TETYPE (tree) = getSpec (TTYPE (tree));
- SPEC_SCLS (TETYPE (tree)) = S_AUTO;
-
- }
- else
- {
- TTYPE (tree) =
- computeType (LTYPE (tree), RTYPE (tree));
- TETYPE (tree) = getSpec (TTYPE (tree));
- }
- }
-#else
TTYPE (tree) =
computeType (LTYPE (tree), RTYPE (tree));
TETYPE (tree) = getSpec (TTYPE (tree));
-#endif
+
LRVAL (tree) = RRVAL (tree) = 1;
return tree;
}
/* if bit field then error */
if (IS_BITVAR (tree->left->etype))
{
- werror (E_ILLEGAL_ADDR, "addrress of bit variable");
+ werror (E_ILLEGAL_ADDR, "address of bit variable");
goto errorTreeReturn;
}
goto errorTreeReturn;
}
- if (LRVAL (tree))
+ if (IS_LITERAL(LTYPE(tree)))
+ {
+ werror (E_ILLEGAL_ADDR, "address of literal");
+ goto errorTreeReturn;
+ }
+
+ if (LRVAL (tree))
{
werror (E_LVALUE_REQUIRED, "address of");
goto errorTreeReturn;
DCL_TYPE (p) = IPOINTER;
else if (SPEC_SCLS (tree->left->etype) == S_EEPROM)
DCL_TYPE (p) = EEPPOINTER;
+ else if (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))
{
}
TTYPE (tree) = copyLinkChain ((IS_PTR (LTYPE (tree)) || IS_ARRAY (LTYPE (tree))) ?
LTYPE (tree)->next : NULL);
- TETYPE (tree) = getSpec (TTYPE (tree));
- tree->args = tree->left->args;
- tree->hasVargs = tree->left->hasVargs;
+ TETYPE (tree) = getSpec (TTYPE (tree));
SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
return tree;
}
LRVAL (tree) = 1;
}
#else
+ /* 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);
+ }
/* if the right is a literal replace the tree */
if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree))) {
tree->type = EX_VALUE;
TTYPE (tree) = LTYPE (tree);
LRVAL (tree) = 1;
}
-#endif
-
+#endif
TETYPE (tree) = getSpec (TTYPE (tree));
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 '?' */
-/*----------------------------*/
+ /*----------------------------*/
case '?':
/* the type is value of the colon operator (on the right) */
assert(IS_COLON_OP(tree->right));
- TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree).
- TETYPE (tree) = getSpec (TTYPE (tree));
+ /* if already known then replace the tree : optimizer will do it
+ but faster to do it here */
+ if (IS_LITERAL (LTYPE(tree))) {
+ if ( ((int) floatFromVal (valFromType (LETYPE (tree)))) != 0) {
+ return decorateType(tree->right->left) ;
+ } else {
+ return decorateType(tree->right->right) ;
+ }
+ } else {
+ tree->right = decorateType(tree->right);
+ TTYPE (tree) = RTYPE(tree);
+ TETYPE (tree) = getSpec (TTYPE (tree));
+ }
return tree;
case ':':
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
case AND_ASSIGN:
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
}
LLVAL (tree) = 1;
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
tree->right = decorateType (newNode ('+', copyAst (tree->left), tree->right));
tree->opval.op = '=';
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
if (IS_VOID (LTYPE (tree)))
{
werror (E_CAST_ZERO);
- fprintf (stderr, "type --> '");
- printTypeChain (RTYPE (tree), stderr);
- fprintf (stderr, "' ");
- fprintf (stderr, "assigned to type --> '");
- printTypeChain (LTYPE (tree), stderr);
- fprintf (stderr, "'\n");
+ printFromToType(RTYPE(tree), LTYPE(tree));
}
TETYPE (tree) = getSpec (TTYPE (tree) =
goto errorTreeReturn;
}
- propAsgType (tree);
-
return tree;
/*------------------------------------------------------------------*/
parmNumber = 1;
if (processParms (tree->left,
- tree->left->args,
- tree->right, &parmNumber, TRUE))
+ FUNC_ARGS(tree->left->ftype),
+ tree->right, &parmNumber, TRUE)) {
goto errorTreeReturn;
+ }
- if (options.stackAuto || IS_RENT (LETYPE (tree)))
+ if ((options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) &&
+ !IFFUNC_ISBUILTIN(LTYPE(tree)))
{
- tree->left->args = reverseVal (tree->left->args);
+ //FUNC_ARGS(tree->left->ftype) =
+ //reverseVal (FUNC_ARGS(tree->left->ftype));
reverseParms (tree->right);
}
- tree->args = tree->left->args;
TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
return tree;
if (compareType (currFunc->type->next, RTYPE (tree)) == 0)
{
werror (W_RETURN_MISMATCH);
+ printFromToType (RTYPE(tree), currFunc->type->next);
goto errorTreeReturn;
}
/* if there is going to be a casing required then add it */
if (compareType (currFunc->type->next, RTYPE (tree)) < 0)
{
-#if 0 && defined DEMAND_INTEGER_PROMOTION
- if (IS_INTEGRAL (currFunc->type->next))
- {
- pushTypeCastToLeaves (currFunc->type->next, tree->right, &(tree->right));
- }
- else
-#endif
- {
- tree->right =
- decorateType (newNode (CAST,
- newAst_LINK (copyLinkChain (currFunc->type->next)),
- tree->right));
- }
+ tree->right =
+ decorateType (newNode (CAST,
+ newAst_LINK (copyLinkChain (currFunc->type->next)),
+ tree->right));
}
RRVAL (tree) = 1;
symbol *ifTrue, *ifFalse, *ifEnd;
/* if neither exists */
- if (!elseBody && !ifBody)
- return condAst;
+ if (!elseBody && !ifBody) {
+ // if there are no side effects (i++, j() etc)
+ if (!hasSEFcalls(condAst)) {
+ return condAst;
+ }
+ }
/* create the labels */
sprintf (buffer, "_iffalse_%d", Lblnum);
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 */
sym_link *fetype;
iCode *piCode = NULL;
+ if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
+ fprintf (stderr, "SDCCast.c:createFunction(%s)\n", name->name);
+
/* if check function return 0 then some problem */
- if (checkFunction (name) == 0)
+ if (checkFunction (name, NULL) == 0)
return NULL;
/* create a dummy block if none exists */
}
name->lastLine = yylineno;
currFunc = name;
- processFuncArgs (currFunc, 0);
+
+#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;
- if (IS_ISR (name->etype))
+ if (IFFUNC_ISISR (name->type))
stackPtr -= port->stack.direction * port->stack.isr_overhead;
- if (IS_RENT (name->etype) || options.stackAuto)
+ if (IFFUNC_ISREENT (name->type) || options.stackAuto)
stackPtr -= port->stack.direction * port->stack.reent_overhead;
xstackPtr = -port->stack.direction * port->stack.call_overhead;
fetype = getSpec (name->type); /* get the specifier for the function */
/* if this is a reentrant function then */
- if (IS_RENT (fetype))
+ if (IFFUNC_ISREENT (name->type))
reentrant++;
- allocParms (name->args); /* allocate the parameters */
+ allocParms (FUNC_ARGS(name->type)); /* allocate the parameters */
/* do processing for parameters that are passed in registers */
- processRegParms (name->args, body);
+ processRegParms (FUNC_ARGS(name->type), body);
/* set the stack pointer */
stackPtr = 0;
body = resolveSymbols (body); /* resolve the symbols */
body = decorateType (body); /* 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 = name->args;
-
+ ex->values.args = FUNC_ARGS(name->type);
+ ex->decorated=1;
+ if (options.dump_tree) PA(ex);
if (fatalError)
{
werror (E_FUNC_NO_CODE, name->name);
/* dealloc the block variables */
processBlockVars (body, &stack, DEALLOCATE);
/* deallocate paramaters */
- deallocParms (name->args);
+ deallocParms (FUNC_ARGS(name->type));
- if (IS_RENT (fetype))
+ if (IFFUNC_ISREENT (name->type))
reentrant--;
/* we are done freeup memory & cleanup */
noLineno--;
labelKey = 1;
name->key = 0;
- name->fbody = 1;
+ FUNC_HASBODY(name->type) = 1;
addSet (&operKeyReset, name);
applyToSet (operKeyReset, resetParmKey);
}
if (tree->opval.op == FUNCTION) {
- fprintf(outfile,"FUNCTION (%p) type (",tree);
+ 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->ftype,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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4,outfile);
- fprintf(outfile,"DECLARE SYMBOL %s, type(",decls->name);
+ 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+4);
+ ast_print(tree->right,outfile,indent+2);
+ INDENT(indent,outfile);
fprintf(outfile,"}\n");
return;
}
} else {
fprintf(outfile,"SYMBOL ");
}
- fprintf(outfile,"(%p) name= %s ",tree,tree->opval.val->sym->name);
+ fprintf(outfile,"(%s=%p)",
+ tree->opval.val->sym->name,tree);
}
if (tree->ftype) {
fprintf(outfile," type (");
fprintf(outfile,"ARRAY_OP (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
fprintf(outfile,"STRUCT_ACCESS (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"PTR_ACCESS (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"INC_OP (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
case DEC_OP:
fprintf(outfile,"DEC_OP (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"& (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
}
return ;
/*----------------------------*/
fprintf(outfile,"OR (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"XOR (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"DIV (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"MOD (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"DEREF (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
}
/*------------------------------------------------------------------*/
fprintf(outfile,"MULT (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
fprintf(outfile,"UPLUS (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
} else {
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"ADD (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
}
return;
/*------------------------------------------------------------------*/
fprintf(outfile,"UMINUS (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
} else {
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"SUB (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
}
return;
/*------------------------------------------------------------------*/
fprintf(outfile,"COMPL (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"NOT (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"RRC (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
+ 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+4);
+ 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+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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) type (",tree);
+ 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+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"GT(>) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
/*------------------------------------------------------------------*/
/*----------------------------*/
/* sizeof */
fprintf(outfile,"QUEST(?) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
fprintf(outfile,"MULASS(*=) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ 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+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"SUBASS(-=) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"ADDASS(+=) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"ASSIGN(=) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"COMMA(,) (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
/*------------------------------------------------------------------*/
/*----------------------------*/
fprintf(outfile,"CALL (%p) type (",tree);
printTypeChain(tree->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->left,outfile,indent+4);
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
+ ast_print(tree->right,outfile,indent+2);
return;
case PARAM:
- fprintf(outfile,"PARM ");
- ast_print(tree->left,outfile,indent+4);
- if (tree->right && !IS_AST_PARAM(tree->right)) {
- fprintf(outfile,"PARM ");
- ast_print(tree->right,outfile,indent+4);
+ 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 ;
/*------------------------------------------------------------------*/
fprintf(outfile,"RETURN (%p) type (",tree);
printTypeChain(tree->right->ftype,outfile);
fprintf(outfile,")\n");
- ast_print(tree->right,outfile,indent+4);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
/* label statement */
/*----------------------------*/
case LABEL :
- fprintf(outfile,"LABEL (%p)",tree);
- ast_print(tree->left,outfile,indent+4);
+ fprintf(outfile,"LABEL (%p)\n",tree);
+ ast_print(tree->left,outfile,indent+2);
ast_print(tree->right,outfile,indent);
return;
/*------------------------------------------------------------------*/
fprintf(outfile,"SWITCH (%p) ",tree);
ast_print(tree->left,outfile,0);
for (val = tree->values.switchVals.swVals; val ; val = val->next) {
- INDENT(indent+4,outfile);
+ INDENT(indent+2,outfile);
fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",
(int) floatFromVal(val),
tree->values.switchVals.swNum,
/* ifx Statement */
/*----------------------------*/
case IFX:
- ast_print(tree->left,outfile,indent);
- INDENT(indent,outfile);
fprintf(outfile,"IF (%p) \n",tree);
+ ast_print(tree->left,outfile,indent+2);
if (tree->trueLabel) {
INDENT(indent,outfile);
- fprintf(outfile,"NE(==) 0 goto %s\n",tree->trueLabel->name);
+ fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name);
}
if (tree->falseLabel) {
INDENT(indent,outfile);
fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name);
}
- ast_print(tree->right,outfile,indent);
+ ast_print(tree->right,outfile,indent+2);
return ;
/*------------------------------------------------------------------*/
/*----------------------------*/
case FOR:
fprintf(outfile,"FOR (%p) \n",tree);
if (AST_FOR( tree, initExpr)) {
- INDENT(indent+4,outfile);
+ INDENT(indent+2,outfile);
fprintf(outfile,"INIT EXPR ");
- ast_print(AST_FOR(tree, initExpr),outfile,indent+4);
+ ast_print(AST_FOR(tree, initExpr),outfile,indent+2);
}
if (AST_FOR( tree, condExpr)) {
- INDENT(indent+4,outfile);
+ INDENT(indent+2,outfile);
fprintf(outfile,"COND EXPR ");
- ast_print(AST_FOR(tree, condExpr),outfile,indent+4);
+ ast_print(AST_FOR(tree, condExpr),outfile,indent+2);
}
if (AST_FOR( tree, loopExpr)) {
- INDENT(indent+4,outfile);
+ INDENT(indent+2,outfile);
fprintf(outfile,"LOOP EXPR ");
- ast_print(AST_FOR(tree, loopExpr),outfile,indent+4);
+ ast_print(AST_FOR(tree, loopExpr),outfile,indent+2);
}
fprintf(outfile,"FOR LOOP BODY \n");
- ast_print(tree->left,outfile,indent+4);
+ ast_print(tree->left,outfile,indent+2);
return ;
default:
return ;
void PA(ast *t)
{
- ast_print(t,stdout,1);
+ ast_print(t,stdout,0);
}