0ad/source/ps/Parser.cpp

/* Copyright (C) 2009 Wildfire Games.
 * This file is part of 0 A.D.
 *
 * 0 A.D. is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * 0 A.D. is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "precompiled.h"

#include "Parser.h"

#if MSC_VERSION
#pragma warning(disable:4786)
#endif


//-------------------------------------------------
// Macros
//-------------------------------------------------

#define REGULAR_MAX_LENGTH			10
#define START_DYNAMIC				'<'
#define END_DYNAMIC					'>'
#define START_OPTIONAL				'['
#define END_OPTIONAL				']'
#define REGULAR_EXPRESSION			'$'

// use GetDouble and type-cast it to <<type>>
#define FUNC_IMPL_CAST_GETDOUBLE(func_name,type)		\
bool CParserValue::func_name(type &ret)					\
{														\
	double d;											\
	if (GetDouble(d))									\
		return ret = (type)d, true;						\
	else												\
		return false;									\
}

// Function-implementation creator for GetArg%type% that will call
//  Get%type% from the CParserValue
// func_name must belong to CParserFile
#define FUNC_IMPL_GETARG(func_name, get_name, type)		\
bool CParserLine::func_name(size_t arg, type &ret)		\
{														\
	if (GetArgCount() <= arg)							\
		return false;									\
	return m_Arguments[arg].get_name(ret);				\
}

//-------------------------------------------------
// Function definitions
//-------------------------------------------------

static bool _IsStrictNameChar(const char& c);
static bool _IsValueChar(const char& c);


// Functions used for checking a character if it belongs to a value
//  or not

// Checks ident
static bool _IsStrictNameChar(const char& c)
{
	return ((c >= 'a' && c <= 'z') ||
			(c >= 'A' && c <= 'Z') ||
			(c >= '0' && c <= '9'));
}

// Checks value
static bool _IsValueChar(const char& c)
{
	return ((c >= 'a' && c <= 'z') ||
			(c >= 'A' && c <= 'Z') ||
			(c >= '0' && c <= '9') ||
			c=='.' || c=='_');
}

// CParserValue
// ---------------------------------------------------------------------| Class

CParserValue::CParserValue()
{
}

CParserValue::~CParserValue()
{
}

// Parse the std::string in Value to different types

// bool
bool CParserValue::GetBool(bool &ret)
{
	// TODO Raj Add or remove some? I can make it all lowercase
	//  first so True and TRUE also works, or you could just
	//  add them too

	// true
	if (m_String == "true" ||
		m_String == "on" ||
		m_String == "1" ||
		m_String == "yes")
	{
		ret = true;
		return true;
	}
	else
	// false
	if (m_String == "false" ||
		m_String == "off" ||
		m_String == "0" ||
		m_String == "no")
	{
		ret = false;
		return true;
	}

	// point only erroneous runs reach
	return false;
}

// double
bool CParserValue::GetDouble(double &ret)
{
	// locals
	double			TempRet = 0.0;
	size_t			Size = m_String.size();
	size_t			i;
	bool			AtLeastOne = false;		// Checked if at least one of the loops
											//  run, otherwise "." would parse OK
	size_t			DecimalPos;
	bool			Negative = false;		// "-" is found

	// Check if '-' is found
	if (m_String[0]=='-')
	{
		Negative = true;
	}
	
	// find decimal position
	DecimalPos = m_String.find(".");
	if (DecimalPos == std::string::npos)	
		DecimalPos = Size;

	// Iterate left of the decimal sign
	//
	for (i=(Negative?1:0); i < DecimalPos; ++i)
	{
		// Set AtLeastOne to true
		AtLeastOne = true;

		// Check if a digit is found
		if (m_String[i] >= '0' && m_String[i] <= '9')
		{
			double exp = (DecimalPos-i-1);	// disambiguate pow() argument type
			TempRet += (m_String[i]-'0')*pow(10.0, exp);
		}
		else
		{
			// parse error!
			return false;
		}
	}

	// Iterate right of the decimal sign
	//
	for (i=DecimalPos+1; i < Size; ++i)
	{
		// Set AtLeastOne to true
		AtLeastOne = true;

		// Check if a digit is found
		if (m_String[i] >= '0' && m_String[i] <= '9')
		{
			double exp = (int)(DecimalPos-i);	// disambiguate pow() argument type
			TempRet += (m_String[i]-'0')*pow(10.0,exp);
		}
		// It will accept and ending f, like 1.0f
		else if (!(i==Size-1 && m_String[i] == 'f'))
		{
			// parse error!
			return false;
		}
	}

	if (!AtLeastOne)return false;

	// Set the reference to the temp value and return success
	ret = (Negative?-TempRet:TempRet);
	return true;
}

// std::string - only return m_String, can't fail
bool CParserValue::GetString(std::string &ret)
{
	ret = m_String;
	return true;
}

bool CParserValue::GetString( CStr& ret )
{
	ret = m_String;
	return true; 
}

// These macros include the IMPLEMENTATION of the 
// the function in the macro argument for CParserValue
// They use GetDouble, and then type-cast it
FUNC_IMPL_CAST_GETDOUBLE(GetFloat,			float)
FUNC_IMPL_CAST_GETDOUBLE(GetChar,			char)
FUNC_IMPL_CAST_GETDOUBLE(GetShort,			short)
FUNC_IMPL_CAST_GETDOUBLE(GetInt,			int)
FUNC_IMPL_CAST_GETDOUBLE(GetLong,			long)
FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedShort,	unsigned short)
FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedInt,	unsigned int)
FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedLong,	unsigned long)

// CParserTaskTypeNode
// ---------------------------------------------------------------------| Class

CParserTaskTypeNode::CParserTaskTypeNode() : m_ParentNode(NULL), m_NextNode(NULL), m_AltNode(NULL)
{
}

CParserTaskTypeNode::~CParserTaskTypeNode()
{
}

// Delete all children
void CParserTaskTypeNode::DeleteChildren()
{
	// Delete nodes if applicable
	if (m_NextNode)
	{
		m_NextNode->DeleteChildren();
		delete m_NextNode;
		m_NextNode = NULL;
	}

	if (m_AltNode)
	{
		m_AltNode->DeleteChildren();
		delete m_AltNode;
		m_AltNode = NULL;
	}
}

// CParserTaskType
// ---------------------------------------------------------------------| Class

CParserTaskType::CParserTaskType() : m_BaseNode(NULL)
{
}

CParserTaskType::~CParserTaskType()
{
}

// Delete m_BaseNode and all of its children
void CParserTaskType::DeleteTree()
{
	if (m_BaseNode)
	{
		m_BaseNode->DeleteChildren();
		delete m_BaseNode;
		m_BaseNode = NULL;
	}
}

// CParserLine
// ---------------------------------------------------------------------| Class

CParserLine::CParserLine()
{
}

CParserLine::~CParserLine()
{
	
	ClearArguments();
}

// Clear arguments (deleting m_Memory
bool CParserLine::ClearArguments()
{
	// Now we can actually clear it
	m_Arguments.clear();
	return true;
}

// Implementation of CParserFile::GetArg*
//  it just checks if argument isn't out of range, and
//  then it uses the the respective function in CParserValue
FUNC_IMPL_GETARG(GetArgString,			GetString,			std::string)
FUNC_IMPL_GETARG(GetArgBool,			GetBool,			bool)
FUNC_IMPL_GETARG(GetArgChar,			GetChar,			char)
FUNC_IMPL_GETARG(GetArgShort,			GetShort,			short)
FUNC_IMPL_GETARG(GetArgInt,				GetInt,				int)
FUNC_IMPL_GETARG(GetArgLong,			GetLong,			long)
FUNC_IMPL_GETARG(GetArgUnsignedShort,	GetUnsignedShort,	unsigned short)
FUNC_IMPL_GETARG(GetArgUnsignedInt,		GetUnsignedInt,		unsigned int)
FUNC_IMPL_GETARG(GetArgUnsignedLong,	GetUnsignedLong,	unsigned long)
FUNC_IMPL_GETARG(GetArgFloat,			GetFloat,			float)
FUNC_IMPL_GETARG(GetArgDouble,			GetDouble,			double)

// ParseString
// ------------------------------------------------------------------| Function
// Parses a line, dividing it into segments according to defined semantics
// each segment is called an argument and represents a value of some kind
// ex:
// variable = 5		=> variable, =, 5
// CallFunc(4,2)	=> CallFunc, 4, 2

// TODO Gee: Make Parser use CStr.
bool CParserLine::ParseString(const CParser& Parser, const std::string &strLine)
{
	// Don't process empty std::string
	if (strLine == std::string())
	{
		m_ParseOK = false;		// Empty lines should never be inputted by CParserFile
		return m_ParseOK;
	}

	// Locals
	bool				Extract=false;
	size_t				ExtractPos=0;
	char				Buffer[256];
	char				Letter[] = {'\0','\0'};		// Letter as std::string
	std::vector<std::string>		Segments;
	std::string				strSub;
	size_t				i;

	// Set result to false, then if a match is found, turn it true
	m_ParseOK = false;

	/* 
	TODO Gee Remove this comment!
	// Remove C++-styled comments!
	// * * * *
	int pos = strLine.find("//");
	if (pos != std::string::npos)
		strLine = strLine.substr(0,pos);
	*/

	// Divide std::string into smaller std::vectors, separators are unusual signs
	// * * * *

	for (i=0; i<strLine.size(); ++i)
	{
		// Check if we're trying to use some kind of type
		if (!Extract)
		{
			// GET NAME, IDENT, FLOAT
			if (_IsValueChar(strLine[i]))
			{
				Extract = true;
				ExtractPos = i;
				memset((void*)Buffer, '\0', sizeof(char)*256);
			}
			else
			// GET STRING BETWEEN QUOTES	
			if (strLine[i] == '\"')
			{
				// Extract a std::string, search for another "
				size_t pos = strLine.find("\"", i+1);

				// If matching can't be found,
				//  the parsing will fail!
				if (pos == std::string::npos)
				{
					// TODO Gee - Output in logfile
					m_ParseOK = false;
					return m_ParseOK;
				}

				// Get substring
				// Add a " to indicate this is a "..." std::string
				//  and can't be used as name
				strSub = "\"" + strLine.substr(i+1, pos-i-1);

				// Input substring!
				Segments.push_back(strSub);

				// Now we can't skip everything that we 
				//  we just read in, update i
				i = pos;
			}
			// GET JUST ONE CHARACTER
			else
			{
				// Input just the one char
				Letter[0] = strLine[i];
				Segments.push_back(Letter);
				continue;
			}
		}
		// Extract whatever
		if (Extract)
		{
			// No type names are longer than 256 characters
			if (i-ExtractPos >= 256)
			{
				Extract=false;
			}
			else
			{
				// Extract std::string after $ !
				// break whenever we reach a sign that's not A-Z a-z
				if (_IsValueChar(strLine[i]))
				{
					Buffer[i-ExtractPos] = strLine[i];
				}
				else
				{
					// Extraction is finished
					Extract=false;

					// strLine[i] is now a non-regular character
					//  we'll jump back one step so that will
					//  be included next loop
					--i;
				}

				// Check if std::string is complete
				if (i == strLine.size()-1)
					Extract=false;
			}

			// If extraction was finished! Input Buffer
			if (Extract == false)
			{
				Segments.push_back( std::string(Buffer) );
			}
		}
	}

	// Try to find an appropriate CParserTaskType in parser
	// * * * *

	// Locals
	size_t Progress;						// progress in Segments index
	size_t Lane=0;							// Have many alternative routes we are in
	bool Match;							// If a task-type match has been found
	// The std::vector of these three represents the different lanes
	//  LastValidProgress[1] takes you back to lane 1 and how
	//  the variables was set at that point
	std::vector<size_t> LastValidProgress;		// When diving into a dynamic argument store store
										//  the last valid so you can go back to it
	std::vector<size_t> LastValidArgCount;		// If an alternative route turns out to fail, we
										//  need to know the amount of arguments on the last
										//  valid position, so we can remove them.
	std::vector<bool> LastValidMatch;		// Match at that point
	bool BlockAltNode = false;			// If this turns true, the alternative route
										//  tested was not a success, and the settings
										//  should be set back in order to test the 
										//  next node instead
	bool LookNoFurther = false;			// If this turns true, it means a definite match has been
										//  found and no further looking is required
	CParserTaskTypeNode *CurNode=NULL;	// Current node on task type
	CParserTaskTypeNode *PrevNode=NULL;	// Last node
	UNUSED2(PrevNode);

	// Iterate all different TaskType, and all TaskTypeElements... 
	//  start from left and go  to the right (prog), comparing 
	//  the similarities. If enough
	//  similarities are found, then we can declare progress as
	//  that type and exit loop
	std::vector<CParserTaskType>::const_iterator cit_tt;
	for (cit_tt = Parser.m_TaskTypes.begin(); 
		 cit_tt != Parser.m_TaskTypes.end(); 
		 ++cit_tt)
	{
		// Reset for this task-type
		Match = true;
		Progress = 0;
		ClearArguments();				// Previous failed can have filled this
		CurNode = cit_tt->m_BaseNode;	// Start at base node
		LookNoFurther = false;
		BlockAltNode = false;

		// This loop will go through the whole tree until
		// it reaches an empty node
		while (!LookNoFurther)
		{
			// Check if node is valid
			//  otherwise try to jump back to parent
			if (CurNode->m_NextNode == NULL &&
				(CurNode->m_AltNode == NULL || BlockAltNode))
			{
				// Jump back to valid
				//CurNode = PrevNode;

				// If the node has no children, it's the last, and we're
				//  on lane 0, i.e. with no 
				if (CurNode->m_NextNode == NULL &&
					(CurNode->m_AltNode == NULL || BlockAltNode) &&
					Lane == 0)
				{
					if (Progress != Segments.size())
						Match = false;

					break;
				}
				else
				{
					CParserTaskTypeNode *OldNode = NULL;

					// Go back to regular route!
					for(;;)
					{
						OldNode = CurNode;
						CurNode = CurNode->m_ParentNode;

						if (CurNode->m_AltNode == OldNode)
						{
							break;
						}
					}

					// If the alternative route isn't repeatable, block alternative route for
					//  next loop cycle
					if (!CurNode->m_AltNodeRepeatable)
						BlockAltNode = true;

					// Decrease lane
					--Lane;
				}
			}

			// Check alternative route
			// * * * *

			// Check if alternative route is present
			//  note, if an alternative node has already failed
			//  we don't want to force usage of the next node
			//  therefore BlockAltNode has to be false
			if (!BlockAltNode)
			{
				if (CurNode->m_AltNode)
				{
					// Alternative route found, we'll test this first!
					CurNode = CurNode->m_AltNode;

					// --- New node is set!

					// Make sure they are large enough
					if (LastValidProgress.size() < Lane+1)
					{
						LastValidProgress.resize(Lane+1);
						LastValidMatch.resize(Lane+1);
						LastValidArgCount.resize(Lane+1);
					}

					// Store last valid progress
					LastValidProgress[Lane] = Progress;
					LastValidMatch[Lane] = Match;
					LastValidArgCount[Lane] = (int)m_Arguments.size();

					++Lane;

					continue;
				}
			}
			else BlockAltNode = false;

			// Now check Regular Next Node
			// * * * *

			if (CurNode->m_NextNode)
			{
				// Important!
				// Change working node to the next node!
				CurNode = CurNode->m_NextNode;

				// --- New node is set!

				// CHECK IF LETTER IS CORRECT
				if (CurNode->m_Letter != '\0')
				{
					// OPTIONALLY SKIP BLANK SPACES
					if (CurNode->m_Letter == '_')
					{
						// Find blank space if any!
						//  and jump to the next non-blankspace
						if (Progress < Segments.size())
						{	
							// Skip blankspaces AND tabs!
							while (Segments[Progress].size()==1 &&
								   (Segments[Progress][0]==' ' || 
									Segments[Progress][0]=='\t'))
							{
								++Progress;

								// Check length
								if (Progress >= Segments.size())
								{
									break;
								}
							}
						}
					}
					else
					// CHECK LETTER IF IT'S CORRECT
					{
						if (Progress < Segments.size())
						{
							// This should be 1-Letter long
							if (Segments[Progress].size() != 1)
								Match = false;

							// Check Letter
							if (CurNode->m_Letter != Segments[Progress][0])
								Match = false;

							// Update progress
							++Progress;
						}
						else Match = false;
					}
				}

				else if (CurNode->m_Type == typeNull)
				{
					// Match without doing anything (leaving Match==true)
				}

				// CHECK NAME
				else
				{
					// Do this first, because we wan't to
					//  avoid the Progress and Segments.size()
					//  check for this
					if (CurNode->m_Type == typeAddArg)
					{
						// Input argument
						CParserValue value;
						value.m_String = CurNode->m_String;
						m_Arguments.push_back(value);
					}
					else
					{
						// Alright! An ident or const has been acquired, if we
						//  can't find any or if the std::string has run out
						//  that invalidates the match

						// String end?
						if (Progress >= Segments.size())
						{
							Match = false;
						}
						else
						{
							// Store argument in CParserValue!
							CParserValue value;

							switch(CurNode->m_Type)
							{
							case typeIdent:
								// Check if this really is a std::string
								if (!_IsStrictNameChar(Segments[Progress][0]))
								{
									Match = false;
									break;
								}
								
								// Same as at typeValue, but this time
								//  we won't allow strings like "this", just
								//  like this
								if (Segments[Progress][0] == '\"')
									Match = false;
								else
									value.m_String = Segments[Progress];
								
								// Input argument!
								m_Arguments.push_back(value);

								++Progress;
								break;
							case typeValue:
								// Check if this really is a std::string
								if (!_IsValueChar(Segments[Progress][0]) &&
									Segments[Progress][0] != '\"')
								{
									Match = false;
									break;
								}
										
								// Check if initial is -> " <-, because that means it was
								//  stored from a "String like these with quotes"
								//  We don't want to store that prefix
								if (Segments[Progress][0] == '\"')
									value.m_String = Segments[Progress].substr(1, Segments[Progress].size()-1);
								else
									value.m_String = Segments[Progress];
								
								// Input argument!
								m_Arguments.push_back(value);

								++Progress;
								break;
							case typeRest:
								// This is a comment, don't store it.
								// Now BREAK EVERYTHING !
								//  We're done, we found our match and let's get out
								LookNoFurther = true;
								//Match = true;
								break;
							default:
								break;
							}
						}
					}
				}
			}

			// Check if match is false! if it is, try returning to last valid state
			if (!Match && Lane > 0)
			{
				// The alternative route failed
				BlockAltNode = true;

				CParserTaskTypeNode *OldNode = NULL;

				// Go back to regular route!
				for(;;)
				{
					OldNode = CurNode;
					CurNode = CurNode->m_ParentNode;

					if (CurNode->m_AltNode == OldNode)
					{
						break;
					}
				}

				// Decrease lane
				--Lane;

				// Restore values as before
				Progress = LastValidProgress[Lane];
				Match = LastValidMatch[Lane];
				m_Arguments.resize(LastValidArgCount[Lane]);
			}
		}

		// Check if it was a match!
		if (Match)
		{
			// Before we celebrate the match, let's check if whole
			//  of Segments has been used, and if so we have to
			//  nullify the match
			//if (Progress == Segments.size())
			{
				// *** REPORT MATCH WAS FOUND ***
				m_TaskTypeName = cit_tt->m_Name;
				m_ParseOK = true;
				break;
			}
		}
	}

	// POST-PROCESSING OF ARGUMENTS!
	
	// if _minus is found as argument, remove it and add "-" to the one after that
	// note, it's easier if std::iterator isn't used here
	
	for (i=1; i<GetArgCount(); ++i)
	{
		if (m_Arguments[i-1].m_String == "_minus")
		{
			// Add "-" to next, and remove "_minus"
			m_Arguments[i].m_String = "-" + m_Arguments[i].m_String;
			m_Arguments.erase(m_Arguments.begin() + (i-1));
		}
	}

	return m_ParseOK;
}

// CParser
// ---------------------------------------------------------------------| Class

// ctor
CParser::CParser()
{
}

// dtor
CParser::~CParser()
{
	// Delete all task type trees
	std::vector<CParserTaskType>::iterator itTT;
	for (itTT = m_TaskTypes.begin();
		 itTT != m_TaskTypes.end();
		 ++itTT)
	{
		itTT->DeleteTree();
	}
}

// InputTaskType
// ------------------------------------------------------------------| Function
// A task-type is a std::string representing the acquired syntax when parsing
//  This function converts that std::string into a binary tree, making it easier
//  and faster to later parse.
bool CParser::InputTaskType(const std::string& strName, const std::string& strSyntax)
{
	// Locals
	CParserTaskType TaskType;	// Object we acquire to create
	char Buffer[REGULAR_MAX_LENGTH];
	size_t ExtractPos = 0;
	bool Extract = false;
	bool Error = false;
	size_t i;

	// Construct base node
	TaskType.m_BaseNode = new CParserTaskTypeNode();

	// Working node
	CParserTaskTypeNode *CurNode = TaskType.m_BaseNode;

	// Loop through the std::string and construct nodes in the binary tree
	//  when applicable
	for (i=0; i<strSyntax.size(); ++i)
	{
		// Extract is a variable that is true when we want to extract
		//  parts that is longer than one character.
		if (!Extract)
		{
			if (strSyntax[i] == REGULAR_EXPRESSION)
			{
				Extract = true;
				ExtractPos = i+1; // Skip $
				memset((void*)Buffer, '\0', sizeof(char)*REGULAR_MAX_LENGTH);

				// We don't want to extract '$' so we'll just continue to next loop run
				continue;
			}
			else
			if (strSyntax[i] == START_DYNAMIC || strSyntax[i] == START_OPTIONAL)
			{

				// Slight hack: because things are stored in a binary tree,
				// it can't handle "<[a][b]>" -- the <...> node has only
				// one slot for an optional [...] node. To avoid this problem,
				// typeNull nodes are used to indicate things that always
				// succeed but can have altnodes attached:
/*
	parent			parent
	  \		===>	  \
	<...>	===>	<...>		<-- CurNode
	/	\			/	\
   /	 \		   /	 \
next	[a]		Null	[a]		<-- added NewNode
				/  \
			  next	[b]
*/
				if (CurNode->m_AltNode)
				{

					// Rearrange the tree, as shown above:

					// Create NewNode
					CParserTaskTypeNode* NewNode = new CParserTaskTypeNode();
					NewNode->m_ParentNode = CurNode;
					NewNode->m_Letter = '\0';
					NewNode->m_Type = typeNull;

					// Copy 'next' into NewNode
					NewNode->m_NextNode = CurNode->m_NextNode;
					// Replace 'next' with NewNode inside CurNode
					CurNode->m_NextNode = NewNode;
		
					// Update CurNode, so the following code inserts into [b]
					CurNode = NewNode;
				}

				// Dive into the alternative node
				ENSURE(! CurNode->m_AltNode);
				CurNode->m_AltNode = new CParserTaskTypeNode();
				CurNode->m_AltNode->m_ParentNode = CurNode;

				// It's repeatable
				CurNode->m_AltNodeRepeatable = bool(strSyntax[i]==START_DYNAMIC);

				// Set to current
				CurNode = CurNode->m_AltNode;

				// We're done extracting for now
				continue;
			}
			else
			if (strSyntax[i] == END_DYNAMIC || strSyntax[i] == END_OPTIONAL)
			{
				CParserTaskTypeNode *OldNode = NULL;

				// Jump out of this alternative route
				for(;;)
				{
					OldNode = CurNode;
					CurNode = CurNode->m_ParentNode;

					if (CurNode == NULL)
					{
						// Syntax error
						Error = true;
						break;
					}

					if (CurNode->m_AltNode == OldNode)
					{
						break;
					}
				}
				
				if (Error)break;
			}
			else
			{
				// Check if this is the first input
				// CONSTRUCT A CHILD NODE
				ENSURE(! CurNode->m_NextNode);
				CurNode->m_NextNode = new CParserTaskTypeNode();
				CurNode->m_NextNode->m_ParentNode = CurNode;

				// Jump into !
				CurNode = CurNode->m_NextNode;	

				// Set CurNode
				CurNode->m_Letter = strSyntax[i];		
			}
		}

		// Extact
		if (Extract)
		{
			// No type names are longer than REGULAR_MAX_LENGTH characters
			if (i-ExtractPos >= REGULAR_MAX_LENGTH)
			{
				Extract=false;
			}
			else
			{
				// Extract std::string after $ !
				// break whenever we reach a sign that's not A-Z a-z
				if (_IsStrictNameChar(strSyntax[i]))
				{
					Buffer[i-ExtractPos] = strSyntax[i];
				}
				else
				{
					// Extraction is finished
					Extract=false;

					// strLine[i] is now a non-regular character
					//  we'll jump back one step so that will
					//  be included next loop
					--i;
				}

				// Check if std::string is complete
				if (i == strSyntax.size()-1)
					Extract=false;
			}

			// If extraction was finished! Input Buffer
			if (Extract == false)
			{
				// CONSTRUCT A CHILD NODE
				ENSURE(! CurNode->m_NextNode);
				CurNode->m_NextNode = new CParserTaskTypeNode();
				CurNode->m_NextNode->m_ParentNode = CurNode;

				// Jump into !
				CurNode = CurNode->m_NextNode;					

				CurNode->m_Letter = '\0';

				std::string str = std::string(Buffer);

				// Check value and set up CurNode accordingly
				if (str == "value")		CurNode->m_Type = typeValue;
				else 
				if (str == "ident")		CurNode->m_Type = typeIdent;
				else
				if (str == "rest")		CurNode->m_Type = typeRest;
				else
				if (str == "rbracket")	CurNode->m_Letter = '>';
				else 
				if (str == "lbracket")	CurNode->m_Letter = '<';
				else 
				if (str == "rbrace")	CurNode->m_Letter = ']';
				else 
				if (str == "lbrace")	CurNode->m_Letter = '[';
				else 
				if (str == "dollar")	CurNode->m_Letter = '$';
				else
				if (str == "arg")
				{
					// After $arg, you need a parenthesis, within that parenthesis is a std::string
					//  that will be added as an argument when it's passed through

					CurNode->m_Type = typeAddArg;
					
					// Check length, it has to have place for at least a '(' and ')' after $arg
					if (ExtractPos+4 >= strSyntax.size())
					{
						Error = true;
						break;
					}
					
					// We want to extract what's inside the parenthesis after $arg
					//  if it's not there at all, it's a syntactical error
					if (strSyntax[ExtractPos+3] != '(')
					{
						Error = true;
						break;
					}

					// Now try finding the second ')'
					size_t Pos = strSyntax.find(")", ExtractPos+5);

					// Check if ')' exists at all
					if (Pos == std::string::npos)
					{
						Error = true;
						break;
					}

					// Now extract std::string within ( and )
					CurNode->m_String = strSyntax.substr(ExtractPos+4, Pos-(ExtractPos+4));

					// Now update position
					i = (int)Pos;
				}
				else
				{
					// TODO Gee report in log too
					Error = true;
				}
			}
		}
	}

	// Input TaskType
	if (!Error)
	{
		// Set name and input
		TaskType.m_Name = strName;
		m_TaskTypes.push_back(TaskType);
	}

	return !Error;
}


CParserCache::CacheType CParserCache::m_Cached;

CParser& CParserCache::Get(const char* str)
{
	CacheType::iterator it = m_Cached.find(str);
	if (it == m_Cached.end())
	{
		CParser* parser = new CParser;
		parser->InputTaskType("", str);
		m_Cached[str] = parser;
		return *parser;
	}
	else
	{
		CParser* parser = it->second;
		return *parser;
	}
}