/*
 * This file is a part of EZC -- Easy templating in C++ library
 * and is distributed under the BSD 3-Clause licence.
 * Author: Tomasz Sowa <t.sowa@ttmath.org>
 */

/* 
 * Copyright (c) 2007-2014, Tomasz Sowa
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *    
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *    
 *  * Neither the name Tomasz Sowa nor the names of contributors to this
 *    project may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */


#ifndef headerfile_ezc_generator
#define headerfile_ezc_generator

#include "blocks.h"
#include "pattern.h"
#include "functions.h"
#include <sstream>
#include <fstream>
#include <vector>


namespace Ezc
{



/*
StreamType
 we use only method write(const wchar_t * str, size_t len) from the stream
*/
template<class StreamType>
class Generator
{
public:

	Generator();
	Generator(const Generator & n);
	Generator & operator=(const Generator & n);
	~Generator();

	void SetPattern(Pattern & pattern);
	void SetBlocks(Blocks & blocks);
	void SetFunctions(Functions<StreamType> & functions);

	void SetMax(size_t max_items_, size_t max_for_items_);

	// recognizing some special characters in text patterns (item_text in Patterns)
	// \r will be a carriage return (13)
	// \n will be a new line (10)
	// \t will be a tabulator (9)
	// \s will be a space
	// \\ will be one '\'
	// if the second character is different from those shown above the first slash will be printed
	// so "\x" gives "\x"
	// default: false
	void RecognizeSpecialChars(bool spec);

	// trimming white characters (at the beginning and at the end of an item_text)
	// (special char \s if enabled is not treated as a white character here)
	// default: false 
	void TrimWhite(bool trim);

	// skipping new line characters (from the whole string in an item_text)
	// but you can use a new line character written as "\n" (if special chars are turn on)
	// default: false
	void SkipNewLine(bool skip);

	// default: 20
	void SetMaxFilters(size_t new_len);

	// default stack size: 300
	void SetStackSize(size_t new_stack_size);

	// do not print anything to stream stream_index
	// useful when using Generate() method with StreamType tables
	// this is a small optimization if we know that a stream with stream_index will not be used later
	// set stream_index to -1 to turn off (default)
	void SkipStream(int stream_index);

	// set whether or not we can use cache for functions or blocks
	// true by default
	void CanUseCache(bool can_use_cache);

	// set whether or not we can use variables: [def ...] statement
	// true by default
	void CanUseVars(bool can_use_variables);

	// the main methods for generating
	void Generate(StreamType & o);
	void Generate(std::vector<StreamType>  & o);
	void Generate(std::vector<StreamType*> & o);

	void SetCommentary(const char * com_start,         const char * com_stop);
	void SetCommentary(const std::string & com_start,  const std::string & com_stop);
	void SetCommentary(const wchar_t * com_start,      const wchar_t * com_stop);
	void SetCommentary(const std::wstring & com_start, const std::wstring & com_stop);

private:
	

	// variables set
	typedef std::map<std::wstring, Var> Vars;
	Vars vars;

	Var temp_var;

	struct BlockStack
	{
		std::vector<Var> args;
		StreamType * out_stream;
		bool was_return;
	};

	std::vector<BlockStack> block_stack_tab;
	size_t block_stack_index;
	size_t block_stack_size;

	// current output stream
	// if we are printing only to one stream e.g. [ezc output "3"]
	// then output_stream is pointing directly to that stream 
	// but if we are printing to more than one stream e.g. [ezc output "0" "2" "5"]
	// then output_stream is pointing to output_tmp_stream and at the end
	// output_tmp_stream is copied to the correct streams
	// output_stream can be null e.g. [ezc output] without arguments
	// in such a case we do not print anything (but any functions are evaluated)
	StreamType * output_stream;

	Pattern    * ppattern;
	Blocks     * pblocks;
	Functions<StreamType> * pfunctions;

	// output_tmp_stream is used when outputting to more than one stream
	// (first we output to output_tmp_stream and then the content is copied
	// to the correct streams)
	StreamType output_tmp_stream;

	// pointers to the output streams
	std::vector<StreamType*> output_stream_tab;

	// indices to output_stream_tab
	// they are set by [put stream ...] keyword
	// at the beginning there is only one index created automatically - "0"
	std::vector<size_t> output_stream_index;

	// if has_skip_stream_index is true then when reading stream indices from [put stream ...]
	// a stream with skip_stream_index index will be ignored
	bool has_skip_stream_index;
	size_t skip_stream_index;

	// temporary error messages
	std::wstring temp_msg;

	bool break_generating;
	size_t current_item;
	size_t max_items;
	size_t max_for_items;
	bool special_chars;
	bool trim_white;
	bool skip_new_line;

	size_t stack_index;
	size_t stack_size;

	size_t filter_index;
	size_t filter_size;
	// we have to use a pointers table because standard streams such
	// as std::wostringstream are not copyable
	std::vector<StreamType*> filter_tab;
	const StreamType empty_stream;

	// used in [0] [1] [2] when there is no such argument defined
	std::wstring empty_argument;

	// temporary streams used in [if..] [is...] or [for...]
	// or if output_stream is null and an ezc function should be called
	StreamType stream_temp1, stream_temp2, stream_temp_define;

	// last result from a user function (FunInfo::res)
	bool last_res;

	// true if this Generator is working now
	bool is_generator_working;

	// true if the Generator is working with [for ...], [if ...] etc.
	bool is_generating_for;
	bool is_generating_if;
	bool is_generating_is;
	bool is_generating_normal;
	bool is_generating_filter;

	// an empty string for FunInfo objects
	// when there is no any parameters
	const std::wstring empty;

	// a stack for [for] statements
	std::vector<Stack> stack_tab;

	std::wstring commentary_start, commentary_stop;

	bool can_use_vars;
	bool can_find_in_cache;

	void ResizeFilterTab();
	void ResizeStack();
	void ResizeBlockStack();

	void ClearFilterTab();
	void ClearForStack();
	void ClearBlockStack();

	void ClearStream(StreamType & str);
	void RemoveStackFunData(Stack & sitem);

	template<class CharType>
	CharType ToLower(CharType c);

	bool AreStreamsEqual(StreamType & str1, StreamType & str2);

	bool FindInCache(const Item::Function & item_fun,
					 typename Functions<StreamType>::UserFunction ** function,
					 Item ** item_block,
					 std::wstring ** variable);

	bool FindInFunctionsAndBlocks(const std::wstring & name,
								  typename Functions<StreamType>::UserFunction ** function,
								  Item ** item_block);
										
	bool FindInVariables(const std::wstring & name,
						 std::wstring ** variable);

	bool Find(const Item::Function & item_fun,
			  typename Functions<StreamType>::UserFunction ** function,
			  Item ** item_block,
			  std::wstring ** variable);

	void CallFunction(typename Functions<StreamType>::UserFunction * function,
			  FunInfo<StreamType> & info);

	void CallFunction(typename Functions<StreamType>::UserFunction * function,
					  std::vector<Var> & parameters,
					  StreamType & out_stream,
					  const StreamType & in_stream);

	bool CallBlock(Item & item_block,
				   std::vector<Var> & parameters,
				   StreamType & out_stream);

	bool Call(Item::Function & item_fun,
			  StreamType & out_stream,
			  bool clear_out_stream,
			  const StreamType & in_stream);

	bool Call(Item::Function & item_fun);

	wchar_t CreateSpecialChar(wchar_t c);
	const wchar_t * PrintSpecialChar(const wchar_t * start, const wchar_t * end);
	void PrintSpecialText(const wchar_t * start, const wchar_t * end);
	void PrintNormalText(const wchar_t * start, const wchar_t * end);
	bool IsWhite(wchar_t c);
	void TrimWhite(const wchar_t *& start, const wchar_t *& end);
	void SkipWhite(const wchar_t *& str);
	size_t StrToSize(const wchar_t * str, const wchar_t ** str_end = 0);
	bool LookForLastForStatement(size_t & last_for_index);


	void WriteTmpStreamToStreams();
	void CreateMsg(std::wstring & out, const wchar_t * type, const wchar_t * arg = 0);
	void CreateMsg(const wchar_t * type, const wchar_t * arg = 0);
	void CreateMsg(const std::wstring & type, const std::wstring & arg);
	void CreateMsg(const std::wstring & type);
	void CreateUnknownMsg(const std::wstring & fun);
	bool LimitAchieved();

	void MakeTextIf_go(Item & item, bool result);
	bool MakeTextIfindexnumber(Item & item, size_t for_index, bool & result);
	void MakeTextIf(Item & item);
	void MakeTextIfno(Item & item);
	void MakeTextIfany(Item & item);
	void MakeTextIfone(Item & item);
	void MakeTextIfanyno(Item & item);
	void MakeTextIfoneno(Item & item);
	void MakeTextIfindex(Item & item);
	void MakeTextFor(Item & item);
	void MakeItemText(Item & item);
	void MakeTextContainer(Item & item);
	void MakeTextNormal(Item & item);
	void MakeTextIs(Item & item, bool equal);
	void MakeTextIs(Item & item);
	void MakeTextIsno(Item & item);
	void MakeTextDefine(Item & item);
	void MakeTextFilter(Item & item);
	void MakeTextEzc(Item & item);
	void MakeTextReturn(Item & item);
	void MakeText(Item & item);

	void MakeEzcStream(Item::Function & fun);

	void Generate();



}; // class Generator






template<class StreamType>
Generator<StreamType>::Generator() : empty_stream()
{
	output_stream = 0;
	ppattern      = 0;
	pblocks       = 0;
	pfunctions    = 0;

	max_items     = 50000;
	max_for_items = 5000;
	filter_size   = 20;
	special_chars = false;
	trim_white    = false;
	skip_new_line = false;
	is_generator_working = false;
	stack_size    = 300;
	block_stack_size = 64;
	has_skip_stream_index = false;
	can_find_in_cache = true;
	can_use_vars = true;
}


template<class StreamType>
Generator<StreamType>::Generator(const Generator<StreamType> & n)
{
	operator=(n);
}



template<class StreamType>
Generator<StreamType> & Generator<StreamType>::operator=(const Generator<StreamType> & n)
{
	// !! CHECK ME may output_streams should not be copied?
	output_stream_tab   = n.output_stream_tab;
	output_stream_index = n.output_stream_index;
	output_tmp_stream   = n.output_tmp_stream;
	output_stream       = n.output_stream;

	ppattern       = n.ppattern;
	pblocks        = n.pblocks;
	pfunctions     = n.pfunctions;

	max_items      = n.max_items;
	max_for_items  = n.max_for_items;
	special_chars  = n.special_chars;
	trim_white     = n.trim_white;
	skip_new_line  = n.skip_new_line;
	has_skip_stream_index = n.has_skip_stream_index;
	can_find_in_cache = n.can_find_in_cache;
	can_use_vars   = n.can_use_vars;

	// filter, stack and block_stack will be auto resized when calling Generate() method
	filter_size      = n.filter_size;
	stack_size       = n.stack_size;
	block_stack_size = n.block_stack_size;

	// vars doesn't have to be copied

	// don't copy filter tab
	// don't copy stack

	// !! CHECK ME
	// may copying should be denied when generator is working?
	// don't copy 'is_generator_working' flag
	is_generator_working = false;

return *this;
}



template<class StreamType>
Generator<StreamType>::~Generator()
{
	ClearFilterTab();
	ClearForStack();
	ClearBlockStack();
}


template<class StreamType>
void Generator<StreamType>::SetCommentary(const char * com_start, const char * com_stop)
{
	PT::UTF8ToWide(com_start, commentary_start);
	PT::UTF8ToWide(com_stop,  commentary_stop);
}



template<class StreamType>
void Generator<StreamType>::SetCommentary(const std::string & com_start, const std::string & com_stop)
{
	PT::UTF8ToWide(com_start, commentary_start);
	PT::UTF8ToWide(com_stop,  commentary_stop);
}



template<class StreamType>
void Generator<StreamType>::SetCommentary(const wchar_t * com_start, const wchar_t * com_stop)
{
	commentary_start = com_start;
	commentary_stop  = com_stop;
}



template<class StreamType>
void Generator<StreamType>::SetCommentary(const std::wstring & com_start, const std::wstring & com_stop)
{
	commentary_start = com_start;
	commentary_stop  = com_stop;
}



template<class StreamType>
void Generator<StreamType>::SetPattern(Pattern & pattern)
{
	ppattern = &pattern;
}




template<class StreamType>
void Generator<StreamType>::SetBlocks(Blocks & blocks)
{
	pblocks = &blocks;
}


template<class StreamType>
void Generator<StreamType>::SetFunctions(Functions<StreamType> & functions)
{
	pfunctions = &functions;
}


template<class StreamType>
void Generator<StreamType>::CanUseCache(bool can_use_cache)
{
	can_find_in_cache = can_use_cache;
}


template<class StreamType>
void Generator<StreamType>::CanUseVars(bool can_use_variables)
{
	can_use_vars = can_use_variables;
}



template<class StreamType>
void Generator<StreamType>::ResizeFilterTab()
{
	if( filter_tab.size() != filter_size )
	{
		if( filter_tab.size() < filter_size )
		{
			for(size_t i=filter_tab.size() ; i<filter_size ; ++i)
				filter_tab.push_back( new StreamType() );
		}
		else
		{
			for(size_t i=filter_size ; i<filter_tab.size() ; ++i)
				delete filter_tab[i];
			
			filter_tab.resize(filter_size);
		}
	}
}


template<class StreamType>
void Generator<StreamType>::ResizeStack()
{
	if( stack_tab.size() != stack_size )
	{
		if( stack_tab.size() > stack_size )
		{
			for(size_t i=stack_size ; i<stack_tab.size() ; ++i)
				RemoveStackFunData(stack_tab[i]);
		}

		stack_tab.resize(stack_size);
	}
}


template<class StreamType>
void Generator<StreamType>::ResizeBlockStack()
{
	if( block_stack_tab.size() != block_stack_size )
	{
		if( block_stack_tab.size() < block_stack_size )
		{
			size_t i = block_stack_tab.size();
			block_stack_tab.resize(block_stack_size);

			for( ; i<block_stack_tab.size() ; ++i)
				block_stack_tab[i].out_stream = new StreamType();
		}
		else
		{
			for(size_t i=block_stack_size ; i<block_stack_tab.size() ; ++i)
				delete block_stack_tab[i].out_stream;
			
			block_stack_tab.resize(block_stack_size);
		}
	}
}


template<class StreamType>
void Generator<StreamType>::ClearFilterTab()
{
	for(size_t i=0 ; i<filter_tab.size() ; ++i)
		delete filter_tab[i];
	
	filter_tab.clear();
}


template<class StreamType>
void Generator<StreamType>::ClearBlockStack()
{
	for(size_t i=0 ; i<block_stack_tab.size() ; ++i)
		delete block_stack_tab[i].out_stream;

	block_stack_tab.clear();
}


template<class StreamType>
void Generator<StreamType>::ClearForStack()
{
	for(size_t i=0 ; i<stack_tab.size() ; ++i)
		RemoveStackFunData(stack_tab[i]);
}


template<class StreamType>
void Generator<StreamType>::ClearStream(StreamType & str)
{
	#ifdef EZC_HAS_SPECIAL_STREAM
		str.Clear();
	#else
		str.str(L"");
	#endif
}


template<class StreamType>
void Generator<StreamType>::RemoveStackFunData(Stack & s)
{
	if( s.fun_data && s.auto_remove )
	{
		delete s.fun_data;
		s.fun_data = 0;
	}
}


template<class StreamType>
void Generator<StreamType>::SkipStream(int stream_index)
{
	if( stream_index < 0 )
	{
		has_skip_stream_index = false;
	}
	else
	{
		has_skip_stream_index = true;
		skip_stream_index     = stream_index;
	}
}



template<class StreamType>
template<class CharType>
CharType Generator<StreamType>::ToLower(CharType c)
{
	if( c>='A' && c<='Z' )
		return c - 'A' + 'a';

return c;
}



template<class StreamType>
bool Generator<StreamType>::AreStreamsEqual(StreamType & str1, StreamType & str2)
{
	#ifdef EZC_HAS_SPECIAL_STREAM
		return str1.Str() == str2.Str();
	#else
		return str1.str() == str2.str();
	#endif
}



template<class StreamType>
void Generator<StreamType>::SetMax(size_t max_items_, size_t max_for_items_)
{
	max_items     = max_items_;
	max_for_items = max_for_items_;
}


template<class StreamType>
void Generator<StreamType>::RecognizeSpecialChars(bool spec)
{
	special_chars = spec;
}


template<class StreamType>
void Generator<StreamType>::TrimWhite(bool trim)
{
	trim_white = trim;
}


template<class StreamType>
void Generator<StreamType>::SkipNewLine(bool skip)
{
	skip_new_line = skip;
}


template<class StreamType>
void Generator<StreamType>::SetMaxFilters(size_t new_len)
{
	// the table will be resized when Generate() method is called
	filter_size = new_len;
}


template<class StreamType>
void Generator<StreamType>::SetStackSize(size_t new_stack_size)
{
	// the stack will be resized when Generate() method is called
	stack_size = new_stack_size;
}



template<class StreamType>
void Generator<StreamType>::Generate()
{
	if( is_generator_working )
	{
		CreateMsg(L"generator busy");
		return;
	}

	output_stream = 0;
	output_stream_index.clear();
	ClearStream(output_tmp_stream);

	if( !output_stream_tab.empty() )
	{
		if( !has_skip_stream_index || skip_stream_index != 0 )
		{
			output_stream_index.push_back(0);
			output_stream = output_stream_tab[0];
		}
	}

	break_generating = false;
	current_item     = 0;

	// in the case that there something has left on the stack
	// from previous call to Generate()
	// (an exception could have been thrown)
	ClearForStack();

	ResizeFilterTab();
	ResizeStack();
	ResizeBlockStack();
	filter_index = 0;
	stack_index  = 0;
	block_stack_index = 0;
	vars.clear();

	if( ppattern )
	{
		try
		{
			is_generator_working = true;
			MakeText( ppattern->item_root );
			
			if( output_stream_index.size() > 1 )
				WriteTmpStreamToStreams();

			vars.clear();
			temp_var.str.clear();
			is_generator_working = false;
		}
		catch(...)
		{
			is_generator_working = false;
			throw;
		}
	}
}


template<class StreamType>
void Generator<StreamType>::Generate(StreamType & o)
{
	output_stream_tab.resize(1);
	output_stream_tab[0] = &o;

	Generate();
}



template<class StreamType>
void Generator<StreamType>::Generate(std::vector<StreamType> & o)
{
	output_stream_tab.resize(o.size());

	for(size_t i=0 ; i<o.size() ; ++i)
		output_stream_tab[i] = &o[i];

	Generate();
}


template<class StreamType>
void Generator<StreamType>::Generate(std::vector<StreamType*> & o)
{
	output_stream_tab.resize(o.size());

	for(size_t i=0 ; i<o.size() ; ++i)
		output_stream_tab[i] = o[i];

	Generate();
}


template<class StreamType>
bool Generator<StreamType>::FindInCache(const Item::Function & item_fun,
										typename Functions<StreamType>::UserFunction ** function,
										Item ** item_block,
										std::wstring ** variable)
{
	if( item_fun.arg >= 0 )
	{
		empty_argument.clear();
		*variable = &empty_argument;

		// it's a numeric function -- an argument to a block e.g.: [1]
		if( block_stack_index > 0 )
		{
			BlockStack & block_stack = block_stack_tab[block_stack_index-1];

			if( size_t(item_fun.arg) < block_stack.args.size() )
			{
				*variable = &block_stack.args[item_fun.arg].str;
				last_res  = block_stack.args[item_fun.arg].res;
			}
		}

		return true;
	}

	if( can_find_in_cache )
	{
		if( item_fun.fun_cache )
		{
			*function = reinterpret_cast<typename Functions<StreamType>::UserFunction*>(item_fun.fun_cache);
			return true;
		}

		if( item_fun.item_block )
		{
			*item_block = item_fun.item_block;
			return true;
		}
	}

return false;
}



template<class StreamType>
bool Generator<StreamType>::FindInFunctionsAndBlocks(const std::wstring & name,
													 typename Functions<StreamType>::UserFunction ** function,
													 Item ** item_block)
{
	if( pfunctions )
	{
		typename Functions<StreamType>::Iterator i = pfunctions->Find(name);

		if( i != pfunctions->End() )
		{
			*function = &i->second;
			return true;
		}
	}

	if( pblocks )
	{
		Blocks::Iterator i = pblocks->Find(name);

		if( i != pblocks->End() )
		{
			*item_block = &i->second;
			return true;
		}
	}

return false;
}


template<class StreamType>
bool Generator<StreamType>::FindInVariables(const std::wstring & name,
											std::wstring ** variable)
{
	Vars::iterator i = vars.find(name);

	if( i != vars.end() )
	{
		Var & var = i->second;

		*variable = &var.str;
		last_res  = var.res;
		return true;
	}

return false;
}


template<class StreamType>
bool Generator<StreamType>::Find(const Item::Function & item_fun,
								 typename Functions<StreamType>::UserFunction ** function,
								 Item ** item_block,
								 std::wstring ** variable)
{
	*function   = 0;
	*item_block = 0;
	*variable   = 0;

	if( FindInCache(item_fun, function, item_block, variable) )
		return true;

	if( FindInFunctionsAndBlocks(item_fun.name, function, item_block) )
		return true;

	if( FindInVariables(item_fun.name, variable) )
		return true;

	CreateUnknownMsg(item_fun.name);

return false;
}



template<class StreamType>
void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFunction * function, FunInfo<StreamType> & info)
{
	info.Clear();

	info.is_for    = is_generating_for;
	info.is_if     = is_generating_if;
	info.is_is     = is_generating_is;
	info.is_normal = is_generating_normal;
	info.is_filter = is_generating_filter;
	info.iter      = info.stack.iter;

	(*function)(info);

	last_res = info.res;
}



template<class StreamType>
void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFunction * function,
										 std::vector<Var> & parameters,
										 StreamType & out_stream,
										 const StreamType & in_stream)
{
	if( parameters.empty() )
	{
		FunInfo<StreamType> info(out_stream, parameters, empty, in_stream, stack_tab[stack_index-1]);
		CallFunction(function, info);
	}
	else
	{
		FunInfo<StreamType> info(out_stream, parameters, parameters[0].str, in_stream, stack_tab[stack_index-1]);
		CallFunction(function, info);
	}
}



template<class StreamType>
bool Generator<StreamType>::CallBlock(Item & item_block,
									  std::vector<Var> & parameters,
									  StreamType & out_stream)
{
	if( block_stack_index >= block_stack_tab.size() )
	{
		CreateMsg(L"Generator exceeded allowed number of blocks");
		return false;
	}

	StreamType * old_stream = output_stream;
	BlockStack & block_stack = block_stack_tab[block_stack_index];

	block_stack.was_return = false;
	block_stack.args = parameters;

	output_stream = block_stack.out_stream;
	ClearStream(*output_stream);
	block_stack_index += 1;

	MakeText(item_block);

	#ifdef EZC_HAS_SPECIAL_STREAM
		const std::wstring & str = output_stream->Str();
	#else
		const std::wstring & str = output_stream->str();
	#endif

	out_stream.write(str.c_str(), str.size());
	// last_res is set by [return ...] statement

	ClearStream(*output_stream);
	output_stream = old_stream;
	block_stack_index -= 1;

return true;
}


// return: true if a function or variable was found and called
template<class StreamType>
bool Generator<StreamType>::Call(Item::Function & item_fun,
								 StreamType & out_stream,
								 bool clear_out_stream,
								 const StreamType & in_stream)
{
typename Functions<StreamType>::UserFunction * fun;
Item * item_block;
std::wstring * variable;
std::vector<Var> parameters;

	if( clear_out_stream )
		ClearStream(out_stream);

	if( !Find(item_fun, &fun, &item_block, &variable) )
		return false;

	parameters.resize(item_fun.parameters.size());

	for(size_t i=0 ; i<item_fun.parameters.size() ; ++i)
	{
		Item::Function & fun_child = *item_fun.parameters[i];

		if( !fun_child.name.empty() )
		{
			StreamType local_temp_stream;
			Call(fun_child, local_temp_stream, true, empty_stream);

			#ifdef EZC_HAS_SPECIAL_STREAM
				parameters[i].str = local_temp_stream.Str();
			#else
				parameters[i].str = local_temp_stream.str();
			#endif

			parameters[i].res = last_res;
		}
		else
		{
			parameters[i].str = fun_child.par;
			parameters[i].res = !fun_child.par.empty();
		}
	}

	if( fun )
		CallFunction(fun, parameters, out_stream, in_stream);
	else
	if( item_block )
		return CallBlock(*item_block, parameters, out_stream);
	else
	if( variable )
		out_stream.write(variable->c_str(), variable->size());

return true;
}



// return: true if a function or variable was found and called
template<class StreamType>
bool Generator<StreamType>::Call(Item::Function & item_fun)
{
	return Call(item_fun, stream_temp1, true, empty_stream);
}




template<class StreamType>
wchar_t Generator<StreamType>::CreateSpecialChar(wchar_t c)
{
wchar_t res = 0;

	if( c == 'r' )
		res = '\r';
	else
	if( c == 'n' )
		res = '\n';
	else
	if( c == 't' )
		res = '\t';
	else
	if( c == 's' )
		res = ' ';
	else
	if( c == '\\' )
		res = '\\';

return res;
}



// a special character is precedeed by a slash '\'
// if the special character is unknown the first slash is printing
// so "\t" gives one character of code 9
// and "\x" gives "\x" 
template<class StreamType>
const wchar_t * Generator<StreamType>::PrintSpecialChar(const wchar_t * start, const wchar_t * end)
{
wchar_t special = 0;

	if( *start == '\\' && (start+1) != end )
		special = CreateSpecialChar(*(start+1));

	if( special )
	{
		output_stream->write(&special, 1);
		start += 2;
	}
	else
	{
		if( !skip_new_line || *start != 10 )
			output_stream->write(start, 1);

		start += 1;
	}

return start;
}


template<class StreamType>
void Generator<StreamType>::PrintSpecialText(const wchar_t * start, const wchar_t * end)
{
	if( output_stream )
	{
		while( start != end )
		{
			const wchar_t * end2 = start;

			// looking for a first new line character or a special char
			// (for new line only if skip_new_line is true)
			while( end2 != end && *end2 != '\\' && (!skip_new_line || *end2 != 10) )
				end2 += 1;

			// printing the first part of the text
			if( start != end2 )
				output_stream->write(start, end2 - start);

			start = end2;
			
			// skipping one or more new line characters or special chars
			// (new lines only if skip_new_line is true)
			while( start != end && (*start == '\\' || (skip_new_line && *start == 10)) )
				start = PrintSpecialChar(start, end);
		}
	}
}


template<class StreamType>
void Generator<StreamType>::PrintNormalText(const wchar_t * start, const wchar_t * end)
{
	if( output_stream )
	{
		if( skip_new_line )
		{
			while( start != end )
			{
				const wchar_t * end2 = start;

				// looking for a first new line character
				while( end2 != end && *end2 != 10 )
					end2 += 1;

				// printing the first part of the text (until the new line)
				if( start != end2 )
					output_stream->write(start, end2 - start);

				start = end2;
				
				// skipping one or more new line characters
				while( start != end && *start == 10 )
					start += 1;
			}
		}
		else
		{
			if( start != end )
				output_stream->write(start, end - start);
		}
	}
}


template<class StreamType>
bool Generator<StreamType>::IsWhite(wchar_t c)
{
	// 13 (\r) is from a dos file at the end of a line (\r\n)
	// 160 is a non-breaking space

	if( c==' ' || c=='\t' || c==13 || c==160 || c==10 )
		return true;

return false;
}


template<class StreamType>
void Generator<StreamType>::TrimWhite(const wchar_t *& start, const wchar_t *& end)
{
	while( start != end && IsWhite(*start) )
		++start;

	while( start != end && IsWhite(*(end-1)) )
		--end;
}


template<class StreamType>
void Generator<StreamType>::SkipWhite(const wchar_t *& str)
{
	while( IsWhite(*str) )
		str += 1;
}



template<class StreamType>
size_t Generator<StreamType>::StrToSize(const wchar_t * str, const wchar_t ** str_end)
{
size_t res = 0;

	SkipWhite(str);

	// !! IMPROVE ME
	// overflow is not checked

	while( *str>='0' && *str<='9' )
	{
		res *= 10;
		res += *str - '0';
		str += 1;
	}

	SkipWhite(str);

	if( str_end )
		*str_end = str;

return res;
}


template<class StreamType>
void Generator<StreamType>::WriteTmpStreamToStreams()
{
	#ifdef EZC_HAS_SPECIAL_STREAM
		const std::wstring & str = output_tmp_stream.Str();
	#else
		const std::wstring & str = output_tmp_stream.str();
	#endif


	if( !str.empty() )
	{
		for(size_t s = 0 ; s < output_stream_index.size() ; ++s)
		{
			size_t i = output_stream_index[s];

			if( i < output_stream_tab.size() )
				output_stream_tab[i]->write(str.c_str(), str.size());
		}

		ClearStream(output_tmp_stream);
	}
}



template<class StreamType>
void Generator<StreamType>::CreateMsg(std::wstring & out, const wchar_t * type, const wchar_t * arg)
{
	out = commentary_start;
	out += L"Ezc runtime error: ";
	out += type;

	if( arg )
	{
		out += ' ';
		out += arg;
	}

	out += commentary_stop;
}



template<class StreamType>
void Generator<StreamType>::CreateMsg(const wchar_t * type, const wchar_t * arg)
{
	if( output_stream )
	{
		CreateMsg(temp_msg, type, arg);
		output_stream->write(temp_msg.c_str(), temp_msg.size());
	}
}



template<class StreamType>
void Generator<StreamType>::CreateMsg(const std::wstring & type, const std::wstring & arg)
{
	CreateMsg(type.c_str(), arg.c_str());
}



template<class StreamType>
void Generator<StreamType>::CreateMsg(const std::wstring & type)
{
	CreateMsg(type.c_str());
}


template<class StreamType>
void Generator<StreamType>::CreateUnknownMsg(const std::wstring & fun)
{
	CreateMsg(L"unknown function", fun.c_str());
}




template<class StreamType>
void Generator<StreamType>::MakeItemText(Item & item)
{
const wchar_t * start = item.text.c_str();
const wchar_t * end   = item.text.c_str() + item.text.size();

	if( trim_white )
		TrimWhite(start, end);

	if( special_chars )
		PrintSpecialText(start, end);
	else
		PrintNormalText(start, end);
}


template<class StreamType>
void Generator<StreamType>::MakeTextContainer(Item & item)
{
	std::vector<Item*>::iterator i = item.item_tab.begin();

	for( ; i != item.item_tab.end() && !break_generating ; ++i )
		MakeText(**i);
}



template<class StreamType>
void Generator<StreamType>::MakeTextNormal(Item & item)
{
	if( item.functions.size() != 1 )
		return;

	is_generating_normal = true;

	if( output_stream )
	{
		Call(item.functions[0], *output_stream, false, empty_stream);
	}
	else
	{
		Call(item.functions[0], stream_temp1, false, empty_stream);
		ClearStream(stream_temp1);
	}
}



template<class StreamType>
void Generator<StreamType>::MakeTextIf_go(Item & item, bool result)
{
	if( result )
	{
		if( item.item_tab.size() > 0 )
			MakeText( *item.item_tab[0] );
	}
	else
	{
		// second element can be (or not -- it's from [else])
		if( item.item_tab.size() > 1 )
			MakeText( *item.item_tab[1] );
	}
}



template<class StreamType>
void Generator<StreamType>::MakeTextIf(Item & item)
{
	if( item.functions.size() != 1 )
		return;

	is_generating_if = true;

	if( !Call(item.functions[0]) )
		return;

	MakeTextIf_go(item, last_res);
}


template<class StreamType>
void Generator<StreamType>::MakeTextIfno(Item & item)
{
	if( item.functions.size() != 1 )
		return;

	is_generating_if = true;

	if( !Call(item.functions[0]) )
		return;

	MakeTextIf_go(item, !last_res);
}


template<class StreamType>
void Generator<StreamType>::MakeTextIfany(Item & item)
{
	std::vector<typename Item::Function>::iterator d = item.functions.begin();
	unsigned how_many_true = 0;

	is_generating_if = true;

	for( ; d != item.functions.end() ; ++d )
	{
		if( !Call(*d) )
			return;

		if( last_res )
			++how_many_true;
	}

	MakeTextIf_go(item, how_many_true == item.functions.size());
}


template<class StreamType>
void Generator<StreamType>::MakeTextIfone(Item & item)
{
	std::vector<typename Item::Function>::iterator d = item.functions.begin();
	unsigned how_many_true = 0;

	is_generating_if = true;

	for( ; d != item.functions.end() ; ++d )
	{
		if( Call(*d) )
		{
			if( last_res )
			{
				++how_many_true;
				break; // there is no sense to go through all functions
			}
		}
	}

	MakeTextIf_go(item, how_many_true > 0);
}


template<class StreamType>
void Generator<StreamType>::MakeTextIfanyno(Item & item)
{
	std::vector<typename Item::Function>::iterator d = item.functions.begin();
	unsigned how_many_true = 0;

	is_generating_if = true;

	for( ; d != item.functions.end() ; ++d )
	{
		if( !Call(*d) )
			return;

		if( last_res )
			++how_many_true;
	}

	MakeTextIf_go(item, how_many_true == 0);
}


template<class StreamType>
void Generator<StreamType>::MakeTextIfoneno(Item & item)
{
	std::vector<typename Item::Function>::iterator d = item.functions.begin();
	unsigned how_many_false = 0;

	is_generating_if = true;

	for( ; d != item.functions.end() ; ++d )
	{
		if( Call(*d) )
		{
			if( !last_res )
			{
				++how_many_false;
				break;
			}
		}
	}

	MakeTextIf_go(item, how_many_false > 0);
}



template<class StreamType>
void Generator<StreamType>::MakeTextIs(Item & item, bool equal)
{
	if( item.functions.size() != 2 )
		return;

	is_generating_is = true;

	if( !Call(item.functions[0], stream_temp1, true, empty_stream) )
		return;

	if( !Call(item.functions[1], stream_temp2, true, empty_stream) )
		return;

	bool res = AreStreamsEqual(stream_temp1, stream_temp2);

	if( !equal )
		res = !res;

	MakeTextIf_go(item, res);
}



template<class StreamType>
void Generator<StreamType>::MakeTextIs(Item & item)
{
	MakeTextIs(item, true);
}



template<class StreamType>
void Generator<StreamType>::MakeTextIsno(Item & item)
{
	MakeTextIs(item, false);
}



template<class StreamType>
bool Generator<StreamType>::LookForLastForStatement(size_t & last_for_index)
{
	last_for_index = stack_index;

	while( last_for_index-- > 0 )
	{
		if( stack_tab[last_for_index].is_for )
			return true;
	}

return false;
}



template<class StreamType>
bool Generator<StreamType>::MakeTextIfindexnumber(Item & item, size_t for_index, bool & result)
{
	if( item.functions.size() != 1 )
		return false;

	const wchar_t * number_text = item.functions[0].name.c_str();
	const wchar_t * last_char;

	size_t number = StrToSize(number_text, &last_char);

	if( *last_char != '\0' )
	{
		CreateMsg(L"if-index: syntax error");
		return false;
	}

	result = (stack_tab[for_index].iter == number);

return true;
}



template<class StreamType>
void Generator<StreamType>::MakeTextIfindex(Item & item)
{
size_t for_index;

	if( item.functions.size() != 1 || !LookForLastForStatement(for_index) )
		return;

	bool result = false;

	if( item.functions[0].name == L"odd" )
	{
		result = (stack_tab[for_index].iter & 1) == 1;
	}
	else
	if( item.functions[0].name == L"even" )
	{
		result = (stack_tab[for_index].iter & 1) == 0;
	}
	else
	if( item.functions[0].name == L"first" )
	{
		result = stack_tab[for_index].iter == 0;
	}
	else
	{
		if( !MakeTextIfindexnumber(item, for_index, result) )
			return;
	}

	MakeTextIf_go(item, result);
}



template<class StreamType>
void Generator<StreamType>::MakeTextFor(Item & item)
{
	if( item.functions.size() != 1 )
		return;

	stack_tab[stack_index-1].is_for = true;

	for( ; !break_generating ; stack_tab[stack_index-1].iter += 1 )
	{
		if( stack_tab[stack_index-1].iter >= max_for_items )
		{
			CreateMsg(item.functions[0].name.c_str(),
					  L"function exceeded a limit for a [for] statement");	
			break;
		}

		// is_generating_for will be changed by next call to MakeText()
		// so we should set it in each iterations
		is_generating_for = true;
		Call(item.functions[0], stream_temp1, true, empty_stream);

		if( !last_res )
			break;

		if( !item.item_tab.empty() )
			MakeText( *item.item_tab[0] ); // should be only one item - item_container
	}
}



template<class StreamType>
void Generator<StreamType>::MakeTextDefine(Item & item)
{
Item::Function * pfun = 0;

	if( !can_use_vars )
	{
		CreateMsg(L"[def] statement not available");
		return;
	}
	
	if( item.functions.size() == 1 &&
		item.functions[0].parameters.size() == 1 )
	{
		if( item.functions[0].parameters[0]->name.empty() )
		{
			// it is [def name "string"]
			temp_var.str = item.functions[0].parameters[0]->par;
			temp_var.res = !temp_var.str.empty();
			vars[item.functions[0].name] = temp_var;
		}
		else
		{
			// it is [def name [function "funpar"]]
			pfun = item.functions[0].parameters[0];
		}
	}
		
	if( item.functions.size() == 2 )
	{
		// is is [def name function "funpar"]
		pfun = &item.functions[1];
	}
	
	if( pfun )
	{
		if( Call(*pfun, stream_temp_define, true, empty_stream) )
		{
			#ifdef EZC_HAS_SPECIAL_STREAM
				temp_var.str = stream_temp_define.Str();
			#else
				temp_var.str = stream_temp_define.str();
			#endif

			temp_var.res = last_res;
			vars[item.functions[0].name] = temp_var;
		}
		else
		{
			CreateMsg(L"[def] unknown function/block/variable", pfun->name);
		}
	}
}




template<class StreamType>
void Generator<StreamType>::MakeTextFilter(Item & item)
{
	if( item.functions.size() != 1 )
		return;

	typename Functions<StreamType>::UserFunction * function;
	Item * item_block;
	std::wstring * variable;

	if( !Find(item.functions[0], &function, &item_block, &variable) )
		return;

	// IMPROVE ME
	// what about blocks and variables?
	// may when there is a block we can get the whole content from filter
	// and put it as the first argument to the block?
	if( !function )
		return;

	if( filter_index >= filter_tab.size() )
	{
		CreateMsg(L"Generator exceeded allowed number of filters");
		return;
	}

	
	StreamType * old_stream = output_stream;
	output_stream = filter_tab[filter_index];
	ClearStream(*output_stream);

	filter_index += 1;

	if( !item.item_tab.empty() )
		MakeText( *item.item_tab[0] ); // should be only one item - item_container

	is_generating_filter = true;

	if( old_stream )
	{
		//Call(function, item.functions[0].params, *old_stream, false, *output_stream);
		Call(item.functions[0], *old_stream, false, *output_stream);
	}
	else
	{
		//Call(function, item.functions[0].params, stream_temp1, true, *output_stream);
		Call(item.functions[0], stream_temp1, true, *output_stream);
		ClearStream(stream_temp1);
	}

	ClearStream(*output_stream);
	output_stream = old_stream;
	filter_index -= 1;
}



template<class StreamType>
void Generator<StreamType>::MakeEzcStream(Item::Function & fun)
{
	if( output_stream_index.size() > 1 )
		WriteTmpStreamToStreams();

	output_stream_index.clear();

	for(size_t i=0 ; i<fun.parameters.size() ; ++i)
	{
		size_t index = StrToSize(fun.parameters[i]->par.c_str()); // !! CHECK ME or ->name ?

		if( index < output_stream_tab.size() )
		{
			if( !has_skip_stream_index || skip_stream_index != index )
				output_stream_index.push_back(index);
		}

		// we do not print any information if the index is out of range
		// because we do not know to which stream is should be printed
	}

	if( output_stream_index.size() > 1 )
	{
		ClearStream(output_tmp_stream);
		output_stream = &output_tmp_stream;
	}
	else
	if( output_stream_index.size() == 1 )
	{
		size_t index  = output_stream_index[0];
		output_stream = output_stream_tab[index];
	}
	else
	{
		output_stream = 0;
	}
}


template<class StreamType>
void Generator<StreamType>::MakeTextEzc(Item & item)
{
	for(size_t i=0 ; i<item.functions.size() ; ++i)
	{
		if( item.functions[i].name == L"stream" )
			MakeEzcStream(item.functions[i]);
		else
			CreateMsg(L"incorrect argument to [ezc] statement");

		// in the future we can use more builtin functions
	}
}


template<class StreamType>
void Generator<StreamType>::MakeTextReturn(Item & item)
{
	last_res = false;

	if( block_stack_index == 0 )
	{
		// the [return] statement is not called from a [block]
		CreateMsg(L"[return] should be called from a [block]");
		return;
	}

	BlockStack & block_stack = block_stack_tab[block_stack_index - 1];
	block_stack.was_return = true;

	if( !item.functions.empty() )
	{
		// output stream in [return] statement is ignored
		// this Call() sets last_res which is used later when we return to CallBlock()
		Call(item.functions[0], stream_temp1, false, empty_stream);
		ClearStream(stream_temp1);
	}
}


template<class StreamType>
bool Generator<StreamType>::LimitAchieved()
{
	if( break_generating )
		return true;

	if( current_item >= max_items )
	{
		break_generating = true;
		CreateMsg(L"Generator exceeded allowed number of elements");	
		return true;
	}

	if( stack_index >= stack_tab.size() )
	{
		break_generating = true;
		CreateMsg(L"Generator exceeded the stack size");	
		return true;
	}

	if( block_stack_index > 0 )
	{
		BlockStack & block_stack = block_stack_tab[block_stack_index - 1];

		if( block_stack.was_return )
			return true;
	}

return false;
}


template<class StreamType>
void Generator<StreamType>::MakeText(Item & item)
{
	if( LimitAchieved() )
		return;

	current_item         += 1;
	stack_index          += 1;
	is_generating_for    = false;
	is_generating_if     = false;
	is_generating_is     = false;
	is_generating_normal = false;
	is_generating_filter = false;

	stack_tab[stack_index-1].Clear();

	if     ( item.type == Item::item_text )		MakeItemText(item);
	else if( item.type == Item::item_container )MakeTextContainer(item);
	else if( item.type == Item::item_normal )	MakeTextNormal(item);
	else if( item.type == Item::item_if )		MakeTextIf(item);
	else if( item.type == Item::item_ifno )		MakeTextIfno(item);
	else if( item.type == Item::item_ifany )	MakeTextIfany(item);
	else if( item.type == Item::item_ifone )	MakeTextIfone(item);
	else if( item.type == Item::item_ifanyno )	MakeTextIfanyno(item);
	else if( item.type == Item::item_ifoneno )	MakeTextIfoneno(item);
	else if( item.type == Item::item_ifindex )	MakeTextIfindex(item);
	else if( item.type == Item::item_is )		MakeTextIs(item);
	else if( item.type == Item::item_isno )		MakeTextIsno(item);
	else if( item.type == Item::item_def )		MakeTextDefine(item);
	else if( item.type == Item::item_for )		MakeTextFor(item);
	else if( item.type == Item::item_filter )	MakeTextFilter(item);
	else if( item.type == Item::item_ezc )		MakeTextEzc(item);
	else if( item.type == Item::item_return )	MakeTextReturn(item);
	else if( item.type == Item::item_err )
		CreateMsg(L"a wrong directive");

	RemoveStackFunData(stack_tab[stack_index-1]);
	stack_index -=1;
}




} // namespace Ezc


#endif