--- parser3/src/main/pa_charset.C	2003/03/21 14:49:00	1.33.2.19.2.5
+++ parser3/src/main/pa_charset.C	2003/04/08 12:47:31	1.33.2.19.2.16
@@ -5,7 +5,7 @@
 	Author: Alexander Petrosyan<paf@design.ru>(http://paf.design.ru)
 */
 
-static const char* IDENT_CHARSET_C="$Date: 2003/03/21 14:49:00 $";
+static const char* IDENT_CHARSET_C="$Date: 2003/04/08 12:47:31 $";
 
 #include "pa_charset.h"
 #include "pa_charsets.h"
@@ -92,13 +92,6 @@ Charset::Charset(const String& aname, co
 #endif
 }
 
-Charset::~Charset() {
-	// @todonow unregister encodings
-#ifdef XML
-	// not deleting transcoder, that's not our business
-#endif
-}
-
 void Charset::load_definition(const String& afile_spec) {
 	// pcre_tables
 	// lowcase, flipcase, bits digit+word+whitespace, masks
@@ -207,36 +200,21 @@ static XMLByte xlatOneTo(const XMLCh toX
     return not_found;
 }
 
-void Charset::transcode(
-	const Charset& source_charset, const void* source_body, size_t source_content_length,
-	const Charset& dest_charset, const void *& dest_body, size_t& dest_content_length
-	) {
-	if(!source_content_length) {
-		dest_body=0;
-		dest_content_length=0;
-		return;
-	}
+String::C Charset::transcode(const String::C src,
+	const Charset& source_charset, 
+	const Charset& dest_charset) {
+	if(!src.length)
+		return String::C(0, 0);
 
 	switch((source_charset.isUTF8()?0x10:0x00)|(dest_charset.isUTF8()?0x01:0x00)) {
 		default: // 0x00
-			source_charset.transcodeToCharset(dest_charset,
-				source_body, source_content_length,
-				dest_body, dest_content_length);
-			break;
+			return source_charset.transcodeToCharset(src, dest_charset);
 		case 0x01:
-			source_charset.transcodeToUTF8(
-				source_body, source_content_length,
-				dest_body, dest_content_length);
-			break;
+			return source_charset.transcodeToUTF8(src);
 		case 0x10:
-			dest_charset.transcodeFromUTF8(
-				source_body, source_content_length,
-				dest_body, dest_content_length);
-			break;
+			return dest_charset.transcodeFromUTF8(src);
 		case 0x11:
-			dest_body=source_body;
-			dest_content_length=source_content_length;
-			break;
+			return src;
 	}
 }
 
@@ -282,9 +260,9 @@ static const XMLByte gFirstByteMark[7] =
 };
 
 static int transcodeToUTF8(
-							const XMLByte* srcData, size_t& srcLen,
-							XMLByte *toFill, size_t& toFillLen,
-							const Charset::Tables& tables) {
+			   const XMLByte* srcData, size_t& srcLen,
+			   XMLByte *toFill, size_t& toFillLen,
+			   const Charset::Tables& tables) {
 	const XMLByte* srcPtr=srcData;
 	const XMLByte* srcEnd=srcData+srcLen;
 	XMLByte* outPtr=toFill;
@@ -445,135 +423,152 @@ of ocetes consumed.
 }
 
 /// @todo not so memory-hungry with prescan
-void Charset::transcodeToUTF8(
-								 const void* source_body, size_t source_content_length,
-								 const void *& adest_body, size_t& dest_content_length) const {
-	dest_content_length=source_content_length*6/*so that surly enough, max utf8 seq len=6*/;
-	XMLByte *dest_body=new XMLByte[dest_content_length];
+const String::C Charset::transcodeToUTF8(const String::C src) const {
+	size_t src_length=src.length;
+	size_t dest_length=src.length*6/*so that surly enough, max utf8 seq len=6*/;
+	XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
 
 	if(::transcodeToUTF8(
-		(XMLByte *)source_body, source_content_length,
-		dest_body, dest_content_length,
+		(XMLByte *)src.str, src_length,
+		dest_body, dest_length,
 		tables)<0)
 		throw(0, 0,
 			0,
 			"Charset::transcodeToUTF8 buffer overflow");
 
-	// return
-	adest_body=dest_body;
+	dest_body[dest_length]=0; // terminator
+	return String::C((char*)dest_body, dest_length);
 }
-void Charset::transcodeFromUTF8(
-								   const void* source_body, size_t source_content_length,
-								   const void *& adest_body, size_t& dest_content_length) const {
-	dest_content_length=source_content_length*6/*so that surly enough, "&#255;" has max ratio */;
-	XMLByte *dest_body=new XMLByte[dest_content_length];
+const String::C Charset::transcodeFromUTF8(const String::C src) const {
+	size_t src_length=src.length;
+	size_t dest_length=src.length*6/*so that surly enough, "&#255;" has max ratio */;
+	XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
 
 	if(::transcodeFromUTF8(
-		(XMLByte *)source_body, source_content_length,
-		dest_body, dest_content_length,
+		(XMLByte *)src.str, src_length,
+		dest_body, dest_length,
 		tables)<0)
 		throw(0, 0,
 			0,
-			"Charset::transcodeToUTF8 buffer overflow");
+			"Charset::transcodeFromUTF8 buffer overflow");
 
-	// return
-	adest_body=dest_body;
+	dest_body[dest_length]=0; // terminator
+	return String::C((char*)dest_body, dest_length);
 }
 
 /// transcode using both charsets
-void Charset::transcodeToCharset(
-									   const Charset& dest_charset,
-									   const void* source_body, size_t source_content_length,
-									   const void *& adest_body, size_t& adest_content_length) const {
-	if(&dest_charset==this) {
-		adest_body=source_body;
-		adest_content_length=source_content_length;
-	} else {
-		size_t dest_content_length=source_content_length;
-		unsigned char *dest_body=new unsigned char[dest_content_length];
-
-		const XMLByte* srcPtr=(XMLByte *)source_body;
-		const XMLByte* srcEnd=(XMLByte *)source_body+source_content_length;
-
-		for(XMLByte* outPtr=dest_body; srcPtr<srcEnd; srcPtr++) {
-			XMLCh curVal = tables.fromTable[*srcPtr];
-			if(curVal) 
-				*outPtr++=xlatOneTo(curVal, dest_charset.tables, '?');
-			else {
-				// use the replacement character
-				*outPtr++= '?';
-			}	
+const String::C Charset::transcodeToCharset(const String::C src, 
+					    const Charset& dest_charset) const {
+	if(&dest_charset==this) 
+		return src;
+	else {
+		size_t dest_length=src.length;
+		XMLByte* dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/];
+
+		XMLByte* output=dest_body;
+		const XMLByte* input=(XMLByte *)src.str;
+		while(char c=*input++) {
+			XMLCh curVal = tables.fromTable[c];
+			*output++=curVal?
+				xlatOneTo(curVal, dest_charset.tables, '?') // OK
+				:'?'; // use the replacement character
 		}
 
-		adest_body=dest_body;
-		adest_content_length=dest_content_length;
+		dest_body[dest_length]=0; // terminator
+		return String::C((char*)dest_body, dest_length);
 	}
 }			
 
 #ifdef XML
-static int         xml256CharEncodingInputFunc     (
-													unsigned char *out,
-													int *outlen,
-													const unsigned char *in,
-													int *inlen, 
-													void *info) {
-	return transcodeToUTF8(
-							in, *(size_t*)inlen,
-							out, *(size_t*)outlen,
-							*(const Charset::Tables *)info);
-}
-
-static int         xml256CharEncodingOutputFunc    (
-													unsigned char *out,
-													int *outlen,
-													const unsigned char *in,
-													int *inlen, 
-													void *info) {
-	return transcodeFromUTF8(
-							in, *(size_t*)inlen,
-							out, *(size_t*)outlen,
-							*(const Charset::Tables *)info);
-}
 
+static const Charset::Tables* tables[MAX_CHARSETS];
+
+#define declareXml256ioFuncs(i) \
+	static int xml256CharEncodingInputFunc##i( \
+		unsigned char *out, int *outlen, \
+		const unsigned char *in, int *inlen) { \
+		return transcodeToUTF8( \
+			in, *(size_t*)inlen, \
+			out, *(size_t*)outlen, \
+			*tables[i]); \
+	} \
+	static int xml256CharEncodingOutputFunc##i( \
+		unsigned char *out, int *outlen, \
+		const unsigned char *in, int *inlen) { \
+		return transcodeFromUTF8( \
+			in, *(size_t*)inlen, \
+			out, *(size_t*)outlen, \
+			*tables[i]); \
+	}
+
+declareXml256ioFuncs(0)	declareXml256ioFuncs(1)
+declareXml256ioFuncs(2)	declareXml256ioFuncs(3)
+declareXml256ioFuncs(4)	declareXml256ioFuncs(5)
+declareXml256ioFuncs(6)	declareXml256ioFuncs(7)
+declareXml256ioFuncs(8)	declareXml256ioFuncs(9)
+
+static xmlCharEncodingInputFunc inputFuncs[MAX_CHARSETS]={
+	xml256CharEncodingInputFunc0,	xml256CharEncodingInputFunc1,
+	xml256CharEncodingInputFunc2,	xml256CharEncodingInputFunc3,
+	xml256CharEncodingInputFunc4,	xml256CharEncodingInputFunc5,
+	xml256CharEncodingInputFunc6,	xml256CharEncodingInputFunc7,
+	xml256CharEncodingInputFunc8,	xml256CharEncodingInputFunc9
+};
+static xmlCharEncodingOutputFunc outputFuncs[MAX_CHARSETS]={
+	xml256CharEncodingOutputFunc0,	xml256CharEncodingOutputFunc1,
+	xml256CharEncodingOutputFunc2,	xml256CharEncodingOutputFunc3,
+	xml256CharEncodingOutputFunc4,	xml256CharEncodingOutputFunc5,
+	xml256CharEncodingOutputFunc6,	xml256CharEncodingOutputFunc7,
+	xml256CharEncodingOutputFunc8,	xml256CharEncodingOutputFunc9
+};
+static size_t handlers_count=0;
 
 void Charset::addEncoding(char *name_cstr) {
-	xmlCharEncodingHandler* handler=new xmlCharEncodingHandler;
-	fcreated_handler=xmlCharEncodingHandlerPtr(handler);
+	if(handlers_count==MAX_CHARSETS)
+		throw Exception(0,
+			0,
+			"already allocated %d handlers, no space for new encoding '%s'",
+				MAX_CHARSETS, name_cstr);
 
-	handler->name=name_cstr;
-	handler->input=xml256CharEncodingInputFunc; handler->inputInfo=&tables;
-	handler->output=xml256CharEncodingOutputFunc; handler->outputInfo=&tables;
+	xmlCharEncodingHandler* handler=new(PointerFreeGC) xmlCharEncodingHandler;
+	{
+		handler->name=name_cstr;
+		handler->input=inputFuncs[handlers_count]; 
+		handler->output=outputFuncs[handlers_count]; 
+		::tables[handlers_count]=&tables;
+		handlers_count++;
+	}
 	
 	xmlRegisterCharEncodingHandler(handler);
+
 }
 
-void Charset::initTranscoder(const String* source, const char* name_cstr) {
+void Charset::initTranscoder(const String& name, const char* name_cstr) {
 	ftranscoder=xmlFindCharEncodingHandler(name_cstr);
-	transcoder(source); // check right way
+	transcoder(name); // check right way
 }
 
-xmlCharEncodingHandler& Charset::transcoder(const String* source) {
+xmlCharEncodingHandler& Charset::transcoder(const String& name) {
 	if(!ftranscoder)
 		throw Exception("parser.runtime",
-			source,
+			&name,
 			"unsupported encoding");
 	return *ftranscoder;
 }
 
-const char* Charset::transcode_cstrxmlChar* s) {
+const char* Charset::transcode_cstr(xmlChar* s) {
 	if(!s)
 		return "";
 
 	int inlen=strlen((const char* )s);
 	int outlen=inlen+1; // max
-	char *out=new char[outlen];
+	char *out=new(PointerFreeGC) char[outlen];
 	
 	int error;
-	if(xmlCharEncodingOutputFunc output=transcoder(0).output) {
+	if(xmlCharEncodingOutputFunc output=transcoder(fname).output) {
 		error=output(
 			(unsigned char*)out, &outlen,
-			(const unsigned char*)s, &inlen,
-			transcoder(0).outputInfo);
+			(const unsigned char*)s, &inlen);
 	} else {
 		memcpy(out, s, outlen=inlen);
 		error=0;
@@ -586,43 +581,28 @@ const char* Charset::transcode_cstrxmlCh
 	out[outlen/*surely would be less then on input*/]=0;
 	return out;
 }
-const String& Charset::transcodexmlChar* s
-#ifndef NO_STRING_ORIGIN
-		, const String& origin
-#endif
-						   ) { 
-	const String& result(new String());
-	result->APPEND_CLEAN(
-		transcode_cstr(s), 0/*auto-size*/, 
-		origin->origin().file, origin->origin().line);
-	return result; 
+const String& Charset::transcode(xmlChar* s) { 
+	return *new String(transcode_cstr(s), 0/*auto-size*/, true);
 }
-const char* Charset::transcode_cstrGdomeDOMString* s) { 
+const char* Charset::transcode_cstr(GdomeDOMString* s) { 
 	return s?transcode_cstr(BAD_CAST s->str):"";
 }
-const String& Charset::transcodeGdomeDOMString* s
-#ifndef NO_STRING_ORIGIN
-		, const String& origin
-#endif
-						   ) { 
-	const String& result(new String());
-	result->APPEND_CLEAN(transcode_cstr(s), 0/*auto-size*/, origin->origin().file, origin->origin().line);
-	return result; 
+const String& Charset::transcode(GdomeDOMString* s) { 
+	return *new String(transcode_cstr(s), 0/*auto-size*/, true);
 }
 
 /// @test less memory using -maybe- xmlParserInputBufferCreateMem
 void* Charset::transcode_buf2mchar(transcode_buf_malloc_func malloc_func, 
-								   const char* buf, size_t buf_size) {
+				   const char* buf, size_t buf_size) {
 	unsigned char* out;
 	int outlen;
 	int error;
-	if(xmlCharEncodingInputFunc input=transcoder(0).input) {
+	if(xmlCharEncodingInputFunc input=transcoder(fname).input) {
 		outlen=buf_size*6/*max*/;
 		out=(unsigned char*)malloc_func(outlen+1);
 		error=input(
 			out, &outlen,
-			(const unsigned char *)buf,  (int *)&buf_size,
-			transcoder(0).inputInfo);
+			(const unsigned char *)buf,  (int *)&buf_size);
 	} else {
 		outlen=buf_size;
 		out=(unsigned char*)malloc_func(outlen+1);
@@ -652,8 +632,13 @@ GdomeDOMString_auto_ptr Charset::transco
 	return GdomeDOMString_auto_ptr(transcode_buf2gchar(buf, buf_size));
 }
 GdomeDOMString_auto_ptr Charset::transcode(const String& s) { 
-	const char* cstr=s->cstr(String::L_UNSPECIFIED);
+	const char* cstr=s.cstr(String::L_UNSPECIFIED);
 
 	return transcode_buf2dom(cstr, strlen(cstr)); 
 }
+GdomeDOMString_auto_ptr Charset::transcode(const StringBody s) { 
+	const char* cstr=s.cstr();
+
+	return transcode_buf2dom(cstr, s.length()); 
+}
 #endif