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