private Expr Factor()
{
var expr = Unary();
while (Match(STAR, SLASH))
{
var @operator = Previous();
var right = Unary();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
/// <summary>
/// Helper method to extract Binary Expressions.
/// </summary>
/// <param name="NextMethod"></param>
/// <param name="matches"></param>
/// <returns></returns>
private Expr BinaryMethod(Func <Expr> NextMethod, params TokenType[] matches)
{
Expr expr = NextMethod();
while (match(matches))
{
Token @operator = Previous();
Expr right = NextMethod();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Comparision()
{
var expr = Term();
while (Match(TokenType.GREATER, GREATER_EQUAL, LESS, LESS_EQUAL))
{
var @operator = Previous();
var right = Term();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Term()
{
var expr = Factor();
while (Match(PLUS, MINUS))
{
var @operator = Previous();
var right = Factor();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Factor()
{
Expr expr = Unary();
while (Match(TokenType.Slash, TokenType.Star))
{
Token op = Previous();
Expr right = Unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Comparison()
{
Expr expr = Term();
while (Match(TokenType.Greater, TokenType.GreaterEqual, TokenType.Less, TokenType.LessEqual))
{
Token op = Previous();
Expr right = Term();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Term()
{
Expr expr = Factor();
while (Match(TokenType.Minus, TokenType.Plus))
{
Token op = Previous();
Expr right = Factor();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Comparison()
{
// comparison → addition ( ( ">" | ">=" | "<" | "<=" ) addition )* ;
Expr expr = Addition();
while (Match(GREATER, GREATER_EQUAL, LESS, LESS_EQUAL))
{
Token op = Previous();
Expr right = Addition();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
public static Expr Dotted(this Parser parser)
{
Expr expr = parser.Grouping();
while (parser.Match(Lexer.Token.TokenType.DOT))
{
Lexer.Token op = parser.Previous();
Expr right = parser.Grouping();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
public static Expr Multiplication(this Parser parser)
{
Expr expr = parser.Unary();
while (parser.Match(Lexer.Token.TokenType.MULTIPLY, Lexer.Token.TokenType.DIVIDE))
{
Lexer.Token op = parser.Previous();
Expr right = parser.Unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
public static Expr Addition(this Parser parser)
{
Expr left = parser.Multiplication();
while (parser.Match(Lexer.Token.TokenType.PLUS, Lexer.Token.TokenType.MINUS))
{
Lexer.Token op = parser.Previous();
Expr right = parser.Multiplication();
left = new Expr.Binary(left, op, right);
}
return(left);
}
private Expr term()
{
Expr expr = factor();
while (match(TokenType.MINUS, TokenType.PLUS))
{
Token op = previous();
Expr right = factor();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
/// <summary>
/// Parse a equality expression
/// </summary>
/// <returns>The expression</returns>
private Expr Equality()
{
Expr expr = Comparison();
while (Match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL))
{
Token op = Previous();
Expr right = Comparison();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
Expr multiplication()
{
Expr expr = unary();
while (match(Lexer.Token.TokenType.MULTIPLY, Lexer.Token.TokenType.DIVIDE))
{
Lexer.Token op = previous();
Expr right = unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Equality()
{
Expr left = LoxComparison();
while (Match(Kind.BANG_EQUAL, Kind.EQUAL_EQUAL))
{
Token loxOperator = Previous();
Expr right = LoxComparison();
left = new Expr.Binary(left, loxOperator, right);
}
return(left);
}
private Expr Multiplication()
{
Expr expr = UnaryPrefix();
while (Match(SLASH, STAR, STAR_STAR, PERCENT, LESS_LESS, GREATER_GREATER))
{
Token @operator = Previous();
Expr right = UnaryPrefix();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Comparison()
{
Expr expr = Addition();
while (Match(GREATER, GREATER_EQUAL, LESS, LESS_EQUAL))
{
Token @operator = Previous();
Expr right = Addition();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Equality()
{
Expr expr = Comparison();
while (Match(BANG_EQUAL, EQUAL_EQUAL))
{
Token @operator = Previous();
Expr right = Comparison();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
private Expr Multiplication()
{
// multiplication → unary(("/" | "*") unary) * ;
Expr expr = Unary();
while (Match(SLASH, STAR))
{
Token op = Previous();
Expr right = Unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Addition()
{
Expr expr = Multiplication();
while (Match(Kind.MINUS, Kind.PLUS))
{
Token loxOperator = Previous();
Expr right = Multiplication();
expr = new Expr.Binary(expr, loxOperator, right);
}
return(expr);
}
private Expr Equality()
{
var expr = Comparision();
while (Match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL))
{
var @operator = Previous();
Expr right = Comparision(); // NExt one in the tree;
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
Expr addition()
{
Expr expr = multiplication();
while (match(Lexer.Token.TokenType.PLUS, Lexer.Token.TokenType.MINUS))
{
Lexer.Token op = previous();
Expr right = multiplication();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr LoxComparison()
{
Expr expr = Addition();
while (Match(Kind.GREATER, Kind.GREATER_EQUAL, Kind.LESS, Kind.LESS_EQUAL))
{
Token loxOperator = Previous();
Expr right = Addition();
expr = new Expr.Binary(expr, loxOperator, right);
}
return(expr);
}
/// <summary>
/// Parse an addition/subtraction expression
/// </summary>
/// <returns></returns>
private Expr Addition()
{
Expr expr = Multiplication();
while (Match(TokenType.MINUS, TokenType.PLUS))
{
Token op = Previous();
Expr right = Multiplication();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Multiplication()
{
Expr expr = Unary();
while (Match(Kind.SLASH, Kind.STAR))
{
Token loxOperator = Previous();
Expr right = Unary();
expr = new Expr.Binary(expr, loxOperator, right);
}
return(expr);
}
private Expr Equality()
{
Expr expr = Comparsion();
while (Match(EXCLAMATION_EQUAL, EQUAL_EQUAL))
{
Token oper = Previous();
Expr right = Comparsion();
expr = new Expr.Binary(expr, oper, right);
}
return(expr);
}
/// <summary>
/// Parse a comparison expression
/// </summary>
/// <returns>The epxression</returns>
private Expr Comparison()
{
Expr expr = Addition();
while (Match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL))
{
Token op = Previous();
Expr right = Addition();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr factor()
{
Expr expr = unary();
while (match(TokenType.SLASH, TokenType.STAR))
{
Token op = previous();
Expr right = unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
/// <summary>
/// Parse a mulitplication/division expression
/// </summary>
/// <returns></returns>
private Expr Multiplication()
{
Expr expr = Unary();
while (Match(TokenType.SLASH, TokenType.STAR))
{
Token op = Previous();
Expr right = Unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Comma()
{
var expr = Ternary();
while (Match(COMMA))
{
var @operator = Previous();
var right = Ternary();
expr = new Expr.Binary(expr, @operator, right);
}
return(expr);
}
