private static AstNode ParseTerm(Parser.Parser parser)
{
if (parser.MatchToken(TokenType.Number))
{
return(new NumberNode(Convert.ToDouble(parser.ExpectToken(TokenType.Number).Value)));
}
else if (parser.AcceptToken(TokenType.Parentheses, "("))
{
AstNode statement = ExpressionNode.Parse(parser);
parser.ExpectToken(TokenType.Parentheses, ")");
return(statement);
}
else if (parser.AcceptToken(TokenType.Bracket, "["))
{
AstNode statement = ArrayInitializerNode.Parse(parser);
parser.ExpectToken(TokenType.Bracket, "]");
return(statement);
}
else if (parser.MatchToken(TokenType.String))
{
return(new StringNode(parser.ExpectToken(TokenType.String).Value.ToString()));
}
else if (parser.MatchToken(TokenType.Identifier))
{
return(new IdentifierNode(parser.ExpectToken(TokenType.Identifier).Value.ToString()));
}
else
{
throw new Exception("Unexpected in Parser: " + parser.CurrentToken().Value);
}
}
private static AstNode ParseFunctionCall(Parser.Parser parser, AstNode left)
{
if (parser.AcceptToken(TokenType.Parentheses, "("))
{
return(ParseFunctionCall(parser, new FunctionCallNode(left, ArgListNode.Parse(parser))));
}
else if (parser.AcceptToken(TokenType.Bracket, "["))
{
return(ParseFunctionCall(parser, new ArrayGetNode(left, ArrayIndexerNode.Parse(parser))));
}
else
{
return(left);
}
}
private static AstNode ParseAdditive(Parser.Parser parser)
{
AstNode left = ParseMultiplicative(parser);
if (parser.AcceptToken(TokenType.Operation, "+"))
{
AstNode right = ParseAdditive(parser);
return(new BinOpNode(BinaryOperation.Addition, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "-"))
{
AstNode right = ParseAdditive(parser);
return(new BinOpNode(BinaryOperation.Subtraction, left, right));
}
else
{
return(left);
}
}
private static AstNode ParseUnary(Parser.Parser parser)
{
if (parser.AcceptToken(TokenType.UnaryOperation, "!"))
{
return(new UnaryOpNode(UnaryOperation.Not, ParseUnary(parser)));
}
else if (parser.AcceptToken(TokenType.Operation, "-"))
{
return(new UnaryOpNode(UnaryOperation.Negate, ParseUnary(parser)));
}
else if (parser.AcceptToken(TokenType.UnaryOperation, "~"))
{
return(new UnaryOpNode(UnaryOperation.Complement, ParseUnary(parser)));
}
else
{
return(ParseFunctionCall(parser));
}
}
private static AstNode ParseAssignment(Parser.Parser parser)
{
AstNode left = ParseEquality(parser);
if (parser.AcceptToken(TokenType.Assignment))
{
AstNode right = ParseAssignment(parser);
return(new BinOpNode(BinaryOperation.Assignment, left, right));
}
else if (parser.AcceptToken(TokenType.OpAssign))
{
var assigntype = GetBinaryOp(parser.PreviousToken().Value.ToString());
var right = ParseAssignment(parser);
return(new BinOpNode(BinaryOperation.Assignment, assigntype, left, right));
}
else
{
return(left);
}
}
private static AstNode ParseMultiplicative(Parser.Parser parser)
{
AstNode left = ParseUnary(parser);
if (parser.AcceptToken(TokenType.Operation, "*"))
{
AstNode right = ParseMultiplicative(parser);
return(new BinOpNode(BinaryOperation.Multiplication, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "/"))
{
AstNode right = ParseMultiplicative(parser);
return(new BinOpNode(BinaryOperation.Division, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "%"))
{
AstNode right = ParseMultiplicative(parser);
return(new BinOpNode(BinaryOperation.Modulus, left, right));
}
else
{
return(left);
}
}
public static AstNode Parse(Parser.Parser parser)
{
parser.ExpectToken(TokenType.Identifier, "try");
AstNode tryBody = StatementNode.Parse(parser);
parser.ExpectToken(TokenType.Identifier, "catch");
AstNode catchBody = StatementNode.Parse(parser);
if (parser.AcceptToken(TokenType.Identifier, "finally"))
{
AstNode finallyBody = StatementNode.Parse(parser);
return(new TryNode(tryBody, catchBody, finallyBody));
}
return(new TryNode(tryBody, catchBody));
}
public static AstNode Parse(Parser.Parser parser)
{
parser.ExpectToken(TokenType.Identifier, "if");
parser.ExpectToken(TokenType.Parentheses, "(");
AstNode predicate = ExpressionNode.Parse(parser);
parser.ExpectToken(TokenType.Parentheses, ")");
AstNode ifBody = StatementNode.Parse(parser);
if (parser.AcceptToken(TokenType.Identifier, "else"))
{
AstNode elseBody = StatementNode.Parse(parser);
return(new IfNode(predicate, ifBody, elseBody));
}
return(new IfNode(predicate, ifBody));
}
public static ArgListNode Parse(Parser.Parser parser)
{
ArgListNode ret = new ArgListNode();
parser.ExpectToken(TokenType.Parentheses, "(");
while (!parser.MatchToken(TokenType.Parentheses, ")"))
{
ret.Children.Add(ExpressionNode.Parse(parser));
if (!parser.AcceptToken(TokenType.Comma))
{
break;
}
}
parser.ExpectToken(TokenType.Parentheses, ")");
return(ret);
}
public static AstNode Parse(Parser.Parser parser)
{
parser.ExpectToken(TokenType.Identifier, "func");
string name = parser.ExpectToken(TokenType.Identifier).Value.ToString();
parser.ExpectToken(TokenType.Parentheses, "(");
List <string> result = new List <string>();
while (parser.MatchToken(TokenType.Identifier))
{
result.Add(parser.ExpectToken(TokenType.Identifier).Value.ToString());
if (!parser.AcceptToken(TokenType.Comma))
{
break;
}
}
parser.ExpectToken(TokenType.Parentheses, ")");
AstNode body = StatementNode.Parse(parser);
return(new FuncNode(name, result, body));
}
private static AstNode ParseEquality(Parser.Parser parser)
{
AstNode left = ParseAdditive(parser);
if (parser.AcceptToken(TokenType.Comparison, "="))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.Equals, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "!="))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.NotEqualTo, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "<"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.LessThan, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, ">"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.GreaterThan, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "<="))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.LesserOrEqual, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, ">="))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.GreaterOrEqual, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "&&"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.And, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "&&"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.And, left, right));
}
else if (parser.AcceptToken(TokenType.Comparison, "||"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.Or, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "^"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.Xor, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "<<"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.BitshiftLeft, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, ">>"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.BitshiftRight, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "&"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.BitwiseAnd, left, right));
}
else if (parser.AcceptToken(TokenType.Operation, "|"))
{
var right = ParseEquality(parser);
return(new BinOpNode(BinaryOperation.BitwiseOr, left, right));
}
else
{
return(left);
}
}
