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); }