X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=5a17a9ed3857bf969005e57a73ebe94d01b9ec20;hp=c2ebb4b96ad3e474b2f636578e404601282b82ad;hb=9d1fa012a23693768bbe287371e97751c03acc50;hpb=437cd7d38fea1533aab9414d4575acb63d6b9170

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index c2ebb4b9..5a17a9ed 100644
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -35,8 +35,6 @@ namespace GL {
 
 using namespace ProgramSyntax;
 
-// XXX For some reason global declarations are emitted for otherwise undeclared local variables
-
 ProgramCompiler::ProgramCompiler():
 	resources(0),
 	module(0)
@@ -545,14 +543,40 @@ void ProgramCompiler::Formatter::visit(Conditional &cond)
 
 void ProgramCompiler::Formatter::visit(Iteration &iter)
 {
-	formatted += "for(";
-	iter.init_statement->visit(*this);
-	formatted += ' ';
-	iter.condition->visit(*this);
-	formatted += "; ";
-	iter.loop_expression->visit(*this);
-	formatted += ")\n";
-	iter.body.visit(*this);
+	if(!iter.init_statement && iter.condition && !iter.loop_expression)
+	{
+		formatted += "while(";
+		iter.condition->visit(*this);
+		formatted += ')';
+	}
+	else
+	{
+		formatted += "for(";
+		if(iter.init_statement)
+			iter.init_statement->visit(*this);
+		else
+			formatted += ';';
+		if(iter.condition)
+		{
+			formatted += ' ';
+			iter.condition->visit(*this);
+		}
+		formatted += ';';
+		if(iter.loop_expression)
+		{
+			formatted += ' ';
+			iter.loop_expression->visit(*this);
+		}
+		formatted += ')';
+	}
+
+	if(iter.body.body.empty())
+		formatted += " { }";
+	else
+	{
+		formatted += '\n';
+		iter.body.visit(*this);
+	}
 }
 
 void ProgramCompiler::Formatter::visit(Return &ret)
@@ -1175,6 +1199,12 @@ void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary)
 	inline_result = 0;
 }
 
+void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
+{
+	visit_and_inline(memacc.left);
+	inline_result = 0;
+}
+
 void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
 {
 	for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
@@ -1193,6 +1223,13 @@ void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
 		inline_result = 0;
 }
 
+void ProgramCompiler::FunctionInliner::visit(VariableDeclaration &var)
+{
+	if(var.init_expression)
+		visit_and_inline(var.init_expression);
+	inline_result = 0;
+}
+
 void ProgramCompiler::FunctionInliner::visit(Return &ret)
 {
 	TraversingVisitor::visit(ret);
@@ -1204,14 +1241,12 @@ 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, bool c):
-	variable_values(v),
-	const_only(c),
+ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
+	variable_values(&v),
 	result(0.0f),
 	result_valid(false)
 { }
@@ -1236,8 +1271,6 @@ void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
 {
 	if(!var.declaration)
 		return;
-	if(const_only && !var.declaration->constant)
-		return;
 
 	if(variable_values)
 	{
@@ -1298,7 +1331,7 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
 	scope_level(0),
-	in_loop(false)
+	record_only(false)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
@@ -1310,6 +1343,13 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
 		variable_values.erase(i->second);
 }
 
+void ProgramCompiler::ConstantConditionEliminator::visit(UnaryExpression &unary)
+{
+	if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
+		if(unary.oper=="++" || unary.oper=="--")
+			variable_values.erase(var->declaration);
+}
+
 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
 {
 	variable_values.erase(assign.target_declaration);
@@ -1323,30 +1363,49 @@ void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &va
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
 {
-	ExpressionEvaluator eval(&variable_values, in_loop);
-	cond.condition->visit(eval);
-	if(eval.result_valid)
-		flatten_block(eval.result ? cond.body : cond.else_body);
-	else
-		TraversingVisitor::visit(cond);
+	if(!record_only)
+	{
+		ExpressionEvaluator eval(variable_values);
+		cond.condition->visit(eval);
+		if(eval.result_valid)
+		{
+			flatten_block(eval.result ? cond.body : cond.else_body);
+			return;
+		}
+	}
+
+	TraversingVisitor::visit(cond);
 }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
 {
-	// XXX Should this not visit init_statement first?
-	if(iter.condition)
+	if(!record_only)
 	{
-		ExpressionEvaluator eval(0, in_loop);
-		iter.condition->visit(eval);
-		if(eval.result_valid && !eval.result)
+		if(iter.condition)
 		{
-			remove_node = true;
-			return;
+			/* If the loop condition is always false on the first iteration, the
+			entire loop can be removed */
+			if(iter.init_statement)
+				iter.init_statement->visit(*this);
+			ExpressionEvaluator eval(variable_values);
+			iter.condition->visit(eval);
+			if(eval.result_valid && !eval.result)
+			{
+				remove_node = true;
+				return;
+			}
 		}
+
+		/* Record all assignments that occur inside the loop body so those
+		variables won't be considered as constant */
+		SetFlag set_record(record_only);
+		TraversingVisitor::visit(iter);
 	}
 
-	SetFlag set_loop(in_loop);
 	TraversingVisitor::visit(iter);
+
+	if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
+		variable_values.erase(init_decl);
 }
 
 
@@ -1622,6 +1681,12 @@ void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
 		var.init_expression = 0;
 }
 
+void ProgramCompiler::NodeRemover::visit(Iteration &iter)
+{
+	if(to_remove.count(iter.init_statement.get()))
+		iter.init_statement = 0;
+}
+
 
 void ProgramCompiler::PrecisionRemover::visit(Precision &)
 {