--- parser3/src/main/pa_charset.C 2003/11/20 16:34:26 1.41 +++ parser3/src/main/pa_charset.C 2008/07/21 07:36:42 1.64 @@ -1,11 +1,11 @@ /** @file Parser: Charset connection implementation. - Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan(http://paf.design.ru) */ -static const char * const IDENT_CHARSET_C="$Date: 2003/11/20 16:34:26 $"; +static const char * const IDENT_CHARSET_C="$Date: 2008/07/21 07:36:42 $"; #include "pa_charset.h" #include "pa_charsets.h" @@ -14,6 +14,9 @@ static const char * const IDENT_CHARSET_ #include "libxml/encoding.h" #endif +//#define PA_PATCHED_LIBXML_BACKWARD +#define PRECALCULATE_DEST_LENGTH + // globals Charset::UTF8CaseTable::Rec UTF8CaseToUpperRecords[]={ @@ -36,7 +39,7 @@ inline void prepare_case_tables(unsigned unsigned char *lcc_table=tables+lcc_offset; unsigned char *fcc_table=tables+fcc_offset; for(int i=0; i<0x100; i++) - lcc_table[i]=fcc_table[i]=i; + lcc_table[i]=fcc_table[i]=(unsigned char)i; } inline void cstr2ctypes(unsigned char *tables, const unsigned char *cstr, unsigned char bit) { @@ -126,29 +129,29 @@ void Charset::load_definition(Request_ch // parse cells char *row; - while(row=getrow(&data)) { + while((row=getrow(&data))) { // remove empty&comment lines if(!*row || *row=='#') continue; // char white-space digit hex-digit letter word lowercase unicode1 unicode2 - unsigned int c=0; + unsigned char c=0; char *cell; - for(int column=0; cell=lsplit(&row, '\t'); column++) { + for(int column=0; (cell=lsplit(&row, '\t')); column++) { switch(column) { - case 0: c=to_wchar_code(cell); break; + case 0: c=(unsigned char)to_wchar_code(cell); break; // pcre_tables case 1: element2ctypes(c, to_bool(cell), pcre_tables, ctype_space, cbit_space); break; case 2: element2ctypes(c, to_bool(cell), pcre_tables, ctype_digit, cbit_digit); break; case 3: element2ctypes(c, to_bool(cell), pcre_tables, ctype_xdigit); break; case 4: element2ctypes(c, to_bool(cell), pcre_tables, ctype_letter); break; case 5: element2ctypes(c, to_bool(cell), pcre_tables, ctype_word, cbit_word); break; - case 6: element2case(c, to_wchar_code(cell), pcre_tables); break; + case 6: element2case(c, (unsigned char)to_wchar_code(cell), pcre_tables); break; case 7: case 8: // charset if(tables.toTableSize>MAX_CHARSET_UNI_CODES) - throw Exception("parser.runtime", + throw Exception(PARSER_RUNTIME, &afile_spec, "charset must contain not more then %d unicode values", MAX_CHARSET_UNI_CODES); @@ -185,6 +188,7 @@ void Charset::sort_ToTable() { //fclose(f); } +// @todo: precache for spedup searching static XMLByte xlatOneTo(const XMLCh toXlat, const Charset::Tables& tables, XMLByte not_found) { @@ -314,17 +318,17 @@ static int transcodeToUTF8(const XMLByte // here, so bump up the output pointer and work down as we go. outPtr+= encodedBytes; switch(encodedBytes) { - case 6: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 5: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 4: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 3: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 2: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); - curVal>>= 6; - case 1: *--outPtr = XMLByte(curVal | gFirstByteMark[encodedBytes]); + case 6: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 5: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 4: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 3: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 2: *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL); + curVal>>= 6; + case 1: *--outPtr = XMLByte(curVal | gFirstByteMark[encodedBytes]); } // Add the encoded bytes back in again to indicate we've eaten them @@ -362,7 +366,7 @@ static int transcodeFromUTF8(const XMLBy const XMLByte firstByte =* srcPtr; // Special-case ASCII, which is a leading byte value of<= 127 - if(firstByte<= 127) { + if(firstByte<=127) { *outPtr++= firstByte; srcPtr++; continue; @@ -391,7 +395,7 @@ static int transcodeFromUTF8(const XMLBy default: throw Exception(0, 0, - "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes); + "transcodeFromUTF8 error: wrong trailingBytes value(%d)", trailingBytes); // never } tmpVal-=gUTFOffsets[trailingBytes]; @@ -401,12 +405,14 @@ static int transcodeFromUTF8(const XMLBy if(!(tmpVal & 0xFFFF0000)) { if(XMLByte xlat=xlatOneTo(tmpVal, tables, 0)) *outPtr++=xlat; - else - outPtr+=sprintf((char *)outPtr, "&#%d;", tmpVal); // &#decimal; - } else - throw Exception(0, - 0, - "transcodeFromUTF8 error: too big tmpVal(0x%08X)", tmpVal); + else { + outPtr+=sprintf((char *)outPtr, "&#%u;", tmpVal); // &#decimal; + } + } else { + const XMLByte* recoverPtr=srcPtr-trailingBytes-1; + for(uint i=0; i<=trailingBytes; i++) + outPtr+=sprintf((char*)outPtr, "%%%02X", *recoverPtr++); + } } // Update the bytes eaten @@ -426,10 +432,241 @@ of ocetes consumed. return 0; } -/// @todo not so memory-hungry with prescan +static bool is_escaped(char c){ + return + !(c<=127 + && ( + ((c>='0') && (c<='9')) + || ((c>='A') && (c<='Z')) + || ((c>='a') && (c<='z')) + || strchr("*@-_+./", c)!=0 + )); +} + +// read one utf8 character, return number of bytes needed for store it +static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + firstByte=*srcPtr; + + if(firstByte<=127){ + UTF8Char=firstByte; + srcPtr++; + return 1; + } + + unsigned int trailingBytes=gUTFBytes[firstByte]; + + if(srcPtr+trailingBytes>=srcEnd){ + return 0; // not enough bytes in source string for reading + } + + uint tmpVal=0; + switch(trailingBytes){ + case 5: tmpVal+=*srcPtr++; tmpVal<<=6; + case 4: tmpVal+=*srcPtr++; tmpVal<<=6; + case 3: tmpVal+=*srcPtr++; tmpVal<<=6; + case 2: tmpVal+=*srcPtr++; tmpVal<<=6; + case 1: tmpVal+=*srcPtr++; tmpVal<<=6; + case 0: tmpVal+=*srcPtr++; + } + + tmpVal-=gUTFOffsets[trailingBytes]; + UTF8Char=tmpVal; + + return trailingBytes+1; +} + +static unsigned int skipChar(const XMLByte*& srcPtr, const XMLByte* srcEnd){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + unsigned int trailingBytes=gUTFBytes[*srcPtr]+1; + srcPtr+=trailingBytes; + + return trailingBytes; +} + +// read char, return number of bytes needed for store it as UTF8 +static unsigned int readChar(const XMLByte*& srcPtr, const XMLByte* srcEnd, XMLByte& firstByte, XMLCh& UTF8Char, const Charset::Tables& tables){ + if(!srcPtr || !*srcPtr || srcPtr>=srcEnd) + return 0; + + firstByte=*srcPtr++; + UTF8Char=tables.fromTable[firstByte]; + + if(UTF8Char<0x80) + return 1; + else if(UTF8Char<0x800) + return 2; + else if(UTF8Char<0x10000) + return 3; + else if(UTF8Char<0x200000) + return 4; + else if(UTF8Char<0x4000000) + return 5; + else if(UTF8Char<= 0x7FFFFFFF) + return 6; + + // will use the replacement character '?' + firstByte=0; + return 1; +} + +static int escape(const XMLByte* srcData, size_t& srcLen, + XMLByte* toFill, size_t& toFillLen) { + const XMLByte* srcPtr=srcData; + const XMLByte* srcEnd=srcData+srcLen; + XMLByte* outPtr=toFill; + XMLByte* outEnd=toFill+toFillLen; + XMLByte firstByte; + XMLCh UTF8Char; + uint charSize; + + // loop until we either run out of input data, or room to store + while((outPtr < outEnd) && (charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char))){ + if(charSize==1){ + if(is_escaped(firstByte)) // %XX + outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte); + else + *outPtr++=firstByte; + } else + outPtr+=sprintf((char*)outPtr, "%%u%04X", UTF8Char); // %uXXXX + } + + // Update the bytes eaten + srcLen=srcPtr-srcData; + + // Return the characters read + toFillLen=outPtr-toFill; + + return 0; +} + +static int escape(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; + XMLByte firstByte; + XMLCh UTF8Char; + uint charSize; + + while(charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)){ + if(charSize==1){ + if(firstByte){ + if(is_escaped(firstByte)) // %XX + outPtr+=sprintf((char*)outPtr, "%%%02X", firstByte); + else + *outPtr++=firstByte; + } else // add replacement char '?' + *outPtr++='?'; + } else + outPtr+=sprintf((char*)outPtr, "%%u%04X", UTF8Char); // %uXXXX + } + + // Update the bytes eaten + srcLen = srcPtr - srcData; + + // Return the characters read + toFillLen = outPtr - toFill; + + return 0; +} + + +String::C Charset::escape(const String::C src, const Charset& source_charset){ + size_t src_length=src.length; + if(!src_length) + return String::C("", 0); + +#ifdef PRECALCULATE_DEST_LENGTH + size_t dest_length=0; + const XMLByte* srcPtr=(XMLByte*)src.str; + const XMLByte* srcEnd=srcPtr+src_length; + XMLByte firstByte; + XMLCh UTF8Char; + + if(source_charset.isUTF8()){ + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char)){ + if(charSize==1) + dest_length+=!is_escaped(firstByte)?1:3/*%XX*/; + else + dest_length+=6; // '%uXXXX' + } + } else { + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, source_charset.tables)){ + if(charSize==1) + dest_length+=(!firstByte/*replacement char '?'*/ || !is_escaped(firstByte))?1:3/*'%XX'*/; + else + dest_length+=6; // '%uXXXX' + } + } +#else + size_t dest_length=src_length*6; // enough for %uXXXX but too memory-hungry +#endif + + //throw Exception(0,0,"%u",dest_length); + +#ifndef NDEBUG + size_t saved_dest_length=dest_length; +#endif + XMLByte *dest_body=new(PointerFreeGC) XMLByte[dest_length+1/*for terminator*/]; + + int status; + if(source_charset.isUTF8()){ + status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length); + } else { + status=::escape((XMLByte *)src.str, src_length, dest_body, dest_length, source_charset.tables); + } + + if(status<0) + throw Exception(0, + 0, + "Charset::escapeString buffer overflow"); + + assert(dest_length<=saved_dest_length); + dest_body[dest_length]=0; // terminator + return String::C((char*)dest_body, dest_length); +} + +String::Body Charset::escape(const String::Body src, const Charset& source_charset) { + const char *src_ptr=src.cstr(); + size_t src_size=strlen(src_ptr); + + String::C dest=Charset::escape(String::C(src_ptr, src_size), + source_charset); + + return String::Body(dest.str, dest.length); +} + +String& Charset::escape(const String& src, const Charset& source_charset) { + if(!src.length()) + return *new String("", 0, false); + + return *new String(escape((String::Body)src, source_charset), String::L_CLEAN); +} + 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*/; + +#ifdef PRECALCULATE_DEST_LENGTH + size_t dest_length=0; + const XMLByte* srcPtr=(XMLByte*)src.str; + const XMLByte* srcEnd=srcPtr+src_length; + XMLByte firstByte; + XMLCh UTF8Char; + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char, tables)) + dest_length+=charSize; +#else + size_t dest_length=src_length*6; // so that surly enough (max utf8 seq len=6) but too memory-hyngry +#endif + + //throw Exception(0,0,"%u",dest_length); + #ifndef NDEBUG size_t saved_dest_length=dest_length; #endif @@ -439,11 +676,12 @@ const String::C Charset::transcodeToUTF8 (XMLByte *)src.str, src_length, dest_body, dest_length, tables)<0) - throw(0, 0, + throw Exception(0, 0, "Charset::transcodeToUTF8 buffer overflow"); - assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); + dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } @@ -467,7 +705,7 @@ static XMLCh change_case_UTF8(const XMLC return src; } -static void store_UTF8(XMLCh src, XMLByte*& outPtr ) { +static void store_UTF8(XMLCh src, XMLByte*& outPtr){ if(!src) { // use the replacement character *outPtr++= '?'; @@ -519,14 +757,20 @@ static void change_case_UTF8(XMLCh src, const Charset::UTF8CaseTable& table) { store_UTF8(change_case_UTF8(src, table), outPtr); }; -void change_case_UTF8(const XMLByte* srcData, XMLByte* toFill, - const Charset::UTF8CaseTable& table) { +void change_case_UTF8(const XMLByte* srcData, size_t srcLen, + XMLByte* toFill, size_t toFillLen, + const Charset::UTF8CaseTable& table) { const XMLByte* srcPtr=srcData; + const XMLByte* srcEnd=srcData+srcLen; XMLByte* outPtr=toFill; + XMLByte* outEnd=toFill+toFillLen; - // Get the next leading byte out - while (const XMLByte firstByte = *srcPtr) { - if(firstByte<= 127) { + // We now loop until we either run out of input data, or room to store + while ((srcPtr < srcEnd) && (outPtr < outEnd)) { + // Get the next leading byte out + const XMLByte firstByte =* srcPtr; + + if(firstByte<=127) { change_case_UTF8(firstByte, outPtr, table); srcPtr++; continue; @@ -570,10 +814,43 @@ void change_case_UTF8(const XMLByte* src "change_case_UTF8 error: end pointers do not match"); } +static size_t getDecNumLength(XMLCh UTF8Char){ + return + (UTF8Char < 100) + ?2 + :(UTF8Char < 1000) + ?3 + :(UTF8Char < 10000) + ?4 + :5; +} 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, "ÿ" has max ratio */; + +#ifdef PRECALCULATE_DEST_LENGTH + size_t dest_length=0; + const XMLByte* srcPtr=(XMLByte*)src.str; + const XMLByte* srcEnd=srcPtr+src_length; + XMLByte firstByte; + XMLCh UTF8Char; + while(uint charSize=readChar(srcPtr, srcEnd, firstByte, UTF8Char)){ + if(charSize==1) + dest_length++; + else + dest_length+=(UTF8Char & 0xFFFF0000) + ?charSize*3 // '%XX' for each byte + :(xlatOneTo(UTF8Char, tables, 0)!=0) + ?1 // can convert it to single char + :getDecNumLength(UTF8Char)+3; // &#XX; - &#XXXXX; + } +#else + // so that surly enough, "&#XXX;" has max ratio (huh? 8 bytes needed for '&#XXXXX;') + size_t dest_length=src_length*6; +#endif + + //throw Exception(0,0,"%u",dest_length); + #ifndef NDEBUG size_t saved_dest_length=dest_length; #endif @@ -583,11 +860,12 @@ const String::C Charset::transcodeFromUT (XMLByte *)src.str, src_length, dest_body, dest_length, tables)<0) - throw(0, 0, + throw Exception(0, 0, "Charset::transcodeFromUTF8 buffer overflow"); - assert(dest_length<=saved_dest_length); dest_body[dest_length]=0; // terminator + assert(dest_length<=saved_dest_length); + dest_body[dest_length]=0; // terminator return String::C((char*)dest_body, dest_length); } @@ -614,10 +892,39 @@ const String::C Charset::transcodeToChar } } +void Charset::store_Char(XMLByte*& outPtr, XMLCh src, XMLByte not_found){ + if(isUTF8()) + store_UTF8(src, outPtr); + else if(char ch=xlatOneTo(src, tables, not_found)) + *outPtr++=ch; +} + #ifdef XML static const Charset::Tables* tables[MAX_CHARSETS]; +#ifdef PA_PATCHED_LIBXML_BACKWARD + +#define declareXml256ioFuncs(i) \ + static int xml256CharEncodingInputFunc##i( \ + unsigned char *out, int *outlen, \ + const unsigned char *in, int *inlen, void*) { \ + 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, void*) { \ + return transcodeFromUTF8( \ + in, *(size_t*)inlen, \ + out, *(size_t*)outlen, \ + *tables[i]); \ + } + +#else + #define declareXml256ioFuncs(i) \ static int xml256CharEncodingInputFunc##i( \ unsigned char *out, int *outlen, \ @@ -636,6 +943,9 @@ static const Charset::Tables* tables[MAX *tables[i]); \ } +#endif + + declareXml256ioFuncs(0) declareXml256ioFuncs(1) declareXml256ioFuncs(2) declareXml256ioFuncs(3) declareXml256ioFuncs(4) declareXml256ioFuncs(5) @@ -665,7 +975,7 @@ void Charset::addEncoding(char *name_cst "already allocated %d handlers, no space for new encoding '%s'", MAX_CHARSETS, name_cstr); - xmlCharEncodingHandler* handler=new(PointerFreeGC) xmlCharEncodingHandler; + xmlCharEncodingHandler* handler=new(UseGC) xmlCharEncodingHandler; { handler->name=name_cstr; handler->input=inputFuncs[handlers_count]; @@ -685,18 +995,18 @@ void Charset::initTranscoder(const Strin xmlCharEncodingHandler& Charset::transcoder(const String::Body NAME) { if(!ftranscoder) - throw Exception("parser.runtime", + throw Exception(PARSER_RUNTIME, new String(NAME, String::L_TAINTED), "unsupported encoding"); return *ftranscoder; } -String::C Charset::transcode_cstr(xmlChar* s) { +String::C Charset::transcode_cstr(const xmlChar* s) { if(!s) return String::C("", 0); int inlen=strlen((const char*)s); - int outlen=inlen; // max + int outlen=inlen*6/*strlen("ÿ")*/; // max #ifndef NDEBUG int saved_outlen=outlen; #endif @@ -706,7 +1016,11 @@ String::C Charset::transcode_cstr(xmlCha if(xmlCharEncodingOutputFunc output=transcoder(FNAME).output) { error=output( (unsigned char*)out, &outlen, - (const unsigned char*)s, &inlen); + (const unsigned char*)s, &inlen +#ifdef PA_PATCHED_LIBXML_BACKWARD + ,0 +#endif + ); } else { memcpy(out, s, outlen=inlen); error=0; @@ -719,15 +1033,7 @@ String::C Charset::transcode_cstr(xmlCha assert(outlen<=saved_outlen); out[outlen]=0; return String::C(out, outlen); } -const String& Charset::transcode(xmlChar* s) { - String::C cstr=transcode_cstr(s); - return *new String(cstr.str, cstr.length, true); -} -String::C Charset::transcode_cstr(GdomeDOMString* s) { - return s?transcode_cstr(BAD_CAST s->str) - :String::C("", 0); -} -const String& Charset::transcode(GdomeDOMString* s) { +const String& Charset::transcode(const xmlChar* s) { String::C cstr=transcode_cstr(s); return *new String(cstr.str, cstr.length, true); } @@ -741,14 +1047,18 @@ xmlChar* Charset::transcode_buf2xchar(co int saved_outlen; #endif if(xmlCharEncodingInputFunc input=transcoder(FNAME).input) { - outlen=buf_size*6/*max*/; + outlen=buf_size*6/*max UTF8 bytes per char*/; #ifndef NDEBUG saved_outlen=outlen; #endif out=(xmlChar*)xmlMalloc(outlen+1); error=input( out, &outlen, - (const unsigned char*)buf, (int*)&buf_size); + (const unsigned char*)buf, (int*)&buf_size +#ifdef PA_PATCHED_LIBXML_BACKWARD + ,0 +#endif + ); } else { outlen=buf_size; #ifndef NDEBUG @@ -767,18 +1077,15 @@ xmlChar* Charset::transcode_buf2xchar(co assert(outlen<=saved_outlen); out[outlen]=0; return out; } -GdomeDOMString_auto_ptr Charset::transcode_buf2dom(const char* buf, size_t buf_size) { - return GdomeDOMString_auto_ptr(transcode_buf2xchar(buf, buf_size)); -} -GdomeDOMString_auto_ptr Charset::transcode(const String& s) { +xmlChar* Charset::transcode(const String& s) { const char* cstr=s.cstr(String::L_UNSPECIFIED); - return transcode_buf2dom(cstr, strlen(cstr)); + return transcode_buf2xchar(cstr, strlen(cstr)); } -GdomeDOMString_auto_ptr Charset::transcode(const String::Body s) { +xmlChar* Charset::transcode(const String::Body s) { const char* cstr=s.cstr(); - return transcode_buf2dom(cstr, s.length()); + return transcode_buf2xchar(cstr, s.length()); } #endif @@ -825,9 +1132,41 @@ static void transcode_pair(const String: *info->source_transcoder, *info->dest_transcoder); } + void Charset::transcode(HashStringString& src, const Charset& source_transcoder, const Charset& dest_transcoder) { Transcode_pair_info info={&source_transcoder, &dest_transcoder}; - src.for_each_ref(transcode_pair, &info); + src.for_each_ref(transcode_pair, &info); +} + +size_t getUTF8BytePos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t charPos){ + const XMLByte* ptr=srcBegin; + while(charPos-- && skipChar(ptr, srcEnd)); + + return ptr-srcBegin; +} + +size_t getUTF8CharPos(const XMLByte* srcBegin, const XMLByte* srcEnd, size_t bytePos){ + size_t charPos=0; + const XMLByte* ptr=srcBegin; + const XMLByte* ptrEnd=srcBegin+bytePos; + while(skipChar(ptr, srcEnd)){ + if(ptr>ptrEnd) + return charPos; + charPos++; + } + + // scan till end but position in bytes still too low + throw Exception(0, + 0, + "Error convertion byte pos to char pos"); +} + +size_t lengthUTF8(const XMLByte* srcBegin, const XMLByte* srcEnd){ + size_t size=0; + while(skipChar(srcBegin, srcEnd)) + size++; + + return size; }