You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by tn...@apache.org on 2002/12/31 19:42:54 UTC

cvs commit: xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU IconvGNUTransService.cpp

tng         2002/12/31 10:42:54

  Modified:    c/src/xercesc/util/Transcoders/IconvGNU
                        IconvGNUTransService.cpp
  Log:
  [Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
  
  Revision  Changes    Path
  1.4       +533 -530  xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
  
  Index: IconvGNUTransService.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- IconvGNUTransService.cpp	4 Nov 2002 15:14:34 -0000	1.3
  +++ IconvGNUTransService.cpp	31 Dec 2002 18:42:54 -0000	1.4
  @@ -56,6 +56,9 @@
   
   /*
    * $Log$
  + * Revision 1.4  2002/12/31 18:42:54  tng
  + * [Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
  + *
    * Revision 1.3  2002/11/04 15:14:34  tng
    * C++ Namespace Support.
    *
  @@ -83,15 +86,15 @@
   // Description of encoding schemas, supported by iconv()
   // ---------------------------------------------------------------------------
   typedef struct __IconvGNUEncoding {
  -    const char*	fSchema;	// schema name
  -    size_t	fUChSize;	// size of the character
  -    unsigned int fUBO;		// byte order, relative to the host
  +    const char*    fSchema;    // schema name
  +    size_t    fUChSize;    // size of the character
  +    unsigned int fUBO;        // byte order, relative to the host
   } IconvGNUEncoding;
   
  -static const IconvGNUEncoding	gIconvGNUEncodings[] = {
  -    { "UCS-2LE",		2,	LITTLE_ENDIAN },
  -    { "ucs-2-internal",		2,	LITTLE_ENDIAN },
  -    { NULL, 0,	0 }
  +static const IconvGNUEncoding    gIconvGNUEncodings[] = {
  +    { "UCS-2LE",        2,    LITTLE_ENDIAN },
  +    { "ucs-2-internal",        2,    LITTLE_ENDIAN },
  +    { NULL, 0,    0 }
   };
   
   //--------------------------------------------------
  @@ -100,59 +103,59 @@
   // and encoding schemas.
   
   # if BYTE_ORDER == LITTLE_ENDIAN
  -#  define IXMLCh2WC16(x,w)			\
  -	*(w) = ((*(x)) >> 8) & 0xFF;		\
  -	*((w)+1) = (*(x)) & 0xFF
  -#  define IWC162XMLCh(w,x)	*(x) = ((*(w)) << 8) | (*((w)+1))
  -#  define XMLCh2WC16(x,w)			\
  -	*(w) = (*(x)) & 0xFF;			\
  -	*((w)+1) = ((*(x)) >> 8) & 0xFF
  -#  define WC162XMLCh(w,x)	*(x) = ((*((w)+1)) << 8) | (*(w))
  -
  -#  define IXMLCh2WC32(x,w)			\
  -	*(w) = ((*(x)) >> 24) & 0xFF;		\
  -	*((w)+1) = ((*(x)) >> 16) & 0xFF;	\
  -	*((w)+2) = ((*(x)) >> 8) & 0xFF;	\
  -	*((w)+3) = (*(x)) & 0xFF
  -#  define IWC322XMLCh(w,x)				\
  -	  *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |	\
  -		  ((*((w)+2)) << 8) | (*((w)+3))
  -#  define XMLCh2WC32(x,w)			\
  -	*((w)+3) = ((*(x)) >> 24) & 0xFF;	\
  -	*((w)+2) = ((*(x)) >> 16) & 0xFF;	\
  -	*((w)+1) = ((*(x)) >> 8) & 0xFF;	\
  -	*(w) = (*(x)) & 0xFF
  -#  define WC322XMLCh(w,x)					\
  -	  *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |	\
  -		((*((w)+1)) << 8) | (*(w))
  +#  define IXMLCh2WC16(x,w)            \
  +    *(w) = ((*(x)) >> 8) & 0xFF;        \
  +    *((w)+1) = (*(x)) & 0xFF
  +#  define IWC162XMLCh(w,x)    *(x) = ((*(w)) << 8) | (*((w)+1))
  +#  define XMLCh2WC16(x,w)            \
  +    *(w) = (*(x)) & 0xFF;            \
  +    *((w)+1) = ((*(x)) >> 8) & 0xFF
  +#  define WC162XMLCh(w,x)    *(x) = ((*((w)+1)) << 8) | (*(w))
  +
  +#  define IXMLCh2WC32(x,w)            \
  +    *(w) = ((*(x)) >> 24) & 0xFF;        \
  +    *((w)+1) = ((*(x)) >> 16) & 0xFF;    \
  +    *((w)+2) = ((*(x)) >> 8) & 0xFF;    \
  +    *((w)+3) = (*(x)) & 0xFF
  +#  define IWC322XMLCh(w,x)                \
  +      *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |    \
  +          ((*((w)+2)) << 8) | (*((w)+3))
  +#  define XMLCh2WC32(x,w)            \
  +    *((w)+3) = ((*(x)) >> 24) & 0xFF;    \
  +    *((w)+2) = ((*(x)) >> 16) & 0xFF;    \
  +    *((w)+1) = ((*(x)) >> 8) & 0xFF;    \
  +    *(w) = (*(x)) & 0xFF
  +#  define WC322XMLCh(w,x)                    \
  +      *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |    \
  +        ((*((w)+1)) << 8) | (*(w))
   
   # else /* BYTE_ORDER != LITTLE_ENDIAN */
   
  -#  define XMLCh2WC16(x,w)			\
  -	*(w) = ((*(x)) >> 8) & 0xFF;		\
  -	*((w)+1) = (*(x)) & 0xFF
  -#  define WC162XMLCh(w,x)	*(x) = ((*(w)) << 8) | (*((w)+1))
  -#  define IXMLCh2WC16(x,w)			\
  -	*(w) = (*(x)) & 0xFF;			\
  -	*((w)+1) = ((*(x)) >> 8) & 0xFF
  -#  define IWC162XMLCh(w,x)	*(x) = ((*((w)+1)) << 8) | (*(w))
  -
  -#  define XMLCh2WC32(x,w)			\
  -	*(w) = ((*(x)) >> 24) & 0xFF;		\
  -	*((w)+1) = ((*(x)) >> 16) & 0xFF;	\
  -	*((w)+2) = ((*(x)) >> 8) & 0xFF;	\
  -	*((w)+3) = (*(x)) & 0xFF
  -#  define WC322XMLCh(w,x)				\
  -	  *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |	\
  -		  ((*((w)+2)) << 8) | (*((w)+3))
  -#  define IXMLCh2WC32(x,w)			\
  -	*((w)+3) = ((*(x)) >> 24) & 0xFF;	\
  -	*((w)+2) = ((*(x)) >> 16) & 0xFF;	\
  -	*((w)+1) = ((*(x)) >> 8) & 0xFF;	\
  -	*(w) = (*(x)) & 0xFF
  -#  define IWC322XMLCh(w,x)					\
  -	  *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |	\
  -		((*((w)+1)) << 8) | (*(w))
  +#  define XMLCh2WC16(x,w)            \
  +    *(w) = ((*(x)) >> 8) & 0xFF;        \
  +    *((w)+1) = (*(x)) & 0xFF
  +#  define WC162XMLCh(w,x)    *(x) = ((*(w)) << 8) | (*((w)+1))
  +#  define IXMLCh2WC16(x,w)            \
  +    *(w) = (*(x)) & 0xFF;            \
  +    *((w)+1) = ((*(x)) >> 8) & 0xFF
  +#  define IWC162XMLCh(w,x)    *(x) = ((*((w)+1)) << 8) | (*(w))
  +
  +#  define XMLCh2WC32(x,w)            \
  +    *(w) = ((*(x)) >> 24) & 0xFF;        \
  +    *((w)+1) = ((*(x)) >> 16) & 0xFF;    \
  +    *((w)+2) = ((*(x)) >> 8) & 0xFF;    \
  +    *((w)+3) = (*(x)) & 0xFF
  +#  define WC322XMLCh(w,x)                \
  +      *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |    \
  +          ((*((w)+2)) << 8) | (*((w)+3))
  +#  define IXMLCh2WC32(x,w)            \
  +    *((w)+3) = ((*(x)) >> 24) & 0xFF;    \
  +    *((w)+2) = ((*(x)) >> 16) & 0xFF;    \
  +    *((w)+1) = ((*(x)) >> 8) & 0xFF;    \
  +    *(w) = (*(x)) & 0xFF
  +#  define IWC322XMLCh(w,x)                    \
  +      *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |    \
  +        ((*((w)+1)) << 8) | (*(w))
   # endif /* BYTE_ORDER == LITTLE_ENDIAN */
   
   #include <wchar.h>
  @@ -172,8 +175,8 @@
   // ---------------------------------------------------------------------------
   //  Local, const data
   // ---------------------------------------------------------------------------
  -static const unsigned int	gTempBuffArraySize = 4096;
  -static const XMLCh		gMyServiceId[] =
  +static const unsigned int    gTempBuffArraySize = 4096;
  +static const XMLCh        gMyServiceId[] =
   {
       chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull
   };
  @@ -199,8 +202,8 @@
   
   #include <xercesc/util/Mutexes.hpp>
   // Iconv() access syncronization point
  -static XMLMutex	*gIconvMutex = NULL;
  -#  define ICONV_LOCK	XMLMutexLock lockConverter(gIconvMutex);
  +static XMLMutex    *gIconvMutex = NULL;
  +#  define ICONV_LOCK    XMLMutexLock lockConverter(gIconvMutex);
   
   #else /* APP_NO_THREADS */
   
  @@ -219,15 +222,15 @@
   {
   }
   
  -IconvGNUWrapper::IconvGNUWrapper ( iconv_t	cd_from,
  -			   iconv_t	cd_to,
  -			   size_t	uchsize,
  -			   unsigned int	ubo )
  +IconvGNUWrapper::IconvGNUWrapper ( iconv_t    cd_from,
  +               iconv_t    cd_to,
  +               size_t    uchsize,
  +               unsigned int    ubo )
       : fUChSize(uchsize), fUBO(ubo),
         fCDTo(cd_to), fCDFrom(cd_from)
   {
       if (fCDFrom == (iconv_t) -1 || fCDTo == (iconv_t) -1) {
  -	XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
  +    XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
       }
   }
   
  @@ -236,66 +239,66 @@
   }
   
   // Convert "native unicode" character into XMLCh
  -void	IconvGNUWrapper::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
  +void    IconvGNUWrapper::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
   {
       if (fUBO == LITTLE_ENDIAN) {
  -	if (fUChSize == sizeof(XMLCh))
  -	    *toRet = *((XMLCh*) mbc);
  -	else if (fUChSize == 2) {
  -	    WC162XMLCh( mbc, toRet );
  -	} else {
  -	    WC322XMLCh( mbc, toRet );
  -	}
  +        if (fUChSize == sizeof(XMLCh))
  +            *toRet = *((XMLCh*) mbc);
  +        else if (fUChSize == 2) {
  +            WC162XMLCh( mbc, toRet );
  +        } else {
  +            WC322XMLCh( mbc, toRet );
  +        }
       } else {
  -	if (fUChSize == 2) {
  -	    IWC162XMLCh( mbc, toRet );
  -	} else {
  -	    IWC322XMLCh( mbc, toRet );
  -	}
  +        if (fUChSize == 2) {
  +            IWC162XMLCh( mbc, toRet );
  +        } else {
  +            IWC322XMLCh( mbc, toRet );
  +        }
       }
   }
   
   // Convert XMLCh into "native unicode" character
  -void	IconvGNUWrapper::xmlChToMbc (XMLCh xch, char *mbc) const
  +void    IconvGNUWrapper::xmlChToMbc (XMLCh xch, char *mbc) const
   {
       if (fUBO == LITTLE_ENDIAN) {
  -	if (fUChSize == sizeof(XMLCh)) {
  -	    memcpy (mbc, &xch, fUChSize);
  -	    return;
  -	}
  -	if (fUChSize == 2) {
  -	    XMLCh2WC16( &xch, mbc );
  -	} else {
  -	    XMLCh2WC32( &xch, mbc );
  -	}
  +        if (fUChSize == sizeof(XMLCh)) {
  +            memcpy (mbc, &xch, fUChSize);
  +            return;
  +        }
  +        if (fUChSize == 2) {
  +            XMLCh2WC16( &xch, mbc );
  +        } else {
  +            XMLCh2WC32( &xch, mbc );
  +        }
       } else {
  -	if (fUChSize == 2) {
  -	    IXMLCh2WC16( &xch, mbc );
  -	} else {
  -	    IXMLCh2WC32( &xch, mbc );
  -	}
  +        if (fUChSize == 2) {
  +            IXMLCh2WC16( &xch, mbc );
  +        } else {
  +            IXMLCh2WC32( &xch, mbc );
  +        }
       }
   }
   
   // Return uppercase equivalent for XMLCh
  -XMLCh	IconvGNUWrapper::toUpper (const XMLCh ch) const
  +XMLCh    IconvGNUWrapper::toUpper (const XMLCh ch) const
   {
       if (ch <= 0x7F)
  -	return toupper(ch);
  +        return toupper(ch);
   
  -    char	wcbuf[fUChSize * 2];
  +    char    wcbuf[fUChSize * 2];
       xmlChToMbc (ch, wcbuf);
   
  -    char	tmpArr[4];
  -    char*	ptr = wcbuf;
  -    size_t	len = fUChSize;
  -    char	*pTmpArr = tmpArr;
  -    size_t	bLen = 2;
  +    char    tmpArr[4];
  +    char*    ptr = wcbuf;
  +    size_t    len = fUChSize;
  +    char    *pTmpArr = tmpArr;
  +    size_t    bLen = 2;
   
       ICONV_LOCK;
       if (::iconv (fCDTo, &ptr, &len,
  -		 &pTmpArr, &bLen) == (size_t) -1)
  -	return 0;
  +         &pTmpArr, &bLen) == (size_t) -1)
  +    return 0;
       tmpArr[1] = toupper (*((unsigned char *)tmpArr));
       *tmpArr = tmpArr[1];
       len = 1;
  @@ -303,31 +306,31 @@
       bLen = fUChSize;
       ptr = tmpArr;
       if (::iconv (fCDFrom, &ptr, &len,
  -		 &pTmpArr, &bLen) == (size_t) -1)
  -	return 0;
  +         &pTmpArr, &bLen) == (size_t) -1)
  +    return 0;
       mbcToXMLCh (wcbuf, (XMLCh*) &ch);
       return ch;
   }
   
   // Return lowercase equivalent for XMLCh
  -XMLCh	IconvGNUWrapper::toLower (const XMLCh ch) const
  +XMLCh    IconvGNUWrapper::toLower (const XMLCh ch) const
   {
       if (ch <= 0x7F)
  -	return tolower(ch);
  +        return tolower(ch);
   
  -    char	wcbuf[fUChSize * 2];
  +    char    wcbuf[fUChSize * 2];
       xmlChToMbc (ch, wcbuf);
   
  -    char	tmpArr[4];
  -    char*	ptr = wcbuf;
  -    size_t	len = fUChSize;
  -    char	*pTmpArr = tmpArr;
  -    size_t	bLen = 2;
  +    char    tmpArr[4];
  +    char*    ptr = wcbuf;
  +    size_t    len = fUChSize;
  +    char    *pTmpArr = tmpArr;
  +    size_t    bLen = 2;
   
       ICONV_LOCK;
       if (::iconv (fCDTo, &ptr, &len,
  -		 &pTmpArr, &bLen) == (size_t) -1)
  -	return 0;
  +         &pTmpArr, &bLen) == (size_t) -1)
  +    return 0;
       tmpArr[1] = tolower (*((unsigned char*)tmpArr));
       *tmpArr = tmpArr[1];
       len = 1;
  @@ -335,131 +338,131 @@
       bLen = fUChSize;
       ptr = tmpArr;
       if (::iconv (fCDFrom, &ptr, &len,
  -		 &pTmpArr, &bLen) == (size_t) -1)
  -	return 0;
  +         &pTmpArr, &bLen) == (size_t) -1)
  +    return 0;
       mbcToXMLCh (wcbuf, (XMLCh*) &ch);
       return ch;
   }
   
   // Check if passed characters belongs to the :space: class
  -bool	IconvGNUWrapper::isSpace(const XMLCh toCheck) const
  +bool    IconvGNUWrapper::isSpace(const XMLCh toCheck) const
   {
       if (toCheck <= 0x7F)
  -	return isspace(toCheck);
  +        return isspace(toCheck);
   
  -    char	wcbuf[fUChSize * 2];
  -    char	tmpArr[4];
  +    char    wcbuf[fUChSize * 2];
  +    char    tmpArr[4];
   
       xmlChToMbc (toCheck, wcbuf);
  -    char*	ptr = wcbuf;
  -    size_t	len = fUChSize;
  -    char	*pTmpArr = tmpArr;
  -    size_t	bLen = 2;
  +    char*    ptr = wcbuf;
  +    size_t    len = fUChSize;
  +    char    *pTmpArr = tmpArr;
  +    size_t    bLen = 2;
   
       {
  -	ICONV_LOCK;
  -	if (::iconv (fCDTo, &ptr, &len,
  -		     &pTmpArr, &bLen) == (size_t) -1)
  -	    return 0;
  +        ICONV_LOCK;
  +        if (::iconv (fCDTo, &ptr, &len,
  +                 &pTmpArr, &bLen) == (size_t) -1)
  +            return 0;
       }
       return isspace(*tmpArr);
   }
   
   // Fill array of XMLCh characters with data, supplyed in the array
   // of "native unicode" characters.
  -XMLCh*	IconvGNUWrapper::mbsToXML
  +XMLCh*    IconvGNUWrapper::mbsToXML
   (
  -    const char*		mbs_str
  -    ,	  size_t	mbs_cnt
  -    ,	  XMLCh*	xml_str
  -    ,	  size_t	xml_cnt
  +    const char*        mbs_str
  +    ,      size_t    mbs_cnt
  +    ,      XMLCh*    xml_str
  +    ,      size_t    xml_cnt
   ) const
   {
       if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
  -	return NULL;
  -    size_t	cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
  +        return NULL;
  +    size_t    cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
       if (fUBO == LITTLE_ENDIAN) {
  -	if (fUChSize == sizeof(XMLCh)) {
  -	    // null-transformation
  -	    memcpy (xml_str, mbs_str, fUChSize * cnt);
  -	    return xml_str;
  -	}
  -	if (fUChSize == 2)
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  -		WC162XMLCh( mbs_str, xml_str + i);
  -	    }
  -	else
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  -		WC322XMLCh( mbs_str, xml_str + i );
  -	    }
  +        if (fUChSize == sizeof(XMLCh)) {
  +            // null-transformation
  +            memcpy (xml_str, mbs_str, fUChSize * cnt);
  +            return xml_str;
  +        }
  +        if (fUChSize == 2)
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  +                WC162XMLCh( mbs_str, xml_str + i);
  +            }
  +        else
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  +                WC322XMLCh( mbs_str, xml_str + i );
  +            }
       } else {
  -	if (fUChSize == 2)
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  -		IWC162XMLCh( mbs_str, xml_str + i );
  -	    }
  -	else
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  -		IWC322XMLCh( mbs_str, xml_str + i );
  -	    }
  +        if (fUChSize == 2)
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  +                IWC162XMLCh( mbs_str, xml_str + i );
  +            }
  +        else
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  +                IWC322XMLCh( mbs_str, xml_str + i );
  +            }
       }
       return xml_str;
   }
   
   // Fill array of "native unicode" characters with data, supplyed
   // in the array of XMLCh characters.
  -char*	IconvGNUWrapper::xmlToMbs
  +char*    IconvGNUWrapper::xmlToMbs
   (
  -    const XMLCh*	xml_str
  -    ,	  size_t	xml_cnt
  -    ,	  char*		mbs_str
  -    ,	  size_t	mbs_cnt
  +    const XMLCh*    xml_str
  +    ,      size_t    xml_cnt
  +    ,      char*        mbs_str
  +    ,      size_t    mbs_cnt
   ) const
   {
       if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
  -	return NULL;
  -    size_t	cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
  -    char	*toReturn = mbs_str;
  +        return NULL;
  +    size_t    cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
  +    char    *toReturn = mbs_str;
       if (fUBO == LITTLE_ENDIAN) {
  -	if (fUChSize == sizeof(XMLCh)) {
  -	    // null-transformation
  -	    memcpy (mbs_str, xml_str, fUChSize * cnt);
  -	    return toReturn;
  -	}
  -	if (fUChSize == 2)
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  -		XMLCh2WC16( xml_str, mbs_str );
  -	    }
  -	else
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  -		XMLCh2WC32( xml_str, mbs_str );
  -	    }
  +        if (fUChSize == sizeof(XMLCh)) {
  +            // null-transformation
  +            memcpy (mbs_str, xml_str, fUChSize * cnt);
  +            return toReturn;
  +        }
  +        if (fUChSize == 2)
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  +                XMLCh2WC16( xml_str, mbs_str );
  +            }
  +        else
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  +                XMLCh2WC32( xml_str, mbs_str );
  +            }
       } else {
  -	if (fUChSize == 2)
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  -		IXMLCh2WC16( xml_str, mbs_str );
  -	    }
  -	else
  -	    for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  -		IXMLCh2WC32( xml_str, mbs_str );
  -	    }
  +        if (fUChSize == 2)
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  +                IXMLCh2WC16( xml_str, mbs_str );
  +            }
  +        else
  +            for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  +                IXMLCh2WC32( xml_str, mbs_str );
  +            }
       }
       return toReturn;
   }
   
  -size_t	IconvGNUWrapper::iconvFrom ( const char	*fromPtr,
  -				 size_t		*fromLen,
  -				 char		**toPtr,
  -				 size_t		toLen ) const
  +size_t    IconvGNUWrapper::iconvFrom ( const char    *fromPtr,
  +                 size_t        *fromLen,
  +                 char        **toPtr,
  +                 size_t        toLen ) const
   {
       ICONV_LOCK;
       char ** tmpPtr = (char**)&fromPtr;
       return ::iconv (fCDFrom, tmpPtr, fromLen, toPtr, &toLen);
   }
   
  -size_t	IconvGNUWrapper::iconvTo ( const char	*fromPtr,
  -			       size_t		*fromLen,
  -			       char		**toPtr,
  -			       size_t		toLen ) const
  +size_t    IconvGNUWrapper::iconvTo ( const char    *fromPtr,
  +                   size_t        *fromLen,
  +                   char        **toPtr,
  +                   size_t        toLen ) const
   {
       ICONV_LOCK;
       char ** tmpPtr = (char**)&fromPtr;
  @@ -477,111 +480,111 @@
   #if !defined(APP_NO_THREADS)
       // Create global lock object
       if (gIconvMutex == NULL) {
  -	gIconvMutex = new XMLMutex;
  -	if (gIconvMutex == NULL)
  -	    XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
  +        gIconvMutex = new XMLMutex;
  +        if (gIconvMutex == NULL)
  +            XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
       }
   #endif
   
       // Try to obtain local (host) characterset through the environment
  -    char*	fLocalCP = setlocale (LC_CTYPE, "");
  +    char*    fLocalCP = setlocale (LC_CTYPE, "");
       if (fLocalCP == NULL)
  -	fLocalCP = "iso-8859-1";	// fallback locale
  +        fLocalCP = "iso-8859-1";    // fallback locale
       else {
  -	char	*ptr = strchr (fLocalCP, '.');
  -	if (ptr == NULL)
  -	    fLocalCP = "iso-8859-1";	// fallback locale
  -	else
  -	    fLocalCP = ptr + 1;
  +        char    *ptr = strchr (fLocalCP, '.');
  +        if (ptr == NULL)
  +            fLocalCP = "iso-8859-1";    // fallback locale
  +        else
  +            fLocalCP = ptr + 1;
       }
   
       // Select the native unicode characters encoding schema
  -    const IconvGNUEncoding	*eptr;
  +    const IconvGNUEncoding    *eptr;
       // first - try to use the schema with character size, equil to XMLCh
       for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++) {
  -	if (eptr->fUChSize != sizeof(XMLCh))
  -	    continue;
  -	ICONV_LOCK;
  -	// try to create conversion descriptor
  -	iconv_t	cd_to = iconv_open(fLocalCP, eptr->fSchema);
  -	if (cd_to == (iconv_t)-1)
  -	    continue;
  -	iconv_t	cd_from = iconv_open(eptr->fSchema, fLocalCP);
  -	if (cd_to == (iconv_t)-1) {
  -	    iconv_close (cd_to);
  -	    continue;
  -	}
  -	// got it
  -	setUChSize(eptr->fUChSize);
  -	setUBO(eptr->fUBO);
  -	setCDTo(cd_to);
  -	setCDFrom(cd_from);
  -	fUnicodeCP = eptr->fSchema;
  -	break;
  +        if (eptr->fUChSize != sizeof(XMLCh))
  +            continue;
  +        ICONV_LOCK;
  +        // try to create conversion descriptor
  +        iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  +        if (cd_to == (iconv_t)-1)
  +            continue;
  +        iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  +        if (cd_to == (iconv_t)-1) {
  +            iconv_close (cd_to);
  +            continue;
  +        }
  +        // got it
  +        setUChSize(eptr->fUChSize);
  +        setUBO(eptr->fUBO);
  +        setCDTo(cd_to);
  +        setCDFrom(cd_from);
  +        fUnicodeCP = eptr->fSchema;
  +        break;
       }
       if (fUnicodeCP == NULL)
  -	// try to use any known schema
  -	for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++) {
  -	    // try to create conversion descriptor
  -	    ICONV_LOCK;
  -	    iconv_t	cd_to = iconv_open(fLocalCP, eptr->fSchema);
  -	    if (cd_to == (iconv_t)-1)
  -		continue;
  -	    iconv_t	cd_from = iconv_open(eptr->fSchema, fLocalCP);
  -	    if (cd_to == (iconv_t)-1) {
  -		iconv_close (cd_to);
  -		continue;
  -	    }
  -	    // got it
  -	    setUChSize(eptr->fUChSize);
  -	    setUBO(eptr->fUBO);
  -	    setCDTo(cd_to);
  -	    setCDFrom(cd_from);
  -	    fUnicodeCP = eptr->fSchema;
  -	    break;
  -	}
  +        // try to use any known schema
  +        for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++) {
  +            // try to create conversion descriptor
  +            ICONV_LOCK;
  +            iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  +            if (cd_to == (iconv_t)-1)
  +                continue;
  +            iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  +            if (cd_to == (iconv_t)-1) {
  +                iconv_close (cd_to);
  +                continue;
  +            }
  +            // got it
  +            setUChSize(eptr->fUChSize);
  +            setUBO(eptr->fUBO);
  +            setCDTo(cd_to);
  +            setCDFrom(cd_from);
  +            fUnicodeCP = eptr->fSchema;
  +            break;
  +        }
   
       if (fUnicodeCP == NULL || cdTo() == (iconv_t)-1 || cdFrom() == (iconv_t)-1)
  -	XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
  +        XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
   }
   
   IconvGNUTransService::~IconvGNUTransService()
   {
       if (cdTo() != (iconv_t) -1) {
  -	iconv_close (cdTo());
  -	setCDTo ((iconv_t)-1);
  +        iconv_close (cdTo());
  +        setCDTo ((iconv_t)-1);
       }
       if (cdFrom() != (iconv_t) -1) {
  -	iconv_close (cdFrom());
  -	setCDFrom ((iconv_t)-1);
  +        iconv_close (cdFrom());
  +        setCDFrom ((iconv_t)-1);
       }
   }
   
   // ---------------------------------------------------------------------------
   //  IconvGNUTransService: The virtual transcoding service API
   // ---------------------------------------------------------------------------
  -int IconvGNUTransService::compareIString(const XMLCh* const	comp1
  -                                        , const XMLCh* const	comp2)
  +int IconvGNUTransService::compareIString(const XMLCh* const    comp1
  +                                        , const XMLCh* const    comp2)
   {
       const XMLCh* cptr1 = comp1;
       const XMLCh* cptr2 = comp2;
   
  -    XMLCh	c1 = toUpper(*cptr1);
  -    XMLCh	c2 = toUpper(*cptr2);
  +    XMLCh    c1 = toUpper(*cptr1);
  +    XMLCh    c2 = toUpper(*cptr2);
       while ( (*cptr1 != 0) && (*cptr2 != 0) ) {
           if (c1 != c2)
               break;
  -	c1 = toUpper(*(++cptr1));
  -	c2 = toUpper(*(++cptr2));
  +        c1 = toUpper(*(++cptr1));
  +        c2 = toUpper(*(++cptr2));
   
       }
       return (int) ( c1 - c2 );
   }
   
   
  -int IconvGNUTransService::compareNIString(const XMLCh* const	comp1
  -                                         , const XMLCh* const	comp2
  -                                         , const unsigned int	maxChars)
  +int IconvGNUTransService::compareNIString(const XMLCh* const    comp1
  +                                         , const XMLCh* const    comp2
  +                                         , const unsigned int    maxChars)
   {
       unsigned int  n = 0;
       const XMLCh* cptr1 = comp1;
  @@ -589,10 +592,10 @@
   
       while (true && maxChars)
       {
  -	XMLCh	c1 = toUpper(*cptr1);
  -	XMLCh	c2 = toUpper(*cptr2);
  +        XMLCh    c1 = toUpper(*cptr1);
  +        XMLCh    c2 = toUpper(*cptr2);
   
  -	if (c1 != c2)
  +        if (c1 != c2)
               return (int) (c1 - c2);
   
           // If either ended, then both ended, so equal
  @@ -642,43 +645,43 @@
   XMLTranscoder*
   IconvGNUTransService::makeNewXMLTranscoder
   (
  -    const	XMLCh* const	encodingName
  -    ,	XMLTransService::Codes&	resValue
  -    , const	unsigned int	blockSize
  +    const    XMLCh* const    encodingName
  +    ,    XMLTransService::Codes&    resValue
  +    , const    unsigned int    blockSize
   )
   {
       resValue = XMLTransService::UnsupportedEncoding;
  -    IconvGNUTranscoder	*newTranscoder = NULL;
  +    IconvGNUTranscoder    *newTranscoder = NULL;
   
  -    char	*encLocal = XMLString::transcode(encodingName);
  -    iconv_t	cd_from, cd_to;
  +    char    *encLocal = XMLString::transcode(encodingName);
  +    iconv_t    cd_from, cd_to;
   
       {
  -	ICONV_LOCK;
  -	cd_from = iconv_open (fUnicodeCP, encLocal);
  -	if (cd_from == (iconv_t)-1) {
  -	    resValue = XMLTransService::SupportFilesNotFound;
  -	    if (encLocal)
  -		delete [] encLocal;
  -	    return NULL;
  -	}
  -	cd_to = iconv_open (encLocal, fUnicodeCP);
  -	if (cd_to == (iconv_t)-1) {
  -	    resValue = XMLTransService::SupportFilesNotFound;
  -	    iconv_close (cd_from);
  -	    if (encLocal)
  -		delete [] encLocal;
  -	    return NULL;
  -	}
  -	newTranscoder = new IconvGNUTranscoder (encodingName,
  -						 blockSize,
  -						 cd_from, cd_to,
  -						 uChSize(), UBO());
  +        ICONV_LOCK;
  +        cd_from = iconv_open (fUnicodeCP, encLocal);
  +        if (cd_from == (iconv_t)-1) {
  +            resValue = XMLTransService::SupportFilesNotFound;
  +            if (encLocal)
  +                delete [] encLocal;
  +            return NULL;
  +        }
  +        cd_to = iconv_open (encLocal, fUnicodeCP);
  +        if (cd_to == (iconv_t)-1) {
  +            resValue = XMLTransService::SupportFilesNotFound;
  +            iconv_close (cd_from);
  +            if (encLocal)
  +                delete [] encLocal;
  +            return NULL;
  +        }
  +        newTranscoder = new IconvGNUTranscoder (encodingName,
  +                             blockSize,
  +                             cd_from, cd_to,
  +                             uChSize(), UBO());
       }
       if (newTranscoder)
  -	resValue = XMLTransService::Ok;
  +        resValue = XMLTransService::Ok;
       if (encLocal)
  -	delete [] encLocal;
  +        delete [] encLocal;
       return newTranscoder;
   }
   
  @@ -687,7 +690,7 @@
       XMLCh* outPtr = toUpperCase;
       while (*outPtr)
       {
  -	*outPtr = toUpper(*outPtr);
  +        *outPtr = toUpper(*outPtr);
           outPtr++;
       }
   }
  @@ -697,7 +700,7 @@
       XMLCh* outPtr = toLowerCase;
       while (*outPtr)
       {
  -	*outPtr = toLower(*outPtr);
  +        *outPtr = toLower(*outPtr);
           outPtr++;
       }
   }
  @@ -716,21 +719,21 @@
       if (len == 0)
           return 0;
   
  -    char	tmpWideArr[gTempBuffArraySize];
  -    size_t	totalLen = 0;
  +    char    tmpWideArr[gTempBuffArraySize];
  +    size_t    totalLen = 0;
   
       for (;;) {
  -	char		*pTmpArr = tmpWideArr;
  -	const char	*ptr = srcText + srcLen - len;
  -	size_t	rc = iconvFrom(ptr, &len, &pTmpArr, gTempBuffArraySize);
  -	if (rc == (size_t) -1 && errno != E2BIG) {
  -	    ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  -	    /* return 0; */
  -	}
  -	rc = pTmpArr - (char *) tmpWideArr;
  -	totalLen += rc;
  -	if (rc == 0 || len == 0)
  -	    break;
  +        char        *pTmpArr = tmpWideArr;
  +        const char    *ptr = srcText + srcLen - len;
  +        size_t    rc = iconvFrom(ptr, &len, &pTmpArr, gTempBuffArraySize);
  +        if (rc == (size_t) -1 && errno != E2BIG) {
  +            ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  +            /* return 0; */
  +        }
  +        rc = pTmpArr - (char *) tmpWideArr;
  +        totalLen += rc;
  +        if (rc == 0 || len == 0)
  +            break;
       }
       return totalLen / uChSize();
   }
  @@ -745,43 +748,43 @@
       if (wLent == 0)
           return 0;
   
  -    char	tmpWBuff[gTempBuffArraySize];
  -    char	*wBuf = 0;
  -    char	*wBufPtr = 0;
  +    char    tmpWBuff[gTempBuffArraySize];
  +    char    *wBuf = 0;
  +    char    *wBufPtr = 0;
       size_t      len = wLent * uChSize();
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	if (len > gTempBuffArraySize) {
  -	    wBufPtr = new char[len];
  -	    if (wBufPtr == NULL)
  -		return 0;
  -	    wBuf = wBufPtr;
  -	} else
  -	    wBuf = tmpWBuff;
  -	xmlToMbs (srcText, wLent, wBuf, wLent);
  +        if (len > gTempBuffArraySize) {
  +            wBufPtr = new char[len];
  +            if (wBufPtr == NULL)
  +            return 0;
  +            wBuf = wBufPtr;
  +        } else
  +            wBuf = tmpWBuff;
  +        xmlToMbs (srcText, wLent, wBuf, wLent);
       } else
  -	wBuf = (char *) srcText;
  +        wBuf = (char *) srcText;
   
  -    char	tmpBuff[gTempBuffArraySize];
  -    size_t	totalLen = 0;
  -    char	*srcEnd = wBuf + wLent * uChSize();
  +    char    tmpBuff[gTempBuffArraySize];
  +    size_t    totalLen = 0;
  +    char    *srcEnd = wBuf + wLent * uChSize();
   
       for (;;) {
  -	char		*pTmpArr = tmpBuff;
  -	const char	*ptr = srcEnd - len;
  -	size_t	rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
  -	if (rc == (size_t) -1 && errno != E2BIG) {
  -	    if (wBufPtr)
  -		delete [] wBufPtr;
  -	    ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  -	    /* return 0; */
  -	}
  -	rc = pTmpArr - tmpBuff;
  -	totalLen += rc;
  -	if (rc == 0 || len == 0)
  -	    break;
  +        char        *pTmpArr = tmpBuff;
  +        const char    *ptr = srcEnd - len;
  +        size_t    rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
  +        if (rc == (size_t) -1 && errno != E2BIG) {
  +            if (wBufPtr)
  +                delete [] wBufPtr;
  +            ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  +            /* return 0; */
  +        }
  +        rc = pTmpArr - tmpBuff;
  +        totalLen += rc;
  +        if (rc == 0 || len == 0)
  +            break;
       }
       if (wBufPtr)
  -	delete [] wBufPtr;
  +        delete [] wBufPtr;
       return totalLen;
   }
   
  @@ -796,57 +799,57 @@
           unsigned int  wLent = getWideCharLength(toTranscode);
   
           // Calc needed size.
  -	const size_t neededLen = calcRequiredSize (toTranscode);
  +        const size_t neededLen = calcRequiredSize (toTranscode);
           if (neededLen == 0)
               return 0;
  -	// allocate output buffer
  +        // allocate output buffer
           retVal = new char[neededLen + 1];
  -	if (retVal == NULL)
  +        if (retVal == NULL)
  +            return 0;
  +        // prepare the original
  +        char    tmpWBuff[gTempBuffArraySize];
  +        char    *wideCharBuf = 0;
  +        char    *wBufPtr = 0;
  +        size_t  len = wLent * uChSize();
  +
  +        if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  +            if (len > gTempBuffArraySize) {
  +                wBufPtr = new char[len];
  +                if (wBufPtr == NULL)
  +                    return 0;
  +                wideCharBuf = wBufPtr;
  +            } else
  +                wideCharBuf = tmpWBuff;
  +            xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  +        } else
  +            wideCharBuf = (char *) toTranscode;
  +
  +        // perform conversion
  +        wLent *= uChSize();
  +        char    *ptr = retVal;
  +        size_t    rc = iconvTo(wideCharBuf, (size_t *) &wLent, &ptr, neededLen);
  +        if (rc == (size_t)-1) {
  +            if (wBufPtr)
  +            delete [] wBufPtr;
               return 0;
  -	// prepare the original
  -	char	tmpWBuff[gTempBuffArraySize];
  -	char	*wideCharBuf = 0;
  -	char	*wBufPtr = 0;
  -	size_t  len = wLent * uChSize();
  -	
  -	if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	    if (len > gTempBuffArraySize) {
  -		wBufPtr = new char[len];
  -		if (wBufPtr == NULL)
  -		    return 0;
  -		wideCharBuf = wBufPtr;
  -	    } else
  -		wideCharBuf = tmpWBuff;
  -	    xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  -	} else
  -	    wideCharBuf = (char *) toTranscode;
  -
  -	// perform conversion
  -	wLent *= uChSize();
  -	char	*ptr = retVal;
  -	size_t	rc = iconvTo(wideCharBuf, (size_t *) &wLent, &ptr, neededLen);
  -	if (rc == (size_t)-1) {
  -	    if (wBufPtr)
  -		delete [] wBufPtr;
  -	    return 0;
  -	}
  -	if (wBufPtr)
  -	    delete [] wBufPtr;
  +        }
  +        if (wBufPtr)
  +            delete [] wBufPtr;
           retVal[neededLen] = 0;
   
       } else {
           retVal = new char[1];
  -	if (retVal == NULL)
  -	    return 0;
  +        if (retVal == NULL)
  +            return 0;
           retVal[0] = 0;
       }
       return retVal;
   }
   
   
  -bool IconvGNULCPTranscoder::transcode( const   XMLCh* const	toTranscode
  -					, char* const		toFill
  -					, const unsigned int	maxBytes)
  +bool IconvGNULCPTranscoder::transcode( const   XMLCh* const    toTranscode
  +                    , char* const        toFill
  +                    , const unsigned int    maxBytes)
   {
       // Watch for a couple of pyscho corner cases
       if (!toTranscode || !maxBytes) {
  @@ -863,36 +866,36 @@
           wLent = maxBytes;
   
       // Fill the "unicode" string
  -    char	tmpWBuff[gTempBuffArraySize];
  -    char	*wideCharBuf = 0;
  -    char	*wBufPtr = 0;
  +    char    tmpWBuff[gTempBuffArraySize];
  +    char    *wideCharBuf = 0;
  +    char    *wBufPtr = 0;
       size_t  len = wLent * uChSize();
   
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	if (len > gTempBuffArraySize) {
  -	    wBufPtr = new char[len];
  -	    if (wBufPtr == NULL)
  -		return 0;
  -	    wideCharBuf = wBufPtr;
  -	} else
  -	    wideCharBuf = tmpWBuff;
  -	xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  +        if (len > gTempBuffArraySize) {
  +            wBufPtr = new char[len];
  +            if (wBufPtr == NULL)
  +                return 0;
  +        wideCharBuf = wBufPtr;
  +        } else
  +            wideCharBuf = tmpWBuff;
  +        xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
       } else
  -	wideCharBuf = (char *) toTranscode;
  +        wideCharBuf = (char *) toTranscode;
   
       // Ok, go ahead and try the transcoding. If it fails, then ...
  -    char	*ptr = toFill;
  -    size_t	rc = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
  +    char    *ptr = toFill;
  +    size_t    rc = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
       if (rc == (size_t)-1) {
  -	if (wBufPtr)
  -	    delete [] wBufPtr;
  -	return false;
  +        if (wBufPtr)
  +            delete [] wBufPtr;
  +        return false;
       }
       if (wBufPtr)
  -	delete [] wBufPtr;
  +        delete [] wBufPtr;
   
       // Cap it off just in case
  -    toFill[wLent] = 0;
  +    toFill[rc] = 0;
       return true;
   }
   
  @@ -912,52 +915,52 @@
               return retVal;
           }
   
  -	char	tmpWBuff[gTempBuffArraySize];
  -	char	*wideCharBuf = 0;
  -	char	*wBufPtr = 0;
  -	size_t  len = wLent * uChSize();
  -
  -	retVal = new XMLCh[wLent + 1];
  -	if (retVal == NULL)
  -	    return NULL;
  -	if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	    if (len > gTempBuffArraySize) {
  -		wBufPtr = new char[len];
  -		if (wBufPtr == NULL)
  -		    return 0;
  -		wideCharBuf = wBufPtr;
  -	    } else
  -		wideCharBuf = tmpWBuff;
  -	} else
  -	    wideCharBuf = (char *) retVal;
  -
  -	size_t	flen = strlen(toTranscode);
  -	char	*ptr = wideCharBuf;
  -	size_t	rc = iconvFrom(toTranscode, &flen, &ptr, len);
  -	if (rc == (size_t) -1) {
  -	    if (wBufPtr)
  -		delete [] wBufPtr;
  -	    return NULL;
  -	}
  -	if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  -	    mbsToXML (wideCharBuf, wLent, retVal, wLent);
  -	if (wBufPtr)
  -	    delete [] wBufPtr;
  +        char    tmpWBuff[gTempBuffArraySize];
  +        char    *wideCharBuf = 0;
  +        char    *wBufPtr = 0;
  +        size_t  len = wLent * uChSize();
  +
  +        retVal = new XMLCh[wLent + 1];
  +        if (retVal == NULL)
  +            return NULL;
  +        if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  +            if (len > gTempBuffArraySize) {
  +                wBufPtr = new char[len];
  +                if (wBufPtr == NULL)
  +                    return 0;
  +                wideCharBuf = wBufPtr;
  +            } else
  +                wideCharBuf = tmpWBuff;
  +        } else
  +            wideCharBuf = (char *) retVal;
  +
  +        size_t    flen = strlen(toTranscode);
  +        char    *ptr = wideCharBuf;
  +        size_t    rc = iconvFrom(toTranscode, &flen, &ptr, len);
  +        if (rc == (size_t) -1) {
  +            if (wBufPtr)
  +            delete [] wBufPtr;
  +            return NULL;
  +        }
  +        if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  +            mbsToXML (wideCharBuf, wLent, retVal, wLent);
  +        if (wBufPtr)
  +            delete [] wBufPtr;
           retVal[wLent] = 0x00;
       }
       else {
           retVal = new XMLCh[1];
  -	if (retVal == NULL )
  -	    return 0;
  +        if (retVal == NULL )
  +            return 0;
           retVal[0] = 0;
       }
       return retVal;
   }
   
   
  -bool IconvGNULCPTranscoder::transcode(const   char* const	toTranscode
  -				       ,       XMLCh* const	toFill
  -				       , const unsigned int	maxChars)
  +bool IconvGNULCPTranscoder::transcode(const   char* const    toTranscode
  +                       ,       XMLCh* const    toFill
  +                       , const unsigned int    maxChars)
   {
       // Check for a couple of psycho corner cases
       if (!toTranscode || !maxChars)
  @@ -976,35 +979,35 @@
       if (wLent > maxChars)
           wLent = maxChars;
   
  -    char	tmpWBuff[gTempBuffArraySize];
  -    char	*wideCharBuf = 0;
  -    char	*wBufPtr = 0;
  -    size_t	len = wLent * uChSize();
  +    char    tmpWBuff[gTempBuffArraySize];
  +    char    *wideCharBuf = 0;
  +    char    *wBufPtr = 0;
  +    size_t    len = wLent * uChSize();
   
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	if (len > gTempBuffArraySize) {
  -	    wBufPtr = new char[len];
  -	    if (wBufPtr == NULL)
  -		return 0;
  -	    wideCharBuf = wBufPtr;
  -	} else
  -	    wideCharBuf = tmpWBuff;
  +        if (len > gTempBuffArraySize) {
  +            wBufPtr = new char[len];
  +            if (wBufPtr == NULL)
  +                return 0;
  +            wideCharBuf = wBufPtr;
  +        } else
  +            wideCharBuf = tmpWBuff;
       } else
  -	wideCharBuf = (char *) toFill;
  +        wideCharBuf = (char *) toFill;
   
  -    size_t	flen = strlen(toTranscode); // wLent;
  -    char	*ptr = wideCharBuf;
  -    size_t	rc = iconvFrom(toTranscode, &flen, &ptr, len);
  +    size_t    flen = strlen(toTranscode); // wLent;
  +    char    *ptr = wideCharBuf;
  +    size_t    rc = iconvFrom(toTranscode, &flen, &ptr, len);
       if (rc == (size_t)-1) {
  -	if (wBufPtr)
  -	    delete [] wBufPtr;
  -	return false;
  +        if (wBufPtr)
  +            delete [] wBufPtr;
  +        return false;
       }
   
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  -	mbsToXML (wideCharBuf, wLent, toFill, wLent);
  +        mbsToXML (wideCharBuf, wLent, toFill, wLent);
       if (wBufPtr)
  -	delete [] wBufPtr;
  +        delete [] wBufPtr;
   
       toFill[wLent] = 0x00;
       return true;
  @@ -1016,10 +1019,10 @@
   // ---------------------------------------------------------------------------
   
   
  -IconvGNULCPTranscoder::IconvGNULCPTranscoder (iconv_t		cd_from,
  -						iconv_t		cd_to,
  -						size_t		uchsize,
  -						unsigned int	ubo)
  +IconvGNULCPTranscoder::IconvGNULCPTranscoder (iconv_t        cd_from,
  +                        iconv_t        cd_to,
  +                        size_t        uchsize,
  +                        unsigned int    ubo)
       : IconvGNUWrapper (cd_from, cd_to, uchsize, ubo)
   {
   }
  @@ -1033,12 +1036,12 @@
   // ---------------------------------------------------------------------------
   //  IconvGNUTranscoder: Constructors and Destructor
   // ---------------------------------------------------------------------------
  -IconvGNUTranscoder::IconvGNUTranscoder (const	XMLCh* const	encodingName
  -					  , const unsigned int	blockSize
  -					  ,	iconv_t		cd_from
  -					  ,	iconv_t		cd_to
  -					  ,	size_t		uchsize
  -					  ,	unsigned int	ubo
  +IconvGNUTranscoder::IconvGNUTranscoder (const    XMLCh* const    encodingName
  +                      , const unsigned int    blockSize
  +                      ,    iconv_t        cd_from
  +                      ,    iconv_t        cd_to
  +                      ,    size_t        uchsize
  +                      ,    unsigned int    ubo
       )
       : XMLTranscoder(encodingName, blockSize)
       , IconvGNUWrapper (cd_from, cd_to, uchsize, ubo)
  @@ -1049,19 +1052,19 @@
   {
       ICONV_LOCK;
       if (cdTo() != (iconv_t)-1) {
  -	iconv_close (cdTo());
  -	setCDTo ((iconv_t)-1);
  +        iconv_close (cdTo());
  +        setCDTo ((iconv_t)-1);
       }
       if (cdFrom() != (iconv_t)-1) {
  -	iconv_close (cdFrom());
  -	setCDFrom ((iconv_t)-1);
  +        iconv_close (cdFrom());
  +        setCDFrom ((iconv_t)-1);
       }
   }
   
   // ---------------------------------------------------------------------------
   //  IconvGNUTranscoder: Implementation of the virtual transcoder API
   // ---------------------------------------------------------------------------
  -unsigned int	IconvGNUTranscoder::transcodeFrom
  +unsigned int    IconvGNUTranscoder::transcodeFrom
   (
       const   XMLByte* const          srcData
       , const unsigned int            srcCount
  @@ -1074,92 +1077,92 @@
       const char*  startSrc = (const char*) srcData;
       const char*  endSrc = (const char*) srcData + srcCount;
   
  -    char	tmpWBuff[gTempBuffArraySize];
  -    char	*startTarget = 0;
  -    char	*wBufPtr = 0;
  -    size_t	len = maxChars * uChSize();
  +    char    tmpWBuff[gTempBuffArraySize];
  +    char    *startTarget = 0;
  +    char    *wBufPtr = 0;
  +    size_t    len = maxChars * uChSize();
   
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	if (len > gTempBuffArraySize) {
  -	    wBufPtr = new char[len];
  -	    if (wBufPtr == NULL)
  -		return 0;
  -	    startTarget = wBufPtr;
  -	} else
  -	    startTarget = tmpWBuff;
  +        if (len > gTempBuffArraySize) {
  +            wBufPtr = new char[len];
  +            if (wBufPtr == NULL)
  +                return 0;
  +            startTarget = wBufPtr;
  +        } else
  +            startTarget = tmpWBuff;
       } else
  -	startTarget = (char *) toFill;
  +    startTarget = (char *) toFill;
   
       // Do character-by-character transcoding
  -    char	*orgTarget = startTarget;
  -    size_t	srcLen = srcCount;
  -    size_t	prevSrcLen = srcLen;
  +    char    *orgTarget = startTarget;
  +    size_t    srcLen = srcCount;
  +    size_t    prevSrcLen = srcLen;
       unsigned int toReturn = 0;
       bytesEaten = 0;
       for (size_t cnt = 0; cnt < maxChars && srcLen; cnt++) {
  -	size_t	rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize());
  -	if (rc == (size_t)-1) {
  -	    if (errno != E2BIG || prevSrcLen == srcLen) {
  -		if (wBufPtr)
  -		    delete [] wBufPtr;
  -		ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  -	    }
  -	}
  -	charSizes[cnt] = prevSrcLen - srcLen;
  -	prevSrcLen = srcLen;
  -	bytesEaten += charSizes[cnt];
  -	startSrc = endSrc - srcLen;
  -	toReturn++;
  +        size_t    rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize());
  +        if (rc == (size_t)-1) {
  +            if (errno != E2BIG || prevSrcLen == srcLen) {
  +                if (wBufPtr)
  +                    delete [] wBufPtr;
  +                ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  +            }
  +        }
  +        charSizes[cnt] = prevSrcLen - srcLen;
  +        prevSrcLen = srcLen;
  +        bytesEaten += charSizes[cnt];
  +        startSrc = endSrc - srcLen;
  +        toReturn++;
       }
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  -	mbsToXML (startTarget, toReturn, toFill, toReturn);
  +        mbsToXML (startTarget, toReturn, toFill, toReturn);
       if (wBufPtr)
  -	delete [] wBufPtr;
  +        delete [] wBufPtr;
       return toReturn;
   }
   
  -unsigned int	IconvGNUTranscoder::transcodeTo
  +unsigned int    IconvGNUTranscoder::transcodeTo
   (
  -    const   XMLCh* const	srcData
  -    , const unsigned int	srcCount
  -    ,       XMLByte* const	toFill
  -    , const unsigned int	maxBytes
  -    ,       unsigned int&	charsEaten
  -    , const UnRepOpts		options )
  +    const   XMLCh* const    srcData
  +    , const unsigned int    srcCount
  +    ,       XMLByte* const    toFill
  +    , const unsigned int    maxBytes
  +    ,       unsigned int&    charsEaten
  +    , const UnRepOpts        options )
   {
       // Transcode FROM XMLCh
  -    char	tmpWBuff[gTempBuffArraySize];
  -    char	*startSrc = tmpWBuff;
  -    char	*wBufPtr = 0;
  -    size_t	len = srcCount * uChSize();
  +    char    tmpWBuff[gTempBuffArraySize];
  +    char    *startSrc = tmpWBuff;
  +    char    *wBufPtr = 0;
  +    size_t    len = srcCount * uChSize();
   
       if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  -	if (len > gTempBuffArraySize) {
  -	    wBufPtr = new char[len];
  -	    if (wBufPtr == NULL)
  -		return 0;
  -	    startSrc = wBufPtr;
  -	} else
  -	    startSrc = tmpWBuff;
  -	xmlToMbs (srcData, srcCount, startSrc, srcCount);
  +        if (len > gTempBuffArraySize) {
  +            wBufPtr = new char[len];
  +            if (wBufPtr == NULL)
  +                return 0;
  +            startSrc = wBufPtr;
  +        } else
  +            startSrc = tmpWBuff;
  +        xmlToMbs (srcData, srcCount, startSrc, srcCount);
       } else
  -	startSrc = (char *) srcData;
  +        startSrc = (char *) srcData;
   
  -    char*	startTarget = (char *) toFill;
  -    size_t	srcLen = len;
  -    size_t	rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
  +    char*    startTarget = (char *) toFill;
  +    size_t    srcLen = len;
  +    size_t    rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
       if (rc == (size_t)-1 && errno != E2BIG) {
  -	if (wBufPtr)
  -	    delete [] wBufPtr;
  -	ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  +        if (wBufPtr)
  +            delete [] wBufPtr;
  +        ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
       }
       charsEaten = srcCount - srcLen / uChSize();
       if (wBufPtr)
  -	delete [] wBufPtr;
  +        delete [] wBufPtr;
       return startTarget - (char *)toFill;
   }
   
  -bool		IconvGNUTranscoder::canTranscodeTo
  +bool        IconvGNUTranscoder::canTranscodeTo
   (
       const unsigned int toCheck
   )   const
  @@ -1168,21 +1171,21 @@
       //  If the passed value is really a surrogate embedded together, then
       //  we need to break it out into its two chars. Else just one.
       //
  -    char		srcBuf[2 * uChSize()];
  -    unsigned int	srcCount = 1;
  +    char        srcBuf[2 * uChSize()];
  +    unsigned int    srcCount = 1;
       if (toCheck & 0xFFFF0000) {
  -	XMLCh	ch1 = (toCheck >> 10) + 0xD800;
  -	XMLCh	ch2 = toCheck & 0x3FF + 0xDC00;
  -	xmlToMbs(&ch1, 1, srcBuf, 1);
  -	xmlToMbs(&ch2, 1, srcBuf + uChSize(), 1);
  +        XMLCh    ch1 = (toCheck >> 10) + 0xD800;
  +        XMLCh    ch2 = toCheck & 0x3FF + 0xDC00;
  +        xmlToMbs(&ch1, 1, srcBuf, 1);
  +        xmlToMbs(&ch2, 1, srcBuf + uChSize(), 1);
           srcCount++;
       } else
  -	xmlToMbs((const XMLCh*) &toCheck, 1, srcBuf, 1);
  -    size_t	len = srcCount * uChSize();
  -    char	tmpBuf[64];
  -    char*	pTmpBuf = tmpBuf;
  +        xmlToMbs((const XMLCh*) &toCheck, 1, srcBuf, 1);
  +    size_t    len = srcCount * uChSize();
  +    char    tmpBuf[64];
  +    char*    pTmpBuf = tmpBuf;
   
  -    size_t	rc = iconvTo( srcBuf, &len, &pTmpBuf, 64);
  +    size_t    rc = iconvTo( srcBuf, &len, &pTmpBuf, 64);
       return (rc != (size_t)-1) && (len == 0);
   }
   
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org