From 44407c2a4b1bf4e07d64179d8defc1ac410f247e Mon Sep 17 00:00:00 2001
From: Tomasz Sowa <t.sowa@ttmath.org>
Date: Mon, 12 Jul 2021 23:00:11 +0200
Subject: [PATCH] changed: added two new parameters to Generator class:
 template<class StreamType, bool is_pikotools_stream = false, bool
 is_autoescape_stream = false> class Generator changed: added one new
 parameter to Outstreams class: template<class StreamType, bool
 is_pikotools_stream = false> class OutStreams removed macros:
 EZC_GENERATOR_HAS_PT_STREAM, EZC_GENERATOR_HAS_WINIX_STREAM

---
 src/generator.h  | 560 ++++++++++++++++++++++++-----------------------
 src/outstreams.h |  47 ++--
 2 files changed, 305 insertions(+), 302 deletions(-)

diff --git a/src/generator.h b/src/generator.h
index e83d30d..230b7c9 100644
--- a/src/generator.h
+++ b/src/generator.h
@@ -67,7 +67,7 @@ namespace Ezc
 StreamType
  we use only method write(const wchar_t * str, size_t len) from the stream
 */
-template<class StreamType>
+template<class StreamType, bool is_pikotools_stream = false, bool is_autoescape_stream = false>
 class Generator
 {
 public:
@@ -133,8 +133,8 @@ public:
 
 	// the main methods for generating
 	void Generate(StreamType & out);
-	void Generate(StreamType & out, OutStreams<StreamType> & out_streams);
-	void Generate(OutStreams<StreamType> & out_streams);
+	void Generate(StreamType & out, OutStreams<StreamType, is_pikotools_stream> & out_streams);
+	void Generate(OutStreams<StreamType, is_pikotools_stream> & out_streams);
 
 
 
@@ -202,7 +202,7 @@ private:
 
 	// pointer to the output streams map (can be null)
 	// output stream will be created when [ezc frame "stream_name"] statement is found
-	OutStreams<StreamType> * output_frames_streams;
+	OutStreams<StreamType, is_pikotools_stream> * output_frames_streams;
 
 	// temporary error messages
 	std::wstring temp_msg;
@@ -425,8 +425,8 @@ private:
 
 
 
-template<class StreamType>
-Generator<StreamType>::Generator() : empty_stream()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generator() : empty_stream()
 {
 	ppattern      = nullptr;
 	pblocks       = nullptr;
@@ -456,16 +456,17 @@ Generator<StreamType>::Generator() : empty_stream()
 }
 
 
-template<class StreamType>
-Generator<StreamType>::Generator(const Generator<StreamType> & n)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generator(const Generator<StreamType, is_pikotools_stream, is_autoescape_stream> & n)
 {
 	operator=(n);
 }
 
 
 
-template<class StreamType>
-Generator<StreamType> & Generator<StreamType>::operator=(const Generator<StreamType> & n)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+Generator<StreamType, is_pikotools_stream, is_autoescape_stream> &
+Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::operator=(const Generator<StreamType, is_pikotools_stream, is_autoescape_stream> & n)
 {
 	ppattern       = n.ppattern;
 	pblocks        = n.pblocks;
@@ -511,8 +512,8 @@ return *this;
 
 
 
-template<class StreamType>
-Generator<StreamType>::~Generator()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::~Generator()
 {
 	ClearFilterTab();
 	ClearForStack();
@@ -522,8 +523,8 @@ Generator<StreamType>::~Generator()
 
 
 
-template<class StreamType>
-void Generator<StreamType>::SetPattern(Pattern & pattern)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetPattern(Pattern & pattern)
 {
 	ppattern = &pattern;
 }
@@ -531,36 +532,36 @@ void Generator<StreamType>::SetPattern(Pattern & pattern)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::SetBlocks(Blocks & blocks)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetBlocks(Blocks & blocks)
 {
 	pblocks = &blocks;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetFunctions(Functions<StreamType> & functions)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetFunctions(Functions<StreamType> & functions)
 {
 	pfunctions = &functions;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetObjects(Objects<StreamType> & objects)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetObjects(Objects<StreamType> & objects)
 {
 	pobjects = &objects;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetVariables(Vars & variables)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetVariables(Vars & variables)
 {
 	pvars = &variables;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetLogger(pt::Log & logger)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetLogger(pt::Log & logger)
 {
 	plog = &logger;
 }
@@ -568,34 +569,34 @@ void Generator<StreamType>::SetLogger(pt::Log & logger)
 
 
 #ifdef EZC_HAS_MORM_LIBRARY
-template<class StreamType>
-void Generator<StreamType>::SetModels(Models & models)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetModels(Models & models)
 {
 	pmodels = &models;
 }
 #endif
 
-template<class StreamType>
-void Generator<StreamType>::CanUseCache(bool can_use_cache)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CanUseCache(bool can_use_cache)
 {
 	can_find_in_cache = can_use_cache;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::CanUseVars(bool can_use_variables)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CanUseVars(bool can_use_variables)
 {
 	can_use_vars = can_use_variables;
 }
 
-template<class StreamType>
-void Generator<StreamType>::SetProgramMode(bool set_program_mode)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetProgramMode(bool set_program_mode)
 {
 	this->program_mode = set_program_mode;
 }
 
-template<class StreamType>
-void Generator<StreamType>::SetExpressionParser(ExpressionParser * expression_parser)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetExpressionParser(ExpressionParser * expression_parser)
 {
 	this->expression_parser = expression_parser;
 }
@@ -603,8 +604,8 @@ void Generator<StreamType>::SetExpressionParser(ExpressionParser * expression_pa
 
 
 
-template<class StreamType>
-void Generator<StreamType>::ResizeStack()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ResizeStack()
 {
 	if( stack_tab.size() != stack_size )
 	{
@@ -620,8 +621,8 @@ void Generator<StreamType>::ResizeStack()
 
 
 
-template<class StreamType>
-void Generator<StreamType>::ResizeStreamStack(std::vector<StreamType*> & stream_tab, size_t stream_tab_max_size)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ResizeStreamStack(std::vector<StreamType*> & stream_tab, size_t stream_tab_max_size)
 {
 	if( stream_tab.size() != stream_tab_max_size )
 	{
@@ -644,22 +645,22 @@ void Generator<StreamType>::ResizeStreamStack(std::vector<StreamType*> & stream_
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ResizeFilterTab()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ResizeFilterTab()
 {
 	ResizeStreamStack(filter_tab, filter_size);
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ResizeEzcFrameStack()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ResizeEzcFrameStack()
 {
 	ResizeStreamStack(ezc_frame_stack_tab, ezc_frames_stack_size);
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ResizeBlockStack()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ResizeBlockStack()
 {
 	if( block_stack_tab.size() != block_stack_size )
 	{
@@ -683,8 +684,8 @@ void Generator<StreamType>::ResizeBlockStack()
 
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearStreamStack(std::vector<StreamType*> & stream_tab)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearStreamStack(std::vector<StreamType*> & stream_tab)
 {
 	for(size_t i=0 ; i<stream_tab.size() ; ++i)
 		delete stream_tab[i];
@@ -693,22 +694,22 @@ void Generator<StreamType>::ClearStreamStack(std::vector<StreamType*> & stream_t
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearFilterTab()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearFilterTab()
 {
 	ClearStreamStack(filter_tab);
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearEzcFrameTab()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearEzcFrameTab()
 {
 	ClearStreamStack(ezc_frame_stack_tab);
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearBlockStack()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearBlockStack()
 {
 	for(size_t i=0 ; i<block_stack_tab.size() ; ++i)
 		delete block_stack_tab[i].out_stream;
@@ -717,104 +718,104 @@ void Generator<StreamType>::ClearBlockStack()
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearForStack()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearForStack()
 {
 	for(size_t i=0 ; i<stack_tab.size() ; ++i)
 		RemoveStackFunData(stack_tab[i]);
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::ClearStream(StreamType & str)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ClearStream(StreamType & str)
 {
-	#ifdef EZC_GENERATOR_HAS_PT_STREAM
+	if constexpr(is_pikotools_stream)
+	{
 		str.clear();
-	#else
+	}
+	else
+	{
 		str.str(L"");
-	#endif
+	}
 }
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CopyStreamToString(StreamType & src_stream, std::wstring & dst_string)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CopyStreamToString(StreamType & src_stream, std::wstring & dst_string)
 {
 	if constexpr (sizeof(wchar_t) == sizeof(typename StreamType::char_type))
 	{
-		#ifdef EZC_GENERATOR_HAS_PT_STREAM
+		if constexpr(is_pikotools_stream)
+		{
 			src_stream.to_str(dst_string);
-		#else
+		}
+		else
+		{
 			dst_string = src_stream.str();
-		#endif
+		}
 	}
 	else
 	{
-		#ifdef EZC_GENERATOR_HAS_PT_STREAM
+		if constexpr(is_pikotools_stream)
+		{
 			src_stream.to_str(dst_string);
-		#else
+		}
+		else
+		{
 			std::string tmp = src_stream.str();
 			pt::utf8_to_wide(tmp, dst_string);
-		#endif
+		}
 	}
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::CopyStream(StreamType & src_stream, StreamType & dst_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CopyStream(StreamType & src_stream, StreamType & dst_stream)
 {
-	#ifdef EZC_GENERATOR_HAS_PT_STREAM
-		dst_stream << src_stream;
-	#else
-		dst_stream << src_stream.str();
-	#endif
-}
-
-
-template<class StreamType>
-void Generator<StreamType>::CopyStream(pt::WTextStream & src_stream, StreamType & dst_stream, bool should_escape)
-{
-	if constexpr(sizeof(char) == sizeof(typename StreamType::char_type))
+	if constexpr(is_pikotools_stream)
 	{
-	// winix html stream is always wide (wchar_t)
-	// so if we are here then the dst_stream cannot be a Winix::HtmlTextStream
-	#ifndef EZC_GENERATOR_HAS_WINIX_STREAM
-
-		wide_stream_to_utf8(src_stream, dst_stream, false);
-
-	#endif
+		dst_stream << src_stream;
 	}
 	else
 	{
-		pt::WTextStream::iterator i = src_stream.begin();
+		dst_stream << src_stream.str();
+	}
+}
 
-		while( i != src_stream.end() )
+
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CopyStream(pt::WTextStream & src_stream, StreamType & dst_stream, bool should_escape)
+{
+	if constexpr(is_autoescape_stream)
+	{
+		dst_stream.Escape(should_escape);
+		dst_stream << src_stream;
+	}
+	else
+	{
+		if constexpr(is_pikotools_stream)
 		{
-			#ifdef EZC_GENERATOR_HAS_WINIX_STREAM
-
-				// IMPROVEME we need a better api from winix htmltextstream
-
-				if( should_escape )
-				{
-					dst_stream << *i;
-				}
-				else
-				{
-					dst_stream.write(&(*i), 1);
-				}
-			#else
-				dst_stream.write(&(*i), 1);
-			#endif
-
-			++i;
+			dst_stream << src_stream;
+		}
+		else
+		{
+			if constexpr(sizeof(char) == sizeof(typename StreamType::char_type))
+			{
+				wide_stream_to_utf8(src_stream, dst_stream, false);
+			}
+			else
+			{
+				dst_stream << src_stream.to_str();
+			}
 		}
 	}
 }
 
 
 
-template<class StreamType>
-void Generator<StreamType>::RemoveStackFunData(Stack & s)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::RemoveStackFunData(Stack & s)
 {
 	if( s.fun_data && s.auto_remove )
 	{
@@ -824,9 +825,9 @@ void Generator<StreamType>::RemoveStackFunData(Stack & s)
 }
 
 
-template<class StreamType>
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
 template<class CharType>
-CharType Generator<StreamType>::ToLower(CharType c)
+CharType Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ToLower(CharType c)
 {
 	if( c>='A' && c<='Z' )
 		return c - 'A' + 'a';
@@ -835,52 +836,52 @@ return c;
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::ConvertToBool(const std::wstring & str)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ConvertToBool(const std::wstring & str)
 {
 	return !str.empty();
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetMax(size_t max_items_, size_t max_for_items_)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::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)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::RecognizeSpecialChars(bool spec)
 {
 	special_chars = spec;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::TrimWhite(bool trim)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::TrimWhite(bool trim)
 {
 	trim_white = trim;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SkipNewLine(bool skip)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SkipNewLine(bool skip)
 {
 	skip_new_line = skip;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SetMaxFilters(size_t new_len)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::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)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SetStackSize(size_t new_stack_size)
 {
 	// the stack will be resized when Generate() method is called
 	stack_size = new_stack_size;
@@ -888,8 +889,8 @@ void Generator<StreamType>::SetStackSize(size_t new_stack_size)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::Generate()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generate()
 {
 	if( is_generator_working )
 	{
@@ -933,18 +934,18 @@ void Generator<StreamType>::Generate()
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::Generate(StreamType & out)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generate(StreamType & out)
 {
 	output_stream = &out;
-	output_frames_streams = 0;
+	output_frames_streams = nullptr;
 	Generate();
 }
 
 
 
-template<class StreamType>
-void Generator<StreamType>::Generate(StreamType & out, OutStreams<StreamType> & out_streams)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generate(StreamType & out, OutStreams<StreamType, is_pikotools_stream> & out_streams)
 {
 	output_stream = &out;
 	output_frames_streams = &out_streams;
@@ -952,24 +953,24 @@ void Generator<StreamType>::Generate(StreamType & out, OutStreams<StreamType> &
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::Generate(OutStreams<StreamType> & out_streams)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Generate(OutStreams<StreamType, is_pikotools_stream> & out_streams)
 {
-	output_stream = 0;
+	output_stream = nullptr;
 	output_frames_streams = &out_streams;
 	Generate();
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::IsTestingFunctionExistence()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::IsTestingFunctionExistence()
 {
 	return is_generating_if_def || is_generating_if_not_def;
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::CheckBlockArgument(int arg_index, FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CheckBlockArgument(int arg_index, FindHelper & find_helper)
 {
 	if( arg_index < 0 )
 		return false;
@@ -991,8 +992,8 @@ bool Generator<StreamType>::CheckBlockArgument(int arg_index, FindHelper & find_
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::FindInCache(Item::Function & item_fun, FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindInCache(Item::Function & item_fun, FindHelper & find_helper)
 {
 	if( can_find_in_cache )
 	{
@@ -1023,8 +1024,8 @@ return false;
 
 #ifdef EZC_HAS_MORM_LIBRARY
 
-template<class StreamType>
-bool Generator<StreamType>::FindInModels(FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindInModels(FindHelper & find_helper)
 {
 	if( pmodels )
 	{
@@ -1043,8 +1044,8 @@ bool Generator<StreamType>::FindInModels(FindHelper & find_helper)
 #endif
 
 
-template<class StreamType>
-bool Generator<StreamType>::FindInFunctionsAndBlocks(const std::wstring & name, FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindInFunctionsAndBlocks(const std::wstring & name, FindHelper & find_helper)
 {
 	if( pobjects )
 	{
@@ -1083,8 +1084,8 @@ return false;
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::FindInVariables(const std::wstring & name, FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindInVariables(const std::wstring & name, FindHelper & find_helper)
 {
 	if( pvars )
 	{
@@ -1106,8 +1107,8 @@ bool Generator<StreamType>::FindInVariables(const std::wstring & name, FindHelpe
  * fun_name can be null, it is used only with [let ...] statements
  * and if not null then means: as a funcion name we are not using item_fun.name but fun_name
  */
-template<class StreamType>
-bool Generator<StreamType>::Find(Item::Function & item_fun, FindHelper & find_helper)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Find(Item::Function & item_fun, FindHelper & find_helper)
 {
 	#ifdef EZC_HAS_MORM_LIBRARY
 		if( FindInModels(find_helper) )
@@ -1140,8 +1141,8 @@ bool Generator<StreamType>::Find(Item::Function & item_fun, FindHelper & find_he
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::PrepareEnvStruct(FunInfo<StreamType> & info)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrepareEnvStruct(FunInfo<StreamType> & info)
 {
 	info.Clear();
 
@@ -1158,8 +1159,8 @@ void Generator<StreamType>::PrepareEnvStruct(FunInfo<StreamType> & info)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFunction & function, FunInfo<StreamType> & info)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallFunction(typename Functions<StreamType>::UserFunction & function, FunInfo<StreamType> & info)
 {
 	PrepareEnvStruct(info);
 	(function)(info);
@@ -1168,8 +1169,8 @@ void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFun
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFunction & function,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallFunction(typename Functions<StreamType>::UserFunction & function,
 										 std::vector<Var> & parameters,
 										 StreamType & out_stream,
 										 const StreamType & in_stream)
@@ -1192,8 +1193,8 @@ void Generator<StreamType>::CallFunction(typename Functions<StreamType>::UserFun
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallObject(BaseObj<StreamType> & base_obj, int method_index, FunInfo<StreamType> & info)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallObject(BaseObj<StreamType> & base_obj, int method_index, FunInfo<StreamType> & info)
 {
 	PrepareEnvStruct(info);
 	base_obj.CallFun(method_index, info);
@@ -1203,8 +1204,8 @@ void Generator<StreamType>::CallObject(BaseObj<StreamType> & base_obj, int metho
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::HasParam(std::vector<Var> & parameters, const wchar_t * param1, const wchar_t * param2)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::HasParam(std::vector<Var> & parameters, const wchar_t * param1, const wchar_t * param2)
 {
 	for(Var & var : parameters)
 	{
@@ -1222,37 +1223,37 @@ bool Generator<StreamType>::HasParam(std::vector<Var> & parameters, const wchar_
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::ShouldMakeSpaceDump(std::vector<Var> & parameters)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ShouldMakeSpaceDump(std::vector<Var> & parameters)
 {
 	return HasParam(parameters, L"dump", L"dump_to_space");
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::ShouldMakeJsonDump(std::vector<Var> & parameters)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::ShouldMakeJsonDump(std::vector<Var> & parameters)
 {
 	return HasParam(parameters, L"dump_to_json");
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::IsCurrentParam(std::vector<Var> & parameters)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::IsCurrentParam(std::vector<Var> & parameters)
 {
 	return HasParam(parameters, L"current");
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::IsPrettyPrint(std::vector<Var> & parameters)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::IsPrettyPrint(std::vector<Var> & parameters)
 {
 	return HasParam(parameters, L"pretty");
 }
 
 
 
-template<class StreamType>
-void Generator<StreamType>::DumpSpaceIfNeeded(std::vector<Var> & parameters, StreamType & out_stream, pt::Space * space)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::DumpSpaceIfNeeded(std::vector<Var> & parameters, StreamType & out_stream, pt::Space * space)
 {
 	bool dump_space = ShouldMakeSpaceDump(parameters);
 	bool dump_json = ShouldMakeJsonDump(parameters);
@@ -1274,8 +1275,8 @@ void Generator<StreamType>::DumpSpaceIfNeeded(std::vector<Var> & parameters, Str
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::DumpModelIfNeeded(morm::Model & model, std::vector<Var> & parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::DumpModelIfNeeded(morm::Model & model, std::vector<Var> & parameters, StreamType & out_stream)
 {
 	bool dump_space = ShouldMakeSpaceDump(parameters);
 	bool dump_json = ShouldMakeJsonDump(parameters);
@@ -1303,8 +1304,8 @@ void Generator<StreamType>::DumpModelIfNeeded(morm::Model & model, std::vector<V
 
 
 
-template<class StreamType>
-void Generator<StreamType>::PrintDate(pt::Date * date, std::vector<Var> parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate(pt::Date * date, std::vector<Var> parameters, StreamType & out_stream)
 {
 	bool is_roman = HasParam(parameters, L"roman");
 	bool is_no_sec = HasParam(parameters, L"no_sec");
@@ -1313,8 +1314,8 @@ void Generator<StreamType>::PrintDate(pt::Date * date, std::vector<Var> paramete
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::PrintDatePart(pt::Date * date, const std::wstring & field, std::vector<Var> parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDatePart(pt::Date * date, const std::wstring & field, std::vector<Var> parameters, StreamType & out_stream)
 {
 	bool is_test = IsTestingFunctionExistence();
 
@@ -1369,8 +1370,8 @@ bool Generator<StreamType>::PrintDatePart(pt::Date * date, const std::wstring &
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallDate(FindHelper & find_helper, std::vector<std::wstring> & fields, std::vector<Var> parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallDate(FindHelper & find_helper, std::vector<std::wstring> & fields, std::vector<Var> parameters, StreamType & out_stream)
 {
 	bool found = true;
 	bool all_fields_known = (find_helper.field_index == fields.size());
@@ -1409,8 +1410,8 @@ bool Generator<StreamType>::CallDate(FindHelper & find_helper, std::vector<std::
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallSpaceObjectForLastField(std::vector<Var> & parameters, StreamType & out_stream, pt::Space * space)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpaceObjectForLastField(std::vector<Var> & parameters, StreamType & out_stream, pt::Space * space)
 {
 	if( !IsTestingFunctionExistence() )
 	{
@@ -1420,8 +1421,8 @@ void Generator<StreamType>::CallSpaceObjectForLastField(std::vector<Var> & param
 }
 
 
-template<class StreamType>
-pt::Space * Generator<StreamType>::CallSpaceObjectForMiddleField(std::wstring & root_space_name, std::vector<std::wstring> & fields, size_t field_index, pt::Space * space)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+pt::Space * Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpaceObjectForMiddleField(std::wstring & root_space_name, std::vector<std::wstring> & fields, size_t field_index, pt::Space * space)
 {
 	std::wstring & next_field = fields[field_index];
 	space = space->get_space(next_field);
@@ -1436,8 +1437,8 @@ pt::Space * Generator<StreamType>::CallSpaceObjectForMiddleField(std::wstring &
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallSpaceTableForLastField(morm::SpaceWrapper & space_wrapper, std::vector<Var> & parameters, StreamType & out_stream,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpaceTableForLastField(morm::SpaceWrapper & space_wrapper, std::vector<Var> & parameters, StreamType & out_stream,
 													   pt::Space * space, size_t model_wrapper_space_table_index)
 {
 	pt::Space::TableType * table = space->get_table();
@@ -1473,8 +1474,8 @@ void Generator<StreamType>::CallSpaceTableForLastField(morm::SpaceWrapper & spac
 }
 
 
-template<class StreamType>
-pt::Space * Generator<StreamType>::CallSpaceTableForMiddleField(morm::SpaceWrapper & space_wrapper, std::wstring & root_space_name, std::vector<std::wstring> & fields,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+pt::Space * Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpaceTableForMiddleField(morm::SpaceWrapper & space_wrapper, std::wstring & root_space_name, std::vector<std::wstring> & fields,
 																size_t field_index, pt::Space * space, size_t model_wrapper_space_table_index)
 {
 	pt::Space::TableType * table = space->get_table();
@@ -1497,8 +1498,8 @@ pt::Space * Generator<StreamType>::CallSpaceTableForMiddleField(morm::SpaceWrapp
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::PrintLastSpaceField(pt::Space * space, std::vector<Var> & parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintLastSpaceField(pt::Space * space, std::vector<Var> & parameters, StreamType & out_stream)
 {
 	bool no_escape = HasParam(parameters, L"raw", L"noescape");
 
@@ -1516,8 +1517,8 @@ void Generator<StreamType>::PrintLastSpaceField(pt::Space * space, std::vector<V
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallSpace(FindHelper & find_helper, std::vector<std::wstring> & fields, std::vector<Var> & parameters, StreamType & out_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpace(FindHelper & find_helper, std::vector<std::wstring> & fields, std::vector<Var> & parameters, StreamType & out_stream)
 {
 	morm::SpaceWrapper * space_wrapper = find_helper.wrapper->space_wrapper;
 	pt::Space * space = space_wrapper->get_space();
@@ -1602,8 +1603,8 @@ bool Generator<StreamType>::CallSpace(FindHelper & find_helper, std::vector<std:
 
 #ifdef EZC_HAS_MORM_LIBRARY
 
-template<class StreamType>
-bool Generator<StreamType>::CallModelField(morm::Model & model, const std::wstring & field, std::vector<Var> parameters, StreamType & out_stream, const StreamType & in_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModelField(morm::Model & model, const std::wstring & field, std::vector<Var> parameters, StreamType & out_stream, const StreamType & in_stream)
 {
 	/*
 	 * if 'field' is a POD type then 'str' will be used in get_raw_value()
@@ -1637,8 +1638,8 @@ bool Generator<StreamType>::CallModelField(morm::Model & model, const std::wstri
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallModel(morm::Model & model, FindHelper & find_helper, std::vector<std::wstring> & fields,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModel(morm::Model & model, FindHelper & find_helper, std::vector<std::wstring> & fields,
 									  std::vector<Var> parameters, StreamType & out_stream, const StreamType & in_stream)
 {
 	bool found = true;
@@ -1680,8 +1681,8 @@ bool Generator<StreamType>::CallModel(morm::Model & model, FindHelper & find_hel
 
 
 
-template<class StreamType>
-void Generator<StreamType>::FindLastModelWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindLastModelWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields)
 {
 	for(find_helper.field_index = 0 ; find_helper.field_index < fields.size() && find_helper.wrapper->has_model_object() ; ++find_helper.field_index)
 	{
@@ -1722,8 +1723,8 @@ void Generator<StreamType>::FindLastModelWrapper(FindHelper & find_helper, std::
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields,
 										   std::vector<Var> parameters, StreamType & out_stream, const StreamType & in_stream)
 {
 	bool found = true;
@@ -1794,8 +1795,8 @@ bool Generator<StreamType>::CallWrapper(FindHelper & find_helper, std::vector<st
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CallObject(BaseObj<StreamType> & base_obj,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallObject(BaseObj<StreamType> & base_obj,
 										int method_index,
 										std::vector<Var> & parameters,
 										StreamType & out_stream,
@@ -1818,8 +1819,8 @@ void Generator<StreamType>::CallObject(BaseObj<StreamType> & base_obj,
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallBlock(Item & item_block,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallBlock(Item & item_block,
 									  std::vector<Var> & parameters,
 									  StreamType & out_stream)
 {
@@ -1856,8 +1857,8 @@ return true;
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::CallVariable(Item::Function & item_fun, Var & variable, std::vector<Var> & parameters, StreamType & out_stream, const StreamType & in_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallVariable(Item::Function & item_fun, Var & variable, std::vector<Var> & parameters, StreamType & out_stream, const StreamType & in_stream)
 {
 	if( variable.is_function )
 	{
@@ -1882,8 +1883,8 @@ bool Generator<StreamType>::CallVariable(Item::Function & item_fun, Var & variab
  *
  * return: true if a function, variable or block was found and called (evaluated)
  */
-template<class StreamType>
-bool Generator<StreamType>::Call(Item::Function & item_fun,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Call(Item::Function & item_fun,
 								 std::wstring * fun_name,
 								 StreamType & out_stream,
 								 bool clear_out_stream,
@@ -1895,6 +1896,9 @@ std::vector<Var> parameters;
 	if( clear_out_stream )
 		ClearStream(out_stream);
 
+	if constexpr(is_autoescape_stream)
+		out_stream.Escape(true);
+
 	find_helper.fun_name = fun_name;
 
 	if( !find_helper.fun_name )
@@ -1947,8 +1951,8 @@ std::vector<Var> parameters;
 
 
 // return: true if a function or variable was found and called
-template<class StreamType>
-bool Generator<StreamType>::Call(Item::Function & item_fun)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::Call(Item::Function & item_fun)
 {
 	return Call(item_fun, nullptr, stream_temp1, true, empty_stream);
 }
@@ -1956,8 +1960,8 @@ bool Generator<StreamType>::Call(Item::Function & item_fun)
 
 
 
-template<class StreamType>
-wchar_t Generator<StreamType>::CreateSpecialChar(wchar_t c)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+wchar_t Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CreateSpecialChar(wchar_t c)
 {
 wchar_t res = 0;
 
@@ -1985,8 +1989,8 @@ return res;
 // 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)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+const wchar_t * Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintSpecialChar(const wchar_t * start, const wchar_t * end)
 {
 wchar_t special = 0;
 
@@ -2010,8 +2014,8 @@ return start;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::PrintSpecialText(const wchar_t * start, const wchar_t * end)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintSpecialText(const wchar_t * start, const wchar_t * end)
 {
 	if( output_stream )
 	{
@@ -2039,8 +2043,8 @@ void Generator<StreamType>::PrintSpecialText(const wchar_t * start, const wchar_
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::PrintNormalText(const wchar_t * start, const wchar_t * end)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintNormalText(const wchar_t * start, const wchar_t * end)
 {
 	if( output_stream )
 	{
@@ -2074,8 +2078,8 @@ void Generator<StreamType>::PrintNormalText(const wchar_t * start, const wchar_t
 }
 
 
-template<class StreamType>
-bool Generator<StreamType>::IsWhite(wchar_t c)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::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
@@ -2087,8 +2091,8 @@ return false;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::TrimWhite(const wchar_t *& start, const wchar_t *& end)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::TrimWhite(const wchar_t *& start, const wchar_t *& end)
 {
 	while( start != end && IsWhite(*start) )
 		++start;
@@ -2098,8 +2102,8 @@ void Generator<StreamType>::TrimWhite(const wchar_t *& start, const wchar_t *& e
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::SkipWhite(const wchar_t *& str)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::SkipWhite(const wchar_t *& str)
 {
 	while( IsWhite(*str) )
 		str += 1;
@@ -2107,8 +2111,8 @@ void Generator<StreamType>::SkipWhite(const wchar_t *& str)
 
 
 
-template<class StreamType>
-size_t Generator<StreamType>::StrToSize(const wchar_t * str, const wchar_t ** str_end)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+size_t Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::StrToSize(const wchar_t * str, const wchar_t ** str_end)
 {
 size_t res = 0;
 
@@ -2133,8 +2137,8 @@ return res;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::CopyTmpStreamToOutputStreams(Item::Function & fun, StreamType & ezc_out_tmp_stream, StreamType & previous_stream)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CopyTmpStreamToOutputStreams(Item::Function & fun, StreamType & ezc_out_tmp_stream, StreamType & previous_stream)
 {
 	if( output_frames_streams )
 	{
@@ -2172,8 +2176,8 @@ void Generator<StreamType>::CopyTmpStreamToOutputStreams(Item::Function & fun, S
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CreateMsg(const wchar_t * type, const wchar_t * arg)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CreateMsg(const wchar_t * type, const wchar_t * arg)
 {
 	if( plog )
 	{
@@ -2190,8 +2194,8 @@ void Generator<StreamType>::CreateMsg(const wchar_t * type, const wchar_t * arg)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CreateMsg(const wchar_t * type, const std::wstring & model_name, std::vector<std::wstring> & fields, size_t how_many_fields_print,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CreateMsg(const wchar_t * type, const std::wstring & model_name, std::vector<std::wstring> & fields, size_t how_many_fields_print,
 									  const wchar_t * arg, const wchar_t * arg2, const wchar_t * arg3)
 {
 	if( plog )
@@ -2223,8 +2227,8 @@ void Generator<StreamType>::CreateMsg(const wchar_t * type, const std::wstring &
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::CreateMsg(const wchar_t * type, const std::wstring & model_name, std::vector<std::wstring> & fields,
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CreateMsg(const wchar_t * type, const std::wstring & model_name, std::vector<std::wstring> & fields,
 									  const wchar_t * arg, const wchar_t * arg2, const wchar_t * arg3)
 {
 
@@ -2233,24 +2237,24 @@ void Generator<StreamType>::CreateMsg(const wchar_t * type, const std::wstring &
 
 
 
-template<class StreamType>
-void Generator<StreamType>::CreateMsg(const std::wstring & type, const std::wstring & arg)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::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)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CreateMsg(const std::wstring & type)
 {
 	CreateMsg(type.c_str());
 }
 
 
 
-template<class StreamType>
-void Generator<StreamType>::EvaluateProgramNode(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::EvaluateProgramNode(Item & item)
 {
 	if( output_stream )
 	{
@@ -2294,8 +2298,8 @@ void Generator<StreamType>::EvaluateProgramNode(Item & item)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeItemText(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeItemText(Item & item)
 {
 const wchar_t * start = item.text.c_str();
 const wchar_t * end   = item.text.c_str() + item.text.size();
@@ -2310,8 +2314,8 @@ const wchar_t * end   = item.text.c_str() + item.text.size();
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextContainer(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextContainer(Item & item)
 {
 	std::vector<Item*>::iterator i = item.item_tab.begin();
 
@@ -2321,8 +2325,8 @@ void Generator<StreamType>::MakeTextContainer(Item & item)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextFunction(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextFunction(Item & item)
 {
 	is_generating_normal = true;
 
@@ -2346,8 +2350,8 @@ void Generator<StreamType>::MakeTextFunction(Item & item)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextIf_go(Item & item, bool result)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextIf_go(Item & item, bool result)
 {
 	if( result )
 	{
@@ -2364,8 +2368,8 @@ void Generator<StreamType>::MakeTextIf_go(Item & item, bool result)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextIf(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextIf(Item & item)
 {
 	is_generating_if = true;
 
@@ -2383,8 +2387,8 @@ void Generator<StreamType>::MakeTextIf(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextIfDef(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextIfDef(Item & item)
 {
 	is_generating_if_def = true;
 
@@ -2402,8 +2406,8 @@ void Generator<StreamType>::MakeTextIfDef(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextIfNotDef(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextIfNotDef(Item & item)
 {
 	is_generating_if_not_def = true;
 
@@ -2421,8 +2425,8 @@ void Generator<StreamType>::MakeTextIfNotDef(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextFor(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextFor(Item & item)
 {
 	stack_tab[stack_index-1].is_for = true;
 
@@ -2457,8 +2461,8 @@ void Generator<StreamType>::MakeTextFor(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextDefine(Item & item, Var & var)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextDefine(Item & item, Var & var)
 {
 	var.str.clear();
 	var.res = ConvertToBool(var.str);
@@ -2498,8 +2502,8 @@ void Generator<StreamType>::MakeTextDefine(Item & item, Var & var)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextDefine(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextDefine(Item & item)
 {
 	if( !can_use_vars || !pvars )
 	{
@@ -2512,8 +2516,8 @@ void Generator<StreamType>::MakeTextDefine(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextDefineIfNotSet(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextDefineIfNotSet(Item & item)
 {
 	if( !can_use_vars || !pvars )
 	{
@@ -2533,8 +2537,8 @@ void Generator<StreamType>::MakeTextDefineIfNotSet(Item & item)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextLet(Item & item, Var & var)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextLet(Item & item, Var & var)
 {
 	var.str.clear();
 	var.res = ConvertToBool(var.str);
@@ -2563,8 +2567,8 @@ void Generator<StreamType>::MakeTextLet(Item & item, Var & var)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextLet(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextLet(Item & item)
 {
 	if( !can_use_vars || !pvars )
 	{
@@ -2577,8 +2581,8 @@ void Generator<StreamType>::MakeTextLet(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextLetIfNotSet(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextLetIfNotSet(Item & item)
 {
 	if( !can_use_vars || !pvars )
 	{
@@ -2597,8 +2601,8 @@ void Generator<StreamType>::MakeTextLetIfNotSet(Item & item)
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextFilter(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextFilter(Item & item)
 {
 	if( filter_index >= filter_tab.size() )
 	{
@@ -2642,8 +2646,8 @@ void Generator<StreamType>::MakeTextFilter(Item & item)
 	but in the future we can use more complicated class like pt::Space
 	and then nested [ezc frame] statements can product a better output
 */
-template<class StreamType>
-void Generator<StreamType>::MakeEzcFrame(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeEzcFrame(Item & item)
 {
 std::vector<std::wstring*> output_stream_names;
 StreamType * old_stream;
@@ -2684,8 +2688,8 @@ bool stream_added = true;
 
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextEzc(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextEzc(Item & item)
 {
 	if( item.function.name == L"frame" )
 	{
@@ -2702,8 +2706,8 @@ void Generator<StreamType>::MakeTextEzc(Item & item)
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeTextReturn(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeTextReturn(Item & item)
 {
 	last_res = false;
 
@@ -2729,8 +2733,8 @@ void Generator<StreamType>::MakeTextReturn(Item & item)
 
 
 
-template<class StreamType>
-bool Generator<StreamType>::LimitAchieved()
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::LimitAchieved()
 {
 	if( break_generating )
 		return true;
@@ -2761,8 +2765,8 @@ return false;
 }
 
 
-template<class StreamType>
-void Generator<StreamType>::MakeText(Item & item)
+template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
+void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::MakeText(Item & item)
 {
 	if( LimitAchieved() )
 		return;
@@ -2801,8 +2805,6 @@ void Generator<StreamType>::MakeText(Item & item)
 }
 
 
-
-
 } // namespace Ezc
 
 
diff --git a/src/outstreams.h b/src/outstreams.h
index df5840b..c8075cb 100644
--- a/src/outstreams.h
+++ b/src/outstreams.h
@@ -5,7 +5,7 @@
  */
 
 /*
- * Copyright (c) 2015, Tomasz Sowa
+ * Copyright (c) 2015-2021, Tomasz Sowa
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,7 +47,7 @@ namespace Ezc
 {
 
 
-template<class StreamType>
+template<class StreamType, bool is_pikotools_stream = false>
 class OutStreams
 {
 public:
@@ -65,36 +65,35 @@ public:
 	
 	~OutStreams();
 	OutStreams();
-	OutStreams(const OutStreams<StreamType> & o);
-	OutStreams<StreamType> & operator=(const OutStreams<StreamType> & o);
+	OutStreams(const OutStreams & o);
+	OutStreams & operator=(const OutStreams & o);
 	
-
 };
 
 
-template<class StreamType>
-OutStreams<StreamType>::~OutStreams()
+template<class StreamType, bool is_pikotools_stream>
+OutStreams<StreamType, is_pikotools_stream>::~OutStreams()
 {
 	ClearTab();
 }
 
-template<class StreamType>
-OutStreams<StreamType>::OutStreams()
+template<class StreamType, bool is_pikotools_stream>
+OutStreams<StreamType, is_pikotools_stream>::OutStreams()
 {
 }
 
 
 
-template<class StreamType>
-OutStreams<StreamType>::OutStreams(const OutStreams<StreamType> & o)
+template<class StreamType, bool is_pikotools_stream>
+OutStreams<StreamType, is_pikotools_stream>::OutStreams(const OutStreams<StreamType, is_pikotools_stream> & o)
 {
 	// we do not copy streams but creating new ones
 	ResizeTab(o.streams_tab.size());
 }
 
 
-template<class StreamType>
-OutStreams<StreamType> & OutStreams<StreamType>::operator=(const OutStreams<StreamType> & o)
+template<class StreamType, bool is_pikotools_stream>
+OutStreams<StreamType, is_pikotools_stream> & OutStreams<StreamType, is_pikotools_stream>::operator=(const OutStreams<StreamType, is_pikotools_stream> & o)
 {
 	// we do not copy streams but creating new ones
 	streams_map.clear();
@@ -104,8 +103,8 @@ return *this;
 }
 
 
-template<class StreamType>
-void OutStreams<StreamType>::ClearTab()
+template<class StreamType, bool is_pikotools_stream>
+void OutStreams<StreamType, is_pikotools_stream>::ClearTab()
 {
 	for(size_t i=0 ; i<streams_tab.size() ; ++i)
 		delete streams_tab[i];
@@ -115,8 +114,8 @@ void OutStreams<StreamType>::ClearTab()
 }
 
 
-template<class StreamType>
-void OutStreams<StreamType>::ResizeTab(size_t len)
+template<class StreamType, bool is_pikotools_stream>
+void OutStreams<StreamType, is_pikotools_stream>::ResizeTab(size_t len)
 {
 	if( streams_tab.size() != len )
 	{
@@ -141,8 +140,8 @@ void OutStreams<StreamType>::ResizeTab(size_t len)
 }
 
 
-template<class StreamType>
-void OutStreams<StreamType>::ClearMap()
+template<class StreamType, bool is_pikotools_stream>
+void OutStreams<StreamType, is_pikotools_stream>::ClearMap()
 {
 	typename StreamsMap::iterator i;
 
@@ -150,12 +149,14 @@ void OutStreams<StreamType>::ClearMap()
 	{
 		StreamType & str = *(i->second);
 
-		#ifdef EZC_GENERATOR_HAS_PT_STREAM
+		if constexpr(is_pikotools_stream)
+		{
 			str.clear();
-		#else
+		}
+		else
+		{
 			str.str(L"");
-		#endif
-
+		}
 	}
 
 	streams_map.clear();