A_exp ret_Refold(A_pos pos, A_oper oper, A_exp left, A_exp right)
{
A_exp p = checked_malloc(sizeof(*p));
p->kind = A_opExp;
p->pos = pos;
p->u.op.oper = oper;
p->u.op.left = left;
p->u.op.right = right;
//printf("VINPRINT: Left operation : %d , Right_operation: %d, Left kind : %d , Current Operation : %d , Left value:%d Right value:%d ,Right kind : %d Right value: %d\n",left->u.op.oper,right->u.op.oper,left->kind,oper,left->u.intt,right->u.intt,right->kind,right->u.intt);
if (left->kind == A_intExp && right->kind == A_intExp)
{
int l,r;
l=left->u.intt;
r=right->u.intt;
//printf("VINPRINT: Entered int int oper %d pos %d\n",oper,pos);
//printf("VINPRINT:!!@$@#$ Entered int int oper %d pos %d\n",oper,pos);
//Checking operation and performing const folding
switch(oper)
{
case A_plusOp: folded=1;return A_IntExp(pos, (left->u.intt) + (right->u.intt));break;
case A_minusOp: folded=1;return A_IntExp(pos, left->u.intt - right->u.intt);break;
case A_timesOp: folded=1;return A_IntExp(pos, left->u.intt * right->u.intt);break;
case A_divideOp: folded=1;return A_IntExp(pos, left->u.intt / right->u.intt);break;
default: return p; break;
}
}
else if ( (left->kind == A_opExp && right->kind == A_intExp) && ((left->u.op.oper)!= A_timesOp) &&((left->u.op.oper)!= A_divideOp)&&((left->u.op.right)->kind==A_intExp))
{
A_exp leftexp,op_chl,op_chr;
leftexp= left->u.op.right;
//printf("VINPRINT: Entered here\n");
//Checking operation and performing const folding
switch(oper)
{
case A_plusOp: leftexp->u.intt = leftexp->u.intt + right->u.intt;break;
case A_minusOp: leftexp->u.intt = leftexp->u.intt - right->u.intt;break;
case A_timesOp: leftexp->u.intt = leftexp->u.intt * right->u.intt;break;
case A_divideOp: leftexp->u.intt = leftexp->u.intt / right->u.intt;break;
default: return p; break;
}
folded=1;
left->u.op.right = leftexp;
return left;
}
else
{
//printf("VINPRINT: Entered last else Operation : %d , Right Exp operation: %d\n",p->u.op.oper, (p->u.op.right)->u.op.oper);
return p;
folded=0;
}
}
struct expty transExp_forExp(Tr_level level, S_table venv, S_table tenv, A_exp a, Temp_label breakk) {
struct expty lo = transExp(level, venv, tenv, a->u.forr.lo, breakk);
struct expty hi = transExp(level, venv, tenv, a->u.forr.hi, breakk);
if (lo.ty->kind != Ty_int || hi.ty->kind != Ty_int)
EM_error(a->u.forr.lo->pos, "lo or hi expr is not int");
/*
* LET VAR i := lo
* VAR lmt := hi
* IN
* IF lo < hi THEN
* WHILE i <= lmt DO
* (body;
* i := i+1)
*/
A_pos pos1 = a->pos;
A_pos pos2 = a->u.forr.body->pos;
S_symbol var = a->u.forr.var;
S_symbol lmt = S_Symbol("limit");
A_exp ebody = a->u.forr.body;
A_exp transformed = A_LetExp(pos1,
A_DecList(A_VarDec(pos1, var, S_Symbol("int"), a->u.forr.lo),
A_DecList(A_VarDec(pos1, lmt, S_Symbol("int"), a->u.forr.hi), NULL)),
A_IfExp(pos1,
A_OpExp(pos1, A_ltOp, a->u.forr.lo, a->u.forr.hi),
A_WhileExp(pos1,
A_OpExp(pos1, A_leOp, A_VarExp(pos1, A_SimpleVar(pos1, var)), A_VarExp(pos1, A_SimpleVar(pos1, lmt))),
A_SeqExp(pos2, A_ExpList(ebody,
A_ExpList(A_OpExp(pos1, A_plusOp, A_VarExp(pos1, A_SimpleVar(pos1, var)), A_IntExp(pos1, 1)),
A_ExpList(A_SeqExp(pos2, NULL), // return no value
NULL))))),
NULL)
);
return transExp(level, venv, tenv, transformed, breakk);
}
/* Print A_var types. Indent d spaces. */
void retReplace_exp( A_exp *v, int d) {
//printf("Entered here retexp %d\n", (*v)->kind);
//indent( d);
switch ((*v)->kind) {
case A_varExp:
//fprintf( "varExp(\n");
//printf( "varExp(\n");
if(((*v)->u.var)->kind == A_simpleVar)
{
if(ret_TableMatch((*v)->u.var))
{ //printf("here 1\n");
printf("Replacing Variable %s ",S_name(((*v)->u.var)->u.simple));
(*v) = A_IntExp(((*v)->u.var)->pos,current_Const);
//printf("here 2\n");
}
}
else
{
ret_var( &(*v)->u.var, d+1);
}
//f//printf( "%s", ")");
break;
case A_nilExp:
//fprintf( "nilExp()");
//printf( "nilExp()");
break;
case A_intExp:
//fprintf( "intExp(%d)", (*v)->u.intt);
//printf( "intExp(%d)", (*v)->u.intt);
break;
case A_stringExp:
//fprintf( "stringExp(%s)", (*v)->u.stringg);
//printf( "stringExp(%s)", (*v)->u.stringg);
break;
case A_callExp:
//fprintf( "callExp(%s,\n", S_name((*v)->u.call.func));
//printf( "callExp(%s,\n", S_name((*v)->u.call.func));
ret_expList( &(*v)->u.call.args, d+1); //fprintf( ")");
break;
case A_opExp:
ret_oper( (*v)->u.op.oper); //fprintf( ",\n");
retReplace_exp( &(*v)->u.op.left, d+1); //fprintf( ",\n");
retReplace_exp( &(*v)->u.op.right, d+1); ////fprintf( ")");
break;
case A_recordExp:
////fprintf( "recordExp(%s,\n", S_name((*v)->u.record.typ));
ret_efieldList( &(*v)->u.record.fields, d+1); ////fprintf( ")");
break;
case A_seqExp:
////fprintf( "seqExp(\n");
ret_expList( &(*v)->u.seq, d+1); ////fprintf( ")");
break;
case A_assignExp:
////fprintf( "assignExp(\n");
//printf( "assignExp(\n");
ret_var( &(*v)->u.assign.var, d+1); ////fprintf( ",\n");
//printf("fine here11!!!");
retReplace_exp( &(*v)->u.assign.exp, d+1); ////fprintf( ")");
break;
case A_ifExp:
////fprintf( "iffExp(\n");
retReplace_exp( &(*v)->u.iff.test, d+1); ////fprintf( ",\n");
retReplace_exp( &(*v)->u.iff.then, d+1);
if ((*v)->u.iff.elsee) { /* else is optional */
////fprintf( ",\n");
retReplace_exp( &(*v)->u.iff.elsee, d+1);
}
//fprintf( ")");
break;
case A_whileExp:
//fprintf( "whileExp(\n");
retReplace_exp( &(*v)->u.whilee.test, d+1); //fprintf( ",\n");
retReplace_exp( &(*v)->u.whilee.body, d+1); //fprintf( ")\n");
break;
case A_forExp:
//fprintf( "forExp(%s,\n", S_name((*v)->u.forr.var));
retReplace_exp( &(*v)->u.forr.lo, d+1); //fprintf( ",\n");
retReplace_exp( &(*v)->u.forr.hi, d+1); //fprintf( "%s\n", ",");
retReplace_exp( &(*v)->u.forr.body, d+1); //fprintf( ",\n");
//indent( d+1); //fprintf( "%s", (*v)->u.forr.escape ? "TRUE)" : "FALSE)");
break;
case A_breakExp:
//fprintf( "breakExp()");
break;
case A_letExp:
//fprintf( "letExp(\n");
ret_decList( &(*v)->u.let.decs, d+1); //fprintf( ",\n");
retReplace_exp( &(*v)->u.let.body, d+1); //fprintf( ")");
break;
case A_arrayExp:
//fprintf( "arrayExp(%s,\n", S_name((*v)->u.array.typ));
retReplace_exp( &(*v)->u.array.size, d+1); //fprintf( ",\n");
retReplace_exp( &(*v)->u.array.init, d+1); //fprintf( ")");
break;
default:
assert(0);
}
}
