public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { if (op.Equals("<")) { return((e1.eval(tbl, heap) < e2.eval(tbl, heap)) ? 1 : 0); } if (op.Equals("<=")) { return((e1.eval(tbl, heap) <= e2.eval(tbl, heap)) ? 1 : 0); } if (op.Equals("==")) { return((e1.eval(tbl, heap).Equals(e2.eval(tbl, heap))) ? 1 : 0); } if (op.Equals("!=")) { return((!e1.eval(tbl, heap).Equals(e2.eval(tbl, heap))) ? 1 : 0); } if (op.Equals(">")) { return((e1.eval(tbl, heap) > e2.eval(tbl, heap)) ? 1 : 0); } if (op.Equals(">=")) { return((e1.eval(tbl, heap) >= e2.eval(tbl, heap)) ? 1 : 0); } return(0); }
public PrgState execute(PrgState state) { MapInterface <String, int> symTbl = state.SymTable; HeapInterface <int> heap = state.HeapTable; heap.Update(symTbl [Id], Exp.eval(symTbl, heap)); return(null); }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { if (tbl.ContainsKey(id)) { return(tbl [id]); } throw new UninitializedVariableException(); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { try { return readInteger (""); } catch (UnexpectedTypeException) { return eval (tbl, heap); } }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { try { return(readInteger("")); } catch (UnexpectedTypeException) { return(eval(tbl, heap)); } }
public PrgState execute(PrgState state) { MapInterface <String, int> symTbl = state.SymTable; HeapInterface <int> heap = state.HeapTable; int val = exp.eval(symTbl, heap); symTbl [id] = val; return(null); }
public PrgState execute(PrgState state) { ListInterface <int> output = state.Output; MapInterface <String, int> symTbl = state.SymTable; HeapInterface <int> heap = state.HeapTable; output.Add(Exp.eval(symTbl, heap)); return(null); }
//optional field, but good to have public PrgState(StackInterface<IStmt> stack, MapInterface<String, int> dictionary, HeapInterface<int> heap, ListInterface<int> list, IStmt prg) { id = generator++; exeStack = stack; symTable = dictionary; heapTable = heap; output = list; originalProgram = prg; exeStack.Push (originalProgram); }
//optional field, but good to have public PrgState(StackInterface <IStmt> stack, MapInterface <String, int> dictionary, HeapInterface <int> heap, ListInterface <int> list, IStmt prg) { id = generator++; exeStack = stack; symTable = dictionary; heapTable = heap; output = list; originalProgram = prg; exeStack.Push(originalProgram); }
public ProgramState(Stack <Statement.Statement> executionStack, ConcurrentDictionary <string, Value.Value> symbolTable, List <Value.Value> outTable, Statement.Statement st) { this.executionStack = executionStack; this.symbolTable = symbolTable; this.outTable = outTable; this.origProgram = st; this.executionStack.Push(st); fileTable = new ConcurrentDictionary <string, FileStream>(); heapTable = new Heap(); }
public PrgState execute(PrgState state) { MapInterface <String, int> symTbl = state.SymTable; HeapInterface <int> heap = state.HeapTable; if (Exp.eval(symTbl, heap) != 0) { state.ExeStack.Push(this); state.ExeStack.Push(this.Stmt); } return(null); }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { if (op.Equals("&&")) { return((e1.eval(tbl, heap) != 0 && e2.eval(tbl, heap) != 0) ? 1 : 0); } if (op.Equals("||")) { return((e1.eval(tbl, heap) != 0 || e2.eval(tbl, heap) != 0) ? 1 : 0); } return(0); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { if (op == "+") return (e1.eval (tbl, heap) + e2.eval (tbl, heap)); if (op == "-") return (e1.eval (tbl, heap) - e2.eval (tbl, heap)); if (op == "*") return (e1.eval (tbl, heap) * e2.eval (tbl, heap)); if (op == "/") { if (e2.eval (tbl, heap) == 0) throw new DivisionByZeroException (); return (e1.eval (tbl, heap) / e2.eval (tbl, heap)); } return 0; }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { if (op.Equals ("<")) return (e1.eval (tbl, heap) < e2.eval (tbl, heap)) ? 1 : 0; if (op.Equals ("<=")) return (e1.eval (tbl, heap) <= e2.eval (tbl, heap)) ? 1 : 0; if (op.Equals ("==")) return (e1.eval (tbl, heap).Equals (e2.eval (tbl, heap))) ? 1 : 0; if (op.Equals ("!=")) return (!e1.eval (tbl, heap).Equals (e2.eval (tbl, heap))) ? 1 : 0; if (op.Equals (">")) return (e1.eval (tbl, heap) > e2.eval (tbl, heap)) ? 1 : 0; if (op.Equals (">=")) return (e1.eval (tbl, heap) >= e2.eval (tbl, heap)) ? 1 : 0; return 0; }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { if (op == "+") { return(e1.eval(tbl, heap) + e2.eval(tbl, heap)); } if (op == "-") { return(e1.eval(tbl, heap) - e2.eval(tbl, heap)); } if (op == "*") { return(e1.eval(tbl, heap) * e2.eval(tbl, heap)); } if (op == "/") { if (e2.eval(tbl, heap) == 0) { throw new DivisionByZeroException(); } return(e1.eval(tbl, heap) / e2.eval(tbl, heap)); } return(0); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { return number; }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { return(number); }
public Value.Value evaluate(ConcurrentDictionary <string, Value.Value> symTable, HeapInterface heapTable) { if (!(exp1.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new IntType())) || !(exp2.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new IntType()))) { throw new Exception("Invalid types: Arithmetic Expression Works only with INTS!\n"); } Int32 v1 = ((IntValue)exp1.evaluate(symTable, heapTable)).getValue(); Int32 v2 = ((IntValue)exp2.evaluate(symTable, heapTable)).getValue(); Int32 res; switch (operation) { case ("+"): { res = v1 + v2; break; } case ("-"): { res = v1 - v2; break; } case (":"): { if (v2 == 0) { throw new Exception("DIVISION BY 0\n"); } res = v1 / v2; break; } case ("*"): { res = v1 * v2; break; } default: throw new Exception("Invalid operation: " + operation); } return(new IntValue(res)); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { if (tbl.ContainsKey (id)) return tbl [id]; throw new UninitializedVariableException (); }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { return(exp.eval(tbl, heap) == 0 ? 1 : 0); }
public Value.Value evaluate(ConcurrentDictionary<string, Value.Value> symTable, HeapInterface heapTable) { Value.Value result = new BoolValue(false); if(!expr1.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new IntType()) || !expr2.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new IntType()) ) throw new Exception("Incompatible types for expressions!\n"); Int32 v1 = ((IntValue) expr1.evaluate(symTable, heapTable)).getValue(); Int32 v2 = ((IntValue) expr2.evaluate(symTable, heapTable)).getValue(); switch (operation) { case ("=="): { result = new BoolValue(v1==v2); break; } case (">="): { result = new BoolValue(v1>=v2); break; } case (">"): { result = new BoolValue(v1>v2); break; } case("<="): { result = new BoolValue(v1<=v2) ; break; } case ("<"): { result = new BoolValue(v1<v2); break; } default: throw new Exception("Invalid operator given!"); } return result; }
public int eval(MapInterface <String, int> tbl, HeapInterface <int> heap) { int address = tbl [id]; return(heap.Get(address)); }
public Value.Value evaluate(ConcurrentDictionary <string, Value.Value> symTable, HeapInterface heapTable) { if (!symTable.ContainsKey(id)) { throw new Exception("Invalid variable name!\n"); } return(symTable[id]); }
public Value.Value evaluate(ConcurrentDictionary <string, Value.Value> symTable, HeapInterface heapTable) { return(val); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { int address = tbl [id]; return heap.Get (address); }
public int eval(MapInterface<String, int> tbl, HeapInterface<int> heap) { return exp.eval (tbl, heap) == 0 ? 1 : 0; }
public Value.Value evaluate(ConcurrentDictionary <string, Value.Value> symTable, HeapInterface heapTable) { if (!(expr1.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new BoolType())) || !(expr2.evaluate(symTable, heapTable).GetTypeInter().HasSameType(new BoolType()))) { throw new Exception("INVALID TYPES FOR LOGIC EXPRESSION!\n"); } Boolean b1 = ((BoolValue)expr1.evaluate(symTable, heapTable)).getValue(); Boolean b2 = ((BoolValue)expr2.evaluate(symTable, heapTable)).getValue(); Boolean b3 = false; if (operation == "&") { b3 = b1 & b2; } else if (operation == "||") { b3 = b1 || b2; } else { throw new Exception("Invalid logic operation!\n"); } return(new BoolValue(b3)); }
public Value.Value evaluate(ConcurrentDictionary <string, Value.Value> symTable, HeapInterface heapTable) { /* * • the expression must be evaluated to a RefValue. If not, the execution is stopped with an * appropriate error message. * • Take the address component of the RefValue computed before and use it to access Heap * table and return the value associated to that address. If the address is not a key in Heap table, * the execution is stopped with an appropriate error message. */ if (!(expression.evaluate(symTable, heapTable) is ReferenceValue)) { throw new Exception("Evaluation of expression: " + expression + " should result in a Reference Value!\n"); } Int32 address = ((ReferenceValue)expression.evaluate(symTable, heapTable)).getAddress(); if (!((Heap)heapTable).ContainsKey(address)) { throw new Exception("Invalid Heap Address!\n"); } return(((Heap)heapTable)[address]); }