public TypeSpecifier VisitUnaryExpression(Expr.Unary exp)
{
var type = Visit(exp.Right);
var val = _valueStack.Pop();
switch (exp.Operator.Type)
{
case TokenType.MINUS:
if (type.IsInt())
{
_valueStack.Push(LLVM.BuildNeg(_builder, val, "negitmp"));
}
else
{
_valueStack.Push(LLVM.BuildFNeg(_builder, val, "negftmp"));
}
return(type);
case TokenType.NOT:
_valueStack.Push(LLVM.BuildNot(_builder, val, "nottmp"));
return(type);
default: throw new Exception("In unary");
}
}
object Expr.Visitor <object> .VisitUnaryExpr(Expr.Unary expr)
{
Object right = Evaluate(expr.right);
switch (expr.loxOperator._kind)
{
case Kind.BANG:
return(!IsTruthy(right));
case Kind.MINUS:
return(-(double)right);
}
return(null);
}
public object visitUnaryExpr(Expr.Unary expr)
{
object right = evaluate(expr.Right);
switch (expr.Op.type)
{
case TokenType.MINUS:
checkNumberOperand(expr.Op, right);
return(-(float)right);
case TokenType.BANG: return(!isTruthy(right));
}
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
object right = Evaluate(expr.Right);
switch (expr.Oper.Type)
{
case MINUS:
CheckNumberOperand(expr.Oper, right);
return(-(double)right);
case EXCLAMATION:
return(!IsTruthy(right));
}
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
object right = Evaluate(expr.Right);
switch (expr.Operation.Type)
{
case Bang:
return(!IsTruthy(right));
case Minus:
CheckNumberOperand(expr.Operation, right);
return(-(double)right);
}
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
var right = Evaluate(expr.right);
switch (expr.op.Type)
{
case MINUS:
CheckNumberOperand(expr.op, right);
return(-(double)right);
case BANG:
return(!IsTruthy(right));
default:
return(null);
}
}
public object VisitUnaryExpr(Expr.Unary expr)
{
object right = Evalutate(expr.Right);
switch (expr.OpCode.Type)
{
case TokenType.Bang:
return(!IsTruthy(right));
case TokenType.Minus:
CheckNumberOperand(expr.OpCode, right);
return(-(double)right);
default:
throw new RuntimeError(expr.OpCode, "Unrecongnized unary operator");
}
}
public object VisitUnaryExpr(Expr.Unary expr)
{
object right = Evaluate(expr.Right);
switch (expr.Oper.Type)
{
case TokenType.BANG:
return(!IsTruthy(right));
case TokenType.MINUS:
CheckNumberOperand(expr.Oper, right);
return(-(double)right);
default:
return(null);
}
}
public object Visit(Expr.Unary expr)
{
object right = Evaluate(expr.Right);
switch (expr.Operator.Type)
{
case TokenType.BANG_EQUAL:
return(IsTruthy(right));
case TokenType.MINUS:
CheckNumberOperand(expr.Operator, right);
return(-(double)right);
}
// Unreachable?
return(null);
}
public object visitUnaryExpr(Expr.Unary expr)
{
object right = evaluate(expr.right);
switch (expr.operator_.type)
{
case TokenType.TOKEN_BANG:
return(!isTruthy(right));
case TokenType.TOKEN_MINUS:
checkNumberOperand(expr.operator_, right);
return(-(double)right);
}
// Unreachable
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
// This needs to be evaludated first, BEFORE we can apply the unary operator.
// Post-Order traversal.
var right = Evaluate(expr.right);
switch ([email protected])
{
case MINUS:
CheckNumberOperands(expr.@operator, right);
return(-(double)right);
case BANG:
return(!isTruthy(right));
}
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
object right = evaluate(expr.Right);
if (right is int)
{
if (expr.Operator.Type == Lexer.Token.TokenType.MINUS)
{
return(-1 * (int)right);
}
}
else if (right is bool)
{
if (expr.Operator.Type == Lexer.Token.TokenType.BANG)
{
return(!((bool)right));
}
}
throw new RuntimeError($"Wrong type give for {expr.Operator.Literal} operator");
}
public object visitUnaryExpr(Expr.Unary unaryExpr)
{
captureToken(unaryExpr.operator_);
TokenType operatorType = unaryExpr.operator_.type;
compile(unaryExpr.right);
// Emit the operator instruction.
switch (operatorType)
{
case TokenType.TOKEN_BANG:
emitByte(OpCode.OP_NOT);
break;
case TokenType.TOKEN_MINUS:
emitByte(OpCode.OP_NEGATE);
break;
default:
return(null); // Unreachable.
}
return(null);
}
public object VisitUnaryExpr(Expr.Unary expr)
{
Resolve(expr.right);
return(null);
}
public string VisitUnaryExpr(Expr.Unary expr) => Format([email protected], expr.right);
public TrashObject VisitUnaryExpr(Expr.Unary expr)
{
return(this.UnaryExpr(expr));
}
public string VisitUnaryExpr(Expr.Unary expr)
{
return(Parenthesize(expr.OpCode.Lexeme, expr.Right));
}
public string VisitUnaryExpr(Expr.Unary expr)
{
return($"{expr.Oper}");
}
public T VisitUnaryExpression(Expr.Unary exp);
public object VisitUnaryExpr(Expr.Unary expr, object options = null)
{
return(null);
}
public string visitUnaryExpr(Expr.Unary expr)
{
return(Parenthesize(expr.oper.lexeme, expr.right));
}
public string VisitUnaryExpr(Expr.Unary expr) => Printer(expr.Operator.Lexeme, expr.Right);
public static TrashObject UnaryExpr(this Interpreter interpreter, Expr.Unary expr)
{
var right = interpreter.Evaluate(expr.Right);
return(interpreter.RunOverride(expr.Operator, right));
}
public string VisitUnaryExpr(Expr.Unary expr) => Parenthesize([email protected], expr.right);
public string VisitUnaryExpr(Expr.Unary expr) => $"{expr.Op.Lexeme} {expr.Right.Accept(this)}";
public object VisitUnaryExpr(Expr.Unary expr, object options)
{
return(Parenthesize(expr.token.lexeme, expr.right));
}
public string visitUnaryExpr(Expr.Unary expr)
{
return(parenthesize(expr.Op.Lexeme, expr.Right));
}
public Unit VisitUnaryExpr(Expr.Unary expr)
{
Resolve(expr.Right);
return(new Unit());
}
public LoxVoid VisitUnaryExpr(Expr.Unary expr)
{
Resolve(expr.Right);
return(null);
}
