Move unique name generation to syntax.cpp

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

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 0d18b76c311b98c3ab7fbae14eea36cb1f80ba42..c8c9041fd43c7c9814cbd53e4d3ab8a719252cb2 100644 (file)
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -91,20 +91,6 @@ const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &ta
        return r_result_name;
 }
 
-string InlineContentInjector::create_unused_name(const string &base, bool always_prefix)
-{
-       string result = base;
-       if(always_prefix || target_block->variables.count(result))
-               result = format("_%s_%s", source_func->name, base);
-       unsigned initial_size = result.size();
-       for(unsigned i=1; target_block->variables.count(result); ++i)
-       {
-               result.erase(initial_size);
-               result += format("_%d", i);
-       }
-       return result;
-}
-
 void InlineContentInjector::visit(VariableReference &var)
 {
        if(remap_names)
@@ -152,7 +138,7 @@ void InlineContentInjector::visit(VariableDeclaration &var)
        if(!remap_names && !deps_only)
        {
                RefPtr<VariableDeclaration> inlined_var = var.clone();
-               inlined_var->name = create_unused_name(var.name, false);
+               inlined_var->name = get_unused_variable_name(*target_block, var.name, source_func->name);
                r_inlined_statement = inlined_var;
 
                variable_map[var.name] = inlined_var.get();
@@ -167,7 +153,7 @@ void InlineContentInjector::visit(Return &ret)
        {
                /* Create a new variable to hold the return value of the inlined
                function. */
-               r_result_name = create_unused_name("return", true);
+               r_result_name = get_unused_variable_name(*target_block, "_return", source_func->name);
                RefPtr<VariableDeclaration> var = new VariableDeclaration;
                var->source = ret.source;
                var->line = ret.line;
@@ -289,33 +275,6 @@ bool ExpressionInliner::apply(Stage &s)
        return r_any_inlined;
 }
 
-void ExpressionInliner::visit_and_record(RefPtr<Expression> &ptr)
-{
-       r_ref_info = 0;
-       ptr->visit(*this);
-       if(r_ref_info && r_ref_info->expression && r_ref_info->available)
-       {
-               if(iteration_body && !r_ref_info->trivial)
-               {
-                       /* Don't inline non-trivial expressions which were assigned outside
-                       an iteration statement.  The iteration may run multiple times, which
-                       would cause the expression to also be evaluated multiple times. */
-                       Block *i = r_ref_info->assign_scope;
-                       for(; (i && i!=iteration_body); i=i->parent) ;
-                       if(!i)
-                               return;
-               }
-
-               if(r_ref_info->trivial)
-                       inline_expression(*r_ref_info->expression, ptr);
-               else
-                       /* Record the inline point for a non-trivial expression but don't
-                       inline it yet.  It might turn out it shouldn't be inlined after all. */
-                       r_ref_info->inline_point = &ptr;
-       }
-       r_ref_info = 0;
-}
-
 void ExpressionInliner::inline_expression(Expression &expr, RefPtr<Expression> &ptr)
 {
        ptr = expr.clone();
@@ -348,7 +307,30 @@ void ExpressionInliner::visit(Block &block)
 
 void ExpressionInliner::visit(RefPtr<Expression> &expr)
 {
-       visit_and_record(expr);
+       r_ref_info = 0;
+       expr->visit(*this);
+       if(r_ref_info && r_ref_info->expression && r_ref_info->available)
+       {
+               if(iteration_body && !r_ref_info->trivial)
+               {
+                       /* Don't inline non-trivial expressions which were assigned outside
+                       an iteration statement.  The iteration may run multiple times, which
+                       would cause the expression to also be evaluated multiple times. */
+                       Block *i = r_ref_info->assign_scope;
+                       for(; (i && i!=iteration_body); i=i->parent) ;
+                       if(!i)
+                               return;
+               }
+
+               if(r_ref_info->trivial)
+                       inline_expression(*r_ref_info->expression, expr);
+               else
+                       /* Record the inline point for a non-trivial expression but don't
+                       inline it yet.  It might turn out it shouldn't be inlined after all. */
+                       r_ref_info->inline_point = &expr;
+       }
+       r_oper = expr->oper;
+       r_ref_info = 0;
 }
 
 void ExpressionInliner::visit(VariableReference &var)
@@ -373,34 +355,30 @@ void ExpressionInliner::visit(VariableReference &var)
 
 void ExpressionInliner::visit(MemberAccess &memacc)
 {
-       visit_and_record(memacc.left);
-       r_oper = memacc.oper;
+       visit(memacc.left);
        r_trivial = false;
 }
 
 void ExpressionInliner::visit(Swizzle &swizzle)
 {
-       visit_and_record(swizzle.left);
-       r_oper = swizzle.oper;
+       visit(swizzle.left);
        r_trivial = false;
 }
 
 void ExpressionInliner::visit(UnaryExpression &unary)
 {
        SetFlag set_target(mutating, mutating || unary.oper->token[1]=='+' || unary.oper->token[1]=='-');
-       visit_and_record(unary.expression);
-       r_oper = unary.oper;
+       visit(unary.expression);
        r_trivial = false;
 }
 
 void ExpressionInliner::visit(BinaryExpression &binary)
 {
-       visit_and_record(binary.left);
+       visit(binary.left);
        {
                SetFlag clear_target(mutating, false);
-               visit_and_record(binary.right);
+               visit(binary.right);
        }
-       r_oper = binary.oper;
        r_trivial = false;
 }
 
@@ -408,10 +386,10 @@ void ExpressionInliner::visit(Assignment &assign)
 {
        {
                SetFlag set_target(mutating);
-               visit_and_record(assign.left);
+               visit(assign.left);
        }
        r_oper = 0;
-       visit_and_record(assign.right);
+       visit(assign.right);
 
        map<Assignment::Target, ExpressionInfo>::iterator i = expressions.find(assign.target);
        if(i!=expressions.end())
@@ -424,23 +402,20 @@ void ExpressionInliner::visit(Assignment &assign)
                i->second.available = true;
        }
 
-       r_oper = assign.oper;
        r_trivial = false;
 }
 
 void ExpressionInliner::visit(TernaryExpression &ternary)
 {
-       visit_and_record(ternary.condition);
-       visit_and_record(ternary.true_expr);
-       visit_and_record(ternary.false_expr);
-       r_oper = ternary.oper;
+       visit(ternary.condition);
+       visit(ternary.true_expr);
+       visit(ternary.false_expr);
        r_trivial = false;
 }
 
 void ExpressionInliner::visit(FunctionCall &call)
 {
        TraversingVisitor::visit(call);
-       r_oper = 0;
        r_trivial = false;
 }