997 lines
22 KiB
C++
Executable File
997 lines
22 KiB
C++
Executable File
/*
|
|
* 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
|