Don't try to access a nonexistent return expression

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

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 9761177a8086be6ac0e16f69fa29974398548e57..c2ebb4b96ad3e474b2f636578e404601282b82ad 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()));
 
@@ -206,6 +208,7 @@ void ProgramCompiler::generate(Stage &stage)
        apply<InterfaceGenerator>(stage);
        apply<VariableResolver>(stage);
        apply<DeclarationReorderer>(stage);
+       apply<FunctionResolver>(stage);
        apply<LegacyConverter>(stage);
 }
 
@@ -457,6 +460,8 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
        }
        if(var.constant)
                formatted += "const ";
+       if(!var.interpolation.empty())
+               formatted += format("%s ", var.interpolation);
        if(!var.sampling.empty())
                formatted += format("%s ", var.sampling);
        if(!var.interface.empty() && var.interface!=block_interface)
@@ -552,8 +557,12 @@ void ProgramCompiler::Formatter::visit(Iteration &iter)
 
 void ProgramCompiler::Formatter::visit(Return &ret)
 {
-       formatted += "return ";
-       ret.expression->visit(*this);
+       formatted += "return";
+       if(ret.expression)
+       {
+               formatted += ' ';
+               ret.expression->visit(*this);
+       }
        formatted += ';';
 }
 
@@ -985,13 +994,30 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 
 
 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(); )
        {
@@ -1015,13 +1041,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)
@@ -1127,12 +1204,14 @@ void ProgramCompiler::FunctionInliner::visit(Return &ret)
 
 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
        variable_values(0),
+       const_only(false),
        result(0.0f),
        result_valid(false)
 { }
 
-ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
-       variable_values(&v),
+ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap *v, bool c):
+       variable_values(v),
+       const_only(c),
        result(0.0f),
        result_valid(false)
 { }
@@ -1157,6 +1236,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
 {
        if(!var.declaration)
                return;
+       if(const_only && !var.declaration->constant)
+               return;
 
        if(variable_values)
        {
@@ -1216,7 +1297,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
-       scope_level(0)
+       scope_level(0),
+       in_loop(false)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
@@ -1241,7 +1323,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &va
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
 {
-       ExpressionEvaluator eval(variable_values);
+       ExpressionEvaluator eval(&variable_values, in_loop);
        cond.condition->visit(eval);
        if(eval.result_valid)
                flatten_block(eval.result ? cond.body : cond.else_body);
@@ -1251,9 +1333,10 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
 {
+       // XXX Should this not visit init_statement first?
        if(iter.condition)
        {
-               ExpressionEvaluator eval;
+               ExpressionEvaluator eval(0, in_loop);
                iter.condition->visit(eval);
                if(eval.result_valid && !eval.result)
                {
@@ -1262,6 +1345,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
                }
        }
 
+       SetFlag set_loop(in_loop);
        TraversingVisitor::visit(iter);
 }
 
@@ -1692,6 +1776,22 @@ bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const
                return check_version(Version(3, 30));
 }
 
+bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
+{
+       if(target_api==OPENGL_ES2)
+               return check_version(Version(3, 0));
+       else
+               return check_version(Version(1, 20));
+}
+
+bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
+{
+       if(target_api==OPENGL_ES2)
+               return check_version(Version(3, 20));
+       else
+               return check_version(Version(4, 0));
+}
+
 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
 {
        if(var.layout && !supports_interface_layouts())
@@ -1719,6 +1819,17 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
                }
        }
 
+       if(var.sampling=="centroid")
+       {
+               if(!supports_centroid_sampling())
+                       var.sampling = string();
+       }
+       else if(var.sampling=="sample")
+       {
+               if(!supports_sample_sampling())
+                       var.sampling = string();
+       }
+
        if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
        {
                if(stage->type==FRAGMENT && var.interface=="out")