trunk/src/generator.h

/*
 * 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-2018, 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 "objects.h"
#include "outstreams.h"
#include <sstream>
#include <fstream>
#include <vector>
#include "expressionparser.h"


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 SetObjects(Objects<StreamType> & objects);


        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);

        // 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);

        void SetProgramMode(bool program_mode);

        void SetExpressionParser(ExpressionParser * expression_parser);


        // the main methods for generating
        void Generate(StreamType & out);
        void Generate(StreamType & out, OutStreams<StreamType> & out_streams);
        void Generate(OutStreams<StreamType> & out_streams);


        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;


        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 (can be null)
        // at the beginning it is pointing to the main stream (to the StreamType argument passsed to Generate method)
        StreamType * output_stream;

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

        // pointer to the output streams map (can be null)
        // output stream will be created when [ezc out "stream_name"] statement is found
        OutStreams<StreamType> * output_stream_map;

        // 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 ezc_out_stack_index;
        size_t ezc_out_stack_size;

        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;
        std::vector<StreamType*> ezc_out_stack_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..] [for...] or [def ...]
        // or if output_stream is null and an ezc function should be called
        StreamType stream_temp1, 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_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;
        bool program_mode;

        ExpressionParser * expression_parser;


        void ResizeStreamStack(std::vector<StreamType*> & stream_tab, size_t stream_tab_max_size);
        void ResizeFilterTab();
        void ResizeStack();
        void ResizeBlockStack();
        void ResizeEzcOutStack();

        void ClearStreamStack(std::vector<StreamType*> & stream_tab);
        void ClearFilterTab();
        void ClearForStack();
        void ClearBlockStack();
        void ClearEzcOutTab();

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

        bool ConvertToBool(const std::wstring & str);

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


        bool CheckBlockArgument(Item::Function & item_fun, std::wstring ** variable);

        bool FindInCache(Item::Function & item_fun,
                                         BaseObj<StreamType> ** base_obj,
                                         int * method_index,
                                         typename Functions<StreamType>::UserFunction ** function,
                                         Item ** item_block);

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


        bool Find(Item::Function & item_fun,
                          BaseObj<StreamType> ** base_obj,
                          int * method_index,
                          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);


        void CallObject(BaseObj<StreamType> * base_obj, int method_index, FunInfo<StreamType> & info);


        void CallObject(BaseObj<StreamType> * base_obj,
                                        int method_index,
                                        std::vector<Var> & parameters,
                                        StreamType & out_stream,
                                        const StreamType & in_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);


        void CopyTmpStreamToOutputStreams(Item::Function & fun, StreamType & ezc_out_tmp_stream, StreamType & previous_stream);
        void CreateMsg(std::wstring & out, const wchar_t * type, const wchar_t * arg = 0);
        void CreateMsg(StreamType & stream, 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 EvaluateProgramNode(Item & item);

        void MakeTextIf_go(Item & item, bool result);
        void MakeTextIf(Item & item);
        void MakeTextFor(Item & item);
        void MakeItemText(Item & item);
        void MakeTextContainer(Item & item);
        void MakeTextNormal(Item & item);
        void MakeTextDefine(Item & item);
        void MakeTextFilter(Item & item);
        void MakeTextEzc(Item & item);
        void MakeTextReturn(Item & item);
        void MakeText(Item & item);
        void MakeEzcOut(Item & item);

        void Generate();


}; // class Generator


template<class StreamType>
Generator<StreamType>::Generator() : empty_stream()
{
        ppattern      = 0;
        pblocks       = 0;
        pfunctions    = 0;
        pobjects      = 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;
        ezc_out_stack_size = 16;
        can_find_in_cache = true;
        can_use_vars = true;
        expression_parser = nullptr;
        program_mode = false;
}


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


template<class StreamType>
Generator<StreamType> & Generator<StreamType>::operator=(const Generator<StreamType> & n)
{
        ppattern       = n.ppattern;
        pblocks        = n.pblocks;
        pfunctions     = n.pfunctions;
        pobjects       = n.pobjects;

        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;
        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;
        ezc_out_stack_size = n.ezc_out_stack_size;
        expression_parser    = n.expression_parser;
        program_mode     = n.program_mode;

        // vars doesn't have to be copied

        // don't copy filter tab
        // don't copy stack
        // don't copy ezc_out_stack_tab
        // don't copy output_stream and output_stream_map

        // !! 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();
        ClearEzcOutTab();
}


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>::SetObjects(Objects<StreamType> & objects)
{
        pobjects = &objects;
}

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>::SetProgramMode(bool set_program_mode)
{
        this->program_mode = set_program_mode;
}

template<class StreamType>
void Generator<StreamType>::SetExpressionParser(ExpressionParser * expression_parser)
{
        this->expression_parser = expression_parser;
}


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>::ResizeStreamStack(std::vector<StreamType*> & stream_tab, size_t stream_tab_max_size)
{
        if( stream_tab.size() != stream_tab_max_size )
        {
                if( stream_tab.size() < stream_tab_max_size )
                {
                        size_t i = stream_tab.size();
                        stream_tab.resize(stream_tab_max_size);

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


template<class StreamType>
void Generator<StreamType>::ResizeFilterTab()
{
        ResizeStreamStack(filter_tab, filter_size);
}


template<class StreamType>
void Generator<StreamType>::ResizeEzcOutStack()
{
        ResizeStreamStack(ezc_out_stack_tab, ezc_out_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>::ClearStreamStack(std::vector<StreamType*> & stream_tab)
{
        for(size_t i=0 ; i<stream_tab.size() ; ++i)
                delete stream_tab[i];
        
        stream_tab.clear();
}


template<class StreamType>
void Generator<StreamType>::ClearFilterTab()
{
        ClearStreamStack(filter_tab);
}


template<class StreamType>
void Generator<StreamType>::ClearEzcOutTab()
{
        ClearStreamStack(ezc_out_stack_tab);
}


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>
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>::ConvertToBool(const std::wstring & str)
{
        if( str == L"true" )
                return true;

return false;
}


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;
        }

        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();
        ResizeEzcOutStack();
        filter_index = 0;
        stack_index  = 0;
        block_stack_index = 0;
        vars.clear();

        if( ppattern )
        {
                try
                {
                        is_generator_working = true;
                        MakeText( ppattern->item_root );
                        // !! IMPROVE ME we can print an error message if the stacks are not empty
                        // (some [end] statements has been omited)
                        vars.clear();
                        is_generator_working = false;
                }
                catch(...)
                {
                        is_generator_working = false;
                        throw;
                }
        }
}


template<class StreamType>
void Generator<StreamType>::Generate(StreamType & out)
{
        output_stream = &out;
        output_stream_map = 0;
        Generate();
}


template<class StreamType>
void Generator<StreamType>::Generate(StreamType & out, OutStreams<StreamType> & out_streams)
{
        output_stream = &out;
        output_stream_map = &out_streams;
        Generate();
}


template<class StreamType>
void Generator<StreamType>::Generate(OutStreams<StreamType> & out_streams)
{
        output_stream = 0;
        output_stream_map = &out_streams;
        Generate();
}


template<class StreamType>
bool Generator<StreamType>::CheckBlockArgument(Item::Function & item_fun, std::wstring ** variable)
{
        if( item_fun.arg < 0 )
                return false;

        empty_argument.clear();
        *variable = &empty_argument;
        last_res  = ConvertToBool(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;
}


template<class StreamType>
bool Generator<StreamType>::FindInCache(Item::Function & item_fun,
                                                                                BaseObj<StreamType> ** base_obj,
                                                                                int * method_index,
                                                                                typename Functions<StreamType>::UserFunction ** function,
                                                                                Item ** item_block)
{
        if( can_find_in_cache )
        {
                if( item_fun.base_obj )
                {
                        *base_obj = reinterpret_cast<BaseObj<StreamType> * >(item_fun.base_obj);
                        *method_index = item_fun.method_index;
                        return true;
                }

                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,
                                                                                                         BaseObj<StreamType> ** base_obj,
                                                                                                         int * method_index,
                                                                                                         typename Functions<StreamType>::UserFunction ** function,
                                                                                                         Item ** item_block)
{
        if( pobjects )
        {
                typename Objects<StreamType>::Iterator i = pobjects->Find(name, *method_index);

                if( i != pobjects->End() )
                {
                        *base_obj = *i;
                        return true;
                }
        }

        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(Item::Function & item_fun,
                                                                 BaseObj<StreamType> ** base_obj,
                                                                 int * method_index,
                                                                 typename Functions<StreamType>::UserFunction ** function,
                                                                 Item ** item_block,
                                                                 std::wstring ** variable)
{
        *base_obj = 0;
        *method_index = -1;
        *function   = 0;
        *item_block = 0;
        *variable   = 0;

        if( CheckBlockArgument(item_fun, variable) )
                return true;

        if( FindInCache(item_fun, base_obj, method_index, function, item_block) )
                return true;

        if( FindInFunctionsAndBlocks(item_fun.name, base_obj, method_index, 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_normal   = is_generating_normal;
        info.is_filter   = is_generating_filter;
        info.iter        = info.stack.iter;
        info.stack_tab   = &stack_tab[0];//stack_tab.data();/////////////////////////////////////////////////////////
        info.stack_index = stack_index-1;

        (*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], *stack_tab[stack_index-1].item);
                CallFunction(function, info);
        }
        else
        {
                FunInfo<StreamType> info(out_stream, parameters, parameters[0].str, in_stream, stack_tab[stack_index-1], *stack_tab[stack_index-1].item);
                CallFunction(function, info);
        }
}


template<class StreamType>
void Generator<StreamType>::CallObject(BaseObj<StreamType> * base_obj, int method_index, FunInfo<StreamType> & info)
{
        info.Clear();

        info.is_for      = is_generating_for;
        info.is_if       = is_generating_if;
        info.is_normal   = is_generating_normal;
        info.is_filter   = is_generating_filter;
        info.iter        = info.stack.iter;
        info.stack_tab   = &stack_tab[0];//stack_tab.data();/////////////////////////////////////////////////////////
        info.stack_index = stack_index-1;

        base_obj->CallFun(method_index, info);

        last_res = info.res;
}


template<class StreamType>
void Generator<StreamType>::CallObject(BaseObj<StreamType> * base_obj,
                                                                                int method_index,
                                                                                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], *stack_tab[stack_index-1].item);
                CallObject(base_obj, method_index, info);
        }
        else
        {
                FunInfo<StreamType> info(out_stream, parameters, parameters[0].str, in_stream, stack_tab[stack_index-1], *stack_tab[stack_index-1].item);
                CallObject(base_obj, method_index, 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 or other last evaluated function

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

return true;
}


// return: true if a function, variable or block 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)
{
BaseObj<StreamType> * base_obj;
int method_index;
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, &base_obj, &method_index, &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.is_function )
                {
                        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.name;
                        parameters[i].res = ConvertToBool(fun_child.name);
                }
        }

        if( base_obj )
                CallObject(base_obj, method_index, parameters, out_stream, in_stream);
        else
        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>::CopyTmpStreamToOutputStreams(Item::Function & fun, StreamType & ezc_out_tmp_stream, StreamType & previous_stream)
{
        if( output_stream_map )
        {
                #ifdef EZC_HAS_SPECIAL_STREAM
                        const std::wstring & str = ezc_out_tmp_stream.Str();
                #else
                        const std::wstring & str = ezc_out_tmp_stream.str();
                #endif

                if( !str.empty() )
                {
                        previous_stream.write(str.c_str(), str.size());

                        for(size_t s=0 ; s < fun.parameters.size() ; ++s)
                        {
                                std::wstring & name = fun.parameters[s]->name;
                                auto imap = output_stream_map->streams_map.find(name);

                                if( imap == output_stream_map->streams_map.end() )
                                {
                                        if( output_stream_map->streams_map.size() < output_stream_map->streams_tab.size() )
                                        {
                                                /* a new stream from the pool (output_stream_tab) is taken */
                                                StreamType * stream = output_stream_map->streams_tab[ output_stream_map->streams_map.size() ];
                                                output_stream_map->streams_map.insert(std::make_pair(name, stream));
                                                ClearStream(*stream);
                                                stream->write(str.c_str(), str.size());
                                        }
                                        else
                                        {
                                                CreateMsg(previous_stream, L"limit of output streams in OutStreams<> has been reached");
                                        }
                                }
                                else
                                {
                                        StreamType * stream = imap->second;
                                        stream->write(str.c_str(), str.size());
                                }
                        }
                }
        }
}


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(StreamType & stream, const wchar_t * type, const wchar_t * arg)
{
        CreateMsg(temp_msg, type, arg);
        stream.write(temp_msg.c_str(), temp_msg.size());
        temp_msg.clear();
}


template<class StreamType>
void Generator<StreamType>::CreateMsg(const wchar_t * type, const wchar_t * arg)
{
        if( output_stream )
                CreateMsg(*output_stream, type, arg);
}


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>::EvaluateProgramNode(Item & item)
{
        if( output_stream )
        {
                if( item.type == Item::item_function )
                        *output_stream << " expression: " << item.text;

                if( item.type == Item::item_if )
                        *output_stream << " if: " << item.text;

                if( item.type == Item::item_for )
                        *output_stream << " for: " << item.text;
        }

        last_res = false;

        if( expression_parser )
        {
                if( expression_parser->Parse(item.text) )
                {
                        last_res = expression_parser->LastResultToBool();

                        if( output_stream )
                        {
                                *output_stream << " -> " << expression_parser->LastResult();
                        }
                }
                else
                {
                        if( output_stream )
                        {
                                *output_stream << " -> syntax error when evaluating expression: error code: " << (int)expression_parser->LastError();
                        }
                }
        }

        if( output_stream )
        {
                *output_stream << "\n";
        }
}


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)
{
        is_generating_normal = true;

        if( program_mode )
        {
                EvaluateProgramNode(item);
        }
        else
        {
                if( output_stream )
                {
                        Call(item.function, *output_stream, false, empty_stream);
                }
                else
                {
                        Call(item.function, 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)
{
        is_generating_if = true;

        if( program_mode )
        {
                EvaluateProgramNode(item);
        }
        else
        {
                if( !Call(item.function) )
                        return;
        }

        MakeTextIf_go(item, last_res);
}


template<class StreamType>
void Generator<StreamType>::MakeTextFor(Item & item)
{
        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.function.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;

                if( program_mode )
                {
                        EvaluateProgramNode(item);
                }
                else
                {
                        Call(item.function, stream_temp1, true, empty_stream);
                }

                if( !last_res )
                        break;

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


template<class StreamType>
void Generator<StreamType>::MakeTextDefine(Item & item)
{
        if( !can_use_vars )
        {
                CreateMsg(L"[def] statement not available");
                return;
        }

        Var & var = vars[item.function.name];
        var.str.clear();
        var.res = false;
        
        for(size_t i=0 ; i < item.function.parameters.size() ; ++i)
        {
                if( !item.function.parameters[i]->is_function )
                {
                        var.str += item.function.parameters[i]->name;
                        var.res = ConvertToBool(item.function.parameters[i]->name);
                }
                else
                {
                        // it is a function parameter
                        if( Call(*item.function.parameters[i], stream_temp_define, true, empty_stream) )
                        {
                                #ifdef EZC_HAS_SPECIAL_STREAM
                                        var.str += stream_temp_define.Str();
                                #else
                                        var.str += stream_temp_define.str();
                                #endif

                                var.res = last_res;
                        }
                        else
                        {
                                CreateMsg(L"[def] unknown function/block/variable", item.function.name);
                        }
                }
        }
}


template<class StreamType>
void Generator<StreamType>::MakeTextFilter(Item & item)
{
        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(item.function, *old_stream, false, *output_stream);
        }
        else
        {
                Call(item.function, stream_temp1, true, *output_stream);
                ClearStream(stream_temp1);
        }

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


/*
        although we are using a stack for [etc out] there is no need for the stack now
        because the output is only a one-level map (not nested structure)
        but in the future we can use more complicated class like PT::Space
        and then nested [ezc out] statements can product a better output
*/
template<class StreamType>
void Generator<StreamType>::MakeEzcOut(Item & item)
{
std::vector<std::wstring*> output_stream_names;
StreamType * old_stream;
bool stream_added = true;

        if( ezc_out_stack_index >= ezc_out_stack_tab.size() )
        {
                CreateMsg(L"Generator exceeded allowed number of [ezc out] statements");
                return;
        }

        /*
                if we encounter the first ezc_out statement without arguments e.g. [ezc out] or just [out]
                then we can simply ignore it
        */
        if( item.function.parameters.empty() && ezc_out_stack_index == 0 )
                stream_added = false;

        if( stream_added )
        {
                old_stream = output_stream;
                output_stream = ezc_out_stack_tab[ezc_out_stack_index];
                ClearStream(*output_stream);
                ezc_out_stack_index += 1;
        }

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

        if( stream_added )
        {
                CopyTmpStreamToOutputStreams(item.function, *output_stream, *old_stream);
                ClearStream(*output_stream);
                output_stream = old_stream;
                ezc_out_stack_index -= 1;
        }
}


template<class StreamType>
void Generator<StreamType>::MakeTextEzc(Item & item)
{
        if( item.function.name == L"out" )
                MakeEzcOut(item);

        // 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.has_function )
        {
                // output stream in [return] statement is ignored (we use only the stream produced by the whole block)
                // this Call() sets last_res which is used later when we return to CallBlock()
                Call(item.function, 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_normal = false;
        is_generating_filter = false;

        stack_tab[stack_index-1].Clear();
        stack_tab[stack_index-1].item = &item;

        if     ( item.type == Item::item_text )         MakeItemText(item);
        else if( item.type == Item::item_container )MakeTextContainer(item);
        else if( item.type == Item::item_function )     MakeTextNormal(item);
        else if( item.type == Item::item_if )           MakeTextIf(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

