private void SplitTheExp(ref List <AssignmentStatement> l, BinaryOperationExpression binaryOp) { string replaceLeft = "", replaceRight = ""; if (binaryOp.Operand1 is BinaryOperationExpression) { SplitTheExp(ref l, (BinaryOperationExpression)binaryOp.Operand1); replaceLeft = ((AssignmentStatement)l.Last()).Variable.Name; } if (binaryOp.Operand2 is BinaryOperationExpression) { SplitTheExp(ref l, (BinaryOperationExpression)binaryOp.Operand2); replaceRight = ((AssignmentStatement)l.Last()).Variable.Name; } tempLocals++; string s = "_" + tempLocals; VariableExpression var = new VariableExpression(); var.Name = s; AssignmentStatement toAdd = new AssignmentStatement(); toAdd.Variable = var; if (replaceLeft == "" && replaceRight == "") { toAdd.Value = binaryOp; } else { BinaryOperationExpression change = new BinaryOperationExpression(); change.Operator = binaryOp.Operator; if (replaceLeft != "") { VariableExpression var2 = new VariableExpression(); var2.Name = replaceLeft; change.Operand1 = var2; } else { change.Operand1 = binaryOp.Operand1; } if (replaceRight != "") { VariableExpression var2 = new VariableExpression(); var2.Name = replaceRight; change.Operand2 = var2; } else { change.Operand2 = binaryOp.Operand1; } toAdd.Value = change; } l.Add(toAdd); }
private List <string> isNumaricAssigment(List <string> AssemblyList, AssignmentStatement aSimple) { NumericExpression Num = (NumericExpression)(aSimple.Value); int value = Num.Value; AssemblyList.Add("@" + value); AssemblyList.Add("D = A"); AssemblyList.Add("@RETURN"); AssemblyList.Add("M = D"); computeVariabletoR0(AssemblyList, aSimple.Variable.Name); updateDestinationWithResult(AssemblyList); return(AssemblyList); }
private List <string> isVariableAssigment(List <string> AssemblyList, AssignmentStatement aSimple) { AssemblyList.Add("@" + symbolTable[((VariableExpression)aSimple.Value).Name]); AssemblyList.Add("D = A"); AssemblyList.Add("@LOCAL"); AssemblyList.Add("A = D + M"); AssemblyList.Add("D = M"); AssemblyList.Add("@RESULT"); AssemblyList.Add("M = D"); computeVariabletoR0(AssemblyList, ((VariableExpression)aSimple.Variable).Name); updateDestinationWithResult(AssemblyList); return(AssemblyList); }
//Compile a single line containing only an assignment of the form "let <var> = <expression>;" public List <string> Compile(string sAssignment) { //Tokenize the string into a stack of tokens Stack <Token> sTokens = Tokenize(sAssignment); //Parse the tokens into objects representing the meaning of the statement AssignmentStatement s = Parse(sTokens); //Simplify complex expressions in order for the code generation to be simpler List <AssignmentStatement> lSimpleAssignments = SimplifyExpressions(s); //Compute the symbol table here ComputeSymbolTable(lSimpleAssignments); //Generate the actual code List <string> lAssembly = GenerateCode(lSimpleAssignments); return(lAssembly); }
static void Test1() { Console.WriteLine("test1"); Compiler c = new Compiler(); string s = "let x = 5;"; Stack <Token> sTokens = c.Tokenize(s); string[] aTokens = new string[] { "let", "x", "=", "5", ";" }; List <Token> answer = new List <Token>(); for (int i = 0; i < aTokens.Length; i++) { Token sToken = sTokens.Pop(); answer.Add(sToken); bool print = false; if (sToken.ToString() != aTokens[i]) { print = true; } if (print) { Console.WriteLine("tokens should be: " + aTokens + " but your answer is: " + answer); } } sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); if (assignment.ToString() != s) { Console.WriteLine("BUGBUG"); } List <AssignmentStatement> lSimple = c.SimplifyExpressions(assignment); if (lSimple.Count != 1 || lSimple[0].ToString() != assignment.ToString()) { Console.WriteLine("BUGBUG"); } //List<string> lAssembly = c.GenerateCode(lSimple); c.Compile(s); }
//Simplify an expression by creating artificial local variables, and using them for intermidiate computations. //For example, let x = (+ (- y 2) (- 5 z)); will be simplified into: //let _1 = (- y 2); //let _2 = (- 5 z); //let x = (+ _1 _2); public List <AssignmentStatement> SimplifyExpressions(AssignmentStatement s) { //your code here List <AssignmentStatement> ListToReturn = new List <AssignmentStatement>(); if ((!(s.Value is BinaryOperationExpression)) || (!(((BinaryOperationExpression)s.Value).Operand1 is BinaryOperationExpression) && !(((BinaryOperationExpression)s.Value).Operand2 is BinaryOperationExpression))) { ListToReturn.Add(s); } else { SplitTheExp(ref ListToReturn, (BinaryOperationExpression)s.Value); VariableExpression temp = new VariableExpression(); temp.Name = "_" + tempLocals; s.Value = temp; ListToReturn.Add(s); } return(ListToReturn); }
static void TestCompile() { Compiler c = new Compiler(); string wrongToken; Console.WriteLine(""); string s = "let x == 1;"; Stack <Token> sTokens = c.Tokenize(s); wrongToken = "="; bool answerWasWrong; bool testPerfect; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = = 2;;"; wrongToken = "="; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let 1 = 3;"; wrongToken = "1"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = 4;;"; wrongToken = ";"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let let x = 5;"; wrongToken = "let"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let 1BadName = 5;"; wrongToken = "1BadName"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = ( (+ x 5) (- y z));"; wrongToken = "("; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (- (+ x 5) (- y z));"; wrongToken = "("; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot catch that there are more '(' then ')'"); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (* x 5) (- y z));"; wrongToken = "*"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ 5 y z);"; wrongToken = "z"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = ( 5 + z );"; wrongToken = "5"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (; x 5) (- y z));"; wrongToken = ";"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (+ x 5); (- y z));"; wrongToken = ";"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "x = (+ (+ x 5) (- y z));"; wrongToken = "x"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (+ x 5) WOW (- y z));"; wrongToken = ")"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+(-(+ (+ x 5) (- y z));"; wrongToken = "("; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } //________________________________________________________________________________________________ //------------------------------------------------------------------------------------------------ Console.WriteLine(""); s = "let x = (+ (+ x 5)-)+) (- y z));"; wrongToken = ")"; Console.WriteLine("testing: " + s); answerWasWrong = true; testPerfect = true; try { sTokens = c.Tokenize(s); AssignmentStatement assignment = c.Parse(sTokens); } catch (SyntaxErrorException e) { answerWasWrong = false; if (e.Token == null) { Console.WriteLine("you throwed an Exception as needed, but your Token is NULL"); testPerfect = false; } else if (e.Token.Name != wrongToken) { Console.WriteLine("token in Exception should be " + wrongToken + " but you sent: " + e.Token.Name); testPerfect = false; } } if (answerWasWrong) { Console.WriteLine("you didnot throw Exception on: " + wrongToken); } else if (testPerfect) { Console.WriteLine("good work, this test was perfect"); } }
//Generates assembly code for a simple assignment statement. Can accept only the following: //let <var> = <number>; e.g. let x = 5; //let <var> = <var>; e.g. let x = y; //let <var> = (<operator> <operand1> <operand2>); where operand1 and operand2 can only by either numbers or variables, but not nested expressions. e.g. let x = (- y 5); public List <string> GenerateCode(AssignmentStatement aSimple) { List <string> AssemblyList = new List <string>(); if (aSimple.Value is NumericExpression) { AssemblyList = isNumaricAssigment(AssemblyList, aSimple); } else if (aSimple.Value is VariableExpression) { VariableExpression var = (VariableExpression)aSimple.Value; if (!symbolTable.ContainsKey(var.Name)) { throw new SyntaxErrorException("Undefined variable, please define the variable " + var.Name + " first.", new Token()); } else { AssemblyList = isVariableAssigment(AssemblyList, aSimple); } } else { BinaryOperationExpression temp = new BinaryOperationExpression(); temp = (BinaryOperationExpression)aSimple.Value; if (temp.Operand1 is NumericExpression) { AssemblyList.Add("@" + ((NumericExpression)temp.Operand1).Value); AssemblyList.Add("D = A"); AssemblyList.Add("@OPERAND1"); AssemblyList.Add(" M = D"); } else { AssemblyList.Add("@" + symbolTable[((VariableExpression)temp.Operand1).Name]); AssemblyList.Add("D = A"); AssemblyList.Add("@LOCAL"); AssemblyList.Add("D = D + M"); AssemblyList.Add("A = D"); AssemblyList.Add("D = M"); AssemblyList.Add("@OPERAND1"); AssemblyList.Add("M = D"); } if (temp.Operand2 is NumericExpression) { AssemblyList.Add("@" + ((NumericExpression)temp.Operand2).Value); AssemblyList.Add("D = A"); AssemblyList.Add("@OPERAND2"); AssemblyList.Add("M = D"); } else { AssemblyList.Add("@" + symbolTable[((VariableExpression)temp.Operand2).Name]); AssemblyList.Add("D = A"); AssemblyList.Add("@LOCAL"); AssemblyList.Add("D = D + M"); AssemblyList.Add("A = D"); AssemblyList.Add("D = M"); AssemblyList.Add("@OPERAND2"); AssemblyList.Add("M = D"); } AssemblyList.Add("@OPERAND1"); AssemblyList.Add(" D = M"); AssemblyList.Add("@OPERAND2"); if (temp.Operator == "+") { AssemblyList.Add("D = D + M"); } else { AssemblyList.Add("D = D - M"); } AssemblyList.Add("@RESULT"); AssemblyList.Add("M = D"); computeVariabletoR0(AssemblyList, aSimple.Variable.Name); updateDestinationWithResult(AssemblyList); } return(AssemblyList); }
//Parses a stack of tokens, containing a single assignment statement. //The structure must be "let <var> = <expression>;" where expression can be of an arbitrary complexity, i.e., any complex expression is allowed. //Parsing must detect syntax problems (e.g. "let" or "=" are missing, opened parantheses are not closed, sentence does not end with a ;, and so forth). //When syntax errors are detected, a SyntaxErrorException must be thrown, with an appropriate message explaining the problem. public AssignmentStatement Parse(Stack <Token> sTokens) { Token popedToken = new Token(); popedToken = sTokens.Pop(); AssignmentStatement StatmentToReturn = new AssignmentStatement(); VariableExpression variableWorkingOn = new VariableExpression(), SecondVariable = new VariableExpression(); NumericExpression num = new NumericExpression(); if (popedToken.Type != Token.TokenType.Keyword) { throw new SyntaxErrorException("We accept only LL(0) type, Unrecogmized KeyWord", popedToken); } popedToken = sTokens.Pop(); if ((popedToken.Type == Token.TokenType.ID) && (popedToken.Name.ElementAt(0) >= '0') && (popedToken.Name.ElementAt(0) <= '9')) { throw new SyntaxErrorException("All variables can not start with a number", popedToken); } else if (popedToken.Name.Contains("?") || popedToken.Name.Contains("#") || popedToken.Name.Contains("@")) { throw new SyntaxErrorException("Variable can not contain the '?,#,@' signs", popedToken); } else if ((popedToken.Type != Token.TokenType.ID)) { throw new SyntaxErrorException("Expecting a variable name", popedToken); } else { variableWorkingOn.Name = popedToken.Name; StatmentToReturn.Variable = variableWorkingOn; } popedToken = sTokens.Pop(); if (!popedToken.Name.Equals("=")) { throw new SyntaxErrorException("Expecting a '=' sign", popedToken); } popedToken = sTokens.Pop(); if (Char.IsDigit(popedToken.Name, 0)) { bool success = false; success = Int32.TryParse(popedToken.Name, out num.Value); if (!success) { throw new SyntaxErrorException("Invalid number", popedToken); } StatmentToReturn.Value = num; } else if (Char.IsLetter(popedToken.Name, 0)) { SecondVariable.Name = popedToken.Name; StatmentToReturn.Value = SecondVariable; } else if (popedToken.Name == "(") { StatmentToReturn.Value = BinaryExpressionCreate(new BinaryOperationExpression(), ref sTokens); if ((sTokens.Count > 0)) { if (sTokens.Pop().Name != ")") { throw new SyntaxErrorException("Missing ')' symbol", popedToken); } } } else { throw new SyntaxErrorException("Invalid value", popedToken); } if (sTokens.Count > 1) { throw new SyntaxErrorException("Invalid value", popedToken); } if (sTokens.Count == 0 || (sTokens.Count == 1 && (sTokens.Pop().Name != ";"))) { throw new SyntaxErrorException("Expecting ';' at the end of the statement", popedToken); } if (sTokens.Count > 0) { throw new SyntaxErrorException("No code after ';'", popedToken); } return(StatmentToReturn); }