framework/opengl/gluVarTypeUtil.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * 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 variable type utilities.
 *//*--------------------------------------------------------------------*/

#include "gluVarTypeUtil.hpp"

#include <stdlib.h>

namespace glu
{

// VarTokenizer

VarTokenizer::VarTokenizer (const char* str)
	: m_str			(str)
	, m_token		(TOKEN_LAST)
	, m_tokenStart	(0)
	, m_tokenLen	(0)
{
	advance();
}

int VarTokenizer::getNumber (void) const
{
	return atoi(getIdentifier().c_str());
}

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

void VarTokenizer::advance (void)
{
	DE_ASSERT(m_token != TOKEN_END);

	m_tokenStart	+= m_tokenLen;
	m_token			 = TOKEN_LAST;
	m_tokenLen		 = 1;

	if (m_str[m_tokenStart] == '[')
		m_token = TOKEN_LEFT_BRACKET;
	else if (m_str[m_tokenStart] == ']')
		m_token = TOKEN_RIGHT_BRACKET;
	else if (m_str[m_tokenStart] == 0)
		m_token = TOKEN_END;
	else if (m_str[m_tokenStart] == '.')
		m_token = TOKEN_PERIOD;
	else if (isNum(m_str[m_tokenStart]))
	{
		m_token = TOKEN_NUMBER;
		while (isNum(m_str[m_tokenStart+m_tokenLen]))
			m_tokenLen += 1;
	}
	else if (isIdentifierChar(m_str[m_tokenStart]))
	{
		m_token = TOKEN_IDENTIFIER;
		while (isIdentifierChar(m_str[m_tokenStart+m_tokenLen]))
			m_tokenLen += 1;
	}
	else
		TCU_FAIL("Unexpected character");
}

// SubTypeAccess

SubTypeAccess::SubTypeAccess (const VarType& type)
	: m_type(type)
{
}

std::string parseVariableName (const char* nameWithPath)
{
	VarTokenizer tokenizer(nameWithPath);
	TCU_CHECK(tokenizer.getToken() == VarTokenizer::TOKEN_IDENTIFIER);
	return tokenizer.getIdentifier();
}

void parseTypePath (const char* nameWithPath, const VarType& type, TypeComponentVector& path)
{
	VarTokenizer tokenizer(nameWithPath);

	if (tokenizer.getToken() == VarTokenizer::TOKEN_IDENTIFIER)
		tokenizer.advance();

	path.clear();
	while (tokenizer.getToken() != VarTokenizer::TOKEN_END)
	{
		VarType curType = getVarType(type, path);

		if (tokenizer.getToken() == VarTokenizer::TOKEN_PERIOD)
		{
			tokenizer.advance();
			TCU_CHECK(tokenizer.getToken() == VarTokenizer::TOKEN_IDENTIFIER);
			TCU_CHECK_MSG(curType.isStructType(), "Invalid field selector");

			// Find member.
			std::string		memberName	= tokenizer.getIdentifier();
			int				ndx			= 0;
			for (; ndx < curType.getStructPtr()->getNumMembers(); ndx++)
			{
				if (memberName == curType.getStructPtr()->getMember(ndx).getName())
					break;
			}
			TCU_CHECK_MSG(ndx < curType.getStructPtr()->getNumMembers(), "Member not found in type");

			path.push_back(VarTypeComponent(VarTypeComponent::STRUCT_MEMBER, ndx));
			tokenizer.advance();
		}
		else if (tokenizer.getToken() == VarTokenizer::TOKEN_LEFT_BRACKET)
		{
			tokenizer.advance();
			TCU_CHECK(tokenizer.getToken() == VarTokenizer::TOKEN_NUMBER);

			int ndx = tokenizer.getNumber();

			if (curType.isArrayType())
			{
				TCU_CHECK(de::inBounds(ndx, 0, curType.getArraySize()));
				path.push_back(VarTypeComponent(VarTypeComponent::ARRAY_ELEMENT, ndx));
			}
			else if (curType.isBasicType() && isDataTypeMatrix(curType.getBasicType()))
			{
				TCU_CHECK(de::inBounds(ndx, 0, getDataTypeMatrixNumColumns(curType.getBasicType())));
				path.push_back(VarTypeComponent(VarTypeComponent::MATRIX_COLUMN, ndx));
			}
			else if (curType.isBasicType() && isDataTypeVector(curType.getBasicType()))
			{
				TCU_CHECK(de::inBounds(ndx, 0, getDataTypeScalarSize(curType.getBasicType())));
				path.push_back(VarTypeComponent(VarTypeComponent::VECTOR_COMPONENT, ndx));
			}
			else
				TCU_FAIL("Invalid subscript");

			tokenizer.advance();
			TCU_CHECK(tokenizer.getToken() == VarTokenizer::TOKEN_RIGHT_BRACKET);
			tokenizer.advance();
		}
		else
			TCU_FAIL("Unexpected token");
	}
}

std::ostream& operator<< (std::ostream& str, const TypeAccessFormat& format)
{
	const VarType* curType = &format.type;

	for (TypeComponentVector::const_iterator iter = format.path.begin(); iter != format.path.end(); iter++)
	{
		switch (iter->type)
		{
			case VarTypeComponent::ARRAY_ELEMENT:
				curType = &curType->getElementType(); // Update current type.
				// Fall-through.

			case VarTypeComponent::MATRIX_COLUMN:
			case VarTypeComponent::VECTOR_COMPONENT:
				str << "[" << iter->index << "]";
				break;

			case VarTypeComponent::STRUCT_MEMBER:
			{
				const StructMember& member = curType->getStructPtr()->getMember(iter->index);
				str << "." << member.getName();
				curType = &member.getType();
				break;
			}

			default:
				DE_ASSERT(false);
		}
	}

	return str;
}

} // glu