Throw an exception if Texture*::allocate is called before storage

[libs/gl.git] / source / programcompiler.cpp

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index e102349a6482f0dc4a679ee325561210948dd52b..5bb84269f30abe4fcd38198cef0b6a2ae416b2f8 100644 (file)
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -35,6 +35,8 @@ namespace GL {
 
 using namespace ProgramSyntax;
 
+// XXX For some reason global declarations are emitted for otherwise undeclared local variables
+
 ProgramCompiler::ProgramCompiler():
        resources(0),
        module(0)
@@ -130,8 +132,8 @@ Stage *ProgramCompiler::get_builtins(StageType type)
 
 void ProgramCompiler::append_module(ProgramSyntax::Module &mod)
 {
-       list<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
-       for(list<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
+       vector<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
+       for(vector<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
                import((*i)->module);
        apply<NodeRemover>(mod.shared, set<Node *>(imports.begin(), imports.end()));
 
@@ -205,8 +207,8 @@ void ProgramCompiler::generate(Stage &stage)
        apply<VariableResolver>(stage);
        apply<InterfaceGenerator>(stage);
        apply<VariableResolver>(stage);
-       apply<VariableRenamer>(stage);
        apply<DeclarationReorderer>(stage);
+       apply<FunctionResolver>(stage);
        apply<LegacyConverter>(stage);
 }
 
@@ -861,6 +863,7 @@ void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left,
 
        ExpressionStatement *stmt = new ExpressionStatement;
        stmt->expression = assign;
+       stmt->visit(*this);
        insert_nodes.push_back(stmt);
 }
 
@@ -876,7 +879,10 @@ void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
        if(i==prev_out.end())
                i = prev_out.find(in_prefix+var.name);
        if(i!=prev_out.end())
-               generate_interface(*i->second, "in", var.name);
+       {
+               generate_interface(*i->second, "in", i->second->name);
+               var.name = i->second->name;
+       }
 }
 
 void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
@@ -889,7 +895,10 @@ void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
                {
                        remove_node = true;
                        if(var.init_expression)
+                       {
                                insert_assignment(var.name, var.init_expression->clone());
+                               return;
+                       }
                }
        }
        else if(var.interface=="in")
@@ -978,28 +987,31 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 }
 
 
-void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
-{
-       if(var.declaration)
-               var.name = var.declaration->name;
-}
-
-void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
-{
-       if(var.linked_declaration)
-               var.name = var.linked_declaration->name;
-       TraversingVisitor::visit(var);
-}
-
-
 ProgramCompiler::DeclarationReorderer::DeclarationReorderer():
+       scope_level(0),
        kind(NO_DECLARATION)
 { }
 
+void ProgramCompiler::DeclarationReorderer::visit(FunctionCall &call)
+{
+       FunctionDeclaration *def = call.declaration;
+       if(def)
+               def = def->definition;
+       if(def && !ordered_funcs.count(def))
+               needed_funcs.insert(def);
+}
+
 void ProgramCompiler::DeclarationReorderer::visit(Block &block)
 {
+       SetForScope<unsigned> set(scope_level, scope_level+1);
+       if(scope_level>1)
+               return Visitor::visit(block);
+
        list<RefPtr<Node> >::iterator struct_insert_point = block.body.end();
        list<RefPtr<Node> >::iterator variable_insert_point = block.body.end();
+       list<RefPtr<Node> >::iterator function_insert_point = block.body.end();
+       unsigned unordered_func_count = 0;
+       bool ordered_any_funcs = false;
 
        for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
        {
@@ -1023,13 +1035,64 @@ void ProgramCompiler::DeclarationReorderer::visit(Block &block)
                else if(kind>VARIABLE && variable_insert_point==block.body.end())
                        variable_insert_point = i;
 
+               if(kind==FUNCTION)
+               {
+                       if(function_insert_point==block.body.end())
+                               function_insert_point = i;
+
+                       if(needed_funcs.empty())
+                       {
+                               ordered_funcs.insert(i->get());
+                               if(i!=function_insert_point)
+                               {
+                                       block.body.insert(function_insert_point, *i);
+                                       moved = true;
+                               }
+                               else
+                                       ++function_insert_point;
+                               ordered_any_funcs = true;
+                       }
+                       else
+                               ++unordered_func_count;
+               }
+
                if(moved)
+               {
+                       if(function_insert_point==i)
+                               ++function_insert_point;
                        block.body.erase(i++);
+               }
                else
                        ++i;
+
+               if(i==block.body.end() && unordered_func_count)
+               {
+                       if(!ordered_any_funcs)
+                               // A subset of the remaining functions forms a recursive loop
+                               /* TODO pick a function and move it up, adding any necessary
+                               declarations */
+                               break;
+
+                       i = function_insert_point;
+                       unordered_func_count = 0;
+               }
        }
 }
 
+void ProgramCompiler::DeclarationReorderer::visit(ProgramSyntax::VariableDeclaration &var)
+{
+       Visitor::visit(var);
+       kind = VARIABLE;
+}
+
+void ProgramCompiler::DeclarationReorderer::visit(FunctionDeclaration &func)
+{
+       needed_funcs.clear();
+       func.body.visit(*this);
+       needed_funcs.erase(&func);
+       kind = FUNCTION;
+}
+
 
 ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator():
        in_function(0)