added: support for UTF-8 (files utf8.h utf8.cpp)

they can be even used without the rest library as only a library for converting between wide characters and UTF-8 changed: everywhere we use std::wstring instead of std::string changed: Generator and Functions are templates now they take a stream type renamed: Info to FunInfo and it is a template too taking a stream type now you can use other kind of streams with the library previous was only std::ostringstream git-svn-id: svn://ttmath.org/publicrep/ezc/trunk@326 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-22 01:23:32 +00:00
parent b5ea2514e2
commit 8f94937ed1
15 changed files with 3805 additions and 1997 deletions
--- a/src/generator.h
+++ b/src/generator.h
@@ -0,0 +1,996 @@
+/*
+ * This file is a part of EZC -- Easy templating in C++
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2007-2010, 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 "pattern.h"
+#include "functions.h"
+#include <sstream>
+#include <fstream>
+
+namespace Ezc
+{
+
+
+template<class StreamType>
+class Generator
+{
+public:
+
+	Generator();
+	Generator(StreamType & o, Pattern & p, Functions<StreamType> & f);
+
+	void Set(StreamType & o, Pattern & p, Functions<StreamType> & f);
+	void Set(StreamType & o);
+	void Set(Pattern & p);
+	void Set(Functions<StreamType> & f);
+	void SetMax(int max_items_, int 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 '\'
+	// 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);
+
+
+	void Generate();
+
+private:
+	
+	StreamType * output_stream;
+	Pattern   * pattern;
+	Functions<StreamType> * functions;
+	
+	// temporary error messages
+	std::wstring temp_msg;
+
+	bool break_generating;
+	int current_item;
+	int max_items;
+	int max_for_items;
+	bool special_chars;
+	bool trim_white;
+	bool skip_new_line;
+
+	// an empty string for info objects
+	// when there is no any parameters
+	const std::wstring empty;
+
+
+	void PutChar(wchar_t z, StreamType & out);
+	void PutStringGeneric(const wchar_t * start, size_t len, StreamType & out);
+	
+
+// !! tu bedzie chyba problem z kompilacja
+// kiedy typ strumienia to bedzie std::ostream
+// chwilowo zostawiam jak jest
+
+/*
+void PutString(const wchar_t * start, const wchar_t * end, std::ostream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+
+
+
+void PutString(const wchar_t * start, const wchar_t * end, std::iostream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+
+
+void PutString(const wchar_t * start, const wchar_t * end, std::ofstream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+
+
+void PutString(const wchar_t * start, const wchar_t * end, std::fstream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+
+
+void PutString(const wchar_t * start, const wchar_t * end, std::ostringstream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+
+
+void PutString(const wchar_t * start, const wchar_t * end, std::stringstream & out)
+{
+	PutStringGeneric(start, end-start, out);
+}
+*/
+
+
+
+	void PutString(const std::wstring & str, StreamType & out)
+	{
+		PutString(str.c_str(), str.c_str() + str.size(), out);
+	}
+
+	void PutString(const wchar_t * start, const wchar_t * end, StreamType & out)
+	{
+		out.write(start, end-start);
+	}
+
+
+
+	bool Find(const std::wstring & key, typename Functions<StreamType>::Function ** function);
+	
+	void Call(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info);
+	bool Call(const std::wstring & name, FunInfo<StreamType> & info, typename Functions<StreamType>::Function ** pfun = 0);
+	bool Call(typename Item::Function & function, bool * info_res = 0, typename Functions<StreamType>::Function ** pfun = 0);
+	
+	void CallUserFunction(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info);
+	void CallVariable(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info);
+	
+	wchar_t CreateSpecialChar(wchar_t c);
+	void PrintSpecialText(const wchar_t * start, const wchar_t * end);
+	void PrintNormalText(const wchar_t * start, const wchar_t * end);
+	void TrimWhite(const wchar_t *& start, const wchar_t *& end);
+	void SkipWhite(const wchar_t *& str);
+	int  StrToInt(const wchar_t * str, const wchar_t ** str_end);
+
+	void CreateMsg(StreamType & o, const wchar_t * type, const wchar_t * arg = 0);
+	void CreateMsg(StreamType & o, const std::wstring & type, const std::wstring & arg);
+	void CreateMsg(StreamType & o, const std::wstring & type);
+
+	void MakeTextIf_go(Item & item, bool result);
+	bool MakeTextIfindexnumber(Item & item, typename Functions<StreamType>::Function * function, 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 MakeTextForLoop(Item & item, typename Functions<StreamType>::Function * function);
+	void MakeTextFor(Item & item);
+	void MakeItemText(Item & item);
+	void MakeTextContainer(Item & item);
+	void MakeTextNormal(Item & item);
+	void MakeTextIs(Item & item);
+	void MakeTextIsno(Item & item);
+	void MakeTextDefine(Item & item);
+	void MakeText(Item & item);
+
+}; // class Generator
+
+
+
+template<class StreamType>
+void Generator<StreamType>::PutChar(wchar_t z, StreamType & out)
+{
+typedef typename StreamType::char_type CharType;
+
+	out << static_cast<CharType>(z);
+}
+
+/*
+template<class StreamType>
+void Generator<StreamType>::PutString(const wchar_t * start, const wchar_t * end, StreamType & out)
+{
+	out.write(start, end-start);
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::PutString(const std::wstring & str, StreamType & out)
+{
+	PutString(str.c_str(), str.c_str() + str.size(), out);
+}
+*/
+
+
+template<class StreamType>
+void Generator<StreamType>::PutStringGeneric(const wchar_t * start, size_t len, StreamType & out)
+{
+typedef typename StreamType::char_type CharType;
+
+	for(size_t i=0 ; i<len ; ++i)
+		out << static_cast<CharType>(start[i]);
+}
+
+
+
+
+template<class StreamType>
+Generator<StreamType>::Generator()
+{
+	output_stream = 0;
+	pattern       = 0;
+	functions     = 0;
+
+	max_items     = 50000;
+	max_for_items = 5000;
+	special_chars = false;
+	trim_white    = false;
+	skip_new_line = false;
+}
+
+
+template<class StreamType>
+Generator<StreamType>::Generator(StreamType & o, Pattern & p, Functions<StreamType> & f)
+{
+	output_stream = &o;
+	pattern       = &p;
+	functions     = &f;
+
+	max_items     = 50000;
+	max_for_items = 5000;
+	special_chars = false;
+	trim_white    = false;
+	skip_new_line = false;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::Set(StreamType & o, Pattern & p, Functions<StreamType> & f)
+{
+	output_stream = &o;
+	pattern       = &p;
+	functions     = &f;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::Set(StreamType & o)
+{
+	output_stream = &o;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::Set(Pattern & p)
+{
+	pattern = &p;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::Set(Functions<StreamType> & f)
+{
+	functions = &f;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::SetMax(int max_items_, int 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>::Generate()
+{
+	if( !output_stream || !pattern || !functions )
+		return;
+
+	break_generating = false;
+	current_item     = 0;
+
+	MakeText( pattern->item_root );
+}
+
+
+
+
+
+template<class StreamType>
+bool Generator<StreamType>::Find(const std::wstring & key, typename Functions<StreamType>::Function ** function)
+{
+	if( !functions->Find(key, function) )
+	{
+		CreateMsg(*output_stream, L"can't find", key.c_str() );
+		return false;
+	}
+	
+return true;	
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::CallUserFunction(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info)
+{
+	if( function->is_running )
+	{
+		// recurrences are not allowed
+		CreateMsg(*output_stream, L"the function is being executed");
+		return;
+	}
+
+	function->is_running = true;
+	(function->user_function)(info);
+	function->is_running = false;
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::CallVariable(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info)
+{
+	info.res = !function->variable.empty();
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::Call(typename Functions<StreamType>::Function * function, FunInfo<StreamType> & info)
+{
+	info.Clear();
+	info.iter = function->iter;
+
+	if( function->type == Functions<StreamType>::function )
+		CallUserFunction(function, info);
+	else
+		CallVariable(function, info);
+}
+
+
+// return: true if a function or variable was found and called
+template<class StreamType>
+bool Generator<StreamType>::Call(const std::wstring & name, FunInfo<StreamType> & info, typename Functions<StreamType>::Function ** pfun)
+{
+typename Functions<StreamType>::Function * function;
+
+	if( Find(name, &function) )
+	{
+		Call(function, info);
+		
+		if( pfun )	
+			*pfun = function;
+		
+		return true;
+	}
+	
+return false;
+}
+
+
+// return: true if a function or variable was found and called
+template<class StreamType>
+bool Generator<StreamType>::Call(typename Item::Function & function, bool * info_res, typename Functions<StreamType>::Function ** pfun)
+{
+bool called;
+
+	if( function.params.empty() )
+	{
+		FunInfo<StreamType> info(*output_stream, function.params, empty);
+		called = Call(function.name, info, pfun);
+
+		if( info_res )
+			*info_res = info.res;
+	}
+	else
+	{
+		FunInfo<StreamType> info(*output_stream, function.params, function.params[0]);
+		called = Call(function.name, info, pfun);
+
+		if( info_res )
+			*info_res = info.res;
+	}
+
+return called;
+}
+
+
+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;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::PrintSpecialText(const wchar_t * start, const wchar_t * end)
+{
+wchar_t special;
+
+	while( start != end )
+	{
+		special = 0;
+
+		if( *start == '\\' && (start+1) != end )
+			special = CreateSpecialChar(*(start+1));
+
+		if( special )
+		{
+			*output_stream << special;
+			start += 2;
+		}
+		else
+		{
+			if( !(skip_new_line && *start == 10) )
+				*output_stream << *start;
+
+			start += 1;
+		}
+	}
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::PrintNormalText(const wchar_t * start, const wchar_t * end)
+{
+	if( skip_new_line )
+	{
+		for( ; start != end ; ++start)
+		{
+			if( *start != 10 )
+				PutChar(*start, *output_stream);
+		}
+	}
+	else
+	{
+		if( start != end )
+			PutString(start, end, *output_stream);
+	}
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::TrimWhite(const wchar_t *& start, const wchar_t *& end)
+{
+	while( start != end && pattern->IsWhite(*start) )
+		++start;
+
+	while( start != end && pattern->IsWhite(*(end-1)) )
+		--end;
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::SkipWhite(const wchar_t *& str)
+{
+	while( pattern->IsWhite(*str) )
+		str += 1;
+}
+
+
+
+template<class StreamType>
+int Generator<StreamType>::StrToInt(const wchar_t * str, const wchar_t ** str_end)
+{
+int res = 0;
+
+	SkipWhite(str);
+
+	// overflow is not checked
+
+	while( *str>='0' && *str<='9' )
+	{
+		res *= 10;
+		res += *str - '0';
+		str += 1;
+	}
+
+	SkipWhite(str);
+	*str_end = str;
+
+return res;
+}
+
+
+
+
+template<class StreamType>
+void Generator<StreamType>::CreateMsg(StreamType & o, const wchar_t * type, const wchar_t * arg)
+{
+	pattern->CreateMsg(temp_msg, type, arg);
+	PutString(temp_msg, o);
+	temp_msg.clear();
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::CreateMsg(StreamType & o, const std::wstring & type, const std::wstring & arg)
+{
+	CreateMsg(o, type.c_str(), arg.c_str());
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::CreateMsg(StreamType & o, const std::wstring & type)
+{
+	CreateMsg(o, type.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;
+
+	typename Functions<StreamType>::Function * pfun;
+	bool called = Call(item.functions[0], 0, &pfun);
+
+	if( called && pfun->type == Functions<StreamType>::variable )
+		PutString(pfun->variable, *output_stream);
+}
+
+
+
+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)
+{
+bool info_res;
+
+	if( item.functions.size() != 1 )
+		return;
+
+	if( !Call(item.functions[0], &info_res) )
+		return;
+
+	MakeTextIf_go(item, info_res);
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextIfno(Item & item)
+{
+bool info_res;
+
+	if( item.functions.size() != 1 )
+		return;
+
+	if( !Call(item.functions[0], &info_res) )
+		return;
+
+	MakeTextIf_go(item, !info_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;
+	bool info_res;
+
+	for( ; d != item.functions.end() ; ++d )
+	{
+		if( !Call(*d, &info_res) )
+			return;
+
+		if( info_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;
+	bool info_res;
+
+	for( ; d != item.functions.end() ; ++d )
+	{
+		if( Call(*d, &info_res) && info_res )
+		{
+			// there is no sense to go through all functions
+			++how_many_true;
+			break;
+		}
+	}
+
+	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;
+	bool info_res;
+
+	for( ; d != item.functions.end() ; ++d )
+	{
+		if( !Call(*d, &info_res) )
+			return;
+
+		if( info_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;
+	bool info_res;
+
+	for( ; d != item.functions.end() ; ++d )
+	{
+		if( Call(*d, &info_res) && !info_res )
+			++how_many_false;
+	}
+
+	MakeTextIf_go(item, how_many_false > 0);
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextIs(Item & item)
+{
+bool info_res1, info_res2;
+
+	if( item.functions.size() != 2 )
+		return;
+
+	if( !Call(item.functions[0], &info_res1) )
+		return;
+
+	if( !Call(item.functions[1], &info_res2) )
+		return;
+	
+	MakeTextIf_go(item, info_res1 == info_res2);
+}
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextIsno(Item & item)
+{
+bool info_res1, info_res2;
+
+	if( item.functions.size() != 2 )
+		return;
+
+	if( !Call(item.functions[0], &info_res1) )
+		return;
+
+	if( !Call(item.functions[1], &info_res2) )
+		return;
+	
+	MakeTextIf_go(item, info_res1 != info_res2);
+}
+
+
+
+
+
+
+
+template<class StreamType>
+bool Generator<StreamType>::MakeTextIfindexnumber(Item & item, typename Functions<StreamType>::Function * function, bool & result)
+{
+	if( item.functions.size() != 2 )
+		return false;
+
+	const wchar_t * number_text = item.functions[1].name.c_str();
+	const wchar_t * last_char;
+
+	int number = StrToInt(number_text, &last_char);
+
+	if( *last_char != '\0' )
+	{
+		CreateMsg(*output_stream, L"if-index: syntax error");
+		return false;
+	}
+
+	result = (function->iter == number);
+
+return true;
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextIfindex(Item & item)
+{
+	if( item.functions.size() != 2 )
+		return;
+
+	// we actually don't call a function (or variable) here
+	// but only reading the iterator
+	
+	typename Functions<StreamType>::Function * function;
+
+	if( !Find(item.functions[0].name, &function) )
+		return;
+
+	bool result = false;
+
+
+	if( item.functions[1].name == L"odd" )
+	{
+		result = (function->iter & 1) == 1;
+	}
+	else
+	if( item.functions[1].name == L"even" )
+	{
+		result = (function->iter & 1) == 0;
+	}
+	else
+	if( item.functions[1].name == L"first" )
+	{
+		result = function->iter == 0;
+	}
+	else
+	{
+		if( !MakeTextIfindexnumber(item, function, result) )
+			return;
+	}
+
+	MakeTextIf_go(item, result);
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextForLoop(Item & item, typename Functions<StreamType>::Function * function)
+{
+bool info_res;
+
+	for( ; !break_generating ; function->iter += 1 )
+	{
+		if( function->iter >= max_for_items )
+		{
+			CreateMsg(*output_stream, item.functions[0].name.c_str(),
+					  L"function exceeded a limit for a [for] statement");	
+			break;
+		}
+
+		Call(item.functions[0], &info_res);
+
+		if( !info_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>::MakeTextFor(Item & item)
+{
+	if( item.functions.size() != 1 )
+		return;
+
+	typename Functions<StreamType>::Function * function;
+
+	if( !Find(item.functions[0].name, &function) )
+		return;
+
+	if( function->is_for )
+	{
+		CreateMsg(*output_stream, item.functions[0].name.c_str(),
+				  L"this function is already used in a [for] statement");	
+		return;
+	}
+	
+	function->is_for = true;
+	function->iter   = 0;
+
+	MakeTextForLoop(item, function);
+	
+	function->is_for = false;
+	function->iter   = 0;
+}
+
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeTextDefine(Item & item)
+{
+	if( item.functions.size() == 1 )
+	{
+		// inserting a new variable
+		if( item.functions[0].params.size() == 1 )
+			functions->Insert(item.functions[0].name, item.functions[0].params[0]);
+	}
+	else
+	if( item.functions.size() == 2 )
+	{
+		typename Functions<StreamType>::Function * function;
+		
+		if( Find(item.functions[1].name, &function) )
+		{
+			if( function->type == Functions<StreamType>::function )
+			{
+				// inserting a new function
+				functions->Insert(item.functions[0].name, function->user_function);
+			}
+			else
+			{
+				// inserting a new variable (the value is copied)
+				functions->Insert(item.functions[0].name, function->variable);
+			}
+		}
+	}
+}
+
+
+
+
+template<class StreamType>
+void Generator<StreamType>::MakeText(Item & item)
+{
+	if( break_generating )
+		return;
+		
+	if( ++current_item > max_items )
+	{
+		break_generating = true;
+		CreateMsg(*output_stream, L"Generator exceeded allowed number of elements");	
+		return;
+	}
+	
+	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_for )		MakeTextFor(item);
+	else if( item.type == Item::item_def )		MakeTextDefine(item);
+	else if( item.type == Item::item_err )
+		CreateMsg(*output_stream, L"a wrong directive");
+}
+
+
+
+
+} // namespace Ezc
+
+
+#endif