Properly resolve arithmetic assignment operators

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

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index b7ab9d3f7b9fc956c37752f18e7e5bb36df0e0d3..f29d65f58bfeeaf4fe837fa2222226473c6d3c66 100644 (file)
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -584,10 +584,8 @@ void ExpressionResolver::visit(UnaryExpression &unary)
        resolve(unary, basic, unary.expression->lvalue);
 }
 
-void ExpressionResolver::visit(BinaryExpression &binary)
+void ExpressionResolver::visit(BinaryExpression &binary, bool assign)
 {
-       TraversingVisitor::visit(binary);
-
        /* Binary operators are only defined for basic types (not for image or
        structure types). */
        BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(binary.left->type);
@@ -619,6 +617,8 @@ void ExpressionResolver::visit(BinaryExpression &binary)
        Compatibility elem_compat = get_compatibility(*elem_left, *elem_right);
        if(elem_compat==NOT_COMPATIBLE)
                return;
+       if(assign && (compat==LEFT_CONVERTIBLE || elem_compat==LEFT_CONVERTIBLE))
+               return;
 
        TypeDeclaration *type = 0;
        char oper2 = binary.oper->token[1];
@@ -708,6 +708,9 @@ void ExpressionResolver::visit(BinaryExpression &binary)
        else
                return;
 
+       if(assign && type!=basic_left)
+               return;
+
        bool converted = true;
        if(compat==LEFT_CONVERTIBLE)
                convert_to(binary.left, *basic_right);
@@ -721,12 +724,35 @@ void ExpressionResolver::visit(BinaryExpression &binary)
        if(!converted)
                type = 0;
 
-       resolve(binary, type, false);
+       resolve(binary, type, assign);
+}
+
+void ExpressionResolver::visit(BinaryExpression &binary)
+{
+       TraversingVisitor::visit(binary);
+       visit(binary, false);
 }
 
 void ExpressionResolver::visit(Assignment &assign)
 {
        TraversingVisitor::visit(assign);
+
+       if(assign.oper->token[0]!='=')
+               return visit(assign, true);
+       else if(assign.left->type!=assign.right->type)
+       {
+               BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(assign.left->type);
+               BasicTypeDeclaration *basic_right = dynamic_cast<BasicTypeDeclaration *>(assign.right->type);
+               if(!basic_left || !basic_right)
+                       return;
+
+               Compatibility compat = get_compatibility(*basic_left, *basic_right);
+               if(compat==RIGHT_CONVERTIBLE)
+                       convert_to(assign.right, *basic_left);
+               else if(compat!=SAME_TYPE)
+                       return;
+       }
+
        resolve(assign, assign.left->type, true);
 }