ptr = tmpArr;    if (::iconv (fCDFrom, (const char **)&ptr, &len,         &pTmpArr, &bLen) == (size_t) -1)    return 0;    mbcToXMLCh (wcbuf, (XMLCh*) &ch);    return ch;}// Check if passed characters belongs to the :space: classbool    IconvFBSDCD::isSpace(const XMLCh toCheck) const{    if (toCheck <= 0x7F)        return isspace(toCheck);    char    wcbuf[fUChSize * 2];    char    tmpArr[4];    xmlChToMbc (toCheck, wcbuf);    char*    ptr = wcbuf;    size_t    len = fUChSize;    char    *pTmpArr = tmpArr;    size_t    bLen = 2;    {        ICONV_LOCK;        if (::iconv (fCDTo, (const char**) &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*    IconvFBSDCD::mbsToXML(    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;    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 );        }    } 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 );            }    }    return xml_str;}// Fill array of "native unicode" characters with data, supplyed// in the array of XMLCh characters.char*    IconvFBSDCD::xmlToMbs(    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;    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 );            }    } 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 );            }    }    return toReturn;}size_t    IconvFBSDCD::iconvFrom ( const char    *fromPtr,                 size_t        *fromLen,                 char        **toPtr,                 size_t        toLen ) const{    ICONV_LOCK;    return ::iconv (fCDFrom, &fromPtr, fromLen, toPtr, &toLen);}size_t    IconvFBSDCD::iconvTo ( const char    *fromPtr,                   size_t        *fromLen,                   char        **toPtr,                   size_t        toLen ) const{    ICONV_LOCK;    return ::iconv (fCDTo, &fromPtr, fromLen, toPtr, &toLen);}#endif /* !XML_USE_LIBICONV */// ---------------------------------------------------------------------------//  IconvFBSDTransService: Constructors and Destructor// ---------------------------------------------------------------------------IconvFBSDTransService::IconvFBSDTransService()#ifndef XML_USE_LIBICONV{}#else  /* XML_USE_LIBICONV */    : IconvFBSDCD(), fUnicodeCP(0){#if !defined(APP_NO_THREADS)    // Create global lock object    if (gIconvMutex == NULL) {        gIconvMutex = new XMLMutex;        if (gIconvMutex == NULL)            XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);    }#endif    // Try to obtain local (host) characterset through the environment    char*    fLocalCP = setlocale (LC_CTYPE, "");    if (fLocalCP == NULL)        fLocalCP = "iso-8859-1";    // fallback locale    else {        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 IconvFBSDEncoding    *eptr;    // first - try to use the schema with character size, equil to XMLCh    for (eptr = gIconvFBSDEncodings; 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 (fUnicodeCP == NULL)        // try to use any known schema        for (eptr = gIconvFBSDEncodings; 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 (PanicHandler::Panic_NoTransService);}#endif /* XML_USE_LIBICONV */IconvFBSDTransService::~IconvFBSDTransService(){#ifdef XML_USE_LIBICONV    if (cdTo() != (iconv_t) -1) {        iconv_close (cdTo());        setCDTo ((iconv_t)-1);    }    if (cdFrom() != (iconv_t) -1) {        iconv_close (cdFrom());        setCDFrom ((iconv_t)-1);    }#endif /* XML_USE_LIBICONV */}// ---------------------------------------------------------------------------//  IconvFBSDTransService: The virtual transcoding service API// ---------------------------------------------------------------------------int IconvFBSDTransService::compareIString(const XMLCh* const    comp1                                        , const XMLCh* const    comp2){    const XMLCh* cptr1 = comp1;    const XMLCh* cptr2 = comp2;#ifndef XML_USE_LIBICONV    while ( (*cptr1 != 0) && (*cptr2 != 0) ) {        wint_t wch1 = fbsd_towupper(*cptr1);        wint_t wch2 = fbsd_towupper(*cptr2);        if (wch1 != wch2)            break;        cptr1++;        cptr2++;    }    return (int) ( fbsd_towupper(*cptr1) - fbsd_towupper(*cptr2) );#else /* XML_USE_LIBICONV */    XMLCh    c1 = toUpper(*cptr1);    XMLCh    c2 = toUpper(*cptr2);    while ( (*cptr1 != 0) && (*cptr2 != 0) ) {        if (c1 != c2)            break;        c1 = toUpper(*(++cptr1));        c2 = toUpper(*(++cptr2));    }    return (int) ( c1 - c2 );#endif /* !XML_USE_LIBICONV */}int IconvFBSDTransService::compareNIString(const XMLCh* const    comp1                                         , const XMLCh* const    comp2                                         , const unsigned int    maxChars){    unsigned int  n = 0;    const XMLCh* cptr1 = comp1;    const XMLCh* cptr2 = comp2;#ifndef XML_USE_LIBICONV    while (true && maxChars)    {        wint_t wch1 = fbsd_towupper(*cptr1);        wint_t wch2 = fbsd_towupper(*cptr2);        if (wch1 != wch2)            return (int) (wch1 - wch2);        // If either ended, then both ended, so equal        if (!*cptr1 || !*cptr2)            break;        cptr1++;        cptr2++;        //  Bump the count of chars done. If it equals the count then we        //  are equal for the requested count, so break out and return        //  equal.        n++;        if (n == maxChars)            break;    }#else /* XML_USE_LIBICONV */    while (true && maxChars)    {        XMLCh    c1 = toUpper(*cptr1);        XMLCh    c2 = toUpper(*cptr2);        if (c1 != c2)            return (int) (c1 - c2);        // If either ended, then both ended, so equal        if (!*cptr1 || !*cptr2)            break;        cptr1++;        cptr2++;        //  Bump the count of chars done. If it equals the count then we        //  are equal for the requested count, so break out and return        //  equal.        n++;        if (n == maxChars)            break;    }#endif /* !XML_USE_LIBICONV */    return 0;}const XMLCh* IconvFBSDTransService::getId() const{    return gMyServiceId;}bool IconvFBSDTransService::isSpace(const XMLCh toCheck) const{#ifndef XML_USE_LIBICONV    if (toCheck <= 0x7F)        return isspace(toCheck);    char buf[16];    wchar_t    wc = wchar_t(toCheck);    wcstombs( buf, &wc, 16 );    return (isspace(*buf) != 0);#else /* XML_USE_LIBICONV */    return IconvFBSDCD::isSpace(toCheck);#endif /* !XML_USE_LIBICONV */}XMLLCPTranscoder* IconvFBSDTransService::makeNewLCPTranscoder(){    // Just allocate a new transcoder of our type#ifndef XML_USE_LIBICONV    return new IconvFBSDLCPTranscoder;#else /* XML_USE_LIBICONV */    return new IconvFBSDLCPTranscoder (cdFrom(), cdTo(), uChSize(), UBO());#endif /* !XML_USE_LIBICONV */}bool IconvFBSDTransService::supportsSrcOfs() const{    return true;}// ---------------------------------------------------------------------------//  IconvFBSDTransService: The protected virtual transcoding service API// ---------------------------------------------------------------------------XMLTranscoder*IconvFBSDTransService::makeNewXMLTranscoder(    const    XMLCh* const    encodingName    ,    XMLTransService::Codes&    resValue    , const     unsigned int    blockSize    ,       MemoryManager* const    manager){#ifndef XML_USE_LIBICONV    //    //  NOTE: We don't use the block size here    //    //  This is a minimalist transcoding service, that only supports a local    //  default transcoder. All named encodings return zero as a failure,    //  which means that only the intrinsic encodings supported by the parser    //  itself will work for XML data.    //    resValue = XMLTransService::UnsupportedEncoding;    return 0;#else /* XML_USE_LIBICONV */    resValue = XMLTransService::UnsupportedEncoding;    IconvFBSDTranscoder    *newTranscoder = NULL;    char    *encLocal = XMLString::transcode(encodingName, manager);    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)            manager->deallocate(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)            manager->deallocate(encLocal);//delete [] encLocal;            return NULL;        }        newTranscoder = new (manager) IconvFBSDTranscoder (encodingName,                             blockSize,                             cd_from, cd_to,                             uChSize(), UBO(),                             manager);    }    if (newTranscoder)        resValue = XMLTransService::Ok;    if (encLocal)        manager->deallocate(encLocal);//delete [] encLocal;    return newTranscoder;#endif /* !XML_USE_LIBICONV */}void IconvFBSDTransService::upperCase(XMLCh* const toUpperCase) const{    XMLCh* outPtr = toUpperCase;    while (*outPtr)    {#ifndef XML_USE_LIBICONV        *outPtr = fbsd_towupper(*outPtr);#else /* XML_USE_LIBICONV */        *outPtr = toUpper(*outPtr);#endif /* !XML_USE_LIBICONV */        outPtr++;    }}