private Expr equalityExpr()
{
if (match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL))
{
Token operatorExpr = previous();
Expr right = comparisonExpr();
throw error(operatorExpr, "Expected expression before '" + operatorExpr.lexeme + "'.");
}
Expr expr = comparisonExpr();
while (match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL))
{
Token operatorExpr = previous();
Expr right = comparisonExpr();
expr = new ExprBinary(expr, operatorExpr, right);
}
return(expr);
}
private Expr commaSeparatedExprs()
{
if (match(TokenType.COMMA))
{
Token operatorExpr = previous();
Expr right = expression();
throw error(operatorExpr, "Expected expression before '" + operatorExpr.lexeme + "'.");
}
Expr expr = expression();
while (match(TokenType.COMMA))
{
Token operatorExpr = previous();
Expr right = ternaryConditionalExpr();
expr = new ExprBinary(expr, operatorExpr, right);
}
return(expr);
}
private Expr multiplicationExpr()
{
if (match(TokenType.STAR, TokenType.SLASH))
{
Token operatorExpr = previous();
Expr right = unaryExpr();
throw error(operatorExpr, "Expected expression before '" + operatorExpr.lexeme + "'.");
}
Expr expr = unaryExpr();
while (match(TokenType.STAR, TokenType.SLASH))
{
Token operatorExpr = previous();
Expr right = unaryExpr();
expr = new ExprBinary(expr, operatorExpr, right);
}
return(expr);
}
private Expr comparisonExpr()
{
if (match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL))
{
Token operatorExpr = previous();
Expr right = additionExpr();
throw error(operatorExpr, "Expected expression before '" + operatorExpr.lexeme + "'.");
}
Expr expr = additionExpr();
while (match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL))
{
Token operatorExpr = previous();
Expr right = additionExpr();
expr = new ExprBinary(expr, operatorExpr, right);
}
return(expr);
}
public object visitExprBinaryExpr(ExprBinary expr)
{
resolve(expr.left);
resolve(expr.right);
return(null);
}
public object visitExprBinaryExpr(ExprBinary expr)
{
object left = evaluate(expr.left);
object right = evaluate(expr.right);
switch (expr.eOperator.type)
{
case TokenType.GREATER:
checkNumberOperands(expr.eOperator, left, right);
return((double)left > (double)right);
case TokenType.GREATER_EQUAL:
checkNumberOperands(expr.eOperator, left, right);
return((double)left >= (double)right);
case TokenType.LESS:
checkNumberOperands(expr.eOperator, left, right);
return((double)left < (double)right);
case TokenType.LESS_EQUAL:
checkNumberOperands(expr.eOperator, left, right);
return((double)left <= (double)right);
case TokenType.MINUS:
checkNumberOperands(expr.eOperator, left, right);
return((double)left - (double)right);
case TokenType.SLASH:
checkNumberOperands(expr.eOperator, left, right);
if ((double)right == 0)
{
throw new LoxRuntimeException(expr.eOperator, "Divider must not be zero.");
}
return((double)left / (double)right);
case TokenType.STAR:
checkNumberOperands(expr.eOperator, left, right);
return((double)left * (double)right);
case TokenType.PLUS:
if (left.GetType() == typeof(double) && right.GetType() == typeof(double))
{
return((double)left + (double)right);
}
else if (left.GetType() == typeof(string) || right.GetType() == typeof(string))
{
return(string.Concat(toString(left), toString(right)));
}
else
{
throw new LoxRuntimeException(expr.eOperator, "Operands must be two numbers or two strings.");
}
case TokenType.BANG_EQUAL:
return(!left.Equals(right));
case TokenType.EQUAL_EQUAL:
return(left.Equals(right));
case TokenType.COMMA:
return(right);
default:
return(null);
}
}
public object visitExprBinaryExpr(ExprBinary expr)
{
return(parenthesize(expr.eOperator.lexeme, expr.left, expr.right));
}
