iconvfbsdtransservice.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 1,778 行 · 第 1/4 页

    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: class
bool    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++;
    }
}