Exemple #1
0
 ExpTy transVar(Absyn.SimpleVar v, boolean lhs) {
   Entry x = (Entry) env.venv.get(v.name);
   if (x instanceof VarEntry) {
     VarEntry ent = (VarEntry) x;
     if (lhs && ent instanceof LoopVarEntry) error(v.pos, "assignment to loop index");
     return new ExpTy(translate.SimpleVar(ent.access, level), ent.ty);
   }
   error(v.pos, "undeclared variable: " + v.name);
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #2
0
 ExpTy transExp(Absyn.RecordExp e) {
   Types.NAME name = (Types.NAME) env.tenv.get(e.typ);
   if (name != null) {
     Type actual = name.actual();
     if (actual instanceof Types.RECORD) {
       Types.RECORD r = (Types.RECORD) actual;
       return new ExpTy(translate.RecordExp(transFields(e.pos, r, e.fields)), name);
     }
     error(e.pos, "record type required");
   } else error(e.pos, "undeclared type: " + e.typ);
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #3
0
 ExpTy transVar(Absyn.SubscriptVar v) {
   ExpTy var = transVar(v.var);
   ExpTy index = transExp(v.index);
   checkInt(index, v.index.pos);
   Type actual = var.ty.actual();
   if (actual instanceof Types.ARRAY) {
     Types.ARRAY array = (Types.ARRAY) actual;
     return new ExpTy(translate.SubscriptVar(var.exp, index.exp), array.element);
   }
   error(v.var.pos, "array required");
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #4
0
 ExpTy transVar(Absyn.FieldVar v) {
   ExpTy var = transVar(v.var);
   Type actual = var.ty.actual();
   if (actual instanceof Types.RECORD) {
     int count = 0;
     for (Types.RECORD field = (Types.RECORD) actual; field != null; field = field.tail) {
       if (field.fieldName == v.field)
         return new ExpTy(translate.FieldVar(var.exp, count), field.fieldType);
       ++count;
     }
     error(v.pos, "undeclared field: " + v.field);
   } else error(v.var.pos, "record required");
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #5
0
 ExpTy transExp(Absyn.ArrayExp e) {
   Types.NAME name = (Types.NAME) env.tenv.get(e.typ);
   ExpTy size = transExp(e.size);
   ExpTy init = transExp(e.init);
   checkInt(size, e.size.pos);
   if (name != null) {
     Type actual = name.actual();
     if (actual instanceof Types.ARRAY) {
       Types.ARRAY array = (Types.ARRAY) actual;
       if (!init.ty.coerceTo(array.element)) error(e.init.pos, "element type mismatch");
       return new ExpTy(translate.ArrayExp(size.exp, init.exp), name);
     } else error(e.pos, "array type required");
   } else error(e.pos, "undeclared type: " + e.typ);
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #6
0
 ExpTy transExp(Absyn.CallExp e) {
   Entry x = (Entry) env.venv.get(e.func);
   if (x instanceof FunEntry) {
     FunEntry f = (FunEntry) x;
     ExpList args = transArgs(e.pos, f.formals, e.args);
     if (f.level == null)
       return new ExpTy(
           f.result.coerceTo(VOID)
               ? translate.ProcExp(e.func, args, level)
               : translate.FunExp(e.func, args, level),
           f.result);
     else
       return new ExpTy(
           f.result.coerceTo(VOID)
               ? translate.ProcExp(f.level, args, level)
               : translate.FunExp(f.level, args, level),
           f.result);
   }
   error(e.pos, "undeclared function: " + e.func);
   return new ExpTy(translate.Error(), VOID);
 }
Exemple #7
0
  ExpTy transExp(Absyn.Exp e) {
    ExpTy result;

    if (e == null) return new ExpTy(translate.Error(), VOID);
    else if (e instanceof Absyn.VarExp) result = transExp((Absyn.VarExp) e);
    else if (e instanceof Absyn.NilExp) result = transExp((Absyn.NilExp) e);
    else if (e instanceof Absyn.IntExp) result = transExp((Absyn.IntExp) e);
    else if (e instanceof Absyn.StringExp) result = transExp((Absyn.StringExp) e);
    else if (e instanceof Absyn.CallExp) result = transExp((Absyn.CallExp) e);
    else if (e instanceof Absyn.OpExp) result = transExp((Absyn.OpExp) e);
    else if (e instanceof Absyn.RecordExp) result = transExp((Absyn.RecordExp) e);
    else if (e instanceof Absyn.SeqExp) result = transExp((Absyn.SeqExp) e);
    else if (e instanceof Absyn.AssignExp) result = transExp((Absyn.AssignExp) e);
    else if (e instanceof Absyn.IfExp) result = transExp((Absyn.IfExp) e);
    else if (e instanceof Absyn.WhileExp) result = transExp((Absyn.WhileExp) e);
    else if (e instanceof Absyn.ForExp) result = transExp((Absyn.ForExp) e);
    else if (e instanceof Absyn.BreakExp) result = transExp((Absyn.BreakExp) e);
    else if (e instanceof Absyn.LetExp) result = transExp((Absyn.LetExp) e);
    else if (e instanceof Absyn.ArrayExp) result = transExp((Absyn.ArrayExp) e);
    else throw new Error("Semant.transExp");
    e.type = result.ty;
    return result;
  }