framework/randomshaders/rsgShaderGenerator.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program Random Shader Generator
  * ----------------------------------------------------
  *
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Shader generator.
  *//*--------------------------------------------------------------------*/

 #include "rsgShaderGenerator.hpp"
 #include "rsgFunctionGenerator.hpp"
 #include "rsgToken.hpp"
 #include "rsgPrettyPrinter.hpp"
 #include "rsgUtils.hpp"
 #include "deString.h"

 #include <iterator>

 using std::string;
 using std::vector;

 namespace rsg
 {

 ShaderGenerator::ShaderGenerator (GeneratorState& state)
 	: m_state		(state)
 	, m_varManager	(state.getNameAllocator())
 {
 	state.setVariableManager(m_varManager);
 }

 ShaderGenerator::~ShaderGenerator (void)
 {
 }

 namespace
 {

 const char* getFragColorName (const GeneratorState& state)
 {
 	switch (state.getProgramParameters().version)
 	{
 		case VERSION_100:	return "gl_FragColor";
 		case VERSION_300:	return "dEQP_FragColor";
 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 void createAssignment (BlockStatement& block, const Variable* dstVar, const Variable* srcVar)
 {
 	VariableRead* varRead = new VariableRead(srcVar);
 	try
 	{
 		block.addChild(new AssignStatement( dstVar, varRead));
 	}
 	catch (const std::exception&)
 	{
 		delete varRead;
 		throw;
 	}
 }

 const ValueEntry* findByName (VariableManager& varManager, const char* name)
 {
 	AnyEntry::Iterator	iter	= varManager.getBegin<AnyEntry>();
 	AnyEntry::Iterator	end		= varManager.getEnd<AnyEntry>();
 	for (; iter != end; iter++)
 	{
 		const ValueEntry* entry = *iter;
 		if (deStringEqual(entry->getVariable()->getName(), name))
 			return entry;
 	}
 	return DE_NULL;
 }

 void genVertexPassthrough (GeneratorState& state, Shader& shader)
 {
 	// Create copies from shader inputs to outputs
 	vector<const ValueEntry*> entries;
 	std::copy(state.getVariableManager().getBegin<AnyEntry>(), state.getVariableManager().getEnd<AnyEntry>(), std::inserter(entries, entries.begin()));

 	for (vector<const ValueEntry*>::const_iterator i = entries.begin(); i != entries.end(); i++)
 	{
 		const ValueEntry*	entry		= *i;
 		const Variable*		outVar		= entry->getVariable();
 		std::string			inVarName;

 		if (outVar->getStorage() != Variable::STORAGE_SHADER_OUT)
 			continue;

 		// Name: a_[name], remove v_ -prefix if such exists
 		inVarName = "a_";
 		if (deStringBeginsWith(outVar->getName(), "v_"))
 			inVarName += (outVar->getName()+2);
 		else
 			inVarName += outVar->getName();

 		Variable* inVar = state.getVariableManager().allocate(outVar->getType(), Variable::STORAGE_SHADER_IN, inVarName.c_str());

 		// Update value range. This will be stored into shader input info.
 		state.getVariableManager().setValue(inVar, entry->getValueRange());

 		// Add assignment from input to output into main() body
 		createAssignment(shader.getMain().getBody(), entry->getVariable(), inVar);
 	}
 }

 void genFragmentPassthrough (GeneratorState& state, Shader& shader)
 {
 	// Add simple gl_FragColor = v_color; assignment
 	const ValueEntry* fragColorEntry = findByName(state.getVariableManager(), getFragColorName(state));
 	TCU_CHECK(fragColorEntry);

 	Variable* inColorVariable = state.getVariableManager().allocate(fragColorEntry->getVariable()->getType(), Variable::STORAGE_SHADER_IN, "v_color");

 	state.getVariableManager().setValue(inColorVariable, fragColorEntry->getValueRange());
 	createAssignment(shader.getMain().getBody(), fragColorEntry->getVariable(), inColorVariable);
 }

 // Sets undefined (-inf..inf) components to some meaningful values. Used for sanitizing final shader input value ranges.
 void fillUndefinedComponents (ValueRangeAccess valueRange)
 {
 	VariableType::Type baseType = valueRange.getType().getBaseType();
 	TCU_CHECK(baseType == VariableType::TYPE_FLOAT	||
 			  baseType == VariableType::TYPE_INT	||
 			  baseType == VariableType::TYPE_BOOL);

 	for (int elemNdx = 0; elemNdx < valueRange.getType().getNumElements(); elemNdx++)
 	{
 		if (isUndefinedValueRange(valueRange.component(elemNdx)))
 		{
 			ValueAccess min = valueRange.component(elemNdx).getMin();
 			ValueAccess max = valueRange.component(elemNdx).getMax();

 			switch (baseType)
 			{
 				case VariableType::TYPE_FLOAT:	min = 0.0f;		max = 1.0f;		break;
 				case VariableType::TYPE_INT:	min = 0;		max = 1;		break;
 				case VariableType::TYPE_BOOL:	min = false;	max = true;		break;
 				default: DE_ASSERT(DE_FALSE);
 			}
 		}
 	}
 }

 void fillUndefinedShaderInputs (vector<ShaderInput*>& inputs)
 {
 	for (vector<ShaderInput*>::iterator i = inputs.begin(); i != inputs.end(); i++)
 	{
 		if (!(*i)->getVariable()->getType().isSampler()) // Samplers are assigned at program-level.
 			fillUndefinedComponents((*i)->getValueRange());
 	}
 }

 } // anonymous

 void ShaderGenerator::generate (const ShaderParameters& shaderParams, Shader& shader, const vector<ShaderInput*>& outputs)
 {
 	// Global scopes
 	VariableScope&	globalVariableScope	= shader.getGlobalScope();
 	ValueScope		globalValueScope;

 	// Init state
 	m_state.setShader(shaderParams, shader);
 	DE_ASSERT(m_state.getExpressionFlags() == 0);

 	// Reserve some scalars for gl_Position & dEQP_Position
 	ReservedScalars reservedScalars;
 	if (shader.getType() == Shader::TYPE_VERTEX)
 		m_state.getVariableManager().reserve(reservedScalars, 4*2);

 	// Push global scopes
 	m_varManager.pushVariableScope(globalVariableScope);
 	m_varManager.pushValueScope(globalValueScope);

 	// Init shader outputs.
 	{
 		for (vector<ShaderInput*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
 		{
 			const ShaderInput*	input		= *i;
 			Variable*			variable	= m_state.getVariableManager().allocate(input->getVariable()->getType(), Variable::STORAGE_SHADER_OUT, input->getVariable()->getName());

 			m_state.getVariableManager().setValue(variable, input->getValueRange());
 		}

 		if (shader.getType() == Shader::TYPE_FRAGMENT)
 		{
 			// gl_FragColor
 			// \todo [2011-11-22 pyry] Multiple outputs from fragment shader!
 			Variable*	fragColorVar	= m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, getFragColorName(m_state));
 			ValueRange	valueRange(fragColorVar->getType());

 			valueRange.getMin() = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
 			valueRange.getMax() = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);

 			fragColorVar->setLayoutLocation(0); // Bind color output to location 0 (applies to GLSL ES 3.0 onwards).

 			m_state.getVariableManager().setValue(fragColorVar, valueRange.asAccess());
 		}
 	}

 	// Construct shader code.
 	{
 		Function& main = shader.getMain();
 		main.setReturnType(VariableType(VariableType::TYPE_VOID));

 		if (shaderParams.randomize)
 		{
 			FunctionGenerator funcGen(m_state, main);

 			// Mandate assignment into to all shader outputs in main()
 			const vector<Variable*>& liveVars = globalVariableScope.getLiveVariables();
 			for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
 			{
 				Variable* variable = *i;
 				if (variable->getStorage() == Variable::STORAGE_SHADER_OUT)
 					funcGen.requireAssignment(variable);
 			}

 			funcGen.generate();
 		}
 		else
 		{
 			if (shader.getType() == Shader::TYPE_VERTEX)
 				genVertexPassthrough(m_state, shader);
 			else
 			{
 				DE_ASSERT(shader.getType() == Shader::TYPE_FRAGMENT);
 				genFragmentPassthrough(m_state, shader);
 			}
 		}

 		if (shader.getType() == Shader::TYPE_VERTEX)
 		{
 			// Add gl_Position = dEQP_Position;
 			m_state.getVariableManager().release(reservedScalars);

 			Variable* glPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, "gl_Position");
 			Variable* qpPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_IN, "dEQP_Position");

 			ValueRange valueRange(glPosVariable->getType());

 			valueRange.getMin() = tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f);
 			valueRange.getMax() = tcu::Vec4( 1.0f,  1.0f, 0.0f, 1.0f);

 			m_state.getVariableManager().setValue(qpPosVariable, valueRange.asAccess()); // \todo [2011-05-24 pyry] No expression should be able to use gl_Position or dEQP_Position..

 			createAssignment(main.getBody(), glPosVariable, qpPosVariable);
 		}
 	}

 	// Declare live global variables.
 	{
 		vector<Variable*> liveVariables;
 		std::copy(globalVariableScope.getLiveVariables().begin(), globalVariableScope.getLiveVariables().end(), std::inserter(liveVariables, liveVariables.begin()));

 		vector<Variable*> createDeclarationStatementVars;

 		for (vector<Variable*>::iterator i = liveVariables.begin(); i != liveVariables.end(); i++)
 		{
 			Variable*		variable	= *i;
 			const char*		name		= variable->getName();
 			bool			declare		= !deStringBeginsWith(name, "gl_"); // Do not declare built-in types.

 			// Create input entries (store value range) if necessary
 			vector<ShaderInput*>& inputs	= shader.getInputs();
 			vector<ShaderInput*>& uniforms	= shader.getUniforms();

 			switch (variable->getStorage())
 			{
 				case Variable::STORAGE_SHADER_IN:
 				{
 					const ValueEntry* value = m_state.getVariableManager().getValue(variable);

 					inputs.reserve(inputs.size()+1);
 					inputs.push_back(new ShaderInput(variable, value->getValueRange()));
 					break;
 				}

 				case Variable::STORAGE_UNIFORM:
 				{
 					const ValueEntry* value = m_state.getVariableManager().getValue(variable);

 					uniforms.reserve(uniforms.size()+1);
 					uniforms.push_back(new ShaderInput(variable, value->getValueRange()));
 					break;
 				}

 				default:
 					break;
 			}

 			if (declare)
 				createDeclarationStatementVars.push_back(variable);
 			else
 			{
 				// Just move to global scope without declaration statement.
 				m_state.getVariableManager().declareVariable(variable);
 			}
 		}

 		// All global initializers must be constant expressions, no variable allocation is allowed
 		DE_ASSERT(m_state.getExpressionFlags() == 0);
 		m_state.pushExpressionFlags(CONST_EXPR|NO_VAR_ALLOCATION);

 		// Create declaration statements
 		for (vector<Variable*>::iterator i = createDeclarationStatementVars.begin(); i != createDeclarationStatementVars.end(); i++)
 		{
 			shader.getGlobalStatements().reserve(shader.getGlobalStatements().size());
 			shader.getGlobalStatements().push_back(new DeclarationStatement(m_state, *i));
 		}

 		m_state.popExpressionFlags();
 	}

 	// Pop global scopes
 	m_varManager.popVariableScope();
 	m_varManager.popValueScope();

 	// Fill undefined (unused) components in inputs with dummy values
 	fillUndefinedShaderInputs(shader.getInputs());
 	fillUndefinedShaderInputs(shader.getUniforms());

 	// Tokenize shader and write source
 	{
 		TokenStream tokenStr;
 		shader.tokenize(m_state, tokenStr);

 		std::ostringstream	str;
 		PrettyPrinter		printer(str);

 		// Append #version if necessary.
 		if (m_state.getProgramParameters().version == VERSION_300)
 			str << "#version 300 es\n";

 		printer.append(tokenStr);
 		shader.setSource(str.str().c_str());
 	}
 }

 } // rsg
	/*-------------------------------------------------------------------------
	* drawElements Quality Program Random Shader Generator
	* ----------------------------------------------------
	*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Shader generator.
	//--------------------------------------------------------------------*/

	#include "rsgShaderGenerator.hpp"
	#include "rsgFunctionGenerator.hpp"
	#include "rsgToken.hpp"
	#include "rsgPrettyPrinter.hpp"
	#include "rsgUtils.hpp"
	#include "deString.h"

	#include <iterator>

	using std::string;
	using std::vector;

	namespace rsg
	{

	ShaderGenerator::ShaderGenerator (GeneratorState& state)
	: m_state (state)
	, m_varManager (state.getNameAllocator())
	{
	state.setVariableManager(m_varManager);
	}

	ShaderGenerator::~ShaderGenerator (void)
	{
	}

	namespace
	{

	const char* getFragColorName (const GeneratorState& state)
	{
	switch (state.getProgramParameters().version)
	{
	case VERSION_100: return "gl_FragColor";
	case VERSION_300: return "dEQP_FragColor";
	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	void createAssignment (BlockStatement& block, const Variable* dstVar, const Variable* srcVar)
	{
	VariableRead* varRead = new VariableRead(srcVar);
	try
	{
	block.addChild(new AssignStatement( dstVar, varRead));
	}
	catch (const std::exception&)
	{
	delete varRead;
	throw;
	}
	}

	const ValueEntry* findByName (VariableManager& varManager, const char* name)
	{
	AnyEntry::Iterator iter = varManager.getBegin<AnyEntry>();
	AnyEntry::Iterator end = varManager.getEnd<AnyEntry>();
	for (; iter != end; iter++)
	{
	const ValueEntry* entry = *iter;
	if (deStringEqual(entry->getVariable()->getName(), name))
	return entry;
	}
	return DE_NULL;
	}

	void genVertexPassthrough (GeneratorState& state, Shader& shader)
	{
	// Create copies from shader inputs to outputs
	vector<const ValueEntry*> entries;
	std::copy(state.getVariableManager().getBegin<AnyEntry>(), state.getVariableManager().getEnd<AnyEntry>(), std::inserter(entries, entries.begin()));

	for (vector<const ValueEntry*>::const_iterator i = entries.begin(); i != entries.end(); i++)
	{
	const ValueEntry* entry = *i;
	const Variable* outVar = entry->getVariable();
	std::string inVarName;

	if (outVar->getStorage() != Variable::STORAGE_SHADER_OUT)
	continue;

	// Name: a_[name], remove v_ -prefix if such exists
	inVarName = "a_";
	if (deStringBeginsWith(outVar->getName(), "v_"))
	inVarName += (outVar->getName()+2);
	else
	inVarName += outVar->getName();

	Variable* inVar = state.getVariableManager().allocate(outVar->getType(), Variable::STORAGE_SHADER_IN, inVarName.c_str());

	// Update value range. This will be stored into shader input info.
	state.getVariableManager().setValue(inVar, entry->getValueRange());

	// Add assignment from input to output into main() body
	createAssignment(shader.getMain().getBody(), entry->getVariable(), inVar);
	}
	}

	void genFragmentPassthrough (GeneratorState& state, Shader& shader)
	{
	// Add simple gl_FragColor = v_color; assignment
	const ValueEntry* fragColorEntry = findByName(state.getVariableManager(), getFragColorName(state));
	TCU_CHECK(fragColorEntry);

	Variable* inColorVariable = state.getVariableManager().allocate(fragColorEntry->getVariable()->getType(), Variable::STORAGE_SHADER_IN, "v_color");

	state.getVariableManager().setValue(inColorVariable, fragColorEntry->getValueRange());
	createAssignment(shader.getMain().getBody(), fragColorEntry->getVariable(), inColorVariable);
	}

	// Sets undefined (-inf..inf) components to some meaningful values. Used for sanitizing final shader input value ranges.
	void fillUndefinedComponents (ValueRangeAccess valueRange)
	{
	VariableType::Type baseType = valueRange.getType().getBaseType();
	TCU_CHECK(baseType == VariableType::TYPE_FLOAT \|\|
	baseType == VariableType::TYPE_INT \|\|
	baseType == VariableType::TYPE_BOOL);

	for (int elemNdx = 0; elemNdx < valueRange.getType().getNumElements(); elemNdx++)
	{
	if (isUndefinedValueRange(valueRange.component(elemNdx)))
	{
	ValueAccess min = valueRange.component(elemNdx).getMin();
	ValueAccess max = valueRange.component(elemNdx).getMax();

	switch (baseType)
	{
	case VariableType::TYPE_FLOAT: min = 0.0f; max = 1.0f; break;
	case VariableType::TYPE_INT: min = 0; max = 1; break;
	case VariableType::TYPE_BOOL: min = false; max = true; break;
	default: DE_ASSERT(DE_FALSE);
	}
	}
	}
	}

	void fillUndefinedShaderInputs (vector<ShaderInput*>& inputs)
	{
	for (vector<ShaderInput*>::iterator i = inputs.begin(); i != inputs.end(); i++)
	{
	if (!(*i)->getVariable()->getType().isSampler()) // Samplers are assigned at program-level.
	fillUndefinedComponents((*i)->getValueRange());
	}
	}

	} // anonymous

	void ShaderGenerator::generate (const ShaderParameters& shaderParams, Shader& shader, const vector<ShaderInput*>& outputs)
	{
	// Global scopes
	VariableScope& globalVariableScope = shader.getGlobalScope();
	ValueScope globalValueScope;

	// Init state
	m_state.setShader(shaderParams, shader);
	DE_ASSERT(m_state.getExpressionFlags() == 0);

	// Reserve some scalars for gl_Position & dEQP_Position
	ReservedScalars reservedScalars;
	if (shader.getType() == Shader::TYPE_VERTEX)
	m_state.getVariableManager().reserve(reservedScalars, 4*2);

	// Push global scopes
	m_varManager.pushVariableScope(globalVariableScope);
	m_varManager.pushValueScope(globalValueScope);

	// Init shader outputs.
	{
	for (vector<ShaderInput*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
	{
	const ShaderInput* input = *i;
	Variable* variable = m_state.getVariableManager().allocate(input->getVariable()->getType(), Variable::STORAGE_SHADER_OUT, input->getVariable()->getName());

	m_state.getVariableManager().setValue(variable, input->getValueRange());
	}

	if (shader.getType() == Shader::TYPE_FRAGMENT)
	{
	// gl_FragColor
	// \todo [2011-11-22 pyry] Multiple outputs from fragment shader!
	Variable* fragColorVar = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, getFragColorName(m_state));
	ValueRange valueRange(fragColorVar->getType());

	valueRange.getMin() = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
	valueRange.getMax() = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);

	fragColorVar->setLayoutLocation(0); // Bind color output to location 0 (applies to GLSL ES 3.0 onwards).

	m_state.getVariableManager().setValue(fragColorVar, valueRange.asAccess());
	}
	}

	// Construct shader code.
	{
	Function& main = shader.getMain();
	main.setReturnType(VariableType(VariableType::TYPE_VOID));

	if (shaderParams.randomize)
	{
	FunctionGenerator funcGen(m_state, main);

	// Mandate assignment into to all shader outputs in main()
	const vector<Variable*>& liveVars = globalVariableScope.getLiveVariables();
	for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
	{
	Variable* variable = *i;
	if (variable->getStorage() == Variable::STORAGE_SHADER_OUT)
	funcGen.requireAssignment(variable);
	}

	funcGen.generate();
	}
	else
	{
	if (shader.getType() == Shader::TYPE_VERTEX)
	genVertexPassthrough(m_state, shader);
	else
	{
	DE_ASSERT(shader.getType() == Shader::TYPE_FRAGMENT);
	genFragmentPassthrough(m_state, shader);
	}
	}

	if (shader.getType() == Shader::TYPE_VERTEX)
	{
	// Add gl_Position = dEQP_Position;
	m_state.getVariableManager().release(reservedScalars);

	Variable* glPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, "gl_Position");
	Variable* qpPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_IN, "dEQP_Position");

	ValueRange valueRange(glPosVariable->getType());

	valueRange.getMin() = tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f);
	valueRange.getMax() = tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f);

	m_state.getVariableManager().setValue(qpPosVariable, valueRange.asAccess()); // \todo [2011-05-24 pyry] No expression should be able to use gl_Position or dEQP_Position..

	createAssignment(main.getBody(), glPosVariable, qpPosVariable);
	}
	}

	// Declare live global variables.
	{
	vector<Variable*> liveVariables;
	std::copy(globalVariableScope.getLiveVariables().begin(), globalVariableScope.getLiveVariables().end(), std::inserter(liveVariables, liveVariables.begin()));

	vector<Variable*> createDeclarationStatementVars;

	for (vector<Variable*>::iterator i = liveVariables.begin(); i != liveVariables.end(); i++)
	{
	Variable* variable = *i;
	const char* name = variable->getName();
	bool declare = !deStringBeginsWith(name, "gl_"); // Do not declare built-in types.

	// Create input entries (store value range) if necessary
	vector<ShaderInput*>& inputs = shader.getInputs();
	vector<ShaderInput*>& uniforms = shader.getUniforms();

	switch (variable->getStorage())
	{
	case Variable::STORAGE_SHADER_IN:
	{
	const ValueEntry* value = m_state.getVariableManager().getValue(variable);

	inputs.reserve(inputs.size()+1);
	inputs.push_back(new ShaderInput(variable, value->getValueRange()));
	break;
	}

	case Variable::STORAGE_UNIFORM:
	{
	const ValueEntry* value = m_state.getVariableManager().getValue(variable);

	uniforms.reserve(uniforms.size()+1);
	uniforms.push_back(new ShaderInput(variable, value->getValueRange()));
	break;
	}

	default:
	break;
	}

	if (declare)
	createDeclarationStatementVars.push_back(variable);
	else
	{
	// Just move to global scope without declaration statement.
	m_state.getVariableManager().declareVariable(variable);
	}
	}

	// All global initializers must be constant expressions, no variable allocation is allowed
	DE_ASSERT(m_state.getExpressionFlags() == 0);
	m_state.pushExpressionFlags(CONST_EXPR\|NO_VAR_ALLOCATION);

	// Create declaration statements
	for (vector<Variable*>::iterator i = createDeclarationStatementVars.begin(); i != createDeclarationStatementVars.end(); i++)
	{
	shader.getGlobalStatements().reserve(shader.getGlobalStatements().size());
	shader.getGlobalStatements().push_back(new DeclarationStatement(m_state, *i));
	}

	m_state.popExpressionFlags();
	}

	// Pop global scopes
	m_varManager.popVariableScope();
	m_varManager.popValueScope();

	// Fill undefined (unused) components in inputs with dummy values
	fillUndefinedShaderInputs(shader.getInputs());
	fillUndefinedShaderInputs(shader.getUniforms());

	// Tokenize shader and write source
	{
	TokenStream tokenStr;
	shader.tokenize(m_state, tokenStr);

	std::ostringstream str;
	PrettyPrinter printer(str);

	// Append #version if necessary.
	if (m_state.getProgramParameters().version == VERSION_300)
	str << "#version 300 es\n";

	printer.append(tokenStr);
	shader.setSource(str.str().c_str());
	}
	}

	} // rsg