lexing: comparison Fahad/MCG-CS/Parser.cs

equal deleted inserted replaced

-:a751aa1ee4f7
+:7545b1bc1514
+using System;
+using System.Collections.Generic;
+using System.Text;
+public sealed class Parser
+{
+private int currentToken;
+private readonly Statement parsingOutput;
+private IList<object> listTokens;
+public Parser(IList<object> tokens)
+{
+listTokens = tokens;
+currentToken = 0;
+parsingOutput = ParseStatement();
+}
+public Statement GetParsedStatement
+{
+get { return parsingOutput; }
+}
+public void ExceptionHandler(string strException)
+{
+throw new Exception(strException);
+}
+private Statement ParseStatement()
+{
+Statement parsedStatement;
+if (currentToken == listTokens.Count)
+{
+ExceptionHandler("statement was expected before end of file");
+}
+if (listTokens[currentToken].Equals("print"))
+{
+currentToken++;
+Write _Write = new Write();
+_Write.Expression = ParseExpression();
+parsedStatement = _Write;
+}
+else if (listTokens[currentToken].Equals("var"))
+{
+currentToken++;
+DeclareVariable _DeclareVariable = new DeclareVariable();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_DeclareVariable.Identifier = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("variable name was expected after 'var'");
+}
+currentToken++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("= sign was expected after 'var identifier'");
+}
+currentToken++;
+_DeclareVariable.Expression = ParseExpression();
+parsedStatement = _DeclareVariable;
+}
+else if (listTokens[currentToken].Equals("call"))
+{
+currentToken++;
+CallFunction _CallFunction = new CallFunction();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_CallFunction.FunctionName = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("function name is expected after 'call'");
+}
+currentToken++;
+_CallFunction.Parameter1 = ParseExpression();
+//index++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.Comma.ToString())
+{
+ExceptionHandler("',' sign was expected after first parameter");
+}
+currentToken++;
+_CallFunction.Parameter2 = ParseExpression();
+//index++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.Comma.ToString())
+{
+ExceptionHandler("',' sign was expected after second parameter");
+}
+currentToken++;
+_CallFunction.Parameter3 = ParseExpression();
+//index++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.Terminator.ToString())
+{
+ExceptionHandler("';' sign was expected after third parameter");
+}
+parsedStatement = _CallFunction;
+}
+else if (listTokens[currentToken].Equals("string") || listTokens[currentToken].Equals("numeric") || listTokens[currentToken].Equals("void"))
+{
+DeclareFunction _DeclareFunction = new DeclareFunction();
+_DeclareFunction.ReturnType = listTokens[currentToken].ToString();
+currentToken++;
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_DeclareFunction.FunctionName = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("function name is expected after return type");
+}
+currentToken++;
+if (listTokens[currentToken].Equals("var"))
+{
+currentToken++;
+DeclareVariable _DeclareVariable = new DeclareVariable();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_DeclareVariable.Identifier = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("variable name was expected after 'var'");
+}
+currentToken++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("= sign was expected after 'var identifier'");
+}
+currentToken++;
+_DeclareVariable.Expression = ParseExpression();
+_DeclareFunction.Parameter1 = _DeclareVariable;
+}
+currentToken++;
+if (listTokens[currentToken].Equals("var"))
+{
+currentToken++;
+DeclareVariable _DeclareVariable = new DeclareVariable();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_DeclareVariable.Identifier = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("variable name was expected after 'var'");
+}
+currentToken++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("= sign was expected after 'var identifier'");
+}
+currentToken++;
+_DeclareVariable.Expression = ParseExpression();
+_DeclareFunction.Parameter2 = _DeclareVariable;
+}
+currentToken++;
+if (listTokens[currentToken].Equals("var"))
+{
+currentToken++;
+DeclareVariable _DeclareVariable = new DeclareVariable();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_DeclareVariable.Identifier = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("variable name was expected after 'var'");
+}
+currentToken++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("= sign was expected after 'var identifier'");
+}
+currentToken++;
+_DeclareVariable.Expression = ParseExpression();
+_DeclareFunction.Parameter3 = _DeclareVariable;
+}
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("begin"))
+{
+ExceptionHandler("expected 'begin' after input parameters");
+}
+currentToken++;
+_DeclareFunction.Body = ParseStatement();
+parsedStatement = _DeclareFunction;
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("endfunc"))
+{
+ExceptionHandler("unterminated function', 'endfunc' expected at the end");
+}
+currentToken++;
+}
+else if (listTokens[currentToken].Equals("read"))
+{
+currentToken++;
+ReadInput _ReadInput = new ReadInput();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_ReadInput.Identifier = (string)listTokens[currentToken++];
+parsedStatement = _ReadInput;
+}
+else
+{
+ExceptionHandler("variable name is expected after 'read'");
+parsedStatement = null;
+}
+}
+//    IfThenElse ifThenElse = new IfThenElse();
+//    RelationalExpression relExpr = new RelationalExpression();
+//    relExpr.Left = ParseExpression();
+//    if (listTokens[index] == Scanner.EqualTo)
+//        relExpr.Operand = RelationalOperands.EqualTo;
+//    else if (listTokens[index] == Scanner.LessThan)
+//        relExpr.Operand = RelationalOperands.LessThan;
+//    else if (listTokens[index] == Scanner.GreaterThan)
+//        relExpr.Operand = RelationalOperands.GreaterThan;
+//    else
+//    {
+//        ExceptionHandler("expected relational operand");
+//    }
+//    index++;
+//    relExpr.Right = ParseExpression();
+//    ifThenElse.If = relExpr;
+//    index++;
+//    ifThenElse.Then = ParseStatement();
+//    parsedStatement = ifThenElse;
+//    //index++;
+else if (listTokens[this.currentToken].Equals("while"))
+{
+currentToken++;
+While _while = new While();
+_while.LeftExpression = ParseExpression();
+if (listTokens[currentToken].ToString() == Lexer.Tokens.EqualTo.ToString())
+_while.Operand = RelationalOperands.EqualTo;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.LessThan.ToString())
+_while.Operand = RelationalOperands.LessThan;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.GreaterThan.ToString())
+_while.Operand = RelationalOperands.GreaterThan;
+currentToken++;
+_while.RightExpression = ParseExpression();
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("do"))
+{
+ExceptionHandler("expected 'do' after while");
+}
+currentToken++;
+_while.Body = ParseStatement();
+parsedStatement = _while;
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("endwhile"))
+{
+ExceptionHandler("unterminated 'while', endwhile expected at the end");
+}
+currentToken++;
+}
+else if (listTokens[this.currentToken].Equals("if"))
+{
+currentToken++;
+IfThen _IfThen = new IfThen();
+_IfThen.LeftExpression = ParseExpression();
+if (listTokens[currentToken].ToString() == Lexer.Tokens.EqualTo.ToString())
+_IfThen.Operand = RelationalOperands.EqualTo;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.LessThan.ToString())
+_IfThen.Operand = RelationalOperands.LessThan;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.GreaterThan.ToString())
+_IfThen.Operand = RelationalOperands.GreaterThan;
+currentToken++;
+_IfThen.RightExpression = ParseExpression();
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("then"))
+{
+ExceptionHandler("expected 'then' after if");
+}
+currentToken++;
+_IfThen.ThenBody = ParseStatement();
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("else"))
+{
+ExceptionHandler("'else' is expected");
+}
+currentToken++;
+_IfThen.ElseBody = ParseStatement();
+parsedStatement = _IfThen;
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("endif"))
+{
+ExceptionHandler("unterminated 'if', endif expected at the end");
+}
+currentToken++;
+}
+else if (listTokens[currentToken].Equals("for"))
+{
+currentToken++;
+For _For = new For();
+if (currentToken < listTokens.Count && listTokens[currentToken] is string)
+{
+_For.Identifier = (string)listTokens[currentToken];
+}
+else
+{
+ExceptionHandler("expected identifier after 'for'");
+}
+currentToken++;
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("for missing '='");
+}
+currentToken++;
+_For.From = ParseExpression();
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("to"))
+{
+ExceptionHandler("expected 'to' after for");
+}
+currentToken++;
+_For.To = ParseExpression();
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("do"))
+{
+ExceptionHandler("expected 'do' after from expression in for loop");
+}
+currentToken++;
+_For.Body = ParseStatement();
+parsedStatement = _For;
+if (currentToken == listTokens.Count || !listTokens[currentToken].Equals("end"))
+{
+ExceptionHandler("unterminated 'for' loop body");
+}
+currentToken++;
+}
+else if (listTokens[currentToken] is string)
+{
+// assignment
+Assignment _Assignment = new Assignment();
+_Assignment.Identifier = (string)listTokens[currentToken++];
+if (currentToken == listTokens.Count || listTokens[currentToken].ToString() != Lexer.Tokens.EqualTo.ToString())
+{
+ExceptionHandler("expected '='");
+}
+currentToken++;
+_Assignment.Expression = ParseExpression();
+parsedStatement = _Assignment;
+}
+else
+{
+ExceptionHandler("parse error at token " + currentToken + ": " + listTokens[currentToken]);
+parsedStatement = null;
+}
+if (currentToken < listTokens.Count && listTokens[currentToken].ToString() == Lexer.Tokens.Terminator.ToString())
+{
+currentToken++;
+if (currentToken < listTokens.Count && !listTokens[currentToken].Equals("end")
+&& !listTokens[currentToken].Equals("else") && !listTokens[currentToken].Equals("endif")
+&& !listTokens[currentToken].Equals("endwhile") && !listTokens[currentToken].Equals("endfunc"))
+{
+StatementSequence sequence = new StatementSequence();
+sequence.Left = parsedStatement;
+sequence.Right = ParseStatement();
+parsedStatement = sequence;
+}
+}
+return parsedStatement;
+}
+private Expression ParseExpression()
+{
+Expression parsedExpression;
+if (currentToken == listTokens.Count)
+{
+ExceptionHandler("expected expression, got EOF");
+}
+if (listTokens[currentToken] is StringBuilder)
+{
+string value = ((StringBuilder)listTokens[currentToken++]).ToString();
+AlphaNumericValue _AlphaNumericValue = new AlphaNumericValue();
+_AlphaNumericValue.Value = value;
+parsedExpression = _AlphaNumericValue;
+}
+else if (listTokens[currentToken] is int)
+{
+int intValue = (int)listTokens[currentToken++];
+NumericValue _NumericValue = new NumericValue();
+_NumericValue.Value = intValue;
+parsedExpression = _NumericValue;
+}
+else if (listTokens[currentToken] is string)
+{
+string identifier = (string)listTokens[currentToken++];
+Identifier _Identifier = new Identifier();
+_Identifier.IdentifierName = identifier;
+parsedExpression = _Identifier;
+}
+else
+{
+ExceptionHandler("expected string literal, int literal, or variable");
+return null;
+}
+//if (index < listTokens.Count && listTokens[index] != Scanner.Terminator && listTokens[index].GetType() != typeof(StringBuilder))
+if (listTokens[currentToken].ToString() != Lexer.Tokens.Terminator.ToString())
+{
+if (listTokens[currentToken].ToString() == Lexer.Tokens.Add.ToString() || listTokens[currentToken].ToString() == Lexer.Tokens.Subtract.ToString()
+|| listTokens[currentToken].ToString() == Lexer.Tokens.Multiply.ToString() || listTokens[currentToken].ToString() == Lexer.Tokens.Divide.ToString())
+{
+ArithmaticExpression arithmaticExpression = new ArithmaticExpression();
+arithmaticExpression.Left = parsedExpression;
+if (listTokens[currentToken].ToString() == Lexer.Tokens.Add.ToString())
+arithmaticExpression.Operand = ArithmaticOperands.Add;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.Subtract.ToString())
+arithmaticExpression.Operand = ArithmaticOperands.Subtract;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.Multiply.ToString())
+arithmaticExpression.Operand = ArithmaticOperands.Multiply;
+else if (listTokens[currentToken].ToString() == Lexer.Tokens.Divide.ToString())
+arithmaticExpression.Operand = ArithmaticOperands.Division;
+currentToken++;
+arithmaticExpression.Right = ParseExpression();
+parsedExpression = arithmaticExpression;
+}
+}
+return parsedExpression;
+}
+}