--- parser3/src/main/pa_charset.C	2001/12/28 18:12:30	1.10
+++ parser3/src/main/pa_charset.C	2002/06/28 09:59:01	1.24
@@ -1,10 +1,10 @@
 /** @file
 	Parser: Charset connection implementation.
 
-	Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
+	Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexander Petrosyan<paf@design.ru>(http://paf.design.ru)
 
-	$Id: pa_charset.C,v 1.10 2001/12/28 18:12:30 paf Exp $
+	$Id: pa_charset.C,v 1.24 2002/06/28 09:59:01 paf Exp $
 */
 
 #include "pa_charset.h"
@@ -153,7 +153,7 @@ void Charset::loadDefinition(const Strin
 			case 8:
 				// charset
 				if(tables.toTableSize>MAX_CHARSET_UNI_CODES)
-					throw Exception(0, 0,
+					throw Exception("parser.runtime",
 						&request_file_spec,
 						"charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES);
 
@@ -287,14 +287,14 @@ static const XMLByte gFirstByteMark[7] =
     0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
 };
 
-static size_t transcodeToUTF8(
-							const void *source_body, size_t source_content_length,
-							XMLByte *dest_body, size_t dest_buf_length,
+static int transcodeToUTF8(
+							const XMLByte* srcData, size_t& srcLen,
+							XMLByte *toFill, size_t& toFillLen,
 							const Charset::Tables& tables) {
-	const XMLByte* srcPtr=(const XMLByte*)source_body;
-	const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;
-	XMLByte* outPtr=dest_body;
-	XMLByte* outEnd=dest_body+dest_buf_length;
+	const XMLByte* srcPtr=srcData;
+	const XMLByte* srcEnd=srcData+srcLen;
+	XMLByte* outPtr=toFill;
+	XMLByte* outEnd=toFill+toFillLen;
 
     while(srcPtr<srcEnd) {
         uint curVal = tables.fromTable[*srcPtr];
@@ -354,17 +354,22 @@ static size_t transcodeToUTF8(
         outPtr+= encodedBytes;
     }
 
-	// eaten
-	return outPtr-dest_body;
+    // Update the bytes eaten
+    srcLen = srcPtr - srcData;
+
+    // Return the characters read
+    toFillLen = outPtr - toFill;
+
+	return srcPtr==srcEnd?(int)toFillLen:-1;
 }
 static size_t transcodeFromUTF8(
-								   const void *source_body, size_t source_content_length,
-								   XMLByte* dest_body, size_t dest_buf_length,
-									const Charset::Tables& tables) {
-	const XMLByte* srcPtr=(const XMLByte*)source_body;
-	const XMLByte* srcEnd=(const XMLByte*)source_body+source_content_length;
-	XMLByte* outPtr=dest_body;
-	XMLByte* outEnd=dest_body+dest_buf_length;
+								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;
+	XMLByte* outEnd=toFill+toFillLen;
 
     //  We now loop until we either run out of input data, or room to store
     while ((srcPtr < srcEnd) && (outPtr < outEnd)) {
@@ -399,7 +404,7 @@ static size_t transcodeFromUTF8(
                      break;
 
             default:
-                throw Exception(0, 0,
+                throw Exception(0,
 					0,
 					"transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes);
         }
@@ -411,56 +416,54 @@ static size_t transcodeFromUTF8(
         if(!(tmpVal & 0xFFFF0000))
             *outPtr++= xlatOneTo(tmpVal, tables);
 		else
-			throw Exception(0, 0,
+			throw Exception(0,
 				0,
 				"transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal);
 	}
 
-	// eaten
-	return outPtr-dest_body;
+    // Update the bytes eaten
+    srcLen = srcPtr - srcData;
+
+    // Return the characters read
+    toFillLen = outPtr - toFill;
+
+	return srcPtr==srcEnd?(int)toFillLen:-1;
 }
 
 /// @todo not so memory-hungry with prescan
-/// @test buf overflow
 void Charset::transcodeToUTF8(Pool& pool,
 								 const void *source_body, size_t source_content_length,
-								 const void *& adest_body, size_t& adest_content_length) const {
-	size_t dest_buf_length=source_content_length*6/*so that surly enough*/;
-	XMLByte *dest_body=(XMLByte*)pool.malloc(dest_buf_length);
-
-	size_t dest_content_length=::transcodeToUTF8(
-		source_body, source_content_length,
-		dest_body, dest_buf_length,
-		tables);
-	/*if(dest_content_length<dest_buf_length)
+								 const void *& adest_body, size_t& dest_content_length) const {
+	dest_content_length=source_content_length*6/*so that surly enough*/;
+	XMLByte *dest_body=(XMLByte*)pool.malloc(dest_content_length);
+
+	if(::transcodeToUTF8(
+		(XMLByte *)source_body, source_content_length,
+		dest_body, dest_content_length,
+		tables)<0)
 		throw(0, 0,
 			0,
-			"Charset::transcodeToUTF8 error");*/
+			"Charset::transcodeToUTF8 buffer overflow");
 
 	// return
 	adest_body=dest_body;
-	adest_content_length=dest_content_length;
 }
-/// @test buf overflow
 void Charset::transcodeFromUTF8(Pool& pool,
 								   const void *source_body, size_t source_content_length,
-								   const void *& adest_body, size_t& adest_content_length) const {
-	size_t dest_buf_length=source_content_length/*surly enough*/;
-	XMLByte *dest_body=(XMLByte*)pool.malloc(dest_buf_length);
-
-	size_t dest_content_length=::transcodeFromUTF8(
-		source_body, source_content_length,
-		dest_body, dest_buf_length,
-		tables);
-/*	if(dest_content_length!=dest_buf_length)
+								   const void *& adest_body, size_t& dest_content_length) const {
+	dest_content_length=source_content_length/*surly enough*/;
+	XMLByte *dest_body=(XMLByte*)pool.malloc(dest_content_length);
+
+	if(::transcodeFromUTF8(
+		(XMLByte *)source_body, source_content_length,
+		dest_body, dest_content_length,
+		tables)<0)
 		throw(0, 0,
 			0,
-			"Charset::transcodeToUTF8 error");*/
-
+			"Charset::transcodeToUTF8 buffer overflow");
 
 	// return
 	adest_body=dest_body;
-	adest_content_length=dest_content_length;
 }
 
 /// transcode using both charsets
@@ -475,8 +478,8 @@ void Charset::transcodeToCharset(Pool& p
 		size_t dest_content_length=source_content_length;
 		unsigned char *dest_body=(unsigned char *)pool.malloc(dest_content_length);
 
-		const XMLByte* srcPtr=(const XMLByte*)source_body;
-		const XMLByte* srcEnd=(const XMLByte*)source_body+source_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];
@@ -501,8 +504,8 @@ static int         xml256CharEncodingInp
 													int *inlen, 
 													void *info) {
 	return transcodeToUTF8(
-							in, *inlen,
-							out, *(unsigned int*)outlen,
+							in, *(size_t*)inlen,
+							out, *(size_t*)outlen,
 							*(const Charset::Tables *)info);
 }
 
@@ -513,8 +516,8 @@ static int         xml256CharEncodingOut
 													int *inlen, 
 													void *info) {
 	return transcodeFromUTF8(
-							in, *inlen,
-							out, *outlen,
+							in, *(size_t*)inlen,
+							out, *(size_t*)outlen,
 							*(const Charset::Tables *)info);
 }
 
@@ -530,63 +533,80 @@ void Charset::addEncoding(char *name_cst
 }
 
 void Charset::initTranscoder(const String *source, const char *name_cstr) {
-	transcoder=xmlFindCharEncodingHandler(name_cstr);
-	if(!transcoder)
-		throw Exception(0, 0,
+	ftranscoder=xmlFindCharEncodingHandler(name_cstr);
+	transcoder(source); // check right way
+}
+
+xmlCharEncodingHandler *Charset::transcoder(const String *source) {
+	if(!ftranscoder)
+		throw Exception("parser.runtime",
 			source,
 			"unsupported encoding");
+	return ftranscoder;
 }
 
-const char *Charset::transcode_cstr(GdomeDOMString *s) { 
-	if(!transcoder)
-		throw Exception(0, 0,
-			0,
-			"transcode_cstr no transcoder");
+const char *Charset::transcode_cstr(xmlChar *s) {
+	if(!s)
+		return "";
 
-	int inlen=gdome_str_length(s);
+	int inlen=strlen((const char *)s);
 	int outlen=inlen+1; // max
 	char *out=(char *)malloc(outlen*sizeof(char));
 	
-	int size=transcoder->output(
-		(unsigned char*)out, &outlen,
-		(const unsigned char*)s->str, &inlen,
-		transcoder->outputInfo);
+	int size;
+	if(xmlCharEncodingOutputFunc output=transcoder(0)->output) {
+		size=output(
+			(unsigned char*)out, &outlen,
+			(const unsigned char*)s, &inlen,
+			transcoder(0)->outputInfo);
+	} else
+		memcpy(out, s, size=inlen);
 	if(size<0)
-		throw Exception(0, 0,
+		throw Exception(0,
 			0,
 			"transcode_cstr failed (%d)", size);
 
 	out[size]=0;
 	return out;
 }
+String& Charset::transcode(xmlChar *s) { 
+	return *NEW String(pool(), transcode_cstr(s)); 
+}
+const char *Charset::transcode_cstr(GdomeDOMString *s) { 
+	return s?transcode_cstr(BAD_CAST s->str):"";
+}
 String& Charset::transcode(GdomeDOMString *s) { 
 	return *NEW String(pool(), transcode_cstr(s)); 
 }
 
 /// @test less memory using -maybe- xmlParserInputBufferCreateMem
-GdomeDOMString *Charset::transcode_buf(const char *buf, size_t buf_size) { 
-	if(!transcoder)
-		throw Exception(0, 0,
-			0,
-			"transcode_buf no transcoder");
-
+xmlChar *Charset::transcode_buf2xchar(const char *buf, size_t buf_size) {
 	int outlen=buf_size*6/*max*/+1;
 	unsigned char *out=(unsigned char*)malloc(outlen*sizeof(unsigned char));
-	int size=transcoder->input(
-		out, &outlen,
-		(const unsigned char *)buf,  (int *)&buf_size,
-		transcoder->inputInfo);
+
+	int size;
+	if(xmlCharEncodingInputFunc input=transcoder(0)->input) {
+		size=input(
+			out, &outlen,
+			(const unsigned char *)buf,  (int *)&buf_size,
+			transcoder(0)->inputInfo);
+	} else
+		memcpy(out, buf, size=buf_size);
+	
 	if(size<0)
-		throw Exception(0, 0,
+		throw Exception(0,
 			0,
 			"transcode_buf failed (%d)", size);
 
 	out[size]=0;
-	return gdome_str_mkref_own((gchar*)out);
+	return (xmlChar *)out;
+}
+GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char *buf, size_t buf_size) { 
+	return GdomeDOMString_auto_ptr((gchar*)transcode_buf2xchar(buf, buf_size));
 }
-GdomeDOMString *Charset::transcode(const String& s) { 
+GdomeDOMString_auto_ptr Charset::transcode(const String& s) { 
 	const char *cstr=s.cstr(String::UL_UNSPECIFIED);
 
-	return transcode_buf(cstr, strlen(cstr)); 
+	return transcode_buf2dom(cstr, strlen(cstr)); 
 }
 #endif