public ProgState execute(ProgState prog)
{
MyIDictionary <string, int> dict = prog.getDict();
try
{
if (dict.isDefined(this.id) == 1)
{
dict.update(id, exp.eval(dict));
}
else
{
dict.add(id, exp.eval(dict));
}
return(prog);
}
catch (StmtExceptions e)
{
throw new ControllerException(e);
}
catch (DivizionByZeroException e)
{
throw new ControllerException(e);
}
}
public ProgramState(MyIStack <IStatement> executionStack, MyIDictionary <string, int> symbolTable,
MyIList <int> output)
{
this.executionStack = executionStack;
this.symbolTable = symbolTable;
this.output = output;
}
public ProgState execute(ProgState prog)
{
MyIDictionary <string, int> dict = prog.getDict();
MyIFileTable <Tuple> Tpl = prog.getFile();
try
{
int val = exp.eval(dict);
Tuple tpl = Tpl.get(val);
if (tpl != null)
{
tpl.getST().Close();
Tpl.remove(val);
}
else
{
throw new ControllerException("The file does not exist!! \n");
}
}
catch (StmtExceptions e)
{ throw new ControllerException(e); }
catch (IOException e)
{ Console.WriteLine(e.ToString()); }
return(prog);
}
public override int evaluate(MyIDictionary <string, int> symTable)
{
int x1 = this.e1.evaluate(symTable);
int x2 = this.e2.evaluate(symTable);
int ret = x1;
switch (this.op)
{
case Operation.ADD:
ret += x2;
break;
case Operation.SUBTRACT:
ret -= x2;
break;
case Operation.MULTIPLY:
ret *= x2;
break;
case Operation.DIVIDE:
ret /= x2;
break;
}
return(ret);
}
public PrgState execute(PrgState state)
{
MyIStack <IStmt> stk = state.getExeStack();
// stk.pop();
MyIDictionary <String, int> symTbl = state.getSymTable();
IFileTable <int, FileTuple> fileTbl = state.getFileTable();
int value_exp = this.exp_file_id.eval(symTbl);
FileTuple ft = fileTbl.getValue(value_exp);
if (!fileTbl.isDefined(value_exp))
{
throw new Exception("The key is not defined in the file table");
}
StreamReader streamReader = fileTbl.getValue(value_exp).getStreamReader();
try
{
streamReader.Close();
}
catch (IOException ex) { throw new Exception(ex.Message); }
fileTbl.remove(value_exp);
return(state);
}
public bool NegTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("NegTest1: The IDictionary is read-only");
try
{
IDictionary iDictionary = new MyIDictionary();
iDictionary.Clear();
TestLibrary.TestFramework.LogError("101", "The NotSupportedException was not thrown as expected");
retVal = false;
}
catch (NotSupportedException)
{
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return(retVal);
}
public int Eval(MyIDictionary <string, int> tbl)
{
if (op == 1)
{
return(e1.Eval(tbl) + e2.Eval(tbl));
}
if (op == 2)
{
return(e1.Eval(tbl) - e2.Eval(tbl));
}
if (op == 3)
{
return(e1.Eval(tbl) * e2.Eval(tbl));
}
if (op == 4)
{
if (e2.Eval(tbl) == 0)
{
MyException ex = new MyException("Division by 0!");
throw ex;
}
return(e1.Eval(tbl) / e2.Eval(tbl));
}
return(0);
}
public ProgState execute(ProgState prog)
{
MyIDictionary <string, int> dict = prog.getDict();
MyIFileTable <Tuple> Tpl = prog.getFile();
try
{
if (Tpl.isEmpty() == 1)
{
for (int i = 1; i <= Tpl.getKey(); i++)
{
Tuple tpl = Tpl.get(i);
if (tpl != null && tpl.getName() == filename)
{
throw new ControllerException("The file does not exist!! \n");
}
}
}
StreamReader st = new StreamReader(filename);
Tuple tup = new Tuple(filename, st);
Tpl.add(tup);
dict.add(varName, Tpl.getKey());
return(prog);
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.ToString());
}
catch (DictExceptions e)
{ throw new ControllerException(e.ToString()); }
return(null);
}
public PrgState Execute(PrgState state)
{
MyIDictionary <String, int> symTable = state.GetSymTable();
int file_id = this.exp_file_id.Eval(symTable);
MyIPair <String, StreamReader> fileTable = state.GetFileTable().Lookup(file_id);
if (fileTable == null)
{
throw new MyException("File not opened");
}
int anotherVal;
String line = fileTable.GetSecond().ReadLine();
if (line == null)
{
anotherVal = 0;
}
else
{
anotherVal = System.Convert.ToInt32(line);
}
if (symTable.IsDefinedU(var_name))
{
symTable.Update(var_name, anotherVal);
}
else
{
symTable.Add(var_name, anotherVal);
}
return(state);
}
public override int Eval(MyIDictionary <String, int> tbl)
{
switch (op)
{
case ('+'):
return(e1.Eval(tbl) + e2.Eval(tbl));
case ('-'):
return(e1.Eval(tbl) - e2.Eval(tbl));
case ('*'):
return(e1.Eval(tbl) * e2.Eval(tbl));
case ('/'):
if (e2.Eval(tbl) == 0)
{
throw new MyException("Division with zero!");
}
else
{
return(e1.Eval(tbl) / e2.Eval(tbl));
}
default:
if (e2.Eval(tbl) == 0)
{
throw new MyException("Division with zero!");
}
else
{
return(e1.Eval(tbl) % e2.Eval(tbl));
}
}
}
public ProgramState Execute(ProgramState programState)
{
MyIDictionary <string, int> symbolTable = programState.SymbolTable;
int fileDescriptor = expFileId.Evaluate(symbolTable);
if (!programState.FileTable.TryGetValue(fileDescriptor, out Tuple <string, TextReader> value))
{
throw new StatementException("Invalid file id provided!");
}
TextReader reader = value.Item2;
try
{
reader.Close();
}
catch (Exception)
{
throw new StatementException("Error while closing file!");
}
programState.FileTable.Remove(fileDescriptor);
return(programState);
}
public override int Evaluate(MyIDictionary <string, int> symbolTable)
{
int l = this.left.Evaluate(symbolTable);
int r = this.right.Evaluate(symbolTable);
int ret = l;
switch (this.op)
{
case Operation.ADD:
ret += r;
break;
case Operation.SUBTRACT:
ret -= r;
break;
case Operation.MULTIPLY:
ret *= r;
break;
case Operation.DIVIDE:
if (r == 0)
{
throw new Exception("Division by zero");
}
ret /= r;
break;
}
return(ret);
}
public PrgState(MyIStack <IStmt> stk, MyIDictionary <String, int> symtbl, MyIList <int> ot, MyIDictionary <int, MyPair <String, StreamReader> > fT, IStmt prg)
{
exeStack = stk;
symTable = symtbl;
outList = ot;
fileTable = fT;
exeStack.Push(prg);
}
public void Clone(MyIDictionary <K, V> toClone)
{
dict = new Dictionary <K, V>();
foreach (K k in toClone.KeySet())
{
this.dict[k] = toClone.Get(k);
}
}
public PrgState(MyIStack <IStmt> exeStack, MyIDictionary <string, int> symTable, MyIList <int> output, MyIFileDictionary <int, KeyValuePair <string, StreamReader> > fileTable, IStmt prg)
{
this.exeStack = exeStack;
this.symTable = symTable;
this.output = output;
this.fileTable = fileTable;
exeStack.push(prg);
}
public PrgState(IStmt prg)
{
exeStack = new MyStack <IStmt>(new Stack <IStmt>());
exeStack.push(prg);
symTable = new MyDictionary <string, int>(new Dictionary <string, int>());
outList = new MyList <int>(new List <int>());
fileTable = new MyDictionary <int, Tuple <string, TextReader> >(new Dictionary <int, Tuple <string, TextReader> >());
}
public PrgState(MyIStack<T> stk, MyIDictionary symtbl, MyIList ot, MyIHeap heap, int id)
{
exeStack = stk;
@out = ot;
symTable = symtbl;
mHeap = heap;
mId = id;
}
public ProgramState(IStatement statement)
{
executionStack = new MyStack <IStatement>(new Stack <IStatement>());
executionStack.Push(statement);
symbolTable = new MyDictionary <string, int>(new Dictionary <string, int>());
outputList = new MyList <int>(new List <int>());
fileTable = new MyDictionary <int, Tuple <string, TextReader> >(new Dictionary <int, Tuple <string, TextReader> >());
}
public PrgState execute(PrgState state)
{
MyIList <int> outList = state.getOutList();
MyIDictionary <string, int> symTabel = state.getSymTable();
outList.add(exp.Eval(symTabel));
return(null);
}
public PrgState execute(PrgState state)
{
MyIList <int> ot = state.getOut();
MyIDictionary <String, int> symTbl = state.getSymTable();
ot.add(exp.eval(state.getSymTable()));
return(state);
}
public ProgState(MyIStack <IStmt> stk, MyIDictionary <string, int> dict, MyIList <int> list, MyIFileTable <Tuple> fileT, IStmt prog)
{
this.stk = stk;
this.dict = dict;
this.list = list;
this.fileT = fileT;
stk.push(prog);
}
public int Evaluate(MyIDictionary <string, int> symbolTable)
{
if (!symbolTable.TryGetValue(id, out int value))
{
throw new ExpressionException("Unassigned variable used!");
}
return(value);
}
public int Eval(MyIDictionary <string, int> tbl)
{
if (!tbl.isDefined(id))
{
MyException ex = new MyException("Variable does not exist!");
throw ex;
}
return(tbl.lookup(id));
}
public PrgState(IStmt prg)
{
this.exeStack = new MyStack <IStmt>();
this.symTable = new MyDictionary <String, int>();
this.outTbl = new MyList <int>();
this.originalProgram = prg.deepCopy();
this.fileTable = new FileTable <int, FileTuple>();
this.exeStack.push(prg);
}
public override int Eval(MyIDictionary tbl, MyIHeap heap)
{
GetIntInput inp = new GetIntInput();
inp.ShowDialog();
return(Int32.Parse(inp.GetText()));
}
public PrgState Execute(PrgState state)
{
MyIList <int> ot = state.GetOut();
MyIDictionary <String, int> symtbl = state.GetSymTable();
int val = exp.Eval(symtbl);
ot.Add(val);
return(state);
}
public PrgState(IStmt prg)
{
exeStack = new MyStack <IStmt>();
symTable = new MyDictionary <string, int>();
outList = new MyList <int>();
fileTable = new MyFileTable <int, Tuple <string, StreamReader> >();
originalProgram = prg;
exeStack.push(prg);
}
public PrgState(MyIStack <IStmt> stk, MyIDictionary <string, int> symtbl,
MyIList <int> ot, IFileTable <int, FileTuple> fileTable, IStmt prg)
{
this.exeStack = stk;
this.symTable = symtbl;
this.outTbl = ot;
this.originalProgram = prg.deepCopy();
this.fileTable = fileTable;
this.exeStack.push(prg);
}
public override int Evaluate(MyIDictionary <string, int> symTab)
{
try
{
return(symTab.Get(id));
}
catch (InvalidKeyMyDictionaryException)
{
throw new UndeclaredVariableException("Exception: Undeclared variable: " + id + ".");
}
}
public override int eval(MyIDictionary <string, int> tbl)
{
try
{
return(tbl.lookup(id));
}
catch (MyException ex)
{
throw new MyException("" + ex);
}
}
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Check a custom class derived from the interface");
try
{
IDictionary iDictionary = new MyIDictionary();
if (!iDictionary.IsFixedSize)
{
TestLibrary.TestFramework.LogError("005", "The result is not the value as expected ");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public bool NegTest2()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("NegTest2: The IDictionary is readonly");
try
{
IDictionary iDictionary = new MyIDictionary();
iDictionary.Remove(new MyClass());
TestLibrary.TestFramework.LogError("103", "The NotSupportedException was not thrown as expected");
retVal = false;
}
catch (NotSupportedException)
{
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("104", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
