CS计算机代考程序代写 Java package typelang;

程序代写 CS代考 / Java代写代考

package typelang;
import static typelang.AST.*;
import static typelang.Heap.*;
import static typelang.Value.*;

import java.util.List;
import java.util.ArrayList;
import java.io.File;
import java.io.IOException;

import typelang.Env.*;

public class Evaluator implements Visitor> {

Printer.Formatter ts = new Printer.Formatter();

Env initEnv = initialEnv(); //New for definelang
Heap heap = new Heap16Bit(); //New for reflang

Value valueOf(Program p) {
return (Value) p.accept(this, initEnv);
}

@Override
public Value visit(AddExp e, Env env) {
List operands = e.all();
int result = 0;
for(Exp exp: operands) {
NumVal intermediate = (NumVal) exp.accept(this, env); // Dynamic type-checking
result += intermediate.v(); //Semantics of AddExp in terms of the target language.
}
return new NumVal(result);
}

@Override
public Value visit(UnitExp e, Env env) {
return new UnitVal();
}

@Override
public Value visit(NumExp e, Env env) {
return new NumVal(e.v());
}

@Override
public Value visit(StrExp e, Env env) {
return new StringVal(e.v());
}

@Override
public Value visit(BoolExp e, Env env) {
return new BoolVal(e.v());
}

@Override
public Value visit(DivExp e, Env env) {
List operands = e.all();
NumVal lVal = (NumVal) operands.get(0).accept(this, env);
double result = lVal.v();
for(int i=1; i env) {
List operands = e.all();
double result = 1;
for(Exp exp: operands) {
NumVal intermediate = (NumVal) exp.accept(this, env); // Dynamic type-checking
result *= intermediate.v(); //Semantics of MultExp.
}
return new NumVal(result);
}

@Override
public Value visit(Program p, Env env) {
try {
for(DefineDecl d: p.decls())
d.accept(this, initEnv);
return (Value) p.e().accept(this, initEnv);
} catch (ClassCastException e) {
return new DynamicError(e.getMessage());
}
}

@Override
public Value visit(SubExp e, Env env) {
List operands = e.all();
NumVal lVal = (NumVal) operands.get(0).accept(this, env);
double result = lVal.v();
for(int i=1; i env) {
// Previously, all variables had value 42. New semantics.
return env.get(e.name());
}

@Override
public Value visit(LetExp e, Env env) { // New for varlang.
List names = e.names();
List value_exps = e.value_exps();
List values = new ArrayList(value_exps.size());

for(Exp exp : value_exps)
values.add((Value)exp.accept(this, env));

Env new_env = env;
for (int index = 0; index < names.size(); index++) new_env = new ExtendEnv(new_env, names.get(index), values.get(index));

return (Value) e.body().accept(this, new_env);
}

@Override
public Value visit(DefineDecl e, Env env) { // New for definelang.
String name = e.name();
Exp value_exp = e.value_exp();
Value value = (Value) value_exp.accept(this, env);
((GlobalEnv) initEnv).extend(name, value);
return new Value.UnitVal();
}

@Override
public Value visit(LambdaExp e, Env env) { // New for funclang.
return new Value.FunVal(env, e.formals(), e.body());
}

@Override
public Value visit(CallExp e, Env env) { // New for funclang.
Object result = e.operator().accept(this, env);
if(!(result instanceof Value.FunVal))
return new Value.DynamicError(“Operator not a function in call ” + ts.visit(e, null));
Value.FunVal operator = (Value.FunVal) result; //Dynamic checking
List operands = e.operands();

// Call-by-value semantics
List actuals = new ArrayList(operands.size());
for(Exp exp : operands)
actuals.add((Value)exp.accept(this, env));

List formals = operator.formals();
if (formals.size()!=actuals.size())
return new Value.DynamicError(“Argument mismatch in call ” + ts.visit(e, null));

Env fun_env = operator.env();
for (int index = 0; index < formals.size(); index++) fun_env = new ExtendEnv(fun_env, formals.get(index), actuals.get(index));

return (Value) operator.body().accept(this, fun_env);
}

@Override
public Value visit(IfExp e, Env env) { // New for funclang.
Object result = e.conditional().accept(this, env);
if(!(result instanceof Value.BoolVal))
return new Value.DynamicError(“Condition not a boolean in expression ” + ts.visit(e, null));
Value.BoolVal condition = (Value.BoolVal) result; //Dynamic checking

if(condition.v())
return (Value) e.then_exp().accept(this, env);
else return (Value) e.else_exp().accept(this, env);
}

@Override
public Value visit(LessExp e, Env env) { // New for funclang.
Value.NumVal first = (Value.NumVal) e.first_exp().accept(this, env);
Value.NumVal second = (Value.NumVal) e.second_exp().accept(this, env);
return new Value.BoolVal(first.v() < second.v()); } @Override public Value visit(EqualExp e, Env env) { // New for funclang.
Value.NumVal first = (Value.NumVal) e.first_exp().accept(this, env);
Value.NumVal second = (Value.NumVal) e.second_exp().accept(this, env);
return new Value.BoolVal(first.v() == second.v());
}

@Override
public Value visit(GreaterExp e, Env env) { // New for funclang.
Value.NumVal first = (Value.NumVal) e.first_exp().accept(this, env);
Value.NumVal second = (Value.NumVal) e.second_exp().accept(this, env);
return new Value.BoolVal(first.v() > second.v());
}

@Override
public Value visit(CarExp e, Env env) {
Value.PairVal pair = (Value.PairVal) e.arg().accept(this, env);
return pair.fst();
}

@Override
public Value visit(CdrExp e, Env env) {
Value.PairVal pair = (Value.PairVal) e.arg().accept(this, env);
return pair.snd();
}

@Override
public Value visit(ConsExp e, Env env) {
Value first = (Value) e.fst().accept(this, env);
Value second = (Value) e.snd().accept(this, env);
return new Value.PairVal(first, second);
}

@Override
public Value visit(ListExp e, Env env) { // New for funclang.
List elemExps = e.elems();
int length = elemExps.size();
if(length == 0)
return new Value.Null();

//Order of evaluation: left to right e.g. (list (+ 3 4) (+ 5 4))
Value[] elems = new Value[length];
for(int i=0; i=0; i–)
result = new PairVal(elems[i], result);
return result;
}

@Override
public Value visit(NullExp e, Env env) {
Value val = (Value) e.arg().accept(this, env);
return new BoolVal(val instanceof Value.Null);
}

@Override
public Value visit(LetrecExp e, Env env) { // New for reclang.
List names = e.names();
List fun_exps = e.fun_exps();
List funs = new ArrayList(fun_exps.size());

for(Exp exp : fun_exps)
funs.add((Value.FunVal)exp.accept(this, env));

Env new_env = new ExtendEnvRec(env, names, funs);
return (Value) e.body().accept(this, new_env);
}

@Override
public Value visit(RefExp e, Env env) { // New for reflang.
Exp value_exp = e.value_exp();
Value value = (Value) value_exp.accept(this, env);
return heap.ref(value);
}

@Override
public Value visit(DerefExp e, Env env) { // New for reflang.
Exp loc_exp = e.loc_exp();
Value.RefVal loc = (Value.RefVal) loc_exp.accept(this, env);
return heap.deref(loc);
}

@Override
public Value visit(AssignExp e, Env env) { // New for reflang.
Exp rhs = e.rhs_exp();
Exp lhs = e.lhs_exp();
//Note the order of evaluation below.
Value rhs_val = (Value) rhs.accept(this, env);
Value.RefVal loc = (Value.RefVal) lhs.accept(this, env);
Value assign_val = heap.setref(loc, rhs_val);
return assign_val;
}

@Override
public Value visit(FreeExp e, Env env) { // New for reflang.
Exp value_exp = e.value_exp();
Value.RefVal loc = (Value.RefVal) value_exp.accept(this, env);
heap.free(loc);
return new Value.UnitVal();
}

public Value visit(EvalExp e, Env env) {
StringVal programText = (StringVal) e.code().accept(this, env);
Program p = _reader.parse(programText.v());
return (Value) p.accept(this, env);
}

public Value visit(ReadExp e, Env env) {
StringVal fileName = (StringVal) e.file().accept(this, env);
try {
String text = Reader.readFile(“” + System.getProperty(“user.dir”) + File.separator + fileName.v());
return new StringVal(text);
} catch (IOException ex) {
return new DynamicError(ex.getMessage());
}
}

private Env initialEnv() {
GlobalEnv initEnv = new GlobalEnv();

/* Procedure: (read ). Following is same as (define read (lambda (file) (read file))) */
List formals = new ArrayList<>();
formals.add(“file”);
Exp body = new AST.ReadExp(new VarExp(“file”));
Value.FunVal readFun = new Value.FunVal(initEnv, formals, body);
initEnv.extend(“read”, readFun);

/* Procedure: (require ). Following is same as (define require (lambda (file) (eval (read file)))) */
formals = new ArrayList<>();
formals.add(“file”);
body = new EvalExp(new AST.ReadExp(new VarExp(“file”)));
Value.FunVal requireFun = new Value.FunVal(initEnv, formals, body);
initEnv.extend(“require”, requireFun);

/* Add new built-in procedures here */

return initEnv;
}

Reader _reader;
public Evaluator(Reader reader) {
_reader = reader;
}
}

Related Posts