Make ConstantFolder check the type of the value directly

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index bdaced5c46029299e531b8f3cdbd5055651bc539..63dfcb5c2823758dc054f92cb4d1960650e05d44 100644 (file)
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -553,18 +553,6 @@ void ExpressionInliner::visit(Iteration &iter)
 }
 
 
-BasicTypeDeclaration::Kind ConstantFolder::get_value_kind(const Variant &value)
-{
-       if(value.check_type<bool>())
-               return BasicTypeDeclaration::BOOL;
-       else if(value.check_type<int>())
-               return BasicTypeDeclaration::INT;
-       else if(value.check_type<float>())
-               return BasicTypeDeclaration::FLOAT;
-       else
-               return BasicTypeDeclaration::VOID;
-}
-
 template<typename T>
 T ConstantFolder::evaluate_logical(char oper, T left, T right)
 {
@@ -623,20 +611,18 @@ void ConstantFolder::visit(RefPtr<Expression> &expr)
        if(!r_constant || r_literal || r_uses_iter_var)
                return;
 
-       BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value);
-       if(kind==BasicTypeDeclaration::VOID)
-       {
-               r_constant = false;
-               return;
-       }
-
        RefPtr<Literal> literal = new Literal;
-       if(kind==BasicTypeDeclaration::BOOL)
+       if(r_constant_value.check_type<bool>())
                literal->token = (r_constant_value.value<bool>() ? "true" : "false");
-       else if(kind==BasicTypeDeclaration::INT)
+       else if(r_constant_value.check_type<int>())
                literal->token = lexical_cast<string>(r_constant_value.value<int>());
-       else if(kind==BasicTypeDeclaration::FLOAT)
+       else if(r_constant_value.check_type<float>())
                literal->token = lexical_cast<string>(r_constant_value.value<float>());
+       else
+       {
+               r_constant = false;
+               return;
+       }
        literal->value = r_constant_value;
        expr = literal;
 }
@@ -678,25 +664,27 @@ void ConstantFolder::visit(UnaryExpression &unary)
        if(!can_fold)
                return;
 
-       BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value);
-
        char oper = unary.oper->token[0];
        char oper2 = unary.oper->token[1];
        if(oper=='!')
        {
-               if(kind==BasicTypeDeclaration::BOOL)
+               if(r_constant_value.check_type<bool>())
                        set_result(!r_constant_value.value<bool>());
        }
        else if(oper=='~')
        {
-               if(kind==BasicTypeDeclaration::INT)
+               if(r_constant_value.check_type<int>())
                        set_result(~r_constant_value.value<int>());
+               else if(r_constant_value.check_type<unsigned>())
+                       set_result(~r_constant_value.value<unsigned>());
        }
        else if(oper=='-' && !oper2)
        {
-               if(kind==BasicTypeDeclaration::INT)
+               if(r_constant_value.check_type<int>())
                        set_result(-r_constant_value.value<int>());
-               else if(kind==BasicTypeDeclaration::FLOAT)
+               else if(r_constant_value.check_type<unsigned>())
+                       set_result(-r_constant_value.value<unsigned>());
+               else if(r_constant_value.check_type<float>())
                        set_result(-r_constant_value.value<float>());
        }
 }
@@ -716,45 +704,43 @@ void ConstantFolder::visit(BinaryExpression &binary)
        if(!can_fold)
                return;
 
-       BasicTypeDeclaration::Kind left_kind = get_value_kind(left_value);
-       BasicTypeDeclaration::Kind right_kind = get_value_kind(r_constant_value);
        // Currently only expressions with both sides of equal types are handled.
-       if(left_kind!=right_kind)
+       if(!left_value.check_same_type(r_constant_value))
                return;
 
        char oper = binary.oper->token[0];
        char oper2 = binary.oper->token[1];
        if(oper=='&' || oper=='|' || oper=='^')
        {
-               if(oper2==oper && left_kind==BasicTypeDeclaration::BOOL)
+               if(oper2==oper && left_value.check_type<bool>())
                        set_result(evaluate_logical(oper, left_value.value<bool>(), r_constant_value.value<bool>()));
-               else if(!oper2 && left_kind==BasicTypeDeclaration::INT)
+               else if(!oper2 && left_value.check_type<int>())
                        set_result(evaluate_logical(oper, left_value.value<int>(), r_constant_value.value<int>()));
        }
        else if((oper=='<' || oper=='>') && oper2!=oper)
        {
-               if(left_kind==BasicTypeDeclaration::INT)
+               if(left_value.check_type<int>())
                        set_result(evaluate_relation(binary.oper->token, left_value.value<int>(), r_constant_value.value<int>()));
-               else if(left_kind==BasicTypeDeclaration::FLOAT)
+               else if(left_value.check_type<float>())
                        set_result(evaluate_relation(binary.oper->token, left_value.value<float>(), r_constant_value.value<float>()));
        }
        else if((oper=='=' || oper=='!') && oper2=='=')
        {
-               if(left_kind==BasicTypeDeclaration::INT)
+               if(left_value.check_type<int>())
                        set_result((left_value.value<int>()==r_constant_value.value<int>()) == (oper=='='));
-               if(left_kind==BasicTypeDeclaration::FLOAT)
+               if(left_value.check_type<float>())
                        set_result((left_value.value<float>()==r_constant_value.value<float>()) == (oper=='='));
        }
        else if(oper=='+' || oper=='-' || oper=='*' || oper=='/')
        {
-               if(left_kind==BasicTypeDeclaration::INT)
+               if(left_value.check_type<int>())
                        set_result(evaluate_arithmetic(oper, left_value.value<int>(), r_constant_value.value<int>()));
-               else if(left_kind==BasicTypeDeclaration::FLOAT)
+               else if(left_value.check_type<float>())
                        set_result(evaluate_arithmetic(oper, left_value.value<float>(), r_constant_value.value<float>()));
        }
        else if(oper=='%' || ((oper=='<' || oper=='>') && oper2==oper))
        {
-               if(left_kind!=BasicTypeDeclaration::INT)
+               if(!left_value.check_type<int>())
                        return;
 
                if(oper=='%')

diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h
index ea61b671d2e1ea2a68b10c4b4682e8cb6a560260..a714a97a1b45ce49cf78a5c0fd4c69d2a4b6a661 100644 (file)
--- a/source/glsl/optimize.h
+++ b/source/glsl/optimize.h
@@ -175,7 +175,6 @@ public:
        bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
 
 private:
-       static BasicTypeDeclaration::Kind get_value_kind(const Variant &);
        template<typename T>
        static T evaluate_logical(char, T, T);
        template<typename T>