Check that non-constant data is not accessed from constant expressions

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

diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp
index b313354dc9c54d56688fe7d7b32b24f8328bcbfc..62f997bb5c29ad6d8a507620c3d78745118fc80f 100644 (file)
--- a/source/glsl/validate.cpp
+++ b/source/glsl/validate.cpp
@@ -251,8 +251,12 @@ void DeclarationValidator::visit(VariableDeclaration &var)
        }
 
        TypeDeclaration *type = var.type_declaration;
+       BasicTypeDeclaration::Kind kind = BasicTypeDeclaration::ALIAS;
        while(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(type))
+       {
+               kind = basic->kind;
                type = basic->base_type;
+       }
        if(dynamic_cast<ImageTypeDeclaration *>(type))
        {
                if(scope!=GLOBAL && scope!=FUNCTION_PARAM)
@@ -260,6 +264,10 @@ void DeclarationValidator::visit(VariableDeclaration &var)
                else if(scope==GLOBAL && var.interface!="uniform")
                        error(var, format("Type '%s' only allowed with uniform interface", type->name));
        }
+       else if(kind==BasicTypeDeclaration::VOID)
+               error(var, "Type 'void' not allowed on variable");
+       else if(kind==BasicTypeDeclaration::BOOL && !var.interface.empty() && var.source!=BUILTIN_SOURCE)
+               error(var, "Type 'bool' not allowed on interface variable");
 
        if(var.init_expression)
        {
@@ -353,7 +361,7 @@ void IdentifierValidator::visit(VariableDeclaration &var)
 
 void IdentifierValidator::visit(InterfaceBlock &iface)
 {
-       string key = iface.interface+iface.block_name;
+       string key = format("%s %s", iface.interface, iface.block_name);
        map<string, InterfaceBlock *>::const_iterator i = interface_blocks.find(key);
        if(i!=interface_blocks.end())
                multiple_definition(format("interface block '%s %s'", iface.interface, iface.block_name), iface, *i->second);
@@ -500,9 +508,22 @@ void ReferenceValidator::visit(FunctionDeclaration &func)
 
 
 ExpressionValidator::ExpressionValidator():
-       current_function(0)
+       current_function(0),
+       constant_expression(false)
 { }
 
+void ExpressionValidator::visit(VariableReference &var)
+{
+       if(var.declaration && constant_expression && !var.declaration->constant)
+               error(var, format("Reference to non-constant variable '%s' in a constant expression", var.name));
+}
+
+void ExpressionValidator::visit(InterfaceBlockReference &iface)
+{
+       if(constant_expression)
+               error(iface, format("Reference to interface block '%s' in a constant expression", iface.name));
+}
+
 void ExpressionValidator::visit(Swizzle &swizzle)
 {
        unsigned size = 0;
@@ -547,8 +568,13 @@ void ExpressionValidator::visit(UnaryExpression &unary)
        {
                if(!unary.type)
                        error(unary, format("No matching operator '%s' found for '%s'", unary.oper->token, unary.expression->type->name));
-               else if((unary.oper->token[1]=='+' || unary.oper->token[1]=='-') && !unary.expression->lvalue)
-                       error(unary, format("Operand of '%s' is not an lvalue", unary.oper->token));
+               else if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
+               {
+                       if(constant_expression)
+                               error(unary, format("Use of '%s' in a constant expression", unary.oper->token));
+                       else if(!unary.expression->lvalue)
+                               error(unary, format("Operand of '%s' is not an lvalue", unary.oper->token));
+               }
        }
        TraversingVisitor::visit(unary);
 }
@@ -571,7 +597,9 @@ void ExpressionValidator::visit(Assignment &assign)
 {
        if(assign.left->type)
        {
-               if(!assign.left->lvalue)
+               if(constant_expression)
+                       error(assign, "Assignment in constant expression");
+               else if(!assign.left->lvalue)
                        error(assign, "Target of assignment is not an lvalue");
                if(assign.right->type)
                {
@@ -608,7 +636,19 @@ void ExpressionValidator::visit(VariableDeclaration &var)
        if(var.init_expression && var.init_expression->type && var.type_declaration && var.init_expression->type!=var.type_declaration)
                error(var, format("Initializing a variable of type '%s' with an expression of incompatible type '%s'",
                        var.type_declaration->name, var.init_expression->type->name));
-       TraversingVisitor::visit(var);
+
+       if(var.layout)
+               var.layout->visit(*this);
+       if(var.init_expression)
+       {
+               SetFlag set_const(constant_expression, var.constant);
+               TraversingVisitor::visit(var.init_expression);
+       }
+       if(var.array_size)
+       {
+               SetFlag set_const(constant_expression);
+               TraversingVisitor::visit(var.array_size);
+       }
 }
 
 void ExpressionValidator::visit(FunctionDeclaration &func)
@@ -617,6 +657,28 @@ void ExpressionValidator::visit(FunctionDeclaration &func)
        TraversingVisitor::visit(func);
 }
 
+void ExpressionValidator::visit(Conditional &cond)
+{
+       if(cond.condition->type)
+       {
+               BasicTypeDeclaration *basic_cond = dynamic_cast<BasicTypeDeclaration *>(cond.condition->type);
+               if(!basic_cond || basic_cond->kind!=BasicTypeDeclaration::BOOL)
+                       error(cond, "Condition is not a boolean");
+       }
+       TraversingVisitor::visit(cond);
+}
+
+void ExpressionValidator::visit(Iteration &iter)
+{
+       if(iter.condition->type)
+       {
+               BasicTypeDeclaration *basic_cond = dynamic_cast<BasicTypeDeclaration *>(iter.condition->type);
+               if(!basic_cond || basic_cond->kind!=BasicTypeDeclaration::BOOL)
+                       error(iter, "Loop condition is not a boolean");
+       }
+       TraversingVisitor::visit(iter);
+}
+
 void ExpressionValidator::visit(Return &ret)
 {
        if(current_function && current_function->return_type_declaration)
@@ -660,14 +722,14 @@ void StageInterfaceValidator::visit(VariableDeclaration &var)
                }
                if(var.type_declaration && var.linked_declaration->type_declaration)
                {
-                       const TypeDeclaration *type = var.type_declaration;
+                       TypeDeclaration *type = var.type_declaration;
                        if(stage->type==Stage::GEOMETRY)
                        {
                                if(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
                                        if(basic->kind==BasicTypeDeclaration::ARRAY && basic->base_type)
                                                type = basic->base_type;
                        }
-                       if(!is_same_type(*type, *var.linked_declaration->type_declaration))
+                       if(!TypeComparer().apply(*type, *var.linked_declaration->type_declaration))
                        {
                                error(var, format("Mismatched type '%s' for 'in %s'", type->name, var.name));
                                add_info(*var.linked_declaration, format("Linked to 'out %s' with type '%s'",
@@ -720,7 +782,7 @@ void GlobalInterfaceValidator::check_uniform(const Uniform &uni)
                        error(*uni.node, format("Mismatched binding %d for uniform '%s'", uni.bind_point, uni.name));
                        add_info(*i->second->node, format("Previously declared here with binding %d", i->second->bind_point));
                }
-               if(uni.type && i->second->type && !is_same_type(*uni.type, *i->second->type))
+               if(uni.type && i->second->type && !TypeComparer().apply(*uni.type, *i->second->type))
                {
                        string type_name = (dynamic_cast<const StructDeclaration *>(uni.type) ?
                                "structure" : format("type '%s'", uni.type->name));