/* ==========================================================================
* ÀÛ ¼º ÀÚ : À̼ø±Ô
* ÀÛ ¼º ÀÏ : 2007.06.21
* ³»    ¿ë : 
* ÁÖÀÇ»çÇ× : 
*===========================================================================*/
#pragma once

/// ÅäÅ©³ªÀÌÀú
/// ·º¼­¿Í ´Þ¸® ´Ü¼øÈ÷ ±¸ºÐ ¹®ÀÚ·Î ÅäÅ«À» ºÐ¸®ÇØÁØ´Ù.
template<class T>
class tTokenizer
{
protected:
	/// ÆÄÀϸí
	const T* mFileName;

	/// ¹öÆÛ Æ÷ÀÎÅÍ
	const T* mBuffer;

	/// ¹öÆÛ ±æÀÌ
	unsigned int mBufferLen;

	/// ±¸ºÐ ¹®ÀÚ¿­ (±¸ºÐ ¹®ÀÚµéÀÇ ÁýÇÕ)
	const T* mDelimiters;

	/// ¹®ÀÚ¸¦ ÀÐÀ» À§Ä¡
	unsigned int mPos;
public:
	/// ÁÙ ¹øÈ£
	int mLine;

public:
	tTokenizer();
	tTokenizer( const T* buffer, unsigned int size, const T* delimiters, const T* fileName = 0 );
	~tTokenizer();

	/// ¼Ò½º¸¦ ¼³Á¤
	void SetSource( const T* buffer, unsigned int size, const T* delimiters, const T* fileName = 0 );

	/// ±¸ºÐ ¹®ÀÚµéÀ» ¼³Á¤
	void SetDelimiters( const T* delimiters );

	/// ´ÙÀ½ ÅäÅ« ¹®ÀÚ¿­À» ¸®ÅÏ
	/// ¸Ç ³¡¿¡ µµ´ÞÇϸé false¸¦ ¸®ÅÏ
	bool GetNext( tBasicString<T, tCharTraits<T> >* str );

	/// ÅäÅ«È­½ÃÅ°Áö ¾ÊÀº ³ª¸ÓÁö ¹®ÀÚ¿­À» ¸®ÅÏ
	const T* GetTail() const;

	/// Á¾·á ¿©ºÎ¸¦ ¸®ÅÏ
	bool IsEnd();
};

template<>
class tTokenizer<char>
{
protected:
	/// ÆÄÀϸí
	const char* mFileName;

	/// ¹öÆÛ Æ÷ÀÎÅÍ
	const char* mBuffer;

	/// ¹öÆÛ ±æÀÌ
	unsigned int mBufferLen;

	/// ±¸ºÐ ¹®ÀÚ¿­
	bool mDelimiters[256];

	/// ¹®ÀÚ¸¦ ÀÐÀ» À§Ä¡
	unsigned int mPos;
public:
	/// ÁÙ ¹øÈ£
	int mLine;

protected:
	bool IsComment( char c )
	{
		char c1 = *( mBuffer + mPos + 1 );
		return (c == '/' && c1 == '/') || (c == '-' && c1 == '-');
	}

	bool IsDelimiter( char c )
	{
		return mDelimiters[c + 128];
	}

public:
	tTokenizer()
		: mFileName( 0 )
		, mBuffer( 0 )
		, mBufferLen( 0 )
		, mPos( 0 )
		, mLine( 1 )
	{
		memset( mDelimiters, false, 256 * sizeof(bool) );
	}

	tTokenizer( const char* buffer, unsigned int size, const char* delimiters, const char* fileName = 0 )
		: mFileName( fileName )
		, mBuffer( buffer )
		, mBufferLen( size )
		, mPos( 0 )
		, mLine( 1 )
	{
		assert( buffer );
		assert( size );

		SetDelimiters( delimiters );
	}

	~tTokenizer()
	{
	}

	void SetSource( const char* buffer, unsigned int size, const char* delimiters, const char* fileName = 0 )
	{
		assert( buffer );
		assert( size );

		mFileName = fileName;
		mBuffer = buffer;
		mBufferLen = size;
		SetDelimiters( delimiters );
	}

	void SetDelimiters( const char* delimiters )
	{
		assert( delimiters );

		memset( mDelimiters, false, 256 * sizeof(bool) );

		for( char c = *delimiters; c; c = *(++delimiters) )
		{
			mDelimiters[c + 128] = true;
		}
	}

	bool GetNext( cString* str )
	{
		assert( str );

		if( mPos >= mBufferLen )
			return false;

		char lexeme[256] = { 0 };
		int i = 0;
		char c = 0;

		for( ; mPos < mBufferLen; ++mPos )
		{
			c = *( mBuffer + mPos );

			if( c == '\n' )
			{
				++mLine;
			}
			else if( IsComment( c ) )
			{
				for( mPos += 2; mPos < mBufferLen; ++mPos )
				{
					c = *( mBuffer + mPos );

					if( c == '\n' )
					{
						++mLine;
						break;
					}
				}
				if( i == 0 )
				{
					continue;
				}
				else
				{
					++mPos;
					break;
				}
			}
			if( IsDelimiter( c ) )
			{
				if( i == 0 )
				{
					continue;
				}
				else
				{
					++mPos;
					break;
				}
			}
			if( i < 255 )
			{
				lexeme[i] = c;
				++i;
			}
		}

		lexeme[i] = 0;
		*str = lexeme;
		return i != 0;
	}

	void GotoNextLine()
	{
		for( ; mPos < mBufferLen; ++mPos )
		{
			if( *( mBuffer + mPos ) == '\n' )
			{
				++mLine;
				++mPos;
				break;
			}
		}
	}

	const char* GetTail() const
	{
		if( mPos >= mBufferLen )
			return 0;
		else
			return mBuffer + mPos;
	}

	bool IsEnd()
	{
		unsigned int pos = mPos;
		char c = 0;

		for( ; mPos < mBufferLen; ++mPos )
		{
			c = *( mBuffer + mPos );

			if( c == '\n' || c == ' ' )
			{
				continue;
			}
			if( IsComment( c ) )
			{
				for( mPos += 2; mPos < mBufferLen; ++mPos )
				{
					c = *( mBuffer + mPos );

					if( c == '\n' )
						break;
				}
				continue;
			}
			if( IsDelimiter( c ) )
			{
				continue;
			}
			mPos = pos;
			return false;
		}
		mPos = pos;
		return true;
	}
};

template<>
class tTokenizer<wchar_t>
{
protected:
	/// ÆÄÀϸí
	const wchar_t* mFileName;

	/// ¹öÆÛ Æ÷ÀÎÅÍ
	const wchar_t* mBuffer;

	/// ¹öÆÛ ±æÀÌ
	unsigned int mBufferLen;

	/// ±¸ºÐ ¹®ÀÚ¿­
	const wchar_t* mDelimiters;

	/// ¹®ÀÚ¸¦ ÀÐÀ» À§Ä¡
	unsigned int mPos;

	/// ÁÙ ¹øÈ£
	int mLine;

protected:
	bool IsComment( wchar_t c )
	{
		wchar_t c1 = *( mBuffer + mPos + 1 );
		return (c == L'/' && c1 == L'/') || (c == L'-' && c1 == L'-');
	}

	bool IsDelimiter( wchar_t c )
	{
		for( const wchar_t* p = mDelimiters; *p; ++p )
		{
			if( c == *p )
			{
				return true;
			}
		}
		return false;
	}

public:
	tTokenizer()
		: mFileName( 0 )
		, mBuffer( 0 )
		, mBufferLen( 0 )
		, mDelimiters( 0 )
		, mPos( 0 )
		, mLine( 1 )
	{
	}

	tTokenizer( const wchar_t* buffer, unsigned int size, const wchar_t* delimiters, const wchar_t* fileName = 0 )
		: mFileName( fileName )
		, mBuffer( buffer )
		, mBufferLen( size )
		, mDelimiters( delimiters )
		, mPos( 0 )
		, mLine( 1 )
	{
		assert( buffer );
		assert( size );
		assert( delimiters );
	}

	~tTokenizer()
	{
	}

	void SetSource( const wchar_t* buffer, unsigned int size, const wchar_t* delimiters, const wchar_t* fileName = 0 )
	{
		assert( buffer );
		assert( size );
		assert( delimiters );

		mFileName = fileName;
		mBuffer = buffer;
		mBufferLen = size;
		mDelimiters = delimiters;
	}

	bool GetNext( cStringW* str )
	{
		assert( str );

		if( mPos >= mBufferLen )
			return false;

		wchar_t lexeme[256] = { 0 };
		int i = 0;
		wchar_t c = 0;

		for( ; mPos < mBufferLen; ++mPos )
		{
			c = *( mBuffer + mPos );

			if( c == L'\n' )
			{
				++mLine;
			}
			else if( IsComment( c ) )
			{
				for( mPos += 2; mPos < mBufferLen; ++mPos )
				{
					c = *( mBuffer + mPos );

					if( c == L'\n' )
					{
						++mLine;
						break;
					}
				}
				if( i == 0 )
				{
					continue;
				}
				else
				{
					++mPos;
					break;
				}
			}
			if( IsDelimiter( c ) )
			{
				if( i == 0 )
				{
					continue;
				}
				else
				{
					++mPos;
					break;
				}
			}
			if( i < 255 )
			{
				lexeme[i] = c;
				++i;
			}
		}

		lexeme[i] = 0;
		*str = lexeme;
		return i != 0;
	}

	void GotoNextLine()
	{
		for( ; mPos < mBufferLen; ++mPos )
		{
			if( *( mBuffer + mPos ) == L'\n' )
			{
				++mLine;
				++mPos;
				break;
			}
		}
	}

	const wchar_t* GetTail() const
	{
		if( mPos >= mBufferLen )
			return 0;
		else
			return mBuffer + mPos;
	}

	bool IsEnd()
	{
		unsigned int pos = mPos;
		wchar_t c = 0;

		for( ; mPos < mBufferLen; ++mPos )
		{
			c = *( mBuffer + mPos );

			if( c == L'\n' || c == L' ' )
			{
				continue;
			}
			if( IsComment( c ) )
			{
				for( mPos += 2; mPos < mBufferLen; ++mPos )
				{
					c = *( mBuffer + mPos );

					if( c == L'\n' )
						break;
				}
				continue;
			}
			if( IsDelimiter( c ) )
			{
				continue;
			}
			mPos = pos;
			return false;
		}
		mPos = pos;
		return true;
	}
};

typedef tTokenizer<char> cTokenizer;
typedef tTokenizer<wchar_t> cTokenizerW;

#ifdef _UNICODE
;	typedef	cTokenizerW cTokenizerT;
#else
;	typedef	cTokenizer cTokenizerT;	
#endif //_UNICODE