Rename members of visitors to indicate which are "return values"

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

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index b7236feb6fafb4f7e0495b3b6e8260329f91b29b..8a9992a2dba88a054dfeed5f5f681ba012946147 100644 (file)
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -74,19 +74,19 @@ const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &ta
        source_func = &src;
        for(NodeList<Statement>::iterator i=src.body.body.begin(); i!=src.body.body.end(); ++i)
        {
-               inlined_statement = 0;
+               r_inlined_statement = 0;
                (*i)->visit(*this);
-               if(!inlined_statement)
-                       inlined_statement = (*i)->clone();
+               if(!r_inlined_statement)
+                       r_inlined_statement = (*i)->clone();
 
                SetFlag set_remap(remap_names);
-               inlined_statement->visit(*this);
-               tgtb.body.insert(ins_pt, inlined_statement);
+               r_inlined_statement->visit(*this);
+               tgtb.body.insert(ins_pt, r_inlined_statement);
        }
 
        NodeReorderer().apply(stage, target_func, dependencies);
 
-       return result_name;
+       return r_result_name;
 }
 
 string InlineContentInjector::create_unused_name(const string &base, bool always_prefix)
@@ -151,7 +151,7 @@ void InlineContentInjector::visit(VariableDeclaration &var)
        {
                RefPtr<VariableDeclaration> inlined_var = var.clone();
                inlined_var->name = create_unused_name(var.name, false);
-               inlined_statement = inlined_var;
+               r_inlined_statement = inlined_var;
 
                variable_map[var.name] = inlined_var.get();
        }
@@ -163,40 +163,40 @@ void InlineContentInjector::visit(Return &ret)
 
        if(ret.expression)
        {
-               result_name = create_unused_name("return", true);
+               r_result_name = create_unused_name("return", true);
                RefPtr<VariableDeclaration> var = new VariableDeclaration;
                var->source = ret.source;
                var->line = ret.line;
                var->type = source_func->return_type;
-               var->name = result_name;
+               var->name = r_result_name;
                var->init_expression = ret.expression->clone();
-               inlined_statement = var;
+               r_inlined_statement = var;
        }
 }
 
 
 FunctionInliner::FunctionInliner():
        current_function(0),
-       any_inlined(false)
+       r_any_inlined(false)
 { }
 
 bool FunctionInliner::apply(Stage &s)
 {
        stage = &s;
        inlineable = InlineableFunctionLocator().apply(s);
-       any_inlined = false;
+       r_any_inlined = false;
        s.content.visit(*this);
-       return any_inlined;
+       return r_any_inlined;
 }
 
 void FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
 {
-       inline_result = 0;
+       r_inline_result = 0;
        ptr->visit(*this);
-       if(inline_result)
+       if(r_inline_result)
        {
-               ptr = inline_result;
-               any_inlined = true;
+               ptr = r_inline_result;
+               r_any_inlined = true;
        }
 }
 
@@ -214,20 +214,20 @@ void FunctionInliner::visit(Block &block)
 void FunctionInliner::visit(UnaryExpression &unary)
 {
        visit_and_inline(unary.expression);
-       inline_result = 0;
+       r_inline_result = 0;
 }
 
 void FunctionInliner::visit(BinaryExpression &binary)
 {
        visit_and_inline(binary.left);
        visit_and_inline(binary.right);
-       inline_result = 0;
+       r_inline_result = 0;
 }
 
 void FunctionInliner::visit(MemberAccess &memacc)
 {
        visit_and_inline(memacc.left);
-       inline_result = 0;
+       r_inline_result = 0;
 }
 
 void FunctionInliner::visit(FunctionCall &call)
@@ -249,14 +249,14 @@ void FunctionInliner::visit(FunctionCall &call)
 
                RefPtr<VariableReference> ref = new VariableReference;
                ref->name = result_name;
-               inline_result = ref;
+               r_inline_result = ref;
 
                /* Inlined variables need to be resolved before this function can be
                inlined further. */
                inlineable.erase(current_function);
        }
        else
-               inline_result = 0;
+               r_inline_result = 0;
 }
 
 void FunctionInliner::visit(ExpressionStatement &expr)
@@ -268,7 +268,7 @@ void FunctionInliner::visit(VariableDeclaration &var)
 {
        if(var.init_expression)
                visit_and_inline(var.init_expression);
-       inline_result = 0;
+       r_inline_result = 0;
 }
 
 void FunctionInliner::visit(FunctionDeclaration &func)
@@ -406,10 +406,10 @@ UnusedVariableRemover::VariableInfo::VariableInfo():
 
 UnusedVariableRemover::UnusedVariableRemover():
        aggregate(0),
-       assignment(0),
+       r_assignment(0),
        assignment_target(false),
-       assign_to_subscript(false),
-       side_effects(false)
+       r_assign_to_subscript(false),
+       r_side_effects(false)
 { }
 
 bool UnusedVariableRemover::apply(Stage &stage)
@@ -463,7 +463,7 @@ void UnusedVariableRemover::visit(UnaryExpression &unary)
 {
        TraversingVisitor::visit(unary);
        if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
-               side_effects = true;
+               r_side_effects = true;
 }
 
 void UnusedVariableRemover::visit(BinaryExpression &binary)
@@ -471,7 +471,7 @@ void UnusedVariableRemover::visit(BinaryExpression &binary)
        if(binary.oper->token[0]=='[')
        {
                if(assignment_target)
-                       assign_to_subscript = true;
+                       r_assign_to_subscript = true;
                binary.left->visit(*this);
                SetForScope<bool> set(assignment_target, false);
                binary.right->visit(*this);
@@ -483,19 +483,19 @@ void UnusedVariableRemover::visit(BinaryExpression &binary)
 void UnusedVariableRemover::visit(Assignment &assign)
 {
        {
-               assign_to_subscript = false;
+               r_assign_to_subscript = false;
                SetForScope<bool> set(assignment_target, !assign.self_referencing);
                assign.left->visit(*this);
        }
        assign.right->visit(*this);
-       assignment = &assign;
-       side_effects = true;
+       r_assignment = &assign;
+       r_side_effects = true;
 }
 
 void UnusedVariableRemover::visit(FunctionCall &call)
 {
        TraversingVisitor::visit(call);
-       side_effects = true;
+       r_side_effects = true;
 }
 
 void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained)
@@ -519,12 +519,12 @@ void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_
 
 void UnusedVariableRemover::visit(ExpressionStatement &expr)
 {
-       assignment = 0;
-       side_effects = false;
+       r_assignment = 0;
+       r_side_effects = false;
        TraversingVisitor::visit(expr);
-       if(assignment && assignment->target_declaration)
-               record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
-       if(!side_effects)
+       if(r_assignment && r_assignment->target_declaration)
+               record_assignment(*r_assignment->target_declaration, expr, (r_assignment->self_referencing || r_assign_to_subscript));
+       if(!r_side_effects)
                unused_nodes.insert(&expr);
 }