Consistently use the NodeList and NodeArray types

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

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 5a17a9ed3857bf969005e57a73ebe94d01b9ec20..5027dc9b79788783c0e2cc5860fa91c39b232ef2 100644 (file)
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -1,4 +1,8 @@
+#include <msp/core/algorithm.h>
 #include <msp/core/raii.h>
+#include <msp/gl/extensions/arb_explicit_attrib_location.h>
+#include <msp/gl/extensions/arb_gpu_shader5.h>
+#include <msp/gl/extensions/arb_uniform_buffer_object.h>
 #include <msp/gl/extensions/ext_gpu_shader4.h>
 #include <msp/strings/format.h>
 #include <msp/strings/utils.h>
@@ -8,6 +12,8 @@
 #include "resources.h"
 #include "shader.h"
 
+#undef interface
+
 using namespace std;
 
 namespace {
@@ -162,7 +168,7 @@ void ProgramCompiler::append_stage(Stage &stage)
                target = &*i;
        }
 
-       for(NodeList<Node>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
+       for(NodeList<Statement>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
                target->content.body.push_back(*i);
        apply<DeclarationCombiner>(*target);
 }
@@ -235,8 +241,8 @@ void ProgramCompiler::finalize(Stage &stage)
 
 void ProgramCompiler::inject_block(Block &target, const Block &source)
 {
-       list<RefPtr<Node> >::iterator insert_point = target.body.begin();
-       for(list<RefPtr<Node> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
+       NodeList<Statement>::iterator insert_point = target.body.begin();
+       for(NodeList<Statement>::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
                target.body.insert(insert_point, (*i)->clone());
 }
 
@@ -278,7 +284,7 @@ void ProgramCompiler::BlockModifier::flatten_block(Block &block)
        remove_node = true;
 }
 
-void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
+void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, NodeList<Statement>::iterator &i)
 {
        block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
        insert_nodes.clear();
@@ -292,7 +298,7 @@ void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefP
 
 void ProgramCompiler::BlockModifier::visit(Block &block)
 {
-       for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
        {
                (*i)->visit(*this);
                apply_and_increment(block, i);
@@ -319,6 +325,11 @@ void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s)
                formatted += '\n';
        }
 
+       for(vector<const Extension *>::const_iterator i=s.required_extensions.begin(); i!=s.required_extensions.end(); ++i)
+               formatted += format("#extension %s: require\n", (*i)->get_name());
+       if(!s.required_extensions.empty())
+               formatted += '\n';
+
        Visitor::apply(s);
 }
 
@@ -372,7 +383,7 @@ void ProgramCompiler::Formatter::visit(Assignment &assign)
 void ProgramCompiler::Formatter::visit(FunctionCall &call)
 {
        formatted += format("%s(", call.name);
-       for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
+       for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
        {
                if(i!=call.arguments.begin())
                        formatted += ", ";
@@ -399,7 +410,7 @@ void ProgramCompiler::Formatter::visit(Block &block)
 
        SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
        string spaces(indent*2, ' ');
-       for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
        {
                if(i!=block.body.begin())
                        formatted += '\n';
@@ -504,7 +515,7 @@ void ProgramCompiler::Formatter::visit(InterfaceBlock &iface)
 void ProgramCompiler::Formatter::visit(FunctionDeclaration &func)
 {
        formatted += format("%s %s(", func.return_type, func.name);
-       for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+       for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
        {
                if(i!=func.parameters.begin())
                        formatted += ", ";
@@ -632,6 +643,27 @@ void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var)
                ptr->type = var.type;
                if(var.init_expression)
                        ptr->init_expression = var.init_expression;
+               if(var.layout)
+               {
+                       if(ptr->layout)
+                       {
+                               for(vector<Layout::Qualifier>::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i)
+                               {
+                                       bool found = false;
+                                       for(vector<Layout::Qualifier>::iterator j=ptr->layout->qualifiers.begin(); (!found && j!=ptr->layout->qualifiers.end()); ++j)
+                                               if(j->identifier==i->identifier)
+                                               {
+                                                       j->value = i->value;
+                                                       found = true;
+                                               }
+
+                                       if(!found)
+                                               ptr->layout->qualifiers.push_back(*i);
+                               }
+                       }
+                       else
+                               ptr->layout = var.layout;
+               }
                remove_node = true;
        }
        else
@@ -833,7 +865,7 @@ void ProgramCompiler::InterfaceGenerator::apply(Stage &s)
 void ProgramCompiler::InterfaceGenerator::visit(Block &block)
 {
        SetForScope<unsigned> set(scope_level, scope_level+1);
-       for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
        {
                (*i)->visit(*this);
 
@@ -841,7 +873,7 @@ void ProgramCompiler::InterfaceGenerator::visit(Block &block)
                {
                        for(map<string, RefPtr<VariableDeclaration> >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
                        {
-                               list<RefPtr<Node> >::iterator k = block.body.insert(i, j->second);
+                               NodeList<Statement>::iterator k = block.body.insert(i, j->second);
                                (*k)->visit(*this);
                        }
                        iface_declarations.clear();
@@ -1037,13 +1069,13 @@ void ProgramCompiler::DeclarationReorderer::visit(Block &block)
        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();
+       NodeList<Statement>::iterator struct_insert_point = block.body.end();
+       NodeList<Statement>::iterator variable_insert_point = block.body.end();
+       NodeList<Statement>::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(); )
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
        {
                kind = NO_DECLARATION;
                (*i)->visit(*this);
@@ -1178,7 +1210,7 @@ void ProgramCompiler::FunctionInliner::visit(Block &block)
        if(extract_result)
                --extract_result;
 
-       for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
        {
                (*i)->visit(*this);
                if(extract_result)
@@ -1207,7 +1239,7 @@ void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
 
 void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
 {
-       for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
+       for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
                visit_and_inline(*i);
 
        FunctionDeclaration *def = call.declaration;
@@ -1413,6 +1445,7 @@ ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
        aggregate(0),
        assignment(0),
        assignment_target(false),
+       assign_to_subscript(false),
        global_scope(true)
 { }
 
@@ -1458,6 +1491,8 @@ void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
 {
        if(binary.oper=="[")
        {
+               if(assignment_target)
+                       assign_to_subscript = true;
                binary.left->visit(*this);
                SetForScope<bool> set(assignment_target, false);
                binary.right->visit(*this);
@@ -1469,6 +1504,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
 {
        {
+               assign_to_subscript = false;
                SetForScope<bool> set(assignment_target, !assign.self_referencing);
                assign.left->visit(*this);
        }
@@ -1476,10 +1512,10 @@ void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
        assignment = &assign;
 }
 
-void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
+void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool chained)
 {
        VariableInfo &var_info = variables.back()[&var];
-       if(!self_ref)
+       if(!chained)
                clear_assignments(var_info, true);
        var_info.assignments.push_back(&node);
        var_info.conditionally_assigned = false;
@@ -1500,7 +1536,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
        assignment = 0;
        TraversingVisitor::visit(expr);
        if(assignment && assignment->target_declaration)
-               record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
+               record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
 }
 
 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
@@ -1537,7 +1573,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
 
        {
                SetForScope<bool> set(global_scope, false);
-               for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+               for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
                        (*i)->visit(*this);
                func.body.visit(*this);
        }
@@ -1545,7 +1581,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
        BlockVariableMap &block_variables = variables.back();
        for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
                i->second.conditionally_assigned = true;
-       for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+       for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
                block_variables[i->get()].referenced = true;
        merge_down_variables();
 }
@@ -1657,7 +1693,7 @@ ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
 
 void ProgramCompiler::NodeRemover::visit(Block &block)
 {
-       for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+       for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
        {
                (*i)->visit(*this);
                if(to_remove.count(i->get()))
@@ -1685,6 +1721,7 @@ void ProgramCompiler::NodeRemover::visit(Iteration &iter)
 {
        if(to_remove.count(iter.init_statement.get()))
                iter.init_statement = 0;
+       TraversingVisitor::visit(iter);
 }
 
 
@@ -1769,6 +1806,18 @@ bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_vers
        return true;
 }
 
+bool ProgramCompiler::LegacyConverter::check_extension(const Extension &extension) const
+{
+       if(!extension)
+               return false;
+
+       vector<const Extension *>::iterator i = find(stage->required_extensions, &extension);
+       if(i==stage->required_extensions.end())
+               stage->required_extensions.push_back(&extension);
+
+       return true;
+}
+
 bool ProgramCompiler::LegacyConverter::supports_unified_interface_syntax() const
 {
        if(target_api==OPENGL_ES2)
@@ -1810,7 +1859,7 @@ void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
 {
        if(call.name=="texture" && !call.declaration && !supports_unified_sampling_functions())
        {
-               vector<RefPtr<Expression> >::iterator i = call.arguments.begin();
+               NodeArray<Expression>::iterator i = call.arguments.begin();
                if(i!=call.arguments.end())
                {
                        (*i)->visit(*this);
@@ -1837,24 +1886,30 @@ bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const
 {
        if(target_api==OPENGL_ES2)
                return check_version(Version(3, 0));
+       else if(check_version(Version(3, 30)))
+               return true;
        else
-               return check_version(Version(3, 30));
+               return check_extension(ARB_explicit_attrib_location);
 }
 
 bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
 {
        if(target_api==OPENGL_ES2)
                return check_version(Version(3, 0));
+       else if(check_version(Version(1, 20)))
+               return true;
        else
-               return check_version(Version(1, 20));
+               return check_extension(EXT_gpu_shader4);
 }
 
 bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
 {
        if(target_api==OPENGL_ES2)
                return check_version(Version(3, 20));
+       else if(check_version(Version(4, 0)))
+               return true;
        else
-               return check_version(Version(4, 0));
+               return check_extension(ARB_gpu_shader5);
 }
 
 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
@@ -1916,8 +1971,12 @@ bool ProgramCompiler::LegacyConverter::supports_interface_blocks(const string &i
                else
                        return check_version(Version(3, 20));
        }
+       else if(check_version(Version(1, 50)))
+               return true;
+       else if(iface=="uniform")
+               return check_extension(ARB_uniform_buffer_object);
        else
-               return check_version(Version(1, 50));
+               return false;
 }
 
 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)