private Expr Factor()
{
var expr = Unary();
while (Match(SLASH, STAR))
{
var op = Previous();
var right = Unary();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Term()
{
var expr = Factor();
while (Match(MINUS, PLUS))
{
var op = Previous();
var right = Factor();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
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);
}
private Expr Equality()
{
var expr = Comparison();
while (Match(BANG_EQUAL, EQUAL_EQUAL))
{
var op = Previous();
var right = Comparison();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
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 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 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 Comparison()
{
var expr = Term();
while (Match(GREATER, GREATER_EQUAL, LESS, LESS_EQUAL))
{
var op = Previous();
var right = Term();
expr = new Expr.Binary(expr, op, right);
}
return(expr);
}
private Expr Multiplication()
{
Expr expr = Unary();
while (Match(TokenType.SLASH, TokenType.STAR))
{
Token opp = Previous();
Expr right = Unary();
expr = new Expr.Binary(expr, opp, right);
}
return(expr);
}
public string VisitBinaryExpr(Expr.Binary expr) => Parenthesize(expr.Operator.Lexeme, expr.Left, expr.Right);
public object visitBinaryExpr(Expr.Binary expr)
{
object left = evaluate(expr.left);
object right = evaluate(expr.right);
switch (expr.op.type)
{
case TokenType.MINUS:
checkNumberOperands(expr.op, left, right);
return((double)left - (double)right);
case TokenType.SLASH:
checkNumberOperands(expr.op, left, right);
if ((double)right != 0.0)
{
return((double)left / (double)right);
}
throw new RuntimeError(expr.op,
"Division by zero");
case TokenType.STAR:
checkNumberOperands(expr.op, left, right);
return((double)left * (double)right);
case TokenType.PLUS:
if (left is double && right is double)
{
return((double)left + (double)right);
}
if (left is string && right is string)
{
return((string)left + (string)right);
}
if (left is string && !(right is string))
{
return((string)left + right);
}
if (!(left is string) && right is string)
{
return(left + (string)right);
}
throw new RuntimeError(expr.op,
"Operands must be two numbers or two strings.");
case TokenType.GREATER:
checkNumberOperands(expr.op, left, right);
return((double)left > (double)right);
case TokenType.GREATER_EQUAL:
checkNumberOperands(expr.op, left, right);
return((double)left >= (double)right);
case TokenType.LESS:
checkNumberOperands(expr.op, left, right);
return((double)left < (double)right);
case TokenType.LESS_EQUAL:
checkNumberOperands(expr.op, left, right);
return((double)left <= (double)right);
case TokenType.BANG_EQUAL: return(!isEqual(left, right));
case TokenType.EQUAL_EQUAL: return(isEqual(left, right));
}
// Unreachable.
return(null);
}
object Expr.IVisitor <object> .Visit(Expr.Binary _binary)
{
object left = Evaluate(_binary.left);
object right = Evaluate(_binary.right);
switch (_binary.opp.type)
{
case TokenType.BANG_EQUAL:
CheckNumberOperand(_binary.opp, right);
return(!IsEqual(left, right));
case TokenType.EQUAL_EQUAL:
CheckNumberOperand(_binary.opp, right);
return(IsEqual(left, right));
case TokenType.GREATER:
CheckNumberOperand(_binary.opp, right);
return((double)left > (double)right);
case TokenType.GREATER_EQUAL:
CheckNumberOperand(_binary.opp, right);
return((double)left >= (double)right);
case TokenType.LESS:
CheckNumberOperand(_binary.opp, right);
return((double)left < (double)right);
case TokenType.LESS_EQUAL:
CheckNumberOperand(_binary.opp, right);
return((double)left <= (double)right);
case TokenType.MINUS:
CheckNumberOperands(_binary.opp, left, right);
return((double)left - (double)right);
case TokenType.PLUS:
if (left is double && right is double)
{
return((double)left + (double)right);
}
if (left is string && right is string)
{
return((string)left + (string)right);
}
if (left is string && right is double)
{
return((string)left + ((double)right).ToString());
}
throw new RuntimeError(_binary.opp, "Operands must be two numbers or two strings.");
case TokenType.SLASH:
CheckNumberOperand(_binary.opp, right);
if ((double)right == 0)
{
throw new RuntimeError(_binary.opp, "Cannot divide by zero.");
}
return((double)left / (double)right);
case TokenType.STAR:
CheckNumberOperand(_binary.opp, right);
return((double)left * (double)right);
}
//unreachable
return(null);
}
string Expr.IVisitor <string> .Visit(Expr.Binary _binary)
{
return(Parenthesize(_binary.opp.lexeme, _binary.left, _binary.right));
}
public string VisitBinaryExpr(Expr.Binary expr)
{
return(Parenthesize([email protected], expr.left, expr.right));
}
public string visitBinaryExpr(Expr.Binary expr)
{
return(parenthesize(expr.op.lexeme, expr.left, expr.right));
}
public object VisitBinaryExpr(Expr.Binary expr)
{
Resolve(expr.left);
Resolve(expr.right);
return(null);
}
public Void VisitBinaryExpr(Expr.Binary expr)
{
Resolve(expr.Left);
Resolve(expr.Right);
return(null);
}
