/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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: Uniconv390TransService.cpp 568078 2007-08-21 11:43:25Z amassari $
 */


// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/TranscodingException.hpp>
#include <xercesc/util/RefHashTableOf.hpp>
#include <xercesc/util/RefVectorOf.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XML88591Transcoder390.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLASCIITranscoder390.hpp>
#include <xercesc/util/XMLChTranscoder.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLEBCDICTranscoder390.hpp>
#include <xercesc/util/XMLUCS4Transcoder.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLIBM1047Transcoder390.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLIBM1140Transcoder390.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLUTF8Transcoder390.hpp>
#include <xercesc/util/XMLUTF16Transcoder.hpp>
#include <xercesc/util/Transcoders/Uniconv390/XMLWin1252Transcoder390.hpp>
#include <xercesc/util/TransENameMap.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/Transcoders/ICU/ICUTransService.hpp>
#include "Uniconv390TransService.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <langinfo.h>
#include <locale.h>
#include <xercesc/util/regx/XMLUniCharacter.hpp>

#include <xercesc/util/XML88591Transcoder.hpp>
#include <xercesc/util/XMLASCIITranscoder.hpp>
#include <xercesc/util/XMLChTranscoder.hpp>
#include <xercesc/util/XMLEBCDICTranscoder.hpp>
#include <xercesc/util/XMLIBM1047Transcoder.hpp>
#include <xercesc/util/XMLIBM1140Transcoder.hpp>
#include <xercesc/util/XMLUCS4Transcoder.hpp>
#include <xercesc/util/XMLUTF8Transcoder.hpp>
#include <xercesc/util/XMLUTF16Transcoder.hpp>
#include <xercesc/util/XMLWin1252Transcoder.hpp>
#include <unicode/uchar.h>

XERCES_CPP_NAMESPACE_BEGIN

// debug printfs.... I'll take these out after function test.
/*
#define DBGPRINTF1(a) {}
#define DBGPRINTF2(a,b) {}
#define DBGPRINTF3(a,b,c) {}
#define DBGPRINTF4(a,b,c,d) {}
#define DBGPRINTF5(a,b,c,d,e) {}
#define DBGPRINTF6(a,b,c,d,e,f) {}
#define DBGPRINTF7(a,b,c,d,e,f,g) {}
*/
#define DBGPRINTF1(a) {if (gViewDebug) printf(a);}
#define DBGPRINTF2(a,b) {if (gViewDebug) printf(a,b);}
#define DBGPRINTF3(a,b,c) {if (gViewDebug) printf(a,b,c);}
#define DBGPRINTF4(a,b,c,d) {if (gViewDebug) printf(a,b,c,d);}
#define DBGPRINTF5(a,b,c,d,e) {if (gViewDebug) printf(a,b,c,d,e);}
#define DBGPRINTF6(a,b,c,d,e,f) {if (gViewDebug) printf(a,b,c,d,e,f);}
#define DBGPRINTF7(a,b,c,d,e,f,g) {if (gViewDebug) printf(a,b,c,d,e,f,g);}

// ---------------------------------------------------------------------------
//  Local, const data
// ---------------------------------------------------------------------------
static const XMLCh gMyServiceId[] =
{
    chLatin_U, chLatin_N, chLatin_I, chLatin_C, chLatin_O, chLatin_N, chLatin_V, chNull
};

// These will hold the environment variable settings.
bool gViewTranscoder;
static bool gViewDebug;
static int gForceTranscode;
#define NO_FORCE 0
#define MUST_USE_ICU  1
#define MUST_USE_UNICONV  2
#define MUST_USE_ICU_SRC_OFFS  3

// ---------------------------------------------------------------------------
//  Local functions
// ---------------------------------------------------------------------------

// This is a local service routine to figure out the number of characters (not bytes)
// in a unicode string.
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;
}

// This is a local service routine to open a transcoder to/from unicode.
static uniconvconverter * addConverter(const char* const EncodingName
                             ,XMLTransService::Codes& resValue)
{
DBGPRINTF1("Add converter\n");
   uniconvconverter *tconv = new uniconvconverter;
   tconv->fIconv390DescriptorFrom = uniconv_open("UCS-2",EncodingName);
   if (tconv->fIconv390DescriptorFrom <= (uniconv_t)(0)) {
DBGPRINTF2("uniconv_open from failed rc=%d\n",(int)tconv->fIconv390DescriptorFrom);
      resValue = XMLTransService::UnsupportedEncoding;
      delete tconv;
      return 0;
   }
   tconv->fIconv390DescriptorTo = uniconv_open(EncodingName,"UCS-2");
   if (tconv->fIconv390DescriptorTo <= (uniconv_t)(0)) {
DBGPRINTF2("uniconv_open to failed rc=%d\n",(int)tconv->fIconv390DescriptorTo);
      resValue = XMLTransService::UnsupportedEncoding;
      uniconv_close(tconv->fIconv390DescriptorFrom);
      delete tconv;
      return 0;
   }
   return tconv;
}

// This is a local service routine to close the transcoders.
static void removeConverter(uniconvconverter* const converter)
{
DBGPRINTF1("remove converter\n");
   if (converter) {
      uniconv_close(converter->fIconv390DescriptorFrom);
      uniconv_close(converter->fIconv390DescriptorTo);
      delete converter;
   }
}

// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// *************** Uniconv390TransService Class ******************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ---------------------------------------------------------------------------
//  Uniconv390TransService: Constructor and Destructor
// ---------------------------------------------------------------------------
Uniconv390TransService::Uniconv390TransService()
{

   char * myenviron = getenv("_IXM_FORCE_CONVERSION");
   gForceTranscode = NO_FORCE;
   if ( !strcmp(myenviron,"USE_ICU") )
      gForceTranscode = MUST_USE_ICU;
   else if ( !strcmp(myenviron,"USE_NATIVE") )
      gForceTranscode = MUST_USE_UNICONV;
   else if ( !strcmp(myenviron,"USE_ICU_SRC_OFFS") )
      gForceTranscode = MUST_USE_ICU_SRC_OFFS;
  DBGPRINTF3("FORCE PARM=%s %d\n",myenviron,gForceTranscode);

// If we are forcing ICU to be used for transcoding then we also should
// force it to be used for case conversions.
if ((gForceTranscode == MUST_USE_ICU) ||
    (gForceTranscode == MUST_USE_ICU_SRC_OFFS)) {
   fCaseConverter = new uniconvcaseconverter;
   fCaseConverter->ftoupperhand=UNICONV_ERROR;
   fCaseConverter->ftolowerhand=UNICONV_ERROR;
}
else {
   fCaseConverter = new uniconvcaseconverter;
   fCaseConverter->ftoupperhand=UNICONV_NOHANDLE;
   fCaseConverter->ftolowerhand=UNICONV_NOHANDLE;
}

   if ((gForceTranscode == MUST_USE_ICU) |
       (gForceTranscode == MUST_USE_ICU_SRC_OFFS)) {
         XMLPlatformUtils::fgTransService2 = new ICUTransService;
   }

   gViewTranscoder = false;
   if ( !strcmp(getenv("_IXM_VIEW_CONVERSION"),"YES") )
      gViewTranscoder = true;

   gViewDebug = false;
   if ( !strcmp(getenv("_IXM_DEBUG_CONVERSION"),"YES") )
      gViewDebug = true;
}

Uniconv390TransService::~Uniconv390TransService()
{
   if ( (fCaseConverter->ftoupperhand!=UNICONV_NOHANDLE) &&
        (fCaseConverter->ftoupperhand!=UNICONV_ERROR) ) {
      uniconv_toupper_close(fCaseConverter->ftoupperhand);
      fCaseConverter->ftoupperhand=UNICONV_NOHANDLE;
   }
   if ( (fCaseConverter->ftolowerhand!=UNICONV_NOHANDLE) &&
        (fCaseConverter->ftolowerhand!=UNICONV_ERROR) ) {
      uniconv_tolower_close(fCaseConverter->ftolowerhand);
      fCaseConverter->ftolowerhand=UNICONV_NOHANDLE;
   }
   if (fCaseConverter) {
      delete fCaseConverter;
      fCaseConverter=0;
   }
   if (XMLPlatformUtils::fgTransService2) {
    delete  XMLPlatformUtils::fgTransService2;
   }
}

// ---------------------------------------------------------------------------
//  Uniconv390TransService: The virtual transcoding service API
// ---------------------------------------------------------------------------
int Uniconv390TransService::compareIString(const   XMLCh* const    comp1
                                    , const XMLCh* const    comp2)
{

//char localname1[500];
//XMLString::transcode(comp1,localname1,400);
//char localname2[500];
//XMLString::transcode(comp2,localname2,400);
//DBGPRINTF3("comparing %s %s \n",localname1,localname2);
//printf("toupper handle=%x\n",fCaseConverter->ftoupperhand);

   if (fCaseConverter->ftoupperhand!=UNICONV_ERROR) {
      const XMLCh* psz1 = comp1;
      const XMLCh* psz2 = comp2;
      XMLCh tmp1;
      XMLCh tmp2;

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

      unsigned int curCount = 0;
      while (fCaseConverter->ftoupperhand!=UNICONV_ERROR)
      {
         tmp1 = uniconv_caseit(fCaseConverter->ftoupperhand,*psz1);
         if (errno==0)
            tmp2 = uniconv_caseit(fCaseConverter->ftoupperhand,*psz2);
         if (errno) {
            uniconv_toupper_close(fCaseConverter->ftoupperhand);
            fCaseConverter->ftoupperhand=UNICONV_ERROR;
            break;
         }

         //
         //  If an inequality, then return the difference.
         //
         if (tmp1 != tmp2)
            return int(*psz1) - int(*psz2);

         // If either has ended, then they both ended, so equal
         if (!*psz1 || !*psz2)
            break;

         // Move upwards for the next round
         psz1++;
         psz2++;
      }
   }
   // check if unicode services does not support upper casing again, then call ICU.
   if (fCaseConverter->ftoupperhand == UNICONV_ERROR) {
      if (!XMLPlatformUtils::fgTransService2) {
         XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
         if (!XMLPlatformUtils::fgTransService2) {
            XMLPlatformUtils::fgTransService2 = new ICUTransService;
         }
      }
      return XMLPlatformUtils::fgTransService2->compareIString(comp1,comp2);
   }
   return 0;
}


int Uniconv390TransService::compareNIString(const  XMLCh* const    comp1
                                    , const XMLCh* const    comp2
                                    , const unsigned int    maxChars)
{
//char localname1[500];
//XMLString::transcode(comp1,localname1,400);
//char localname2[500];
//XMLString::transcode(comp2,localname2,400);
//DBGPRINTF3("comparing NI %s %s \n",localname1,localname2);
//printf("toupper handle=%x\n",fCaseConverter->ftoupperhand);
//printf("!!!***comparing NI %s %s\n",localname1,localname2);

   if (fCaseConverter->ftoupperhand!=UNICONV_ERROR) {
      const XMLCh* psz1 = comp1;
      const XMLCh* psz2 = comp2;
      XMLCh tmp1;
      XMLCh tmp2;

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

      unsigned int curCount = 0;
      while (fCaseConverter->ftoupperhand!=UNICONV_ERROR) {
         tmp1 = uniconv_caseit(fCaseConverter->ftoupperhand,*psz1);
         if (errno==0)
            tmp2 = uniconv_caseit(fCaseConverter->ftoupperhand,*psz2);
         if (errno) {
            uniconv_toupper_close(fCaseConverter->ftoupperhand);
            fCaseConverter->ftoupperhand=UNICONV_ERROR;
            break;
         }

         //
         //  If an inequality, then return the difference.
         //
         if (tmp1 != tmp2)
            return int(*psz1) - int(*psz2);

         // If either ended, then both ended, so equal
         if (!*psz1 || !*psz2)
            break;

         // Move upwards to next chars
         psz1++;
         psz2++;

         //
         //  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.
         //
         curCount++;
         if (maxChars == curCount)
            break;
      }
   }
   // check if unicode services does not support upper casing, then call ICU.
   if (fCaseConverter->ftoupperhand == UNICONV_ERROR) {
      if (!XMLPlatformUtils::fgTransService2) {
         XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
         if (!XMLPlatformUtils::fgTransService2) {
            XMLPlatformUtils::fgTransService2 = new ICUTransService;
         }
      }
      return XMLPlatformUtils::fgTransService2->compareNIString(comp1,comp2,maxChars);
   }
   return 0;
}


const XMLCh* Uniconv390TransService::getId() const
{
   return gMyServiceId;
}

bool Uniconv390TransService::isSpace(const XMLCh toCheck) const
{
	/* copied from ICU */
    if ((toCheck == 0x09)
    ||  (toCheck == 0x0A)
    ||  (toCheck == 0x0D))
    {
        return true;
    }
    return (u_isspace(UChar(toCheck)) != 0);
}

bool Uniconv390TransService::supportsSrcOfs() const
{
   if (gForceTranscode == MUST_USE_ICU_SRC_OFFS)
      return true;
    else
      return false;
}

void Uniconv390TransService::upperCase(XMLCh* const toUpperCase) const
{

//char localname1[500];
//XMLString::transcode(toUpperCase,localname1,400);
//DBGPRINTF2("upper casing %s \n",localname1);
//printf("toupper handle=%x\n",fCaseConverter->ftoupperhand);

   if (fCaseConverter->ftoupperhand!=UNICONV_ERROR) {
      XMLCh* outPtr = toUpperCase;

      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) {
     if (!XMLPlatformUtils::fgTransService2) {
          XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
          if (!XMLPlatformUtils::fgTransService2) {
             XMLPlatformUtils::fgTransService2 = new ICUTransService;
          }
     }
     return XMLPlatformUtils::fgTransService2->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) {
     if (!XMLPlatformUtils::fgTransService2) {
        XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
        if (!XMLPlatformUtils::fgTransService2) {
           XMLPlatformUtils::fgTransService2 = new ICUTransService;
        }
     }
     return XMLPlatformUtils::fgTransService2->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) ||
       (gForceTranscode == MUST_USE_ICU_SRC_OFFS)) {
      if (gViewTranscoder)
         printf("IXM1004I LCP - Using ICU - %s\n",nl_langinfo(CODESET));
      if (!XMLPlatformUtils::fgTransService2) {
         XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
         if (!XMLPlatformUtils::fgTransService2) {
            XMLPlatformUtils::fgTransService2 = new ICUTransService;
         }
      }
      fLCPTranscoder = XMLPlatformUtils::fgTransService2->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));
            if (!XMLPlatformUtils::fgTransService2) {
               XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
               if (!XMLPlatformUtils::fgTransService2) {
                  XMLPlatformUtils::fgTransService2 = new ICUTransService;
               }
            }
            fLCPTranscoder = XMLPlatformUtils::fgTransService2->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) ||
       (gForceTranscode == MUST_USE_ICU_SRC_OFFS)) {
      if (gViewTranscoder)
         printf("IXM1001I XML - Using ICU - %s\n",localname);
      if (!XMLPlatformUtils::fgTransService2) {
         XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
         if (!XMLPlatformUtils::fgTransService2) {
            XMLPlatformUtils::fgTransService2 = new ICUTransService;
         }
      }
      return XMLPlatformUtils::fgTransService2->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);
         if (!XMLPlatformUtils::fgTransService2) {
            XMLMutexLock lockConverter(&fCaseConverter->fcaseMutex);
            if (!XMLPlatformUtils::fgTransService2) {
               XMLPlatformUtils::fgTransService2 = new ICUTransService;
            }
         }
         return XMLPlatformUtils::fgTransService2->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::fgUTF16EncodingString5,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString5
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString6,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString6
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString7,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString7
               , 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
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4EncodingString4,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4EncodingString4
               , 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));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString4, new ENameMapFor<XMLIBM1140Transcoder390>(XMLUni::fgIBM1140EncodingString4));

       //
       //  Add in our mappings for Windows-1252. We don't have any aliases for
       //  this one, so there is just one mapping.
       //
       gMappings->put((void*)XMLUni::fgWin1252EncodingString, new ENameMapFor<XMLWin1252Transcoder390>(XMLUni::fgWin1252EncodingString));
    } // use new intrinsics
    else // use old intrinsics
    {
       //
       //  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<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString), XMLRecognizer::US_ASCII);
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString2, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString2));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString3, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString3));
       gMappings->put((void*)XMLUni::fgUSASCIIEncodingString4, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString4));


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

       //
       //  Add in our mappings for Latin1
       //
       gMappings->put((void*)XMLUni::fgISO88591EncodingString, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString2, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString2));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString3, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString3));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString4, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString4));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString5, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString5));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString6, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString6));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString7, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString7));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString8, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString8));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString9, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString9));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString10, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString10));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString11, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString11));
       gMappings->put((void*)XMLUni::fgISO88591EncodingString12, new ENameMapFor<XML88591Transcoder>(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::fgUTF16EncodingString5,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString5
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString6,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString6
               , false
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUTF16EncodingString7,
           new EEndianNameMapFor<XMLUTF16Transcoder>
           (
               XMLUni::fgUTF16EncodingString7
               , 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
           )
       );
       gMappings->put
       (
   		(void*)XMLUni::fgUCS4EncodingString4,
           new EEndianNameMapFor<XMLUCS4Transcoder>
           (
               XMLUni::fgUCS4EncodingString4
               , false
           )
       );

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


       //hhe
       gMappings->put((void*)XMLUni::fgIBM1047EncodingString, new ENameMapFor<XMLIBM1047Transcoder>(XMLUni::fgIBM1047EncodingString));
       gMappings->put((void*)XMLUni::fgIBM1047EncodingString2, new ENameMapFor<XMLIBM1047Transcoder>(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<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString2, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString2));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString3, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString3));
       gMappings->put((void*)XMLUni::fgIBM1140EncodingString4, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString4));

       //
       //  Add in our mappings for Windows-1252. We don't have any aliases for
       //  this one, so there is just one mapping.
       //
       gMappings->put((void*)XMLUni::fgWin1252EncodingString, new ENameMapFor<XMLWin1252Transcoder>(XMLUni::fgWin1252EncodingString));
    } // use old intrinsics

}//end initTransService()


// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// *************** Uniconv390Transcoder Class ********************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************

// ---------------------------------------------------------------------------
//  Uniconv390Transcoder: Constructors and Destructor
// ---------------------------------------------------------------------------
Uniconv390Transcoder::Uniconv390Transcoder(const  XMLCh* const        encodingName
                            ,        uniconvconverter_t * const   toAdopt
                            , const unsigned int        blockSize
                            , MemoryManager* const manager) :
    XMLTranscoder(encodingName, blockSize, manager)
    , fConverter(toAdopt)
{
}

Uniconv390Transcoder::~Uniconv390Transcoder()
{
   // If there is a converter, clean it up
   if (fConverter) {
      removeConverter(fConverter);
      fConverter=0;
   }
}


// ---------------------------------------------------------------------------
//  Uniconv390Transcoder: The virtual transcoder API
// ---------------------------------------------------------------------------
// ignore  charSizes since that is used to generate character offsets.
unsigned int
Uniconv390Transcoder::transcodeFrom(const  XMLByte* const          srcData
                            , const unsigned int            srcCount
                            ,       XMLCh* const            toFill
                            , const unsigned int            maxChars
                            ,       unsigned int&           bytesEaten
                            ,       unsigned char* const    charSizes)
{
   unsigned int countIn = 0;
   unsigned int countOut = 0;
DBGPRINTF2("Uniconv390Transcoder::transcodeFrom bytes=%d\n",srcCount);
   int retCode;
   char *tmpInPtr = (char *) srcData;
   char *tmpOutPtr = (char *) toFill;
   unsigned int inByteLeft = srcCount;
   unsigned int outByteLeft = maxChars*sizeof(XMLCh);
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorFrom, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
DBGPRINTF5("Uniconv390Transcoder::transcodeFrom iconv finished, rc=%d inleft=%d outleft=%d errno=%d \n",retCode,inByteLeft,outByteLeft,errno);
   if ( (retCode < 0 ) && (errno != E2BIG) ) {
      return 0;
   }

   // Give back the counts of eaten and transcoded
   bytesEaten = srcCount-inByteLeft;
   return maxChars-outByteLeft/sizeof(XMLCh);
}

// The returned int is really supposed to be the number of bytes, not chars!
unsigned int
Uniconv390Transcoder::transcodeTo( const   XMLCh* const    srcData
                            , const unsigned int    srcCount
                            ,       XMLByte* const  toFill
                            , const unsigned int    maxBytes
                            ,       unsigned int&   charsEaten
                            , const UnRepOpts       options)
{
   unsigned int countIn = 0;
   unsigned int countOut = 0;
DBGPRINTF2("Uniconv390Transcoder::transcodeTo bytes=%d\n",srcCount);

   int retCode;
   char *tmpInPtr = (char *) srcData;
   char *tmpOutPtr = (char *) toFill;
   unsigned int inByteLeft = srcCount*sizeof(XMLCh);
   unsigned int outByteLeft = maxBytes;
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
   if ( (retCode < 0) && (errno != E2BIG) ) {
      return 0;
   }

   // Give back the counts of eaten and transcoded
   charsEaten = srcCount-inByteLeft/sizeof(XMLCh);
   return maxBytes-outByteLeft;
}


bool Uniconv390Transcoder::canTranscodeTo(const unsigned int toCheck) const
{
   int retCode;
DBGPRINTF1("Uniconv390Transcoder::canTranscodeTo\n");
//printf("!!!***Uniconv390Transcoder::canTranscodeTo\n");
   //
   //  If the passed value is really a surrogate embedded together, then
   //  we need to break it out into its two chars. Else just one. While
   //  we are ate it, convert them to UChar format if required.
   //
   XMLCh          srcBuf[2];
   unsigned int    srcCount = 1;
   if (toCheck & 0xFFFF0000) {
      srcBuf[0] = XMLCh((toCheck >> 10) + 0xD800);
      srcBuf[1] = XMLCh(toCheck & 0x3FF) + 0xDC00;
      srcCount++;
   } else {
      srcBuf[0] = XMLCh(toCheck);
   }

   // Set up a temp buffer to format into. Make it more than big enough
   char  tmpBuf[16];

   char *tmpInPtr = (char *) srcBuf;
   char *tmpOutPtr = (char *) tmpBuf;
   unsigned int inByteLeft = srcCount*sizeof(XMLCh);
   unsigned int outByteLeft = 16;

   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
   if ( (retCode < 0) && (errno != E2BIG) ) {
      return false;
   }

   return true;
}


// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// *************** Uniconv390LCPTranscoder Class *****************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************


// ---------------------------------------------------------------------------
//  Uniconv390LCPTranscoder: Constructor and Destructor
// ---------------------------------------------------------------------------
Uniconv390LCPTranscoder::Uniconv390LCPTranscoder( uniconvconverter_t* const toAdopt) :

    fConverter(toAdopt)
{
}

Uniconv390LCPTranscoder::~Uniconv390LCPTranscoder()
{
    // If there is a converter, clean it up
   if (fConverter) {
      removeConverter(fConverter);
      fConverter=0;
   }
}


// ---------------------------------------------------------------------------
//  Uniconv390LCPTranscoder: calcRequiredSize
//
// The only way I can find to reliably determine the exact required size is to actually
// transcode the string and see how long it is. Fortunately, this is only done as a last
// ditch effort so it should only be used very rarely (if at all).
// ---------------------------------------------------------------------------
unsigned int Uniconv390LCPTranscoder::calcRequiredSize(const XMLCh* const srcText
                                                       , MemoryManager* const manager)
{
DBGPRINTF1("Uniconv390LCPTranscoder::calcRequiredSize(const XMLCh* const srcText)  \n");
//printf("!!!***Uniconv390LCPTranscoder::calcRequiredSize(const XMLCh* const srcText)  \n");
   int thesize=0;
   if (!srcText)
      return 0;
   if (!*srcText)
      return 0;

   char * result = transcode(srcText, manager);
   if (result) {
      thesize = strlen(result);
      manager->deallocate(result);//delete [] result;
   }
   return thesize;
}

unsigned int Uniconv390LCPTranscoder::calcRequiredSize(const char* const srcText
                                                       , MemoryManager* const manager)
{
DBGPRINTF1("Uniconv390LCPTranscoder::calcRequiredSize(const char* const srcText)  \n");
//printf("!!!***Uniconv390LCPTranscoder::calcRequiredSize(const char* const srcText)  \n");
   int thesize=0;
   if (!srcText)
      return 0;
   if (!*srcText)
      return 0;

   XMLCh * result = transcode(srcText, manager);
   if (result) {
      thesize = getWideCharLength(result);
      manager->deallocate(result);//delete [] result;
   }

DBGPRINTF2("Uniconv390LCPTranscoder::calcRequiredSize(const char* const srcText) %d  \n",thesize);
   return thesize;
}


// ---------------------------------------------------------------------------
//  Uniconv390LCPTranscoder: transcode
//
// Now what follows are various methods to transcode to/from unicode.
// ---------------------------------------------------------------------------
char* Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode)
{
//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode) ");
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorTo);
   if (!toTranscode)
      return 0;

   char* retVal = 0;
    // find out the length of the source and use this as an estimate for the needed buffer length.
   unsigned int  wLent = getWideCharLength(toTranscode);
   if (wLent == 0) {
      retVal = new char[1];
      retVal[0] = 0;
      return retVal;
   }
   retVal = new char[wLent * 2 + 1]; // get double just to be sure.
   while (true) {
      int retCode;
      char *tmpInPtr = (char*) toTranscode;
      char *tmpOutPtr = (char*) retVal;
      unsigned int inByteLeft = wLent*sizeof(XMLCh);
      unsigned int outByteLeft = wLent*sizeof(XMLCh);
//printf("!!!transcode len=%d\n",wLent);

      { // Locking scope
         XMLMutexLock lockConverter(&fConverter->fMutex);
         retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
      }
//printf("!!!transcode uniconv finished rc=%d errno=%d\n",retCode,errno);
      // If the data does not fit into our estimation of the buffer size, then delete the buffer,
      // double the estimated length and try again.
      if ( ((retCode < 0) && (errno == E2BIG)) || (outByteLeft == 0) ) {
//printf("!!!Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):Retrying with a bigger buffer.......\n");
         delete [] retVal;
         wLent*=2;
         retVal = new char[wLent*sizeof(XMLCh) + 1];
      }
      // If uniconv doesn't complete for any other reason, then return failure.
      else if (retCode < 0) {
         return 0;
      }
      // it was successful so break out of the loop
      else {
         *tmpOutPtr = 0x00;
         break;
      }
   }
//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):%s\n",retVal);
   return retVal;
}

char* Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode,
                                         MemoryManager* const manager)
{
//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode) ");
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorTo);
   if (!toTranscode)
      return 0;

   char* retVal = 0;
    // find out the length of the source and use this as an estimate for the needed buffer length.
   unsigned int  wLent = getWideCharLength(toTranscode);
   if (wLent == 0) {
      retVal = (char*) manager->allocate(sizeof(char));//new char[1];
      retVal[0] = 0;
      return retVal;
   }
   retVal = (char*) manager->allocate((wLent * 2 + 1) * sizeof(char));//new char[wLent * 2 + 1]; // get double just to be sure.
   while (true) {
      int retCode;
      char *tmpInPtr = (char*) toTranscode;
      char *tmpOutPtr = (char*) retVal;
      unsigned int inByteLeft = wLent*sizeof(XMLCh);
      unsigned int outByteLeft = wLent*sizeof(XMLCh);
//printf("!!!transcode len=%d\n",wLent);

      { // Locking scope
         XMLMutexLock lockConverter(&fConverter->fMutex);
         retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
      }
//printf("!!!transcode uniconv finished rc=%d errno=%d\n",retCode,errno);
      // If the data does not fit into our estimation of the buffer size, then delete the buffer,
      // double the estimated length and try again.
      if ( ((retCode < 0) && (errno == E2BIG)) || (outByteLeft == 0) ) {
//printf("!!!Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):Retrying with a bigger buffer.......\n");
         manager->deallocate(retVal);//delete [] retVal;
         wLent*=2;
         retVal = (char*) manager->allocate
         (
             (wLent*sizeof(XMLCh) + 1) * sizeof(char)
         );//new char[wLent*sizeof(XMLCh) + 1];
      }
      // If uniconv doesn't complete for any other reason, then return failure.
      else if (retCode < 0) {
         return 0;
      }
      // it was successful so break out of the loop
      else {
         *tmpOutPtr = 0x00;
         break;
      }
   }
//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):%s\n",retVal);
   return retVal;
}

XMLCh* Uniconv390LCPTranscoder::transcode(const char* const toTranscode)
{
DBGPRINTF2("Uniconv390LCPTranscoder::transcode(const char* const toTranscode):%s \n",toTranscode);
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorFrom);
   if (!toTranscode)
      return 0;

   XMLCh* retVal = 0;
   const unsigned int len = strlen(toTranscode);
   retVal = new XMLCh[len + 1]; // +1 is for the null terminator!
   if (len == 0) {
      retVal[0] = 0;
      return retVal;
   }

   int retCode;
   char *tmpInPtr = (char*) toTranscode;
   char *tmpOutPtr = (char*) retVal;
   unsigned int inByteLeft = len;
   unsigned int outByteLeft = len*sizeof(XMLCh);
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorFrom, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
   // Because we check the length in the beginning, and we make sure the output buffer
   // is big enough, uniconv should complete the transcoding. If it doesn't for any reason, then
   // return failure.
   if (retCode < 0) {
      delete [] retVal;
      return 0;
   }
   *tmpOutPtr = 0x00;
   *(tmpOutPtr+1) = 0x00;
   return retVal;
}

XMLCh* Uniconv390LCPTranscoder::transcode(const char* const toTranscode,
                                          MemoryManager* const manager)
{
DBGPRINTF2("Uniconv390LCPTranscoder::transcode(const char* const toTranscode):%s \n",toTranscode);
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorFrom);
   if (!toTranscode)
      return 0;

   XMLCh* retVal = 0;
   const unsigned int len = strlen(toTranscode);
   retVal = (XMLCh*) manager->allocate((len + 1) * sizeof(XMLCh));//new XMLCh[len + 1]; // +1 is for the null terminator!
   if (len == 0) {
      retVal[0] = 0;
      return retVal;
   }

   int retCode;
   char *tmpInPtr = (char*) toTranscode;
   char *tmpOutPtr = (char*) retVal;
   unsigned int inByteLeft = len;
   unsigned int outByteLeft = len*sizeof(XMLCh);
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorFrom, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
   // Because we check the length in the beginning, and we make sure the output buffer
   // is big enough, uniconv should complete the transcoding. If it doesn't for any reason, then
   // return failure.
   if (retCode < 0) {
      manager->deallocate(retVal);//delete [] retVal;
      return 0;
   }
   *tmpOutPtr = 0x00;
   *(tmpOutPtr+1) = 0x00;
   return retVal;
}


bool Uniconv390LCPTranscoder::transcode(const  char* const     toTranscode
                                ,       XMLCh* const    toFill
                                , const unsigned int    maxChars
                                , MemoryManager* const  manager)
{
DBGPRINTF1("Uniconv390LCPTranscoder::transcode(const  char* const     toTranscode, etc.... \n");
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorFrom);
    // Check for a couple of psycho corner cases
   if (!toTranscode || !maxChars) {
      toFill[0] = 0;
      return true;
   }

   unsigned int  Lent = strlen(toTranscode);
   if (Lent == 0) {
      toFill[0] = 0;
      return true;
   }

   int retCode;
   char *tmpInPtr = (char*) toTranscode;
   char *tmpOutPtr = (char*) toFill;
   unsigned int inByteLeft = Lent;
   unsigned int outByteLeft = maxChars*2;
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorFrom, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }
   // Because we check the length in the beginning, and the caller makes sure that the output buffer
   // is big enough, uniconv should complete the transcoding. If it doesn't for any reason, then
   // return failure.
   if (retCode < 0) {
      return false;
   }
   *tmpOutPtr = 0x00;
   *(tmpOutPtr+1) = 0x00;
   return true;
}


bool Uniconv390LCPTranscoder::transcode(   const   XMLCh* const    toTranscode
                                    ,       char* const     toFill
                                    , const unsigned int    maxBytes
                                    , MemoryManager* const  manager)
{
DBGPRINTF1("Uniconv390LCPTranscoder::transcode(const  XMLCh* const     toTranscode, etc.... \n");
//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorTo);
   // Watch for a couple of pyscho corner cases
   if (!toTranscode || !maxBytes) {
      toFill[0] = 0;
      return true;
   }
   //-------------------
   unsigned int  wLent = getWideCharLength(toTranscode);
   if (wLent == 0) {
      toFill[0] = 0;
      return true;
   }
   int retCode;
   char *tmpInPtr = (char*) toTranscode;
   char *tmpOutPtr = (char*) toFill;
   unsigned int inByteLeft = wLent*sizeof(XMLCh);
   unsigned int outByteLeft = maxBytes;
   { // locking scope
      XMLMutexLock lockConverter(&fConverter->fMutex);
      retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
   }

   // Because we check the length in the beginning, and the caller makes sure that the output buffer
   // is big enough, uniconv should complete the transcoding. If it doesn't for any reason, then
   // return failure.
   if (retCode < 0) {
      return false;
   }
   *tmpOutPtr = 0x00;
   return true;
}

XERCES_CPP_NAMESPACE_END