/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant 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.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_SCRIPT_SCRIPTTOKENISER_H )
#define INCLUDED_SCRIPT_SCRIPTTOKENISER_H

#include "iscriplib.h"

class ScriptTokeniser : public Tokeniser
{
enum CharType
{
	eWhitespace,
	eCharToken,
	eNewline,
	eCharQuote,
	eCharSolidus,
	eCharStar,
	eCharSpecial,
};

typedef bool ( ScriptTokeniser::*Tokenise )( char c );

Tokenise m_stack[3];
Tokenise* m_state;
SingleCharacterInputStream<TextInputStream> m_istream;
std::size_t m_scriptline;
std::size_t m_scriptcolumn;

char m_token[MAXTOKEN];
char* m_write;

char m_current;
bool m_eof;
bool m_crossline;
bool m_unget;
bool m_emit;

bool m_special;

CharType charType( const char c ){
	switch ( c )
	{
	case '\n': return eNewline;
	case '"': return eCharQuote;
	case '/': return eCharSolidus;
	case '*': return eCharStar;
	case '{': case '(': case '}': case ')': case '[': case ']': case ',': case ':': return ( m_special ) ? eCharSpecial : eCharToken;
	}

	if ( c > 32 ) {
		return eCharToken;
	}
	return eWhitespace;
}

Tokenise state(){
	return *m_state;
}
void push( Tokenise state ){
	ASSERT_MESSAGE( m_state != m_stack + 2, "token parser: illegal stack push" );
	*( ++m_state ) = state;
}
void pop(){
	ASSERT_MESSAGE( m_state != m_stack, "token parser: illegal stack pop" );
	--m_state;
}
void add( const char c ){
	if ( m_write < m_token + MAXTOKEN - 1 ) {
		*m_write++ = c;
	}
}
void remove(){
	ASSERT_MESSAGE( m_write > m_token, "no char to remove" );
	--m_write;
}

bool tokeniseDefault( char c ){
	switch ( charType( c ) )
	{
	case eNewline:
		if ( !m_crossline ) {
			globalErrorStream() << Unsigned( getLine() ) << ":" << Unsigned( getColumn() ) << ": unexpected end-of-line before token\n";
			return false;
		}
		break;
	case eCharToken:
	case eCharStar:
		push( Tokenise( &ScriptTokeniser::tokeniseToken ) );
		add( c );
		break;
	case eCharSpecial:
		push( Tokenise( &ScriptTokeniser::tokeniseSpecial ) );
		add( c );
		break;
	case eCharQuote:
		push( Tokenise( &ScriptTokeniser::tokeniseQuotedToken ) );
		break;
	case eCharSolidus:
		push( Tokenise( &ScriptTokeniser::tokeniseSolidus ) );
		break;
	default:
		break;
	}
	return true;
}
bool tokeniseToken( char c ){
	switch ( charType( c ) )
	{
	case eNewline:
	case eWhitespace:
	case eCharQuote:
	case eCharSpecial:
		pop();
		m_emit = true; // emit token
		break;
	case eCharSolidus:
#if 0 //SPoG: ignore comments in the middle of tokens.
		push( Tokenise( &ScriptTokeniser::tokeniseSolidus ) );
		break;
#endif
	case eCharToken:
	case eCharStar:
		add( c );
		break;
	default:
		break;
	}
	return true;
}
bool tokeniseQuotedToken( char c ){
	switch ( charType( c ) )
	{
	case eNewline:
		if ( m_crossline ) {
			globalErrorStream() << Unsigned( getLine() ) << ":" << Unsigned( getColumn() ) << ": unexpected end-of-line in quoted token\n";
			return false;
		}
		break;
	case eWhitespace:
	case eCharToken:
	case eCharSolidus:
	case eCharStar:
	case eCharSpecial:
		add( c );
		break;
	case eCharQuote:
		pop();
		push( Tokenise( &ScriptTokeniser::tokeniseEndQuote ) );
		break;
	default:
		break;
	}
	return true;
}
bool tokeniseSolidus( char c ){
	switch ( charType( c ) )
	{
	case eNewline:
	case eWhitespace:
	case eCharQuote:
	case eCharSpecial:
		pop();
		add( '/' );
		m_emit = true; // emit single slash
		break;
	case eCharToken:
		pop();
		add( '/' );
		add( c );
		break;
	case eCharSolidus:
		pop();
		push( Tokenise( &ScriptTokeniser::tokeniseComment ) );
		break; // dont emit single slash
	case eCharStar:
		pop();
		push( Tokenise( &ScriptTokeniser::tokeniseBlockComment ) );
		break; // dont emit single slash
	default:
		break;
	}
	return true;
}
bool tokeniseComment( char c ){
	if ( c == '\n' ) {
		pop();
		if ( state() == Tokenise( &ScriptTokeniser::tokeniseToken ) ) {
			pop();
			m_emit = true; // emit token immediatly preceding comment
		}
	}
	return true;
}
bool tokeniseBlockComment( char c ){
	if ( c == '*' ) {
		pop();
		push( Tokenise( &ScriptTokeniser::tokeniseEndBlockComment ) );
	}
	return true;
}
bool tokeniseEndBlockComment( char c ){
	switch ( c )
	{
	case '/':
		pop();
		if ( state() == Tokenise( &ScriptTokeniser::tokeniseToken ) ) {
			pop();
			m_emit = true; // emit token immediatly preceding comment
		}
		break; // dont emit comment
	case '*':
		break; // no state change
	default:
		pop();
		push( Tokenise( &ScriptTokeniser::tokeniseBlockComment ) );
		break;
	}
	return true;
}
bool tokeniseEndQuote( char c ){
	pop();
	m_emit = true; // emit quoted token
	return true;
}
bool tokeniseSpecial( char c ){
	pop();
	m_emit = true; // emit single-character token
	return true;
}

/// Returns true if a token was successfully parsed.
bool tokenise(){
	m_write = m_token;
	while ( !eof() )
	{
		char c = m_current;

		if ( !( ( *this ).*state() )( c ) ) {
			// parse error
			m_eof = true;
			return false;
		}
		if ( m_emit ) {
			m_emit = false;
			return true;
		}

		if ( c == '\n' ) {
			++m_scriptline;
			m_scriptcolumn = 1;
		}
		else
		{
			++m_scriptcolumn;
		}

		m_eof = !m_istream.readChar( m_current );
	}
	return m_write != m_token;
}

const char* fillToken(){
	if ( !tokenise() ) {
		return 0;
	}

	add( '\0' );
	return m_token;
}

bool eof(){
	return m_eof;
}

public:
ScriptTokeniser( TextInputStream& istream, bool special )
	: m_state( m_stack ),
	m_istream( istream ),
	m_scriptline( 1 ),
	m_scriptcolumn( 1 ),
	m_crossline( false ),
	m_unget( false ),
	m_emit( false ),
	m_special( special ){
	m_stack[0] = Tokenise( &ScriptTokeniser::tokeniseDefault );
	m_eof = !m_istream.readChar( m_current );
	m_token[MAXTOKEN - 1] = '\0';
}
void release(){
	delete this;
}
void nextLine(){
	m_crossline = true;
}
const char* getToken(){
	if ( m_unget ) {
		m_unget = false;
		return m_token;
	}

	return fillToken();
}
void ungetToken(){
	ASSERT_MESSAGE( !m_unget, "can't unget more than one token" );
	m_unget = true;
}
std::size_t getLine() const {
	return m_scriptline;
}
std::size_t getColumn() const {
	return m_scriptcolumn;
}
};


inline Tokeniser& NewScriptTokeniser( TextInputStream& istream ){
	return *( new ScriptTokeniser( istream, true ) );
}

inline Tokeniser& NewSimpleTokeniser( TextInputStream& istream ){
	return *( new ScriptTokeniser( istream, false ) );
}

#endif