--- parser3/src/main/untaint.C	2003/03/03 13:44:26	1.115.2.11
+++ parser3/src/main/untaint.C	2004/01/22 08:28:20	1.122.2.2
@@ -5,41 +5,75 @@
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char* IDENT_UNTAINT_C="$Date: 2003/03/03 13:44:26 $";
+static const char* IDENT_UNTAINT_C="$Date: 2004/01/22 08:28:20 $";
+
 
-#include "pa_pool.h"
 #include "pa_string.h"
 #include "pa_hash.h"
 #include "pa_exception.h"
 #include "pa_table.h"
 #include "pa_globals.h"
-#include "pa_sql_connection.h"
 #include "pa_dictionary.h"
 #include "pa_common.h"
 #include "pa_charset.h"
 #include "pa_request_charsets.h"
+#include "pa_sapi.h"
+
+extern "C" { // author forgot to do that
+#include "ec.h"
+}
+
+#define PA_SQL
+
+#ifdef PA_SQL
+#include "pa_sql_connection.h"
+#endif
+
+// defines
+
+
+#undef CORD_ec_append
+// redefining to intercept flushes and implement whitespace optimization
+// of all consequent white space chars leaving only first one
+#define CORD_ec_append(x, c) \
+    {  \
+	bool skip=false; \
+	if(optimize) switch(c) { \
+	case ' ': case '\r': case '\n': case '\t': \
+		if(whitespace) \
+			skip=true; /*skipping subsequent*/ \
+		else \
+			whitespace=true; \
+		break; \
+	default: \
+		whitespace=false; \
+		break; \
+	} \
+	if(!skip) { \
+		if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
+	  		CORD_ec_flush_buf(x); \
+		} \
+		*((x)[0].ec_bufptr)++ = (c); \
+	} \
+    }
+
 
 #define escape(action) \
-	{ \
-		const char* src=fragment->ptr; \
-		for(int size=fragment->size; size--; src++) \
-			action \
+	for(; fragment_length--; CORD_next(info->pos)) { \
+		char c=CORD_pos_fetch(info->pos); \
+		action \
 	}
-#define _default  default: *dest++=*src; break
-#define encode(need_encode_func, prefix)  \
-			if(need_encode_func(*src)) { \
-				static const char* hex="0123456789ABCDEF"; \
-				char chunk[3]={prefix}; \
-				chunk[1]=hex[((unsigned char)*src)/0x10]; \
-				chunk[2]=hex[((unsigned char)*src)%0x10]; \
-				memcpy(dest, chunk, 3);  dest+=3; \
-			} else \
-				*dest++=*src; \
-			break
-#define to_char(c)  *dest++=c
-#define to_string(b, bsize)  \
-		memcpy(dest, b, bsize); \
-		dest+=bsize; \
+#define _default  default: CORD_ec_append(info->result, c); break
+#define encode(need_encode_func, prefix, otherwise)  \
+	if(need_encode_func(c)) { \
+		static const char* hex="0123456789ABCDEF"; \
+		CORD_ec_append(info->result, prefix); \
+		CORD_ec_append(info->result, hex[((unsigned char)c)/0x10]); \
+		CORD_ec_append(info->result, hex[((unsigned char)c)%0x10]); \
+	} else \
+		CORD_ec_append(info->result, otherwise);
+#define to_char(c)  { CORD_ec_append(info->result, c); whitespace=false; }
+#define to_string(s)  { CORD_ec_append_cord(info->result, s); whitespace=false; }
 
 inline bool need_file_encode(unsigned char c){
 	// russian letters and space ENABLED
@@ -47,7 +81,7 @@ inline bool need_file_encode(unsigned ch
 	return strchr(
 			  "*?'\"<>|"
 #ifndef WIN32
-			  ":\\~"
+			  ":\\"
 #endif
 			  , c)!=0;
 }
@@ -133,154 +167,70 @@ inline bool need_quote_http_header(const
 	return false;
 }
 
-//#include "pa_sapi.h"
+#ifndef DOXYGEN
+struct Append_fragment_info {
+	String::Language lang;
+	String::Languages* dest_languages;
+	size_t dest_body_plan_length;
+};
+#endif
+int append_fragment_optimizing(char alang, size_t asize, Append_fragment_info* info) {
+	const String::Language lang=(String::Language)(unsigned char)alang;
+	// main idea here:
+	// tainted piece would get OPTIMIZED bit from 'lang'
+	// clean piece would be marked OPTIMIZED manually
+	// pieces with determined languages [not tainted|clean] would retain theirs langs
+	info->dest_languages->append(info->dest_body_plan_length, 
+		lang==String::L_TAINTED?
+			info->lang
+			:lang==String::L_CLEAN?
+				(String::Language)(String::L_CLEAN|String::L_OPTIMIZE_BIT) // ORing with OPTIMIZED flag
+				:lang,
+		asize);
+	info->dest_body_plan_length+=asize;
+
+	return 0; // 0=continue
+}
+int append_fragment_nonoptimizing(char alang, size_t asize, Append_fragment_info* info) {
+	const String::Language lang=(String::Language)(unsigned char)alang;
+	// The core idea: tainted pieces got marked with context's lang
+	info->dest_languages->append(info->dest_body_plan_length, 
+		lang==String::L_TAINTED?
+			info->lang
+			:lang,
+		asize);
+	info->dest_body_plan_length+=asize;
+
+	return 0; // 0=continue
+}
+
 /** 
 	appends to other String,
 	marking all tainted pieces of it with @a lang.
 	or marking ALL pieces of it with a @a lang when @a forced to,
 	and propagating OPTIMIZE language bit.
 */
-String& String::append_to(String& dest, String_UL lang, bool forced) const {
+String& String::append_to(String& dest, Language lang, bool forced) const {
 	if(is_empty())
 		return dest;
 
-	// without language-chage string?
-	if(lang==UL_PASS_APPENDED) {
-		// can simply append elements
-		ssize_t delta=fused-(dest.fallocated-dest.fused);
-		if(delta>0) // they don't fit?
-			dest.expand(delta);
-
-		// felements[fused...]=src.felements[0..fused], fused+=src.fused
-		memcpy(&dest.felements[dest.fused], felements, sizeof(felements[0])*fused);
-		dest.fused+=fused;
-		dest.fsize+=fsize;
-		return dest;
+	// first: fragment infos
+	
+	if(lang==L_PASS_APPENDED) // without language-change?
+		dest.langs.append(dest.body, body.length(), langs);
+	else if(forced) //forcing passed lang?
+		dest.langs.append(dest.body, lang, length());
+	else { 
+		Append_fragment_info info={lang, &dest.langs, dest.body.length()};
+	    langs.for_each(body, lang&L_OPTIMIZE_BIT?
+			append_fragment_optimizing
+			:append_fragment_nonoptimizing, &info);
 	}
 
-	// manually unrolled code to avoid do{if(const)} constructs
-	if(forced) 
-		STRING_FOREACH_FRAGMENT(
-			dest.APPEND(fragment->ptr, fragment->size, 
-				lang, //forcing passed lang
-				fragment->origin.file, fragment->origin.line);
-		)
-	else if(lang==UL_PASS_APPENDED) 
-		STRING_FOREACH_FRAGMENT(
-			dest.APPEND(fragment->ptr, fragment->size, 
-				fragment->lang, // passing item's lang
-				fragment->origin.file, fragment->origin.line);
-		)
-	else if(lang&UL_OPTIMIZE_BIT) // main idea here
-		// tainted piece would get OPTIMIZED bit from 'lang'
-		// clean piece would be marked OPTIMIZED manually
-		// pieces with determined languages [not tainted|clean] would retain theirs langs
-		STRING_FOREACH_FRAGMENT(
-			dest.APPEND(fragment->ptr, fragment->size, 
-				fragment->lang==UL_TAINTED?lang:(
-					fragment->lang==UL_CLEAN?UL_CLEAN|UL_OPTIMIZE_BIT: // ORing with OPTIMIZED flag
-						fragment->lang
-				), 
-				fragment->origin.file, fragment->origin.line);
-		)
-	else
-		STRING_FOREACH_FRAGMENT(
-			dest.APPEND(fragment->ptr, fragment->size, 
-				fragment->lang==UL_TAINTED?lang:fragment->lang,
-				fragment->origin.file, fragment->origin.line);
-		);
+	// next: letters
+	dest.body<<body;
 
-	return dest;
-}
-
-size_t String::cstr_bufsize(Untaint_lang lang,
-							SQL_Connection *connection,
-							const Request_charsets *charsets) const {
-	size_t dest=1; // for terminating 0
-	STRING_FOREACH_FRAGMENT(
-		String_UL to_lang=lang==UL_UNSPECIFIED?fragment->lang:lang;
-
-		switch(to_lang & ~UL_OPTIMIZE_BIT) {
-		case UL_CLEAN:
-		case UL_TAINTED:
-		case UL_AS_IS:
-			// clean piece
-
-			// tainted piece, but undefined untaint language
-			// for VString.as_double of tainted values
-			// for ^process{body} evaluation
-
-			// tainted, untaint language: as-is
-			dest+=fragment->size;
-			break;
-		case UL_FILE_SPEC:
-			// tainted, untaint language: file [name]
-			dest+=fragment->size*3/* worst: Z->%XX */;
-			break;
-		case UL_URI:
-			// tainted, untaint language: uri
-			dest+=fragment->size*6*3/* worst utf8 x worst Z->%XX */;
-			break;
-		case UL_HTTP_HEADER:
-			// tainted, untaint language: http-field-content-text
-			dest+=fragment->size*3/* worst: Z->%XX */;
-			break;
-		case UL_MAIL_HEADER:
-			// tainted, untaint language: mail-header
-			if(charsets) {
-				int parts_count=1;
-				const char* prev=fragment->ptr;
-				size_t size=fragment->size;
-				while(const char* comma_at=(const char*)memchr(prev, ',', size)) {
-					parts_count++;
-					size-=comma_at-prev;
-					prev=comma_at+1;
-				}
-				// Subject: Re: parser3: =?koi8-r?Q?=D3=C5=CD=C9=CE=C1=D2?=
-				dest+=
-					fragment->size*3+
-					parts_count*(charsets->mail().name()->size()+MAX_STRING/* worst: =?charset?Q?=%XX?= */);
-			} else
-				dest+=fragment->size;
-			break;
-		case UL_TABLE: 
-			// tainted, untaint language: table
-			dest+=fragment->size;
-			break;
-		case UL_SQL:
-			// tainted, untaint language: sql
-			if(connection)
-				dest+=connection->quote(0, fragment->ptr, fragment->size);
-			break;
-		case UL_JS:
-			escape(switch(*src) {
-				case '"': case '\'': case '\n': case '\\': case '\xFF':
-					dest+=2;  break;
-				default: 
-					dest++;  break;
-			});
-			break;
-		case UL_XML:
-			escape(switch(*src) {
-				case '&': case '>': case '<': case '"': case '\'': 
-					dest+= 6;  break;
-				default: 
-					dest++;  break;
-			});
-			break;
-		case UL_HTML:
-			escape(switch(*src) {
-				case '&': 
-				case '>': 
-				case '<': 
-				case '"': 
-					dest+=6;  break;
-				default: 
-					dest++;  break;
-			});
-			break;
-		}
-	);
+	ASSERT_STRING_INVARIANT(dest);
 	return dest;
 }
 
@@ -311,236 +261,258 @@ RFC
 		without "=", or one could not differ "=E0" and "russian letter a"
 		and without "_", or in would mean 0x20
 */
-static bool mail_header_char_valid_within_Qencoded(char c) {
+inline bool mail_header_char_valid_within_Qencoded(char c) {
 	return c>='A' && c<='Z'
 		|| c>='a' && c<='Z'
 		|| c>='0' && c<='9'
 		|| strchr("!*+-/", c);
 }
-char *String::store_to(char *dest, Untaint_lang lang, 
-					   SQL_Connection *connection,
-					   const Request_charsets *charsets) const {
-	// WARNING:
-	//	 before any changes check cstr_bufsize first!!!
-	bool whitespace=true;
-//	STRING_FOREACH_FRAGMENT(
-	element_type *last = felements+fused; element_type *fragment = felements; for(; fragment<last; fragment++) { 
-
-		String_UL to_lang=lang==UL_UNSPECIFIED?fragment->lang:lang;
-
-		char *start=dest;
-
-		switch(to_lang & ~UL_OPTIMIZE_BIT) {
-		case UL_CLEAN:
-		case UL_TAINTED:
-		case UL_AS_IS:
-			// clean piece
-
-			// tainted piece, but undefined untaint language
-			// for VString.as_double of tainted values
-			// for ^process{body} evaluation
-
-			// tainted, untaint language: as-is
-			memcpy(dest, fragment->ptr, fragment->size); 
-			dest+=fragment->size;
-			break;
-		case UL_FILE_SPEC:
-			// tainted, untaint language: file [name]
-			escape(
-				// Macintosh has problems with small Russian letter 'r'
-				if( *src=='\xF0' && charsets && *charsets->source().name()=="windows-1251" ) {
-					// fixing that letter for most common charset
-					to_char('p');
-				} else // fallback to default
-					encode(need_file_encode, '_'); 
-			);
-			break;
-		case UL_URI:
-			// tainted, untaint language: uri
-			const void *client_ptr;
-			size_t client_size;
-			if(charsets) 
-				Charset::transcode(charsets->pool(), 
-					charsets->source(), fragment->ptr, fragment->size,
-					charsets->client(), client_ptr, client_size);
-			else {
-				client_ptr=fragment->ptr; 
-				client_size=fragment->size;
-			}
-
-			{
-				const char* src=(const char* )client_ptr;
-				for(int size=client_size; size--; src++) 
-					encode(need_uri_encode, '%');
-			}
-			break;
-		case UL_HTTP_HEADER:
-			// tainted, untaint language: http-field-content-text
-			escape(
-				encode(need_uri_encode, '%');
-			);
-			break;
-		case UL_MAIL_HEADER:
-			// tainted, untaint language: mail-header
-			// http://www.ietf.org/rfc/rfc2047.txt
-			if(charsets) {
-				const void *mail_ptr;
-				size_t mail_size;
-				Charset::transcode(charsets->pool(), 
-					charsets->source(), fragment->ptr, fragment->size,
-					charsets->mail(), mail_ptr, mail_size);
-				CharPtr charset_name=charsets->mail().name()->cstr();
-
-				// Subject: Re: parser3: =?koi8-r?Q?=D3=C5=CD=C9=CE=C1=D2?=
-				const char* src=(const char* )mail_ptr;
-				bool to_quoted_printable=false;
-
-				bool email=false;
-				for(const char* end=src+mail_size; src<end; src++) {
-					//RFC   + An 'encoded-word' MUST NOT appear in any portion of an 'addr-spec'.
-					if(to_quoted_printable && (*src==',' || *src=='<')) {
-						email=*src=='<';
-						dest+=sprintf(dest, "?=");
-						to_quoted_printable=false;
-					}
-					if(!email && (
-						!to_quoted_printable && (*src & 0x80)  // starting quote-printable-encoding on first 8bit char
-						|| to_quoted_printable && !mail_header_char_valid_within_Qencoded(*src)
-						)) {
-						if(!to_quoted_printable) {
-							dest+=sprintf(dest, "=?%s?Q?", charset_name.get());
-							to_quoted_printable=true;
-						}
-						//RFC Upper case should be used for hexadecimal digits "A" through "F"
-						if(*src == 0x20) // RFC The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) 
-							*dest++='_'; // RFC may be represented as "_" 
-						else
-							dest+=sprintf(dest, "=%02X", *src & 0xFF);
-					} else
-						*dest++=*src;
-					if(*src=='>')
-						email=false;
-				}
-				if(to_quoted_printable) // close
-					dest+=sprintf(dest, "?=");
-			
-			} else {
-				memcpy(dest, fragment->ptr, fragment->size); 
-				dest+=fragment->size;
-			}
-			break;
-		case UL_TABLE: 
-			// tainted, untaint language: table
-			escape(switch(*src) {
-				case '\t': to_char(' ');  break;
-				case '\n': to_char(' ');  break;
-				_default;
-			});
-			break;
-		case UL_SQL:
-			// tainted, untaint language: sql
-			if(connection)
-				dest+=connection->quote(dest, fragment->ptr, fragment->size);
-			else
-				throw Exception(Exception::undefined_type,
-					Exception::undefined_source,
-					"untaint in SQL language failed - no connection specified");
-			break;
-		case UL_JS:
-			escape(switch(*src) {
-				case '"': to_string("\\\"", 2);  break;
-				case '\'': to_string("\\'", 2);  break;
-				case '\n': to_string("\\n", 2);  break;
-				case '\\': to_string("\\\\", 2);  break;
-				case '\xFF': to_string("\\\xFF", 2);  break;
-				_default;
-			});
-			break;
-		case UL_XML:
-			escape(switch(*src) {
-				case '&': to_string("&amp;", 5);  break;
-				case '>': to_string("&gt;", 4);  break;
-				case '<': to_string("&lt;", 4);  break;
-				case '"': to_string("&quot;", 6);  break;
-				case '\'': to_string("&apos;", 6);  break;
-				_default;
-			});
-			break;
-		case UL_HTML:
-			escape(switch(*src) {
-				case '&': to_string("&amp;", 5);  break;
-				case '>': to_string("&gt;", 4);  break;
-				case '<': to_string("&lt;", 4);  break;
-				case '"': to_string("&quot;", 6);  break;
-				_default;
-			});
+inline bool addr_spec_soon(const char *src) {
+	for(char c; c=*src; src++)
+		if(c=='<')
+			return true;
+		else if(!(c==' ' || c=='\t'))
+			return false;
+	return false;
+}
+/**
+	RFC 
+	Upper case should be used for hexadecimal digits "A" through "F"
+	The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) 
+	may be represented as "_" 
+*/
+inline bool mail_header_nonspace_char(char c) {
+	return c != 0x20;
+}
+inline void ec_append(CORD_ec& result, bool& optimize, bool& whitespace, CORD_pos pos, size_t size) {
+	while(size--) {
+		CORD_ec_append(result, CORD_pos_fetch(pos));
+		CORD_next(pos);
+	}
+}
+inline void pa_CORD_pos_advance(CORD_pos pos, size_t n) {
+	while(true) {
+		size_t avail=CORD_pos_chars_left(pos);
+		if(avail==0) {
+			CORD_next(pos);
+			if(!--n)
+				break;
+		} else if(avail<n) {
+			CORD_pos_advance(pos, avail);
+			n-=avail;
+		} else { // avail>=n
+			CORD_pos_advance(pos, n);
 			break;
-		default:
-			throw Exception(Exception::undefined_type, 
-				Exception::undefined_source, 
-				"unknown untaint language #%d", 
-					static_cast<int>(to_lang)); // should never
-			break; // never
 		}
+	}
+}
+
+#ifndef DOXYGEN
+struct Cstr_to_string_body_block_info {
+	// input
+	String::Language lang;
+	SQL_Connection* connection;
+	const Request_charsets* charsets;
+	const String::Body* body;
+
+	// output
+	CORD_ec result;
+
+	// private
+	CORD_pos pos;
+	size_t fragment_begin;
+	bool whitespace;
+};
+#endif
+int cstr_to_string_body_block(char alang, size_t fragment_length, Cstr_to_string_body_block_info* info) {
+	const String::Language fragment_lang=(String::Language)(unsigned char)alang;
+	bool& whitespace=info->whitespace;
+	size_t fragment_end=info->fragment_begin+fragment_length;
+	//fprintf(stderr, "%d, %d\n", fragment.lang, fragment.length);
 
-		if(to_lang & UL_OPTIMIZE_BIT) { 
-			// optimizing whitespace
-			char *stop=dest;  dest=start;
-			for(char *src=start; src<stop; src++)
-				switch(*src) {
-				// of all consequent white space chars leaving only first one
-				case ' ': case '\r': case '\n': case '\t':
-					if(!whitespace) {
-						*dest++=*src;
-						whitespace=true;
+	
+	String::Language to_lang=info->lang==String::L_UNSPECIFIED?fragment_lang:info->lang;
+	bool optimize=(to_lang & String::L_OPTIMIZE_BIT)!=0;
+	if(!optimize)
+		whitespace=false;
+		
+	switch(to_lang & ~String::L_OPTIMIZE_BIT) {
+	case String::L_CLEAN:
+	case String::L_TAINTED:
+	case String::L_AS_IS:
+		// clean piece
+
+		// tainted piece, but undefined untaint language
+		// for VString.as_double of tainted values
+		// for ^process{body} evaluation
+
+		// tainted, untaint language: as-is
+		ec_append(info->result, optimize, whitespace, info->pos, fragment_length);
+		break;
+	case String::L_FILE_SPEC:
+		// tainted, untaint language: file [name]
+		escape(
+			// Macintosh has problems with small Russian letter 'r'
+			if( c=='\xF0' && info->charsets && info->charsets->source().NAME()=="WINDOWS-1251" ) {
+				// fixing that letter for most common charset
+				to_char('p');
+			} else // fallback to default
+				encode(need_file_encode, '_', c); 
+		);
+		break;
+	case String::L_URI:
+		// tainted, untaint language: uri
+		{
+			const char *fragment_str=info->body->mid(info->fragment_begin, fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, fragment_length);
+			String::C output(fragment_str, fragment_length);
+			if(info->charsets) 
+				output=Charset::transcode(output, 
+					info->charsets->source(), 
+					info->charsets->client());
+
+			char c;
+			for(const char* src=output.str; c=*src++; ) 
+				encode(need_uri_encode, '%', c);
+		}
+		break;
+	case String::L_HTTP_HEADER:
+		// tainted, untaint language: http-field-content-text
+		escape(
+			encode(need_uri_encode, '%', c);
+		);
+		break;
+	case String::L_MAIL_HEADER:
+		// tainted, untaint language: mail-header
+		// http://www.ietf.org/rfc/rfc2047.txt
+		if(info->charsets) {
+			size_t mail_size;
+			const char *mail_ptr=
+				info->body->mid(info->fragment_begin, mail_size=fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, mail_size);
+
+			const char* charset_name=info->charsets->mail().NAME().cstr();
+
+			// Subject: Re: parser3: =?koi8-r?Q?=D3=C5=CD=C9=CE=C1=D2?=
+			bool to_quoted_printable=false;
+
+			bool email=false;
+			uchar c;
+			for(const char* src=mail_ptr; c=(uchar)*src++; ) {
+				//RFC   + An 'encoded-word' MUST NOT appear in any portion of an 'addr-spec'.
+				if(to_quoted_printable && (c==',' || addr_spec_soon(src) || c == '"')) {
+					email=c=='<';
+					to_string("?=");
+					to_quoted_printable=false;
+				}
+				if(!email && (
+					!to_quoted_printable && (c & 0x80)  // starting quote-printable-encoding on first 8bit char
+					|| to_quoted_printable && !mail_header_char_valid_within_Qencoded(c)
+					)) {
+					if(!to_quoted_printable) {
+						to_string("=?");
+						to_string(charset_name);
+						to_string("?Q?");
+						to_quoted_printable=true;
 					}
-					break;
-				default:
-					whitespace=false;
-					*dest++=*src;
-					break;
-				};
-		} else // piece without optimization
-			whitespace=false;
-//	);
+					encode(mail_header_nonspace_char, '=', '_'); 
+				} else
+					to_char(c);
+				if(c=='>')
+					email=false;
+			}
+			if(to_quoted_printable) // close
+				to_string("?=");
+		
+		} else
+			ec_append(info->result, optimize, whitespace, info->pos, fragment_length);
+		break;
+	case String::L_TABLE: 
+		// tainted, untaint language: table
+		escape(switch(c) {
+			case '\t': to_char(' ');  break;
+			case '\n': to_char(' ');  break;
+			_default;
+		});
+		break;
+#ifdef PA_SQL
+	case String::L_SQL:
+		// tainted, untaint language: sql
+		if(info->connection) {
+			const char *fragment_str=info->body->mid(info->fragment_begin, fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, fragment_length);
+
+			to_string(info->connection->quote(fragment_str, fragment_length));
+		} else
+			throw Exception(0,
+				0,
+				"untaint in SQL language failed - no connection specified");
+		break;
+#endif
+	case String::L_JS:
+		escape(switch(c) {
+			case '"': to_string("\\\"");  break;
+			case '\'': to_string("\\'");  break;
+			case '\n': to_string("\\n");  break;
+			case '\\': to_string("\\\\");  break;
+			case '\xFF': to_string("\\\xFF");  break;
+			_default;
+		});
+		break;
+	case String::L_XML:
+		escape(switch(c) {
+			case '&': to_string("&amp;");  break;
+			case '>': to_string("&gt;");  break;
+			case '<': to_string("&lt;");  break;
+			case '"': to_string("&quot;");  break;
+			case '\'': to_string("&apos;");  break;
+			_default;
+		});
+		break;
+	case String::L_HTML:
+		escape(switch(c) {
+			case '&': to_string("&amp;");  break;
+			case '>': to_string("&gt;");  break;
+			case '<': to_string("&lt;");  break;
+			case '"': to_string("&quot;");  break;
+			_default;
+		});
+		break;
+	default:
+		assert(!"should never");
+		SAPI::die("unknown untaint language #%d", 
+			static_cast<int>(to_lang)); // should never
+		break; // never
 	}
 
-	return dest;
+	info->fragment_begin=fragment_end;
+
+	return 0; // 0=continue
 }
 
-char *String::cstr_debug_origins(Pool& pool) const {
-	//_asm int 3;
-	char *result=new(pool) char[size()+fused*MAX_STRING*2];
-	char *dest=result;
-	
-	STRING_FOREACH_FRAGMENT(
-IFNDEF_NO_STRING_ORIGIN(
-		if(fragment->origin.file)
-			dest+=sprintf(dest, ORIGIN_FILE_LINE_FORMAT,
-				fragment->origin.file,
-				1+fragment->origin.line);
-		else
-			dest+=sprintf(dest, "<unknown>");
-);
-		String_UL show_lang=fragment->lang & ~UL_OPTIMIZE_BIT;
-		if(show_lang>=sizeof(String_Untaint_lang_name)/sizeof(String_Untaint_lang_name[0]))
-			throw Exception(Exception::undefined_type, 
-				Exception::undefined_source, 
-				"unknown untaint language #%d", 
-					static_cast<int>(show_lang)); // sould never
-
-		dest+=sprintf(dest, "#%s%s: ",
-			String_Untaint_lang_name[show_lang],
-			fragment->lang & UL_OPTIMIZE_BIT?".O":"");
-		char *dest_after_origins=dest;
-
-		memcpy(dest, fragment->ptr, fragment->size); 
-		dest+=fragment->size;
-
-		remove_crlf(dest_after_origins, dest);
-		to_char('\n');
-	);
 
-	*dest=0;
-	return result;
+String::Body String::cstr_to_string_body(Language lang, 
+		  SQL_Connection* connection,
+		  const Request_charsets *charsets) const {
+
+	Cstr_to_string_body_block_info info;
+	// input
+	info.lang=lang;
+	info.connection=connection;
+	info.charsets=charsets;
+	info.body=&body;
+	// output
+	CORD_ec_init(info.result);
+	// private
+	body.set_pos(info.pos, 0);
+	info.fragment_begin=0;
+	info.whitespace=true;
+
+	if(!is_empty())
+		langs.for_each(body, cstr_to_string_body_block, &info);
+
+	return String::Body(CORD_ec_to_cord(info.result));
 }