uniconv390transservice.cpp

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

      XMLMutexLock lockcaser(&fCaseConverter->fcaseMutex);
      if (fCaseConverter->ftoupperhand==UNICONV_NOHANDLE) {
         fCaseConverter->ftoupperhand=uniconv_toupper_open();
      }

      unsigned int curCount = 0;
      while ((fCaseConverter->ftoupperhand!=UNICONV_ERROR) && (*outPtr) ) {
         XMLCh tmp = uniconv_caseit(fCaseConverter->ftoupperhand,*outPtr);
         if (errno) {
            uniconv_toupper_close(fCaseConverter->ftoupperhand);
            fCaseConverter->ftoupperhand=UNICONV_ERROR;
            break;
         }
         *outPtr = tmp;
         outPtr++;
      }
   }
   if (fCaseConverter->ftoupperhand==UNICONV_ERROR) {
     return fICUService->upperCase(toUpperCase);
   }
}

void Uniconv390TransService::lowerCase(XMLCh* const toLowerCase) const
{
//char localname1[500];
//XMLString::transcode(toLowerCase,localname1,400);
//DBGPRINTF2("lower casing %s \n",localname1);
//printf("tolower handle=%x\n",fCaseConverter->ftolowerhand);
//printf("!!!***Lower casing function called: %s \n",localname1);



   if (fCaseConverter->ftolowerhand!=UNICONV_ERROR) {
      XMLCh* outPtr = toLowerCase;

      XMLMutexLock lockcaser(&fCaseConverter->fcaseMutex);
      if (fCaseConverter->ftolowerhand==UNICONV_NOHANDLE) {
         fCaseConverter->ftolowerhand=uniconv_tolower_open();
      }

      unsigned int curCount = 0;
      while ((fCaseConverter->ftolowerhand!=UNICONV_ERROR) && (*outPtr) ) {
         XMLCh tmp = uniconv_caseit(fCaseConverter->ftolowerhand,*outPtr);
         if (errno) {
            uniconv_tolower_close(fCaseConverter->ftolowerhand);
            fCaseConverter->ftolowerhand=UNICONV_ERROR;
            break;
         }
         *outPtr = tmp;
         outPtr++;
      }
   }
   if (fCaseConverter->ftolowerhand==UNICONV_ERROR) {
     return fICUService->lowerCase(toLowerCase);
   }
}

XMLLCPTranscoder* Uniconv390TransService::makeNewLCPTranscoder()
{
   XMLTransService::Codes resValue;
DBGPRINTF2("makeNewLCPTranscoder() localencoding=%s \n",nl_langinfo(CODESET));
   // USS default code page is IBM-1047
   if (gForceTranscode == MUST_USE_ICU) {
      if (gViewTranscoder)
         printf("IXM1004I LCP - Using ICU - %s\n",nl_langinfo(CODESET));
      fLCPTranscoder = fICUService->makeNewLCPTranscoder();
   } else {
      char codepage[32];
      sprintf(codepage,"%s-s390", nl_langinfo(CODESET));
      uniconvconverter *tconv=addConverter(codepage,resValue);
      DBGPRINTF3("gForce=%d,tconv=%x\n",gForceTranscode,(int)tconv);

      if (tconv) {
         if (gViewTranscoder)
            printf("IXM1005I LCP - Using Unicode Services - %s\n",nl_langinfo(CODESET));
         fLCPTranscoder = new Uniconv390LCPTranscoder(tconv);
      } else {
         if (gForceTranscode != MUST_USE_UNICONV) {
            if (gViewTranscoder)
               printf("IXM1006I LCP - Using ICU - %s\n",nl_langinfo(CODESET));
            fLCPTranscoder = fICUService->makeNewLCPTranscoder();
         }
      }
   }
   return fLCPTranscoder;
}

// ---------------------------------------------------------------------------
//  Uniconv390TransService: The protected virtual transcoding service API
// ---------------------------------------------------------------------------
XMLTranscoder* Uniconv390TransService::
makeNewXMLTranscoder(const  XMLCh* const            encodingName
                    ,       XMLTransService::Codes& resValue
                    , const unsigned int            blockSize
                    ,       MemoryManager* const    manager)
{
char * localname = XMLString::transcode(encodingName, manager);
ArrayJanitor<char> janText((char*)localname, manager);
DBGPRINTF3("makeNewXMLTranscoder() encoding=%s blocksize=%d\n",localname,blockSize);

   if (gForceTranscode == MUST_USE_ICU) {
      if (gViewTranscoder)
         printf("IXM1001I XML - Using ICU - %s\n",localname);
      return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize, manager);
   }

   uniconvconverter *tconv=addConverter(localname,resValue);

   if (tconv == 0) {
      DBGPRINTF1("uniconv failed!!!!!!!!\n");
      if (gForceTranscode == MUST_USE_UNICONV)
         return 0;
      else {
         if (gViewTranscoder)
            printf("IXM1002I XML - Using ICU - %s\n",localname);
         return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize, manager);
      }
   }

   if (gViewTranscoder)
      printf("IXM1003I XML - Using Unicode Services - %s\n",localname);
   return new (manager) Uniconv390Transcoder(encodingName, tconv, blockSize, manager);
}
// ---------------------------------------------------------------------------
//  Uniconv390TransService: Hidden Init Method
//
//  This is called by OS390 platform utils during startup.
// ---------------------------------------------------------------------------
void Uniconv390TransService::initTransService()
{
    // Need to first check if the translate instruction is supported
    // by this processor ... if it is use the new intrinsics.

    if (((*(int*) 200) & 0x00001000) != 0)
       {
       //
       //  A stupid way to increment the fCurCount inside the RefVectorOf
       //
       for (unsigned int i = 0; i < XMLRecognizer::Encodings_Count; i++)
           gMappingsRecognizer->addElement(0);

       //
       //  Add in the magical mapping for the native XMLCh transcoder. This
       //  is used for internal entities.
       //
       gMappingsRecognizer->setElementAt(new ENameMapFor<XMLChTranscoder>(XMLUni::fgXMLChEncodingString), XMLRecognizer::XERCES_XMLCH);
       gMappings->put((void*)XMLUni::fgXMLChEncodingString, new ENameMapFor<XMLChTranscoder>(XMLUni::fgXMLChEncodingString));

       //
       //  Add in our mappings for ASCII.
       //
       gMappingsRecognizer->setElementAt(new ENameMapFor<XMLASCIITranscoder390>(XMLUni::fgUSASCIIEncodingString), XMLRecognizer::US_ASCII);
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString, new ENameMapFor<XMLASCIITranscoder390>(XMLUni::fgUSASCIIEncodingString));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString2, new ENameMapFor<XMLASCIITranscoder390>(XMLUni::fgUSASCIIEncodingString2));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString3, new ENameMapFor<XMLASCIITranscoder390>(XMLUni::fgUSASCIIEncodingString3));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString4, new ENameMapFor<XMLASCIITranscoder390>(XMLUni::fgUSASCIIEncodingString4));


       //
       //  Add in our mappings for UTF-8
       //
       gMappingsRecognizer->setElementAt(new ENameMapFor<XMLUTF8Transcoder390>(XMLUni::fgUTF8EncodingString), XMLRecognizer::UTF_8);
       gMappings->put((void*)XMLUni::fgUTF8EncodingString, new ENameMapFor<XMLUTF8Transcoder390>(XMLUni::fgUTF8EncodingString));
       gMappings->put((void*)XMLUni::fgUTF8EncodingString2, new ENameMapFor<XMLUTF8Transcoder390>(XMLUni::fgUTF8EncodingString2));

       //
       //  Add in our mappings for Latin1
       //
       gMappings->put((void*)XMLUni::fgISO88591EncodingString, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString2, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString2));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString3, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString3));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString4, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString4));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString5, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString5));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString6, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString6));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString7, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString7));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString8, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString8));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString9, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString9));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString10, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString10));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString11, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString11));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString12, new ENameMapFor<XML88591Transcoder390>(XMLUni::fgISO88591EncodingString12));

       //
       //  Add in our mappings for UTF-16 and UCS-4, little endian
       //
       bool swapped = false;

       #if defined(ENDIANMODE_BIG)
       swapped = true;
       #endif
       gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUTF16Transcoder>(XMLUni::fgUTF16LEncodingString, swapped), XMLRecognizer::UTF_16L);
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16LEncodingString,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16LEncodingString
               , swapped
           )
       );

       gMappings->put
       (
   		(void*)XMLUni::fgUTF16LEncodingString2,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16LEncodingString2
               , swapped
           )
       );

       gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUCS4Transcoder>(XMLUni::fgUCS4LEncodingString, swapped), XMLRecognizer::UCS_4L);
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4LEncodingString,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4LEncodingString
               , swapped
           )
       );

       gMappings->put
       (
   		(void*)XMLUni::fgUCS4LEncodingString2,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4LEncodingString2
               , swapped
           )
       );

       //
       //  Add in our mappings for UTF-16 and UCS-4, big endian
       //
       swapped = false;
       #if defined(ENDIANMODE_LITTLE)
       swapped = true;
       #endif
       gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUTF16Transcoder>(XMLUni::fgUTF16BEncodingString, swapped), XMLRecognizer::UTF_16B);
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16BEncodingString,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16BEncodingString
               , swapped
           )
       );

       gMappings->put
       (
   		(void*)XMLUni::fgUTF16BEncodingString2,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16BEncodingString2
               , swapped
           )
       );

       gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUCS4Transcoder>(XMLUni::fgUCS4BEncodingString, swapped), XMLRecognizer::UCS_4B);
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4BEncodingString,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4BEncodingString
               , swapped
           )
       );

       gMappings->put
       (
   		(void*)XMLUni::fgUCS4BEncodingString2,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4BEncodingString2
               , swapped
           )
       );

       //
       //  Add in our mappings for UTF-16 and UCS-4 which does not indicate endian
       //  assumes the same endian encoding as the OS
       //

       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString2,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString2
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString3,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString3
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString4,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString4
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4EncodingString,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4EncodingString
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4EncodingString2,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4EncodingString2
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4EncodingString3,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4EncodingString3
               , false
           )
       );

       //
       //  Add in our mappings for IBM037, and the one alias we support for
       //  it, which is EBCDIC-CP-US.
       //
       gMappingsRecognizer->setElementAt(new ENameMapFor<XMLEBCDICTranscoder390>(XMLUni::fgEBCDICEncodingString), XMLRecognizer::EBCDIC);
       gMappings->put((void*)XMLUni::fgIBM037EncodingString, new ENameMapFor<XMLEBCDICTranscoder390>(XMLUni::fgIBM037EncodingString));
       gMappings->put((void*)XMLUni::fgIBM037EncodingString2, new ENameMapFor<XMLEBCDICTranscoder390>(XMLUni::fgIBM037EncodingString2));


       //hhe
       gMappings->put((void*)XMLUni::fgIBM1047EncodingString, new ENameMapFor<XMLIBM1047Transcoder390>(XMLUni::fgIBM1047EncodingString));
       gMappings->put((void*)XMLUni::fgIBM1047EncodingString2, new ENameMapFor<XMLIBM1047Transcoder390>(XMLUni::fgIBM1047EncodingString2));

       //
       //  Add in our mappings for IBM037 with Euro update, i.e. IBM1140. It
       //  has alias IBM01140, the one suggested by IANA
       //
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString, new ENameMapFor<XMLIBM1140Transcoder390>(XMLUni::fgIBM1140EncodingString));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString2, new ENameMapFor<XMLIBM1140Transcoder390>(XMLUni::fgIBM1140EncodingString2));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString3, new ENameMapFor<XMLIBM1140Transcoder390>(XMLUni::fgIBM1140EncodingString3));