PL286/external/deqp/framework/randomshaders/rsgPrettyPrinter.cpp

/*-------------------------------------------------------------------------
 * 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 Source Formatter.
 *//*--------------------------------------------------------------------*/

#include "rsgPrettyPrinter.hpp"
#include "deStringUtil.hpp"

namespace rsg
{

static const char* s_tokenStr[] =
{
	DE_NULL,		// IDENTIFIER,
	"struct",		// STRUCT,
	"invariant",	// INVARIANT,
	"precision",	// PRECISION,
	"void",			// VOID,
	"break",		// BREAK,
	"continue",		// CONTINUE,
	"do ",			// DO,
	"while ",		// WHILE,
	"else ",		// ELSE,
	"for ",			// FOR,
	"if ",			// IF,
	"discard",		// DISCARD,
	"return ",		// RETURN,
	"++",			// INC_OP,
	"--",			// DEC_OP,
	"(",			// LEFT_PAREN,
	")",			// RIGHT_PAREN,
	"[",			// LEFT_BRACKET,
	"]",			// RIGHT_BRACKET,
	"{",			// LEFT_BRACE,
	"}",			// RIGHT_BRACE,
	".",			// DOT,
	", ",			// COMMA,
	" : ",			// COLON,
	";",			// SEMICOLON,
	" - ",			// MINUS,
	" + ",			// PLUS,
	" * ",			// MUL,
	" / ",			// DIV,
	" % ",			// MOD,
	" ? ",			// QUESTION,
	"bool",			// BOOL,
	"bvec2",		// BVEC2,
	"bvec3",		// BVEC3,
	"bvec4",		// BVEC4,
	"int",			// INT,
	"ivec2",		// IVEC2,
	"ivec3",		// IVEC3,
	"ivec4",		// IVEC4,
	"float",		// FLOAT,
	"vec2",			// VEC2,
	"vec3",			// VEC3,
	"vec4",			// VEC4,
	"mat2",			// MAT2,
	"mat3",			// MAT3,
	"mat4",			// MAT4,
	"sampler2D",	// SAMPLER2D,
	"samplerCube",	// SAMPLERCUBE,
	DE_NULL,		// FLOAT_LITERAL,
	DE_NULL,		// INT_LITERAL,
	DE_NULL,		// BOOL_LITERAL,
	" = ",			// EQUAL,
	" *= ",			// MUL_ASSIGN,
	" /= ",			// DIV_ASSIGN,
	" += ",			// ADD_ASSIGN,
	" -= ",			// SUB_ASSIGN,
	" < ",			// CMP_LT,
	" > ",			// CMP_GT,
	" <= ",			// CMP_LE,
	" >= ",			// CMP_GE,
	" == ",			// CMP_EQ,
	" != ",			// CMP_NE,
	" && ",			// LOGICAL_AND,
	" || ",			// LOGICAL_OR,
	"!",			// LOGICAL_NOT,
	" ^^ ",			// LOGICAL_XOR,
	"attribute",	// ATTRIBUTE,
	"uniform",		// UNIFORM,
	"varying",		// VARYING,
	"const",		// CONST,
	"flat",			// FLAT,
	"highp",		// HIGH_PRECISION,
	"mediump",		// MEDIUM_PRECISION,
	"lowp",			// LOW_PRECISION,
	"in",			// IN,
	"out",			// OUT,
	"inout",		// INOUT,
	"layout",		// LAYOUT,
	"location",		// LOCATION,
	DE_NULL,		// INDENT_INC,
	DE_NULL,		// INDENT_DEC,
	"\n"			// NEWLINE,
};

PrettyPrinter::PrettyPrinter (std::ostringstream& str)
	: m_str			(str)
	, m_indentDepth	(0)
{
}

inline const char* PrettyPrinter::getSimpleTokenStr (Token::Type token)
{
	DE_ASSERT(de::inBounds<int>(token, 0, (int)DE_LENGTH_OF_ARRAY(s_tokenStr)));
	return s_tokenStr[token];
}

void PrettyPrinter::append (const TokenStream& tokens)
{
	for (int ndx = 0; ndx < tokens.getSize(); ndx++)
		processToken(tokens[ndx]);
}

inline bool isIdentifierChar (char c)
{
	return de::inRange(c, 'a', 'z') || de::inRange(c, 'A', 'Z') || de::inRange(c, '0', '9') || c == '_';
}

void PrettyPrinter::processToken (const Token& token)
{
	bool prevIsIdentifierChar = m_line.length() > 0 && isIdentifierChar(m_line[m_line.length()-1]);

	switch (token.getType())
	{
		case Token::IDENTIFIER:
			if (prevIsIdentifierChar)
				m_line += " ";
			m_line += token.getIdentifier();
			break;

		case Token::FLOAT_LITERAL:
		{
			std::string f = de::toString(token.getFloat());
			if (f.find('.') == std::string::npos)
				f += ".0"; // Make sure value parses as float
			m_line += f;
			break;
		}

		case Token::INT_LITERAL:
			m_line += de::toString(token.getInt());
			break;

		case Token::BOOL_LITERAL:
			m_line += (token.getBool() ? "true" : "false");
			break;

		case Token::INDENT_INC:
			m_indentDepth += 1;
			break;

		case Token::INDENT_DEC:
			m_indentDepth -= 1;
			break;

		case Token::NEWLINE:
			// Indent
			for (int i = 0; i < m_indentDepth; i++)
				m_str << "\t";

			// Flush line to source
			m_str << m_line + "\n";
			m_line = "";
			break;

		default:
		{
			const char* tokenStr = getSimpleTokenStr(token.getType());
			if (prevIsIdentifierChar && isIdentifierChar(tokenStr[0]))
				m_line += " ";
			m_line += tokenStr;
			break;
		}
	}
}

} // rsg