X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCast.c;h=c631350c72defa5c8b0bf8dd0ff4a0b7a3d06b46;hb=8e771bbd4bcbc2c888bd57e4877f364a63e24787;hp=9dfec48e8d0d0ad50c56340a631bef0fe04f25a8;hpb=363e76eba5dcf06d97647df94f0518b314dd29c6;p=fw%2Fsdcc diff --git a/src/SDCCast.c b/src/SDCCast.c index 9dfec48e..c631350c 100644 --- a/src/SDCCast.c +++ b/src/SDCCast.c @@ -559,6 +559,7 @@ funcOfType (char *name, sym_link * type, sym_link * argType, { args->type = copyLinkChain (argType); args->etype = getSpec (args->type); + SPEC_EXTR(args->etype)=1; if (!nArgs) break; args = args->next = newValue (); @@ -573,6 +574,46 @@ funcOfType (char *name, sym_link * type, sym_link * argType, } +/*-----------------------------------------------------------------*/ +/* 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 */ /*-----------------------------------------------------------------*/ @@ -605,7 +646,7 @@ processParms (ast * func, value *defParm, ast * actParm, int *parmNumber, // unused, although updated - bool rightmost) // double checked? + bool rightmost) { /* if none of them exist */ if (!defParm && !actParm) @@ -643,7 +684,7 @@ processParms (ast * func, return 1; } - if (IS_VOID(actParm->etype)) { + if (IS_VOID(actParm->ftype)) { werror (E_VOID_VALUE_USED); return 1; } @@ -661,20 +702,7 @@ processParms (ast * func, 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) @@ -697,7 +725,7 @@ processParms (ast * func, 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; @@ -734,7 +762,7 @@ processParms (ast * func, * Therefore, if there are more defined parameters, the caller didn't * supply enough. */ - if (0 && rightmost && defParm->next) + if (rightmost && defParm->next) { werror (E_TOO_FEW_PARMS); return 1; @@ -751,7 +779,7 @@ processParms (ast * func, /* 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; @@ -760,6 +788,8 @@ processParms (ast * func, actParm->right = pTree; actParm->etype = defParm->etype; actParm->ftype = defParm->type; + actParm->decorated=0; /* force typechecking */ + decorateType (actParm); } /* make a copy and change the regparm type to the defined parm */ @@ -814,6 +844,12 @@ createIvalStruct (ast * sym, sym_link * type, initList * ilist) 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; } @@ -871,7 +907,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist) 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 @@ -896,7 +932,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist) // 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; } @@ -1032,7 +1068,7 @@ ast * initAggregates (symbol * sym, initList * ival, ast * wid) { 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); } @@ -1099,11 +1135,16 @@ gatherAutoInit (symbol * autoChain) 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); @@ -1119,11 +1160,16 @@ gatherAutoInit (symbol * autoChain) /* 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; @@ -1929,7 +1975,9 @@ decorateType (ast * tree) 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 */ @@ -2087,38 +2135,10 @@ decorateType (ast * 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; } @@ -2172,8 +2192,10 @@ decorateType (ast * tree) 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)) { @@ -2719,6 +2741,12 @@ decorateType (ast * 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; @@ -2733,8 +2761,7 @@ decorateType (ast * tree) TTYPE (tree) = LTYPE (tree); LRVAL (tree) = 1; } -#endif - +#endif TETYPE (tree) = getSpec (TTYPE (tree)); return tree; @@ -2860,6 +2887,79 @@ decorateType (ast * 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 '?' */ @@ -2869,14 +2969,15 @@ decorateType (ast * tree) 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 { - TTYPE (tree) = RTYPE(tree); // #HACK LTYPE(tree). + tree->right = decorateType(tree->right); + TTYPE (tree) = RTYPE(tree); TETYPE (tree) = getSpec (TTYPE (tree)); } return tree; @@ -3093,13 +3194,14 @@ decorateType (ast * tree) if (processParms (tree->left, FUNC_ARGS(tree->left->ftype), - tree->right, &parmNumber, TRUE)) + tree->right, &parmNumber, TRUE)) { goto errorTreeReturn; + } if (options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) { - //IFFUNC_ARGS(tree->left->ftype) = - //reverseVal (IFFUNC_ARGS(tree->left->ftype)); + //FUNC_ARGS(tree->left->ftype) = + //reverseVal (FUNC_ARGS(tree->left->ftype)); reverseParms (tree->right); } @@ -3960,6 +4062,63 @@ optimizeCompare (ast * root) vright = (root->right->type == EX_VALUE ? root->right->opval.val : NULL); + //#define EXPERIMENTAL +#ifdef EXPERIMENTAL + /* if left is unsigned and right is literal */ + if (vleft && vright && + IS_UNSIGNED(vleft->etype) && + IS_LITERAL(vright->etype)) { + double dval=floatFromVal(vright); + int op=root->opval.op; + + fprintf (stderr,"op: '"); + switch (op) { + case LE_OP: fprintf (stderr, "<= '"); break; + case EQ_OP: fprintf (stderr, "== '"); break; + case GE_OP: fprintf (stderr, ">= '"); break; + default: fprintf (stderr, "%c '", op); break; + } + fprintf (stderr, "%f\n", dval); + + switch (op) + { + case EQ_OP: + case LE_OP: + case '<': + if (dval<0 || (op=='<' && dval==0)) { + // unsigned is never < 0 + werror (W_IF_NEVER_TRUE); + optExpr = newAst_VALUE (constVal("0")); + return decorateType (optExpr); + } + if (dval==0) { + if (op==LE_OP) { + // change this into a cheaper EQ_OP + fprintf (stderr, "warning *** changed '<=' to '==' because of unsigned\n"); + root->opval.op=EQ_OP; + return root; + } + } + break; + case GE_OP: + case '>': + if (dval>0 || (op==GE_OP && dval==0)) { + // unsigned is never < 0 + werror (W_IF_ALWAYS_TRUE); + optExpr = newAst_VALUE (constVal("1")); + return decorateType (optExpr); + } + if (dval==0) { + if (op=='>') { + // change this into a cheaper reversed EQ_OP + fprintf (stderr, "warning *** changed '>' to '!=' because of unsigned\n"); + root->opval.op=EQ_OP; + } + } + } + } +#endif + /* if left is a BITVAR in BITSPACE */ /* and right is a LITERAL then opt- */ /* imize else do nothing */ @@ -4100,6 +4259,9 @@ createFunction (symbol * name, ast * body) 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, NULL) == 0) return NULL; @@ -4130,7 +4292,10 @@ createFunction (symbol * name, ast * body) } 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 */ @@ -4171,7 +4336,7 @@ createFunction (symbol * name, ast * body) 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 = FUNC_ARGS(name->type); ex->decorated=1; @@ -4265,27 +4430,40 @@ void ast_print (ast * tree, FILE *outfile, int indent) } 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+4,outfile); + 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); - INDENT(indent+4,outfile); + ast_print(tree->right,outfile,indent+2); + INDENT(indent,outfile); fprintf(outfile,"}\n"); return; } @@ -4318,7 +4496,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) } 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 ("); @@ -4350,8 +4529,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ @@ -4362,8 +4541,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4374,8 +4553,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4386,14 +4565,14 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4405,14 +4584,14 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*----------------------------*/ @@ -4422,8 +4601,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4433,8 +4612,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4445,8 +4624,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4456,8 +4635,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4469,7 +4648,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; } /*------------------------------------------------------------------*/ @@ -4479,8 +4658,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; @@ -4494,7 +4673,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 { /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4503,8 +4682,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ @@ -4516,7 +4695,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 { /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4525,8 +4704,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ @@ -4537,7 +4716,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4547,7 +4726,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4557,59 +4736,61 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4620,43 +4801,43 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 */ @@ -4673,16 +4854,16 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4693,50 +4874,50 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4746,8 +4927,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4757,8 +4938,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4768,8 +4949,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4779,8 +4960,8 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4791,15 +4972,14 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; /*------------------------------------------------------------------*/ @@ -4810,15 +4990,15 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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; /*------------------------------------------------------------------*/ @@ -4831,7 +5011,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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, @@ -4846,7 +5026,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) /*----------------------------*/ case IFX: fprintf(outfile,"IF (%p) \n",tree); - ast_print(tree->left,outfile,indent+4); + ast_print(tree->left,outfile,indent+2); if (tree->trueLabel) { INDENT(indent,outfile); fprintf(outfile,"NE(!=) 0 goto %s\n",tree->trueLabel->name); @@ -4855,7 +5035,7 @@ void ast_print (ast * tree, FILE *outfile, int indent) INDENT(indent,outfile); fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name); } - ast_print(tree->right,outfile,indent+4); + ast_print(tree->right,outfile,indent+2); return ; /*------------------------------------------------------------------*/ /*----------------------------*/ @@ -4864,22 +5044,22 @@ void ast_print (ast * tree, FILE *outfile, int indent) 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 ; @@ -4888,5 +5068,5 @@ void ast_print (ast * tree, FILE *outfile, int indent) void PA(ast *t) { - ast_print(t,stdout,1); + ast_print(t,stdout,0); }