Store a pointer to operator info rather than the token in expressions

[libs/gl.git] / source / glsl / parser.cpp

diff --git a/source/glsl/parser.cpp b/source/glsl/parser.cpp
index 1f0d712467f3b43c2d9990dfa277bb1c46d0ff42..c6f3f5be3cdd186818cbee6322ad966dff46181d 100644 (file)
--- a/source/glsl/parser.cpp
+++ b/source/glsl/parser.cpp
@@ -456,6 +456,7 @@ RefPtr<Expression> Parser::parse_expression(unsigned precedence)
                        {
                                RefPtr<MemberAccess> memacc = new MemberAccess;
                                memacc->left = left;
+                               memacc->oper = oper;
                                tokenizer.parse_token();
                                memacc->member = expect_identifier();
                                left = memacc;
@@ -463,13 +464,13 @@ RefPtr<Expression> Parser::parse_expression(unsigned precedence)
                        else if(oper && oper->type==Operator::POSTFIX)
                        {
                                RefPtr<UnaryExpression> unary = new UnaryExpression;
-                               unary->oper = tokenizer.parse_token();
-                               unary->prefix = false;
+                               unary->oper = oper;
+                               tokenizer.parse_token();
                                unary->expression = left;
                                left = unary;
                        }
                        else if(oper && oper->type==Operator::BINARY)
-                               left = parse_binary(left, oper);
+                               left = parse_binary(left, *oper);
                        else
                                throw parse_error(tokenizer.get_location(), token, "an operator");
                        left_var = 0;
@@ -500,8 +501,8 @@ RefPtr<Expression> Parser::parse_expression(unsigned precedence)
                        else if(oper && oper->type==Operator::PREFIX)
                        {
                                RefPtr<UnaryExpression> unary = new UnaryExpression;
-                               unary->oper = tokenizer.parse_token();
-                               unary->prefix = true;
+                               unary->oper = oper;
+                               tokenizer.parse_token();
                                unary->expression = parse_expression(oper->precedence);
                                left = unary;
                        }
@@ -511,19 +512,19 @@ RefPtr<Expression> Parser::parse_expression(unsigned precedence)
        }
 }
 
-RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator *oper)
+RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator &oper)
 {
-       RefPtr<BinaryExpression> binary = (oper->precedence==16 ? new Assignment : new BinaryExpression);
+       RefPtr<BinaryExpression> binary = (oper.precedence==16 ? new Assignment : new BinaryExpression);
        binary->left = left;
-       binary->oper = tokenizer.parse_token();
-       if(binary->oper=="[")
+       binary->oper = &oper;
+       tokenizer.expect(oper.token);
+       if(oper.token[0]=='[')
        {
                binary->right = parse_expression();
                tokenizer.expect("]");
-               binary->after = "]";
        }
        else
-               binary->right = parse_expression(oper->precedence+(oper->assoc==Operator::RIGHT_TO_LEFT));
+               binary->right = parse_expression(oper.precedence+(oper.assoc==Operator::RIGHT_TO_LEFT));
        return binary;
 }
 
@@ -532,6 +533,7 @@ RefPtr<FunctionCall> Parser::parse_function_call(const VariableReference &var)
        RefPtr<FunctionCall> call = new FunctionCall;
        call->name = var.name;
        call->constructor = is_type(call->name);
+       call->oper = &Operator::get_operator("(", Operator::POSTFIX);
        tokenizer.expect("(");
        while(tokenizer.peek_token()!=")")
        {