private Expression call() { Expression higher_precidence = namespace_value(); while (true) { // If we are calling a function if (expect(Token.Type.LeftParenthesis)) { List <Expression> args = get_args(); higher_precidence = new CallExpr(higher_precidence, args); } // If we are getting a member/method from an object else if (consume(Token.Type.Callable) != null) { Token identifier = consume(Token.Type.Identifier, "Expected identifier after '.'"); higher_precidence = new ObjGetExpr(higher_precidence, identifier); } else { break; } } return(higher_precidence); }
// This is assignment of value, lowest precidence private Expression assignment() { Expression higher_precedence = connective_or(); if (consume(Token.Type.Assignment) != null) { Expression assign_value = assignment(); // If we are assigning to a non-object variable if (higher_precedence.GetType() == typeof(VariableExpr)) { VariableExpr var = (VariableExpr)higher_precedence; return(new AssignExpr(var.name, assign_value)); } // If we are assigning to a namespace value else if (higher_precedence.GetType() == typeof(NamespaceValueExpr)) { NamespaceValueExpr var = (NamespaceValueExpr)higher_precedence; return(new AssignNamespaceExpr(var, assign_value)); } // If we are assigning to a member variable else if (higher_precedence.GetType() == typeof(ObjGetExpr)) { ObjGetExpr member = (ObjGetExpr)higher_precedence; return(new ObjSetExpr(member.obj, member.identifier, assign_value)); } } return(higher_precedence); }
public object visit_obj_get(ObjGetExpr obj_get_expr) { object obj = evaluate(obj_get_expr.obj); if (obj is PlutoObject) { return(((PlutoObject)obj).get(obj_get_expr.identifier)); } throw new RuntimeException("Must be object to get member"); }
private Expression unary() { while (expect(Token.Type.ConnectiveNot) || expect(Token.Type.BitwiseNot) || expect(Token.Type.Increment) || expect(Token.Type.Decrement)) { // If we have an increment, we want an assign expression if (expect(Token.Type.Increment) || expect(Token.Type.Decrement)) { Token un_operator = consume(); Token op = (un_operator.type == Token.Type.Increment) ? new Token(Token.Type.Plus, null) : new Token(Token.Type.Minus, null); Expression to_crement = mul_div_mod_rem(); // Check the type of the incrementing expression // If we are incrementing to a non-object variable if (to_crement.GetType() == typeof(VariableExpr)) { VariableExpr var = (VariableExpr)to_crement; return(new AssignExpr(var.name, new BinaryExpr(to_crement, op, new LiteralExpr(1)))); } // If we are incrementing a namespace value else if (to_crement.GetType() == typeof(NamespaceValueExpr)) { NamespaceValueExpr var = (NamespaceValueExpr)to_crement; return(new AssignNamespaceExpr(var, new BinaryExpr(to_crement, op, new LiteralExpr(1)))); } // If we are incrementing a member variable else if (to_crement.GetType() == typeof(ObjGetExpr)) { ObjGetExpr member = (ObjGetExpr)to_crement; return(new ObjSetExpr(member.obj, member.identifier, new BinaryExpr(to_crement, op, new LiteralExpr(1)))); } else { throw new ParseExceptionUnexpectedToken("Increment assignment cannot be applied to " + to_crement.GetType()); } } else { Token op = consume(); Expression right = unary(); return(new UnaryExpr(op, right)); } } return(call()); }
private Expression mul_div_mod_rem() { Expression higher_precedence = unary(); while (expect(Token.Type.Multiply) || expect(Token.Type.Divide) || expect(Token.Type.Mod) || expect(Token.Type.NoRemainder)) { Token op = consume(); // Check for compound assignment if (consume(Token.Type.Assignment) != null) { Expression value = unary(); // Check the type of the higher precidence // If we are assigning to a non-object variable if (higher_precedence.GetType() == typeof(VariableExpr)) { VariableExpr var = (VariableExpr)higher_precedence; return(new AssignExpr(var.name, new BinaryExpr(higher_precedence, op, value))); } // If we are assigning to a namespace value else if (higher_precedence.GetType() == typeof(NamespaceValueExpr)) { NamespaceValueExpr var = (NamespaceValueExpr)higher_precedence; return(new AssignNamespaceExpr(var, new BinaryExpr(higher_precedence, op, value))); } // If we are assigning to a member variable else if (higher_precedence.GetType() == typeof(ObjGetExpr)) { ObjGetExpr member = (ObjGetExpr)higher_precedence; return(new ObjSetExpr(member.obj, member.identifier, new BinaryExpr(higher_precedence, op, value))); } else { throw new ParseExceptionUnexpectedToken("Compound assignment cannot be applied to " + higher_precedence.GetType()); } } else { Expression right = unary(); higher_precedence = new BinaryExpr(higher_precedence, op, right); } } return(higher_precedence); }
public object visit_obj_get(ObjGetExpr obj_get_expr) { resolve(obj_get_expr.obj); return(null); }