/* * Copyright 1999-2004 The Apache Software Foundation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: Iconv390TransService.cpp 176026 2004-09-08 13:57:07Z peiyongz $ */ // --------------------------------------------------------------------------- // Includes // --------------------------------------------------------------------------- #include "Iconv390TransService.hpp" #include #include #include #include #include #include #include #include #ifdef OS390BATCH #include #endif #include XERCES_CPP_NAMESPACE_BEGIN // // Cannot use the OS/390 c/c++ towupper and towlower functions in the // Unicode environment. We will use mytowupper and mytowlower here. // #undef towupper #undef towlower #define towupper mytowupper #define towlower mytowlower // --------------------------------------------------------------------------- // Local, const data // --------------------------------------------------------------------------- static const int gTempBuffArraySize = 1024; static const XMLCh gMyServiceId[] = { chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull }; // --------------------------------------------------------------------------- // gUnicodeToIBM037XlatTable // This is the translation table for Unicode to ibm-037. This table // contains 255 entries. // --------------------------------------------------------------------------- static const XMLByte gUnicodeToIBM037XlatTable[256] = { 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F , 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F , 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26 , 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F , 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D , 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61 , 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7 , 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F , 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7 , 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6 , 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6 , 0xE7, 0xE8, 0xE9, 0xBA, 0xE0, 0xBB, 0xB0, 0x6D , 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87 , 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96 , 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6 , 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07 , 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17 , 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B , 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08 , 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF , 0x41, 0xAA, 0x4A, 0xB1, 0x9F, 0xB2, 0x6A, 0xB5 , 0xBD, 0xB4, 0x9A, 0x8A, 0x5F, 0xCA, 0xAF, 0xBC , 0x90, 0x8F, 0xEA, 0xFA, 0xBE, 0xA0, 0xB6, 0xB3 , 0x9D, 0xDA, 0x9B, 0x8B, 0xB7, 0xB8, 0xB9, 0xAB , 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9E, 0x68 , 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77 , 0xAC, 0x69, 0xED, 0xEE, 0xEB, 0xEF, 0xEC, 0xBF , 0x80, 0xFD, 0xFE, 0xFB, 0xFC, 0xAD, 0xAE, 0x59 , 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9C, 0x48 , 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57 , 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1 , 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; iconvconverter * converterList; XMLMutex converterListMutex; iconvconverter * addConverter(const char* const EncodingName ,XMLTransService::Codes& resValue) { XMLMutexLock lockConverterlist(&converterListMutex); iconvconverter *tconv=converterList; while ( (tconv) && (strcmp(tconv->name,EncodingName)) ) tconv = tconv->nextconverter; if (tconv) { tconv->usecount++; } else { tconv = new iconvconverter; strcpy(tconv->name,EncodingName); tconv->usecount=1; tconv->fIconv390Descriptor = iconv_open("UCS-2",EncodingName); if (tconv->fIconv390Descriptor == (iconv_t)(-1)) { resValue = XMLTransService::UnsupportedEncoding; delete tconv; return 0; } tconv->nextconverter = converterList; converterList = tconv; } return tconv; } void removeConverter(iconvconverter* const converter) { iconvconverter *pconv,*tconv; tconv = 0; if (converter) { XMLMutexLock lockConverterlist(&converterListMutex); if (--converter->usecount==0) { tconv = converterList; pconv = (iconvconverter*)&converterList; while ( (tconv) && (tconv!=converter) ) { pconv=tconv; tconv=tconv->nextconverter; } pconv->nextconverter=tconv->nextconverter; } } if (tconv) { iconv_close(tconv->fIconv390Descriptor); delete tconv; } } // --------------------------------------------------------------------------- // Local methods // --------------------------------------------------------------------------- static unsigned int getWideCharLength(const XMLCh* const src) { if (!src) return 0; unsigned int len = 0; const XMLCh* pTmp = src; while (*pTmp++) len++; return len; } // --------------------------------------------------------------------------- // Iconv390TransService: Constructors and Destructor // --------------------------------------------------------------------------- Iconv390TransService::Iconv390TransService() { } Iconv390TransService::~Iconv390TransService() { } // --------------------------------------------------------------------------- // Iconv390TransService: The virtual transcoding service API // --------------------------------------------------------------------------- int Iconv390TransService::compareIString( const XMLCh* const comp1 , const XMLCh* const comp2) { const XMLCh* cptr1 = comp1; const XMLCh* cptr2 = comp2; while ( (*cptr1 != 0) && (*cptr2 != 0) ) { wint_t wch1 = towupper(*cptr1); wint_t wch2 = towupper(*cptr2); if (wch1 != wch2) break; cptr1++; cptr2++; } return (int) ( towupper(*cptr1) - towupper(*cptr2) ); } int Iconv390TransService::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; while (true && maxChars) { wint_t wch1 = towupper(*cptr1); wint_t wch2 = 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; } return 0; } const XMLCh* Iconv390TransService::getId() const { return gMyServiceId; } bool Iconv390TransService::isSpace(const XMLCh toCheck) const { unsigned short chartype = XMLUniCharacter::getType(toCheck); if ( (chartype == XMLUniCharacter::SPACE_SEPARATOR) || (chartype == XMLUniCharacter::LINE_SEPARATOR) || (chartype == XMLUniCharacter::PARAGRAPH_SEPARATOR) ) return true; else return false; } XMLLCPTranscoder* Iconv390TransService::makeNewLCPTranscoder() { XMLTransService::Codes resValue; // native MVS default code page is IBM-037 iconvconverter *tconv=addConverter("IBM-037",resValue); if (tconv == 0) { return 0; } return new Iconv390LCPTranscoder(tconv); } bool Iconv390TransService::supportsSrcOfs() const { return true; } // --------------------------------------------------------------------------- // Iconv390TransService: The protected virtual transcoding service API // --------------------------------------------------------------------------- XMLTranscoder* Iconv390TransService::makeNewXMLTranscoder(const XMLCh* const encodingName , XMLTransService::Codes& resValue , const unsigned int , MemoryManager* const) { // 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; } void Iconv390TransService::upperCase(XMLCh* const toUpperCase) const { XMLCh* outPtr = toUpperCase; while (*outPtr != 0) { if ((*outPtr >= 0x61) && (*outPtr <= 0x7A)) *outPtr = *outPtr - 0x20; outPtr++; } } void Iconv390TransService::lowerCase(XMLCh* const toLowerCase) const { XMLCh* outPtr = toLowerCase; while (*outPtr != 0) { if ((*outPtr >= 0x41) && (*outPtr <= 0x5A)) *outPtr = *outPtr + 0x20; outPtr++; } } // --------------------------------------------------------------------------- unsigned int Iconv390LCPTranscoder::calcRequiredSize(const char* const srcText , MemoryManager* const manager) { if (!srcText) return 0; unsigned charLen = ::mblen(srcText, MB_CUR_MAX); if (charLen == -1) return 0; else if (charLen != 0) charLen = strlen(srcText)/charLen; if (charLen == -1) return 0; return charLen; } unsigned int Iconv390LCPTranscoder::calcRequiredSize(const XMLCh* const srcText , MemoryManager* const manager) { if (!srcText) return 0; unsigned int wLent = getWideCharLength(srcText); wchar_t tmpWideCharArr[gTempBuffArraySize]; wchar_t* allocatedArray = 0; wchar_t* wideCharBuf = 0; if (wLent >= gTempBuffArraySize) wideCharBuf = allocatedArray = (wchar_t*) manager->allocate ( (wLent + 1) * sizeof(wchar_t) );//new wchar_t[wLent + 1]; else wideCharBuf = tmpWideCharArr; for (unsigned int i = 0; i < wLent; i++) { wideCharBuf[i] = srcText[i]; } wideCharBuf[wLent] = 0x00; const unsigned int retVal = ::wcstombs(NULL, wideCharBuf, 0); manager->deallocate(allocatedArray);//delete [] allocatedArray; if (retVal == -1) return 0; return retVal; } char* Iconv390LCPTranscoder::transcode(const XMLCh* const toTranscode) { if (!toTranscode) return 0; char* retVal = 0; if (*toTranscode) { unsigned int wLent = getWideCharLength(toTranscode); // // Translate the input from Unicode XMLCh format into // ibm-037 char format via the lookup table. // retVal = new char[wLent + 1]; const XMLCh *srcPtr = toTranscode; char *outPtr = retVal; while (*srcPtr != 0) *outPtr++ = gUnicodeToIBM037XlatTable[*srcPtr++]; *outPtr=0; } else { retVal = new char[1]; retVal[0] = 0; } return retVal; } char* Iconv390LCPTranscoder::transcode(const XMLCh* const toTranscode, MemoryManager* const manager) { if (!toTranscode) return 0; char* retVal = 0; if (*toTranscode) { unsigned int wLent = getWideCharLength(toTranscode); // // Translate the input from Unicode XMLCh format into // ibm-037 char format via the lookup table. // retVal = (char*) manager->allocate((wLent + 1) * sizeof(char));//new char[wLent + 1]; const XMLCh *srcPtr = toTranscode; char *outPtr = retVal; while (*srcPtr != 0) *outPtr++ = gUnicodeToIBM037XlatTable[*srcPtr++]; *outPtr=0; } else { retVal = (char*) manager->allocate(sizeof(char));//new char[1]; retVal[0] = 0; } return retVal; } bool Iconv390LCPTranscoder::transcode( const XMLCh* const toTranscode , char* const toFill , const unsigned int maxBytes , MemoryManager* const manager) { // Watch for a couple of pyscho corner cases if (!toTranscode || !maxBytes) { toFill[0] = 0; return true; } if (!*toTranscode) { toFill[0] = 0; return true; } const XMLCh *srcPtr = toTranscode; char *outPtr = toFill; int bytectr = maxBytes; while (bytectr-- && *srcPtr) *outPtr++ = gUnicodeToIBM037XlatTable[*srcPtr++]; *outPtr=0; return true; } XMLCh* Iconv390LCPTranscoder::transcode(const char* const toTranscode) { if (!toTranscode) return 0; XMLCh* retVal = 0; if (*toTranscode) { const unsigned int len = calcRequiredSize(toTranscode); if (len == 0) { retVal = new XMLCh[1]; retVal[0] = 0; return retVal; } wchar_t tmpWideCharArr[gTempBuffArraySize]; wchar_t* allocatedArray = 0; wchar_t* wideCharBuf = 0; retVal = new XMLCh[len + 1]; size_t retCode; char *tmpInPtr = (char*) toTranscode; char *tmpOutPtr = (char*) retVal; size_t inByteLeft = len; size_t outByteLeft = len*2; { XMLMutexLock lockConverter(&converter->fMutex); retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft); } if (retCode == -1) { delete [] retVal; return 0; } retVal[len] = 0x00; delete [] allocatedArray; } else { retVal = new XMLCh[1]; retVal[0] = 0; } return retVal; } XMLCh* Iconv390LCPTranscoder::transcode(const char* const toTranscode, MemoryManager* const manager) { if (!toTranscode) return 0; XMLCh* retVal = 0; if (*toTranscode) { const unsigned int len = calcRequiredSize(toTranscode, manager); if (len == 0) { retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1]; retVal[0] = 0; return retVal; } wchar_t tmpWideCharArr[gTempBuffArraySize]; wchar_t* allocatedArray = 0; wchar_t* wideCharBuf = 0; retVal = (XMLCh*) manager->allocate((len + 1) * sizeof(XMLCh));//new XMLCh[len + 1]; size_t retCode; char *tmpInPtr = (char*) toTranscode; char *tmpOutPtr = (char*) retVal; size_t inByteLeft = len; size_t outByteLeft = len*2; { XMLMutexLock lockConverter(&converter->fMutex); retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft); } if (retCode == -1) { manager->deallocate(retVal);//delete [] retVal; return 0; } retVal[len] = 0x00; manager->deallocate(allocatedArray);//delete [] allocatedArray; } else { retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1]; retVal[0] = 0; } return retVal; } bool Iconv390LCPTranscoder::transcode( const char* const toTranscode , XMLCh* const toFill , const unsigned int maxChars , MemoryManager* const manager) { // Check for a couple of psycho corner cases if (!toTranscode || !maxChars) { toFill[0] = 0; return true; } if (!*toTranscode) { toFill[0] = 0; return true; } size_t retCode; char *tmpInPtr = (char*) toTranscode; char *tmpOutPtr = (char*) toFill; size_t inByteLeft = maxChars; size_t outByteLeft = maxChars*2; { XMLMutexLock lockConverter(&converter->fMutex); retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft); } if ( (retCode == -1) && (outByteLeft!=0) ) { return false; } toFill[maxChars] = 0x00; return true; } // --------------------------------------------------------------------------- // Iconv390LCPTranscoder: Constructors and Destructor // --------------------------------------------------------------------------- Iconv390LCPTranscoder::Iconv390LCPTranscoder() { } Iconv390LCPTranscoder::Iconv390LCPTranscoder(iconvconverter_t* const toAdopt) : converter (toAdopt) { } Iconv390LCPTranscoder::~Iconv390LCPTranscoder() { removeConverter(converter); converter=0; } XERCES_CPP_NAMESPACE_END