示例#1
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_CloseBracket(std::string& a_TokenName)
{
	if (m_State == IDENTIFIER_DECLARATION || m_State == BASE)
	{
		if (m_ScopeState == GLOBAL)
		{
			// Function
			m_LastFunctionName = m_LastIdentifierBeforeBracketOpen;

			if (m_Database->StructExists(m_LastDataTypeBeforeBracketOpen))
			{
				m_Database->AddFunction(m_LastFunctionName, m_LastDataTypeBeforeBracketOpen, m_LastFuncVarList, false);
			}
			else
			{
				m_Database->AddFunction(m_LastFunctionName, m_LastDataTypeBeforeBracketOpen, m_LastFuncVarList);
			}

			m_LastFuncVarList.clear();
			m_LastIdentifierBeforeBracketOpen.Clear();
		}
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	m_State = BASE;
	return SAVVY_OK;
}
示例#2
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_BuiltInFunc(std::string& a_TokenName)
{
	// Handle cases when a variable has the same name as a built in function
	if (m_State == DATA_TYPE_DECLARATION && m_ScopeState != GLOBAL)
	{
		m_LastIdentifier = a_TokenName;
		m_Database->AddLocalVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastFunctionName);
		m_State = IDENTIFIER_DECLARATION;
	}
	else if (m_State == OPERATION && m_ScopeState != GLOBAL)
	{
		// Handle adding local variables of the same type with a comma
		Database::WordMultiMap& instructionMap = m_Database->GetInstructionMap();
		Database::WordMultiMap::iterator it1 = instructionMap.upper_bound(m_LastFunctionName);
		it1--;
		if (it1->second.m_Name == "," && m_OldState != IN_PLACE_DECLARATION && !m_Database->FunctionExists(a_TokenName) &&
			!m_Database->LocalVariableExists(m_LastFunctionName, a_TokenName))
		{
			if (m_AddedLocalVar)
			{
				ResultCode res;
				res = m_Database->AddLocalVariable(Key(a_TokenName), m_LastTypeQualifierList, m_LastFunctionName);
				m_AddedLocalVar = true;
				m_State = IDENTIFIER_DECLARATION;
				if (res != SAVVY_OK)
				{
					m_LastError = "Could not add local variable " + a_TokenName + " inside function " + m_LastFunctionName.GetString() + ". Local variable already exists.";
					return res;
				}
			}
		}
	}
	AddLocalInstruction(Key(a_TokenName), true, m_LastFunctionName);
	return SAVVY_OK;
}
示例#3
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_DataType(std::string& a_TokenName)
{
	if (m_State == BASE || m_State == LANGUAGE_SPECIFIC_DECLARATION || m_State == OPERATION || m_State == DATA_TYPE_DECLARATION || m_State == IDENTIFIER_USE)
	{
		m_State = DATA_TYPE_DECLARATION;
		m_LastDataType = a_TokenName;

		m_LastTypeQualifierList.push_back(m_LastDataType);
		if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
		{
			if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
			{
				m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
			}
		}

		AddGlobalInstruction(Key(a_TokenName), true, m_LastGlobalVarName);
	}
	else
	{
		m_LastError = "Could not parse data type " + a_TokenName + ". Possible syntax error.";
		return SAVVY_SHADER_SYNTAX_ERROR;
	}

	AddLocalInstruction(Key(a_TokenName), true, m_LastFunctionName);
	return SAVVY_OK;
}
示例#4
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_OpenSquareBracket(std::string& a_TokenName)
{
	if (m_CurrVarType == GLOBAL_VAR || m_CurrVarType == GLOBAL_VAR_INIT)
	{
		if (m_ScopeState == GLOBAL)
		{
			if (!m_LastTypeQualifierList.empty() && m_LastIdentifierBeforeBracketOpen.IsEmpty())
			{
				m_Database->AddGlobalVariable(m_LastIdentifier, m_LastTypeQualifierList);
				m_LastGlobalVarName = m_LastIdentifier;
				m_CurrVarType = GLOBAL_VAR_INIT;
			}
		}
	}
	else if (m_CurrVarType == STRUCT_VAR)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastStructName + "." + m_LastIdentifier);
		m_CurrVarType = STRUCT_VAR_INIT;
	}
	else if (m_CurrVarType == UNIFORM_VAR)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastBufferName + "." + m_LastIdentifier);
		m_CurrVarType = UNIFORM_VAR_INIT;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#5
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_CloseSquareBracket(std::string& a_TokenName)
{
	if (m_CurrVarType == STRUCT_VAR_INIT)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastStructName + "." + m_LastIdentifier);
	}
	else if (m_CurrVarType == UNIFORM_VAR_INIT)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastBufferName + "." + m_LastIdentifier);
	}

	// Add extra instructions on function argument declaration
	if (m_CurrVarType == GLOBAL_VAR || m_CurrVarType == GLOBAL_VAR_INIT)
	{
		if (m_ScopeState == GLOBAL)
		{
			if (!m_LastIdentifierBeforeBracketOpen.IsEmpty())
			{
				m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastIdentifierBeforeBracketOpen + "." + m_LastIdentifier);
			}
		}
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#6
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_FloatValue(std::string& a_TokenName)
{
	if (m_State != LANGUAGE_SPECIFIC_DECLARATION && m_State != BASE)
	{
		m_State = VALUE_DECLARATION;
	}

	// Float values should be saved without 'f'
	if (a_TokenName.back() == 'f')
	{
		a_TokenName.erase(a_TokenName.size() - 1);
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	if (m_ScopeState == LAYOUT_LOCATION_DECL)
	{
		m_LastLayoutIndex = std::stoi(a_TokenName);
	}

	// Add extra instructions on function argument declaration
	if (m_CurrVarType == GLOBAL_VAR || m_CurrVarType == GLOBAL_VAR_INIT)
	{
		if (m_ScopeState == GLOBAL)
		{
			if (!m_LastIdentifierBeforeBracketOpen.IsEmpty())
			{
				m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastIdentifierBeforeBracketOpen + "." + m_LastIdentifier);
			}
		}
	}

	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#7
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_Preprocessor(std::string& a_TokenName)
{
	AddLocalInstruction(Key(a_TokenName + "\n\t"), false, m_LastFunctionName);
	Key tokenKey = a_TokenName;
	if (tokenKey.Contains("define") || tokenKey.Contains("error"))
	{
		m_Database->AddDefine(tokenKey);
	}
	return SAVVY_OK;
}
示例#8
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_BoolValue(std::string& a_TokenName)
{
	if (m_State != LANGUAGE_SPECIFIC_DECLARATION && m_State != BASE)
	{
		m_State = VALUE_DECLARATION;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#9
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_CloseSquareBracket(std::string& a_TokenName)
{
	if (m_CurrVarType == STRUCT_VAR_INIT)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastStructName + "." + m_LastIdentifier);
	}
	else if (m_CurrVarType == UNIFORM_VAR_INIT)
	{
		m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastBufferName + "." + m_LastIdentifier);
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#10
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_IntValue(std::string& a_TokenName)
{
	if (m_State != LANGUAGE_SPECIFIC_DECLARATION && m_State != BASE)
	{
		m_State = VALUE_DECLARATION;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	if (m_ScopeState == LAYOUT_LOCATION_DECL)
	{
		m_LastLayoutIndex = std::stoi(a_TokenName);
	}

	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#11
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_FloatValue(std::string& a_TokenName)
{
	if (m_State != LANGUAGE_SPECIFIC_DECLARATION && m_State != BASE)
	{
		m_State = VALUE_DECLARATION;
	}

	// Float values should be saved without 'f'
	if (a_TokenName.back() == 'f')
	{
		a_TokenName.erase(a_TokenName.size() - 1);
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	if (m_ScopeState == LAYOUT_LOCATION_DECL)
	{
		m_LastLayoutIndex = std::stoi(a_TokenName);
	}

	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#12
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_OpenBrace(std::string& a_TokenName)
{
	m_State = BASE;
	
	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);

	if (m_CurrVarType != GLOBAL_VAR_INIT)
	{
		m_LastTypeQualifierList.clear();
	}

	if (m_LastFunctionName.GetString() != "")
	{
		if (m_ScopeState == GLOBAL)
		{
			m_ConditionalDepth = 0;
			m_ScopeState = IN_FUNCTION;
		}
		else
		{
			m_ConditionalDepth++;
			m_ScopeState = CONDITIONAL;
		}
	}
	else
	{
		if (m_LastDataType == "struct")
		{
			m_CurrVarType = STRUCT_VAR;
			m_LastStructName = m_LastIdentifier;
			m_Database->AddStruct(m_LastIdentifier);
		}
	}
	return SAVVY_OK;
}
示例#13
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_OpenBracket(std::string& a_TokenName)
{
	if (m_State == DATA_TYPE_DECLARATION)
	{
		m_OldState = IN_PLACE_DECLARATION;
	}
	else if (m_State == IDENTIFIER_DECLARATION)
	{
		// Must be a function
		m_LastIdentifierBeforeBracketOpen = m_LastIdentifier;
		m_LastDataTypeBeforeBracketOpen = m_LastDataType;
		m_State = BASE;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);

	if (!m_LastIdentifierBeforeBracketOpen.IsEmpty())
	{
		m_LastTypeQualifierList.clear();
		m_LastFuncVarList.clear();
	}
	return SAVVY_OK;
}
示例#14
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_ID(std::string& a_TokenName)
{
	if (m_State == DATA_TYPE_DECLARATION || m_State == LANGUAGE_SPECIFIC_DECLARATION || m_State == BASE ||
		m_State == IDENTIFIER_USE || m_State == IDENTIFIER_DECLARATION)
	{
		if (m_State == LANGUAGE_SPECIFIC_DECLARATION)
		{
			// Uniform buffer declaration - save the name
			if (m_CurrVarType == UNIFORM_VAR)
			{
				m_LastBufferName = a_TokenName;

				if (m_ScopeState == LAYOUT_LOCATION_DECL)
				{
					m_Database->AddUniformBuffer(m_LastBufferName, m_LastLayoutIndex);
				}
				else
				{
					m_Database->AddUniformBuffer(m_LastBufferName);
				}
			}
			else if (m_CurrVarType == ORIGINAL_SEMANTIC)
			{
				m_Database->AddSemantic(m_InputOrOutput, m_LastIdentifier, Key(a_TokenName));
			}
			else if (m_CurrVarType == GENERIC_BUFFER_VAR)
			{
				m_LastBufferName = a_TokenName;
				if (m_ScopeState == LAYOUT_LOCATION_DECL)
				{
					m_Database->AddGenericBuffer(m_LastBufferName, m_LastLayoutIndex);
				}
				else
				{
					m_Database->AddGenericBuffer(m_LastBufferName);
				}
			}
		}
		else if (m_State == DATA_TYPE_DECLARATION)
		{
			if (m_LastFunctionName.GetString() != "" && m_OldState != IN_PLACE_DECLARATION && !m_Database->FunctionExists(a_TokenName) &&
				!m_Database->LocalVariableExists(m_LastFunctionName, a_TokenName))
			{
				// Check if it's a user defined data type
				if (m_Database->StructExists(a_TokenName))
				{
					m_LastDataType = a_TokenName;
				}

				ResultCode res;
				res = m_Database->AddLocalVariable(Key(a_TokenName), m_LastTypeQualifierList, m_LastFunctionName);
				m_AddedLocalVar = true;
				if (res != SAVVY_OK)
				{
					m_LastError = "Could not add local variable " + a_TokenName + " inside function " + m_LastFunctionName.GetString() + ". Local variable already exists.";
					return res;
				}
			}

			if (m_ScopeState == GLOBAL)
			{
				if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
				{
					m_LastFuncVariable.m_Name = a_TokenName;
					m_LastFuncVarList.push_back(m_LastFuncVariable);
				}
				// Check if it's a user defined data type
				if (m_Database->StructExists(a_TokenName))
				{
					m_LastTypeQualifierList.push_back(a_TokenName);
				}
			}
		}

		// Check if it's a user defined data type
		if (m_Database->StructExists(a_TokenName))
		{
			m_LastTypeQualifierList.push_back(a_TokenName);
			if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
			{
				m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
			}
			m_LastDataType = a_TokenName;
			m_State = DATA_TYPE_DECLARATION;
		}
		else
		{
			if (m_CurrVarType != STRUCT_VAR_INIT && m_CurrVarType != UNIFORM_VAR_INIT)
				m_LastIdentifier = a_TokenName;
			else
			{
				if (m_CurrVarType == STRUCT_VAR_INIT)
				{
					m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastStructName + "." + m_LastIdentifier);
				}
				else if (m_CurrVarType == UNIFORM_VAR_INIT)
				{
					m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastBufferName + "." + m_LastIdentifier);
				}
			}

			if (m_CurrVarType == ORIGINAL_SEMANTIC)
			{
				m_CurrVarType = GLOBAL_VAR;
				m_State = BASE;
			}
			else
			{
				m_State = IDENTIFIER_DECLARATION;
			}
		}
	}
	else if (m_State == OPERATION)
	{
		// Check if it's a user defined data type
		if (m_Database->StructExists(a_TokenName))
		{
			if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
			{
				m_LastTypeQualifierList.push_back(a_TokenName);
				m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
			}
			m_LastDataType = a_TokenName;
			m_State = DATA_TYPE_DECLARATION;
		}
		else if (m_ScopeState == GLOBAL && m_CurrVarType == GLOBAL_VAR_INIT)
		{
			Database::WordMultiMap& instructionMap = m_Database->GetInstructionMap();
			Database::WordMultiMap::iterator it1 = instructionMap.upper_bound(m_LastIdentifier);
			
			it1--;
			if (it1->second.m_Name == ",")
				instructionMap.erase(it1);

			m_LastIdentifier = a_TokenName;
			m_Database->AddGlobalVariable(m_LastIdentifier, m_LastTypeQualifierList);
			m_State = IDENTIFIER_DECLARATION;
		}
		else
		{
			// Handle adding local variables of the same type with a comma
			Database::WordMultiMap& instructionMap = m_Database->GetInstructionMap();
			Database::WordMultiMap::iterator it1 = instructionMap.upper_bound(m_LastFunctionName);
			it1--;
			if (it1->second.m_Name == "," && m_OldState != IN_PLACE_DECLARATION && !m_Database->FunctionExists(a_TokenName) && 
				!m_Database->LocalVariableExists(m_LastFunctionName, a_TokenName))
			{
				if (m_AddedLocalVar)
				{
					ResultCode res;
					res = m_Database->AddLocalVariable(Key(a_TokenName), m_LastTypeQualifierList, m_LastFunctionName);
					m_AddedLocalVar = true;
					if (res != SAVVY_OK)
					{
						m_LastError = "Could not add local variable " + a_TokenName + " inside function " + m_LastFunctionName.GetString() + ". Local variable already exists.";
						return res;
					}
				}
			}
			
			m_State = IDENTIFIER_USE;
		}
	}
	else
	{
		m_LastError = "Could not parse identifier " + a_TokenName + ". Possible syntax error.";
		return SAVVY_SHADER_SYNTAX_ERROR;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	AddGlobalInstruction(Key(a_TokenName), false, m_LastGlobalVarName);
	return SAVVY_OK;
}
示例#15
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_Operator(std::string& a_TokenName)
{
	if (m_State == OPERATION || m_State == IDENTIFIER_DECLARATION || m_State == VALUE_DECLARATION || 
		m_State == LANGUAGE_SPECIFIC_DECLARATION || m_State == IDENTIFIER_USE || m_State == DATA_TYPE_DECLARATION)
	{
		m_State = OPERATION;
	}
	else if (m_State == BASE)
	{
		if (m_OldState == IN_PLACE_DECLARATION)
		{
			m_State = OPERATION;
		}

		if (a_TokenName == ".")
		{
			m_State = OPERATION;
		}
	}
	else
	{
		m_LastError = "Could not parse operator " + a_TokenName + ". Possible syntax error.";
		return SAVVY_SHADER_SYNTAX_ERROR;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	if (m_ScopeState == LAYOUT_LOCATION_DECL)
	{
		if (a_TokenName != "=" && a_TokenName != ",")
		{
			m_LastError = "Could not parse operator " + a_TokenName + ". Possible syntax error.";
			return SAVVY_SHADER_SYNTAX_ERROR;
		}
	}

	if (m_ScopeState != GLOBAL && !m_AddedLocalVar)
	{
		m_LastTypeQualifierList.clear();
	}
	else
	{
		if (!m_LastIdentifierBeforeBracketOpen.IsEmpty())
		{
			m_LastTypeQualifierList.clear();
		}
	}

	if (m_CurrVarType == GLOBAL_VAR || m_CurrVarType == GLOBAL_VAR_INIT)
	{
		if (m_ScopeState == GLOBAL)
		{
			if (!m_LastTypeQualifierList.empty() && m_LastIdentifierBeforeBracketOpen.IsEmpty())
			{
				m_Database->AddGlobalVariable(m_LastIdentifier, m_LastTypeQualifierList);
				m_Database->AddLocalInstruction(Key(a_TokenName), false, m_LastIdentifier);
				m_LastGlobalVarName = m_LastIdentifier;
				m_CurrVarType = GLOBAL_VAR_INIT;
			}
		}
	}

	if (a_TokenName == "=")
	{
		if (m_CurrVarType == UNIFORM_VAR)
		{
			m_Database->AddUniformVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastBufferName);
		}
	}
	return SAVVY_OK;
}
示例#16
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_InstructionEnd(std::string& a_TokenName)
{
	if (m_State == BASE || m_State == IDENTIFIER_DECLARATION || m_State == IDENTIFIER_USE || 
		m_State == VALUE_DECLARATION || m_State == LANGUAGE_SPECIFIC_DECLARATION || m_State == OPERATION)
	{
		if (m_State == IDENTIFIER_DECLARATION && m_ScopeState != IN_FUNCTION)
		{
			ResultCode addVarResult = SAVVY_OK;
			switch (m_CurrVarType)
			{
			case INPUT_VAR:
				if (m_ScopeState == LAYOUT_LOCATION_DECL)
				{
					addVarResult = m_Database->AddInputVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastLayoutIndex);
					m_ScopeState = GLOBAL;
				}
				else
				{
					addVarResult = m_Database->AddInputVariable(m_LastIdentifier, m_LastTypeQualifierList);
				}
				break;
			case OUTPUT_VAR:
				if (m_ScopeState == LAYOUT_LOCATION_DECL)
				{
					addVarResult = m_Database->AddOutputVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastLayoutIndex);
					m_ScopeState = GLOBAL;
				}
				else
				{
					addVarResult = m_Database->AddOutputVariable(m_LastIdentifier, m_LastTypeQualifierList);
				}
				break;
			case STRUCT_VAR_INIT:
			case STRUCT_VAR:
			{
				addVarResult = m_Database->AddStructVariable(m_LastStructName, m_LastIdentifier, m_LastTypeQualifierList);
				m_ScopeState = GLOBAL;
				m_CurrVarType = STRUCT_VAR;
			}
				break;
			case UNIFORM_VAR_INIT:
			case UNIFORM_VAR:

				if (m_LastDataType.Contains("sampler"))
				{
					if (m_ScopeState == LAYOUT_LOCATION_DECL)
					{
						addVarResult = m_Database->AddSampler(m_LastIdentifier, m_LastDataType, m_LastLayoutIndex);
						m_ScopeState = GLOBAL;
					}
					else
					{
						addVarResult = m_Database->AddSampler(m_LastIdentifier, m_LastDataType);
						m_ScopeState = GLOBAL;
					}
				}
				else
				{
					if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
						addVarResult = m_Database->AddUniformVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastBufferName);
				}

				break;

			case GENERIC_BUFFER_VAR:

				if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
					addVarResult = m_Database->AddGenericBufferVariable(m_LastIdentifier, m_LastTypeQualifierList, m_LastBufferName);

				break;

			case GLOBAL_VAR:
			{
				// Global variable
				if (m_ScopeState == GLOBAL)
				{
					if (!m_LastTypeQualifierList.empty())
					{
						m_Database->AddGlobalVariable(m_LastIdentifier, m_LastTypeQualifierList);
					}
					m_CurrVarType = GLOBAL_VAR;
				}
			}
				break;
			default:
				break;
			}

			if (addVarResult != SAVVY_OK)
			{
				m_LastError = "Could not add variable " + m_LastIdentifier.GetString() + " to database. Variable already exists";
				return addVarResult;
			}
		}

		m_State = BASE;
		m_OldState = BASE;

		if (m_LastBufferName.IsEmpty() && m_LastStructName.IsEmpty())
			m_CurrVarType = GLOBAL_VAR;

		m_AddedLocalVar = false;
		if (m_CurrVarType == GLOBAL_VAR_INIT)
		{
			m_CurrVarType = GLOBAL_VAR;
			m_LastGlobalVarName.Clear();
		}
	}
	else
	{
		m_LastError = "Could not parse semicolon. Possible syntax error.";
		return SAVVY_SHADER_SYNTAX_ERROR;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	m_LastTypeQualifierList.clear();
	return SAVVY_OK;
}
示例#17
0
Savvy::ResultCode Savvy::Internal::ParserGLSL::Parse_LangSpecific(std::string& a_TokenName)
{
	if (m_State == BASE || m_State == LANGUAGE_SPECIFIC_DECLARATION || m_State == OPERATION || m_State == DATA_TYPE_DECLARATION)
	{
		m_State = LANGUAGE_SPECIFIC_DECLARATION;

		HandleBuiltInVariable(Key(a_TokenName));

		if (a_TokenName == "in")
		{
			if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
			{
				if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
				{
					m_State = DATA_TYPE_DECLARATION;
					m_LastDataType = a_TokenName;
					m_LastTypeQualifierList.push_back(m_LastDataType);
					m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
				}
				else
				{
					m_CurrVarType = INPUT_VAR;
					m_InputOrOutput.SetString("in");
				}
			}
		}
		else if (a_TokenName == "out")
		{
			if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
			{
				if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
				{
					m_State = DATA_TYPE_DECLARATION;
					m_LastDataType = a_TokenName;
					m_LastTypeQualifierList.push_back(m_LastDataType);
					m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
				}
				else
				{
					m_CurrVarType = OUTPUT_VAR;
					m_InputOrOutput.SetString("out");
				}
			}
		}
		else if (a_TokenName == "inout")
		{
			if (m_ScopeState == GLOBAL || m_ScopeState == LAYOUT_LOCATION_DECL)
			{
				if (m_LastIdentifierBeforeBracketOpen.GetString() != "")
				{
					m_State = DATA_TYPE_DECLARATION;
					m_LastDataType = a_TokenName;
					m_LastTypeQualifierList.push_back(m_LastDataType);
					m_LastFuncVariable.m_QualifierList = m_LastTypeQualifierList;
				}
			}
		}
		else if (a_TokenName == "uniform")
		{
			m_CurrVarType = UNIFORM_VAR;
		}
		else if (a_TokenName == "buffer" && m_ScopeState == GLOBAL)
		{
			m_CurrVarType = GENERIC_BUFFER_VAR;
		}
		else if (a_TokenName == "location" || a_TokenName == "binding")
		{
			m_ScopeState = LAYOUT_LOCATION_DECL;
		}
		else if (a_TokenName == SAVVY_ORIGINAL_SEMANTIC_DECL)
		{
			m_CurrVarType = ORIGINAL_SEMANTIC;
		}
	}
	else
	{
		m_LastError = "Could not parse language specific keyword " + a_TokenName + ". Possible syntax error.";
		return SAVVY_SHADER_SYNTAX_ERROR;
	}

	AddLocalInstruction(Key(a_TokenName), false, m_LastFunctionName);
	return SAVVY_OK;
}