struct expty transExp(Tr_level level, S_table venv, S_table tenv, A_exp a, Temp_label breakk) {
switch (a->kind) {
case A_varExp: return transVar(level, venv, tenv, a->u.var, breakk);
case A_nilExp: return expTy(Tr_nilExp(), Ty_Nil());
case A_intExp: return expTy(Tr_intExp(a->u.intt), Ty_Int());
case A_stringExp: return expTy(Tr_stringExp(a->u.stringg), Ty_String());
case A_breakExp: return expTy(Tr_breakExp(breakk), Ty_Void());
case A_callExp: return transExp_callExp( level, venv, tenv, a, breakk);
case A_opExp: return transExp_opExp( level, venv, tenv, a, breakk);
case A_recordExp: return transExp_recordExp(level, venv, tenv, a, breakk);
case A_seqExp: return transExp_seqExp( level, venv, tenv, a, breakk);
case A_assignExp: return transExp_assignExp(level, venv, tenv, a, breakk);
case A_ifExp: return transExp_ifExp( level, venv, tenv, a, breakk);
case A_whileExp: return transExp_whileExp( level, venv, tenv, a, breakk);
case A_forExp: return transExp_forExp( level, venv, tenv, a, breakk);
case A_letExp: return transExp_letExp( level, venv, tenv, a, breakk);
case A_arrayExp: return transExp_arrayExp( level, venv, tenv, a, breakk);
}
assert(0); /* should have returned from some clause of the switch */
}
static struct expty transExp(Tr_level level, Tr_exp breakk, S_table v, S_table t, A_exp e){
if (!e) { return expTy(Tr_noExp(), Ty_Void()); }
switch (e->kind) {
case A_varExp:
return transVar(level, breakk, v, t, e->u.var);
case A_nilExp:
return expTy(Tr_nilExp(), Ty_Nil());
case A_callExp: {
E_enventry callinfo = S_look(v, e->u.call.func); /*get params and return from tenv*/
A_expList args = NULL;
Tr_expList argList = NULL;
Ty_tyList formals;
Tr_exp trans = Tr_noExp();
if (callinfo && callinfo->kind == E_funEntry){
formals = callinfo->u.fun.formals;
/*
if (args_match(level, breakk, v, t, e->u.call.args, callinfo->u.fun.formals, e)) {//check params is matched
if (callinfo->u.fun.result) {
return expTy(trans, actual_ty(callinfo->u.fun.result));
}
}*/
for (args = e->u.call.args; args && formals; args = args->tail, formals = formals->tail) { /*memory args-info by order*/
struct expty arg = transExp(level, breakk, v, t, args->head);
if (!ty_match(arg.ty, formals->head)) EM_error(args->head->pos, "unmatched type in function %s", S_name(e->u.call.func));
Tr_expList_prepend(arg.exp, &argList);
}
if (!args && formals) EM_error(e->pos, "short few paras");
if (args && !formals) EM_error(e->pos, "too many paras");
trans = Tr_callExp(callinfo->u.fun.label, callinfo->u.fun.level, level, &argList);
return expTy(trans, actual_ty(callinfo->u.fun.result));
} else {
EM_error(e->pos, "undefined function %s\n", S_name(e->u.call.func));
return expTy(trans, Ty_Int());
}
}
case A_recordExp: {/*record create*/
Ty_ty recty = actual_ty(S_look(t, e->u.record.typ));
if (!recty) { /*cant find record-type in table tenv*/
EM_error(e->pos, "undefined type %s (debug recordExp)", S_name(e->u.record.typ));
} else {
if (recty->kind != Ty_record){
EM_error(e->pos, "%s is not a record type", S_name(e->u.record.typ));
return expTy(Tr_noExp(), Ty_Record(NULL));
}
/*
if (efields_match(level, breakk, v, t, recty, e)) {//check record field is matched
Tr_expList l = NULL;
int n = 0;
A_efieldList el;
for (el = e->u.record.fields; el; el = el->tail, n++) {
struct expty val = transExp(level, breakk, v, t, el->head->exp);
Tr_expList_prepend(val.exp, &l);
}
return expTy(Tr_recordExp(n, l), recty);
}*/
Ty_fieldList fieldTys = recty->u.record;
A_efieldList recList;
Tr_expList list = NULL;
int n = 0;
for (recList = e->u.record.fields; recList; recList = recList->tail, fieldTys = fieldTys->tail, n++) {
struct expty et = transExp(level, breakk, v, t, recList->head->exp);
if (recList->head->name != fieldTys->head->name) EM_error(e->pos, "%s not a valid field name", recList->head->name);
if (!ty_match(fieldTys->head->ty, et.ty)) EM_error(recList->head->exp->pos, "type error: given %s but expected %s");
Tr_expList_prepend(et.exp, &list);
}
return expTy(Tr_recordExp(n, list), recty);
}
return expTy(Tr_noExp(), Ty_Record(NULL));
}
case A_arrayExp: {/*array create*/
Ty_ty arrayty = actual_ty(S_look(t, e->u.array.typ));
if (!arrayty) {
EM_error(e->pos, "undeined array type %s", S_name(e->u.array.typ));
return expTy(Tr_noExp(), Ty_Int());
}
if (arrayty->kind != Ty_array) {
EM_error(e->pos, "%s is not a array type", S_name(e->u.array.typ));
return expTy(Tr_noExp(), Ty_Int());
}
struct expty final2 = transExp(level, breakk, v, t, e->u.array.size);
struct expty final3 = transExp(level, breakk, v, t, e->u.array.init);
if (final2.ty->kind != Ty_int) {
EM_error(e->pos, "array size should be int %s", S_name(e->u.array.typ));
} else if (!ty_match(final3.ty, arrayty->u.array)){
EM_error(e->pos, "unmatched array type in %s", S_name(e->u.array.typ));
} else {
return expTy(Tr_arrayExp(final2.exp, final3.exp), arrayty);
}
return expTy(Tr_noExp(), Ty_Int());
}
case A_seqExp: {
Tr_expList l = NULL;
A_expList list = e->u.seq;
struct expty seqone;
if (!list) {
return expTy(Tr_noExp(), Ty_Void());
}
for (; list; list = list->tail) {
seqone = transExp(level, breakk, v, t, list->head);
Tr_expList_prepend(seqone.exp, &l);
}
return expTy(Tr_seqExp(l), seqone.ty);
}
case A_whileExp: {
struct expty final = transExp(level, breakk, v, t, e->u.whilee.test);
if (final.ty->kind != Ty_int) {
EM_error(e->pos, "int required");
}
Tr_exp done = Tr_doneExp();
struct expty body = transExp(level, done, v, t, e->u.whilee.body);
return expTy(Tr_whileExp(final.exp, body.exp, done), Ty_Void());
}
case A_assignExp: {
struct expty final4 = transVar(level, breakk, v, t, e->u.assign.var);
struct expty final5 = transExp(level, breakk, v, t, e->u.assign.exp);
if (!ty_match(final4.ty, final5.ty)) {
EM_error(e->pos, "unmatched assign exp");
}
return expTy(Tr_assignExp(final4.exp, final5.exp), Ty_Void());
}
case A_breakExp:
if (!breakk) return expTy(Tr_noExp(), Ty_Void());
return expTy(Tr_breakExp(breakk), Ty_Void());
case A_forExp: {
EM_error(e->pos, "\nsome one said for is better than while\nmake them unhappy \nahahaha");
return expTy(Tr_noExp(), Ty_Int());
}
case A_letExp: {
A_decList decs;
Tr_expList l = NULL;
S_beginScope(v);
S_beginScope(t);
for (decs = e->u.let.decs; decs; decs = decs->tail) {
Tr_expList_prepend(transDec(level, breakk, v, t, decs->head), &l);
}
struct expty final = transExp(level, breakk, v, t, e->u.let.body);
Tr_expList_prepend(final.exp, &l);
S_endScope(v);
S_endScope(t);
return expTy(Tr_seqExp(l), final.ty);
}
case A_opExp: {
A_oper oper = e->u.op.oper;
struct expty left = transExp(level, breakk, v, t, e->u.op.left);
struct expty right = transExp(level, breakk, v, t, e->u.op.right);
if (0 <= oper && oper < 4) {/* check +,-,*,/ */
if (left.ty->kind != Ty_int && left.ty->kind != Ty_double){
EM_error(e->u.op.left->pos, "int or double required(op)");
} else if (right.ty->kind != Ty_int && right.ty->kind != Ty_double) {
EM_error(e->u.op.right->pos, "int or double required(op)");
} else if (left.ty->kind == Ty_int && right.ty->kind == Ty_int) {
return expTy(Tr_arithExp(oper, left.exp, right.exp), Ty_Int());
} else {
return expTy(Tr_arithExp(oper, left.exp, right.exp), Ty_Double());
}
return expTy(Tr_noExp(), Ty_Int());
} else if (3 < oper && oper < 10) {
Tr_exp translation = Tr_noExp();
if (oper == 4 || oper == 5) {/*check record type can be nil(=, <>)*/
switch(left.ty->kind) {
case Ty_int:
case Ty_double:/*see is double query like int TODO*/
if (right.ty->kind == Ty_int || right.ty->kind == Ty_double) translation = Tr_eqExp(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
case Ty_string:
if (ty_match(right.ty, left.ty)) translation = Tr_eqStringExp(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
case Ty_array:
if (ty_match(right.ty, left.ty)) translation = Tr_eqRef(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
case Ty_record:
if (ty_match(right.ty, left.ty) || right.ty->kind == Ty_nil) translation = Tr_eqRef(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
default:
EM_error(e->u.op.right->pos, "unexpected expression in comparsion");
}
return expTy(translation, Ty_Int());
} else {
switch(left.ty->kind) {
case Ty_double:
case Ty_int:
if (right.ty->kind == Ty_double || right.ty->kind == Ty_int) translation = Tr_relExp(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
case Ty_string:
if (right.ty->kind == Ty_string) translation = Tr_eqStringExp(oper, left.exp, right.exp);
else {EM_error(e->u.op.right->pos, "unexpected type in comparsion");}
break;
default:
EM_error(e->u.op.right->pos, "unexpected type in comparsion");
}
return expTy(translation, Ty_Int());
}
} else {
assert(0);
}
}
case A_ifExp: {
struct expty final = transExp(level, breakk, v, t, e->u.iff.test);
struct expty final2 = transExp(level, breakk, v, t, e->u.iff.then);
struct expty final3 = {NULL, NULL};
if (e->u.iff.elsee) { /*no else-part*/
final3 = transExp(level, breakk, v, t, e->u.iff.elsee);
if (final.ty->kind != Ty_int){
EM_error(e->u.iff.test->pos, "int required");
}
if(!ty_match(final2.ty, final3.ty)) {
EM_error(e->pos, "if-else sentence must return same type");
}
}
return expTy(Tr_ifExp(final.exp, final2.exp, final3.exp), final2.ty);
}
case A_stringExp:
return expTy(Tr_stringExp(e->u.stringg), Ty_String());
case A_intExp:
return expTy(Tr_intExp(e->u.intt), Ty_Int());
case A_doubleExp:
return expTy(Tr_doubleExp(e->u.doublee), Ty_Double());
default:
assert(0);
}
