开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
iconv_cnv.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：22k
源码类别：

词法分析

开发平台：

Visual C++

iconv_cnv.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /**
  58.  * $Log: iconv_cnv.cpp,v $
  59.  * Revision 1.2  2002/11/04 15:14:33  tng
  60.  * C++ Namespace Support.
  61.  *
  62.  * Revision 1.1.1.1  2002/02/01 22:22:36  peiyongz
  63.  * sane_include
  64.  *
  65.  * Revision 1.1  2001/06/25 16:19:14  tng
  66.  * Rename iconv_cnv.c to iconv_cnv.cpp.  AS400 changes by Linda Swan.
  67.  *
  68.  * Revision 1.3  2001/06/19 19:31:04  tng
  69.  * Latest AS/400 update.
  70.  *
  71.  * Revision 1.2  2000/09/12 17:06:49  aruna1
  72.  * Replaced INDEX_OUTOFBOUNDS error to BUFFER_OVERFLOW error for toUnicode and from_Unicode functions for compatibility with icu 1.6
  73.  *
  74.  * Revision 1.1  2000/02/10 18:08:28  abagchi
  75.  * Initial checkin
  76.  *
  77.  */
  79. #include <stdio.h>
  80. #include <stdlib.h>
  81. #include <unistd.h>
  82. #include <errno.h>
  83. #include <iconv_util.hpp>
  84. #include <iconv_cnv.hpp>
  85. #include <qmhrtvm.h>
  86. #include <qusec.h>
  87. #include <xercesc/util/Platforms/OS400/OS400PlatformUtils.hpp>
  88. #include <iconv.h>
  89. #include <errno.h>
  90. #define CHUNK_SIZE 5*1024
  92. XERCES_CPP_NAMESPACE_BEGIN
  94. void Convert_toUnicode(UConverter *,
  95.      UChar **,
  96.      const UChar *,
  97.      const char **,
  98.      const char *,
  99.      int32_t* offsets,
  100.      int,
  101.      UErrorCode *);
  103. void Convert_fromUnicode(UConverter *,
  104.        char **,
  105.        const char *,
  106.        const UChar **,
  107.        const UChar *,
  108.        int32_t* offsets,
  109.        int,
  110.        UErrorCode *);
  112. UChar getNextUChar(UConverter* converter,
  113.        const char** source,
  114.        const char* sourceLimit,
  115.        UErrorCode* err);
  117. void T_UConverter_fromCodepageToCodepage (UConverter * outConverter,
  118.  UConverter * inConverter,
  119.  char **target,
  120.  const char *targetLimit,
  121.  const char **source,
  122.  const char *sourceLimit,
  123.  int32_t* offsets,
  124.  int flush,
  125.  UErrorCode * err);
  126. void Converter_fromUnicode(UConverter * _this,
  127.  char **target,
  128.  const char *targetLimit,
  129.  const UChar ** source,
  130.  const UChar * sourceLimit,
  131.  int32_t *offsets,
  132.  int flush,
  133.  UErrorCode * err);
  135. /*Calls through createConverter */
  136. UConverter* ucnv_open (const char *name,
  137.        UErrorCode * err)
  138. {
  139.   if (U_FAILURE (*err))
  140.     return NULL;
  142.   /*In case "name" is NULL we want to open the default converter */
  143.   if (name != NULL)
  144.     return createConverter (name, err);
  145.   else
  146.     return createConverter (iconv_getDefaultCodepage(), err);
  147. }
  149. /*Extracts the UChar* to a char* and calls through createConverter */
  150. UConverter*  ucnv_openU (const UChar * name,
  151.  UErrorCode * err)
  152. {
  153.   char asciiName[MAX_CONVERTER_NAME_LENGTH];
  155.   if (U_FAILURE (*err))
  156.     return NULL;
  157.   if (name == NULL)
  158.     return ucnv_open (NULL, err);
  159.   if (u_strlen (name) > MAX_CONVERTER_NAME_LENGTH)
  160.     {
  161.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  162.       return NULL;
  163.     }
  164.   return ucnv_open (u_austrcpy (asciiName, name), err);
  165. }
  167. /*Decreases the reference counter in the shared immutable section of the object
  168.  *and frees the mutable part*/
  170. void ucnv_close (UConverter * converter)
  171. {
  172. /* for iconv we will close the handles and free the converter storage*/
  173.   iconv_close(converter->sharedData->toiconv_handle);
  174.   iconv_close(converter->sharedData->fromiconv_handle);
  175.   if (converter == NULL)
  176.     return;
  179.   free (converter);
  181.   return;
  182. }
  184. /* currently required for iconv suuport */
  185. /* XMLReader calls this and uses fact that it is different than min
  186. to go thru a calculation otherwise if max and min same then there is
  187. a calculation speed up - we will keep the two routines but have them
  188. return different sizes - later will ifdef XMLreader for ICONV to remove the calls*/
  189.  int8_t  ucnv_getMaxCharSize (const UConverter * converter)
  190. {
  191.   return (4); /* dummy returns just need to be different in XMLParser - need something else for ICU replacement */
  192. }
  193. /* currently required for iconv support */
  194. /* see note for ucnv_getMaxCharSize */
  195. int8_t  ucnv_getMinCharSize (const UConverter * converter)
  196. {
  197.   return (1);
  198. }
  200. void   ucnv_fromUnicode (UConverter * _this,
  201.  char **target,
  202.  const char *targetLimit,
  203.  const UChar ** source,
  204.  const UChar * sourceLimit,
  205.  int32_t* offsets,
  206.  int flush,
  207.  UErrorCode * err)
  208. {
  209.   /*
  210.    * Check parameters in for all conversions
  211.    */
  212.   if (U_FAILURE (*err))   return;
  213.   if ((_this == NULL) || ((char *) targetLimit < *target) || (sourceLimit < *source))
  214.     {
  215.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  216.       return;
  217.     }
  220.   /*calls the specific conversion routines */
  221.   Converter_fromUnicode(_this,target,targetLimit,source,sourceLimit,
  222.    offsets,flush,err);
  224.   return;
  225. }
  227. void   ucnv_toUnicode (UConverter * _this,
  228.        UChar ** target,
  229.        const UChar * targetLimit,
  230.        const char **source,
  231.        const char *sourceLimit,
  232.        int32_t* offsets,
  233.        int flush,
  234.        UErrorCode * err)
  235. {
  236.   /*
  237.    * Check parameters in for all conversions
  238.    */
  239.   if (U_FAILURE (*err))   return;
  240.   if ((_this == NULL) || ((UChar *) targetLimit < *target) || (sourceLimit < *source))
  241.     {
  242.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  243.       return;
  244.     }
  248.   /*calls the specific conversion routines */
  249.   Convert_toUnicode(_this,target,targetLimit,source,sourceLimit,
  250.   offsets,flush,err);
  251.   return;
  252. }
  254. int32_t   ucnv_fromUChars (const UConverter * converter,
  255.    char *target,
  256.    int32_t targetSize,
  257.    const UChar * source,
  258.    UErrorCode * err)
  259. {
  260.   const UChar *mySource = source;
  261.   const UChar *mySource_limit;
  262.   int32_t mySourceLength = 0;
  263.   UConverter myConverter;
  264.   char *myTarget = target;
  265.   int32_t targetCapacity = 0;
  267.   if (U_FAILURE (*err))
  268.     return 0;
  270.   if ((converter == NULL) || (targetSize < 0))
  271.     {
  272.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  273.       return 0;
  274.     }
  276.   /*makes a local copy of the UConverter */
  277.   myConverter = *converter;
  280.   /*if the source is empty we return immediately */
  281.   mySourceLength = u_strlen (source);
  282.   if (mySourceLength == 0)
  283.     {
  284.       /*for consistency we still need to
  285.        *store 0 in the targetCapacity
  286.        *if the user requires it
  287.        */
  288.       return 0;
  289.     }
  291.   mySource_limit = mySource + mySourceLength;
  293.   if (targetSize > 0)
  294.     {
  295.       ucnv_fromUnicode (&myConverter,
  296. &myTarget,
  297. target + targetSize,
  298. &mySource,
  299. mySource_limit,
  300. NULL,
  301. TRUE,
  302. err);
  303.       targetCapacity = myTarget - target;
  304.     }
  306.   /*Updates targetCapacity to contain the number of bytes written to target */
  308.   if (targetSize == 0)
  309.     {
  310.       *err = U_BUFFER_OVERFLOW_ERROR;
  311.     }
  313.   /* If the output buffer is exhausted, we need to stop writing
  314.    * to it but continue the conversion in order to store in targetSize
  315.    * the number of bytes that was required*/
  316.   if (*err == U_BUFFER_OVERFLOW_ERROR)
  317.     {
  318.       char target2[CHUNK_SIZE];
  319.       char *target2_alias = target2;
  320.       const char *target2_limit = target2 + CHUNK_SIZE;
  322.       /*We use a stack allocated buffer around which we loop
  323.        *(in case the output is greater than CHUNK_SIZE)
  324.        */
  326.       while (*err == U_BUFFER_OVERFLOW_ERROR)
  327. {
  328.   *err = U_ZERO_ERROR;
  329.   target2_alias = target2;
  330.   ucnv_fromUnicode (&myConverter,
  331.     &target2_alias,
  332.     target2_limit,
  333.     &mySource,
  334.     mySource_limit,
  335.     NULL,
  336.     TRUE,
  337.     err);
  339.   /*updates the output parameter to contain the number of char required */
  340.   targetCapacity += (target2_alias - target2) + 1;
  341. }
  342.       /*We will set the erro code to BUFFER_OVERFLOW_ERROR only if
  343.        *nothing graver happened in the previous loop*/
  344.       (targetCapacity)--;
  345.       if (U_SUCCESS (*err))
  346. *err = U_BUFFER_OVERFLOW_ERROR;
  347.     }
  349.   return targetCapacity;
  350. }
  352. int32_t ucnv_toUChars (const UConverter * converter,
  353.        UChar * target,
  354.        int32_t targetSize,
  355.        const char *source,
  356.        int32_t sourceSize,
  357.        UErrorCode * err)
  358. {
  359.   const char *mySource = source;
  360.   const char *mySource_limit = source + sourceSize;
  361.   UConverter myConverter;
  362.   UChar *myTarget = target;
  363.   int32_t targetCapacity;
  365.   if (U_FAILURE (*err))
  366.     return 0;
  368.   if ((converter == NULL) || (targetSize < 0) || (sourceSize < 0))
  369.     {
  370.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  371.       return 0;
  372.     }
  373.   /*Means there is no work to be done */
  374.   if (sourceSize == 0)
  375.     {
  376.       /*for consistency we still need to
  377.        *store 0 in the targetCapacity
  378.        *if the user requires it
  379.        */
  380.       if (targetSize >= 1)
  381. {
  382.   target[0] = 0x0000;
  383.   return 1;
  384. }
  385.       else
  386. return 0;
  387.     }
  389.   /*makes a local copy of the UConverter */
  390.   myConverter = *converter;
  393.   /*Not in pure pre-flight mode */
  394.   if (targetSize > 0)
  395.     {
  396.      /*  Changed from (targetSize * 2) to (targetSize) */
  397.       ucnv_toUnicode (&myConverter,
  398.       &myTarget,
  399.       target + (targetSize-1),   /*Save a spot for the Null terminator */
  400.       &mySource,
  401.       mySource_limit,
  402.       NULL,
  403.       TRUE,
  404.       err);
  406.       /*Null terminates the string */
  407.       *(myTarget) = 0x0000;
  408.     }
  411.   /*Rigs targetCapacity to have at least one cell for zero termination */
  412.   /*Updates targetCapacity to contain the number of bytes written to target */
  413.   targetCapacity = 1;
  414.   targetCapacity += myTarget - target;
  415.   if (targetSize == 0)
  416.     {
  417.       *err = U_BUFFER_OVERFLOW_ERROR;
  418.     }
  419.   /* If the output buffer is exhausted, we need to stop writing
  420.    * to it but if the input buffer is not exhausted,
  421.    * we need to continue the conversion in order to store in targetSize
  422.    * the number of bytes that was required
  423.    */
  424.   if (*err == U_BUFFER_OVERFLOW_ERROR)
  425.     {
  426.       UChar target2[CHUNK_SIZE];
  427.       UChar *target2_alias = target2;
  428.       const UChar *target2_limit = target2 + CHUNK_SIZE;
  430.       /*We use a stack allocated buffer around which we loop
  431.          (in case the output is greater than CHUNK_SIZE) */
  433.       while (*err == U_BUFFER_OVERFLOW_ERROR)
  434. {
  435.   *err = U_ZERO_ERROR;
  436.   target2_alias = target2;
  437.   ucnv_toUnicode (&myConverter,
  438.   &target2_alias,
  439.   target2_limit,
  440.   &mySource,
  441.   mySource_limit,
  442.   NULL,
  443.   TRUE,
  444.   err);
  446.   /*updates the output parameter to contain the number of char required */
  447.   targetCapacity += target2_alias - target2 + 1;
  448. }
  449.       (targetCapacity)--; /*adjust for last one */
  450.       if (U_SUCCESS (*err))
  451. *err = U_BUFFER_OVERFLOW_ERROR;
  452.     }
  454.   return targetCapacity;
  455. }
  457. UChar ucnv_getNextUChar (UConverter * converter,
  458.  const char **source,
  459.  const char *sourceLimit,
  460.  UErrorCode * err)
  461. {
  464.   /*calls the specific conversion routines */
  465.   /*as dictated in a code review, avoids a switch statement */
  466.   return getNextUChar(converter,source,sourceLimit,err);
  467. }
  471. /**************************
  472. * Will convert a sequence of bytes from one codepage to another.
  473. * @param toConverterName: The name of the converter that will be used to encode the output buffer
  474. * @param fromConverterName: The name of the converter that will be used to decode the input buffer
  475. * @param target: Pointer to the output buffer* written
  476. * @param targetLength: on input contains the capacity of target, on output the number of bytes copied to target
  477. * @param source: Pointer to the input buffer
  478. * @param sourceLength: on input contains the capacity of source, on output the number of bytes processed in "source"
  479. * @param internal: used internally to store store state data across calls
  480. * @param err: fills in an error status
  481. */
  482. void
  483. T_UConverter_fromCodepageToCodepage (UConverter * outConverter,
  484.      UConverter * inConverter,
  485.      char **target,
  486.      const char *targetLimit,
  487.      const char **source,
  488.      const char *sourceLimit,
  489.      int32_t* offsets,
  490.      int flush,
  491.      UErrorCode * err)
  492. {
  494.   UChar out_chunk[CHUNK_SIZE];
  495.   const UChar *out_chunk_limit = out_chunk + CHUNK_SIZE;
  496.   UChar *out_chunk_alias;
  497.   UChar const *out_chunk_alias2;
  500.   if (U_FAILURE (*err))    return;
  503.   /*loops until the input buffer is completely consumed
  504.    *or if an error has be encountered
  505.    *first we convert from inConverter codepage to Unicode
  506.    *then from Unicode to outConverter codepage
  507.    */
  508.   while ((*source != sourceLimit) && U_SUCCESS (*err))
  509.     {
  510.       out_chunk_alias = out_chunk;
  511.       ucnv_toUnicode (inConverter,
  512.       &out_chunk_alias,
  513.       out_chunk_limit,
  514.       source,
  515.       sourceLimit,
  516.       NULL,
  517.       flush,
  518.       err);
  520.       /*BUFFER_OVERFLOW_ERROR means that the output "CHUNK" is full
  521.        *we will require at least another loop (it's a recoverable error)
  522.        */
  524.       if (U_SUCCESS (*err) || (*err == U_BUFFER_OVERFLOW_ERROR))
  525. {
  526.   *err = U_ZERO_ERROR;
  527.   out_chunk_alias2 = out_chunk;
  529.   while ((out_chunk_alias2 != out_chunk_alias) && U_SUCCESS (*err))
  530.     {
  531.       ucnv_fromUnicode (outConverter,
  532. target,
  533. targetLimit,
  534. &out_chunk_alias2,
  535. out_chunk_alias,
  536. NULL,
  537. TRUE,
  538. err);
  540.     }
  541. }
  542.       else
  543. break;
  544.     }
  546.   return;
  547. }
  549. int32_t  ucnv_convert(const char *toConverterName,
  550.       const char *fromConverterName,
  551.       char *target,
  552.       int32_t targetSize,
  553.       const char *source,
  554.       int32_t sourceSize,
  555.       UErrorCode * err)
  556. {
  557.   const char *mySource = source;
  558.   const char *mySource_limit = source + sourceSize;
  559.   int32_t mySourceLength = 0;
  560.   UConverter *inConverter;
  561.   UConverter *outConverter;
  562.   char *myTarget = target;
  563.   int32_t targetCapacity = 0;
  565.   if (U_FAILURE (*err))
  566.     return 0;
  568.   if ((targetSize < 0) || (sourceSize < 0))
  569.     {
  570.       *err = U_ILLEGAL_ARGUMENT_ERROR;
  571.       return 0;
  572.     }
  574.   /*if there is no input data, we're done */
  575.   if (sourceSize == 0)
  576.     {
  577.       /*in case the caller passed an output ptr
  578.        *we update it
  579.        */
  580.       return 0;
  581.     }
  583.   /*create the converters */
  584.   inConverter = ucnv_open (fromConverterName, err);
  585.   if (U_FAILURE (*err)) return 0;
  586.   outConverter = ucnv_open (toConverterName, err);
  587.   if (U_FAILURE (*err))
  588.     {
  589.       ucnv_close (inConverter);
  590.       return 0;
  591.     }
  594.   if (targetSize > 0)
  595.     {
  596.       T_UConverter_fromCodepageToCodepage (outConverter,
  597.    inConverter,
  598.    &myTarget,
  599.    target + targetSize,
  600.    &mySource,
  601.    mySource_limit,
  602.    NULL,
  603.    TRUE,
  604.    err);
  605.     }
  608.   /*Updates targetCapacity to contain the number of bytes written to target */
  609.   targetCapacity = myTarget - target;
  610.   if (targetSize == 0)
  611.     {
  612.       *err = U_BUFFER_OVERFLOW_ERROR;
  613.     }
  615.   /* If the output buffer is exhausted, we need to stop writing
  616.    * to it but continue the conversion in order to store in targetSize
  617.    * the number of bytes that was required*/
  618.   if (*err == U_BUFFER_OVERFLOW_ERROR)
  619.     {
  620.       char target2[CHUNK_SIZE];
  621.       char *target2_alias = target2;
  622.       const char *target2_limit = target2 + CHUNK_SIZE;
  624.       /*We use a stack allocated buffer around which we loop
  625.        *(in case the output is greater than CHUNK_SIZE)
  626.        */
  628.       while (*err == U_BUFFER_OVERFLOW_ERROR)
  629. {
  630.   *err = U_ZERO_ERROR;
  631.   target2_alias = target2;
  632.   T_UConverter_fromCodepageToCodepage (outConverter,
  633.        inConverter,
  634.        &target2_alias,
  635.        target2_limit,
  636.        &mySource,
  637.        mySource_limit,
  638.        NULL,
  639.        TRUE,
  640.        err);
  642.   /*updates the output parameter to contain the number of char required */
  643.   targetCapacity += (target2_alias - target2) + 1;
  644. }
  645.       /*We will set the erro code to BUFFER_OVERFLOW_ERROR only if
  646.        *nothing graver happened in the previous loop*/
  647.       (targetCapacity)--;
  648.       if (U_SUCCESS (*err))
  649. *err = U_BUFFER_OVERFLOW_ERROR;
  650.     }
  652.   ucnv_close (inConverter);
  653.   ucnv_close (outConverter);
  655.   return targetCapacity;
  656. }
  658. void Converter_fromUnicode(UConverter * _this,
  659.  char **target,
  660.  const char *targetLimit,
  661.  const UChar ** source,
  662.  const UChar * sourceLimit,
  663.  int32_t *offsets,
  664.  int flush,
  665.  UErrorCode * err)
  666. {
  667.   int chardone;
  668.   const UChar *mySource = *source;
  669.   unsigned char *myTarget = (unsigned char *) *target;
  671.   int32_t targetLength = targetLimit - (char *) myTarget;
  672.   int32_t sourceLength = (sourceLimit - mySource) * 2;
  673.   unsigned char targetChar = 0x00;
  674.   /* pick up the iconv handle and perform the conversion */
  675.   errno = 0;
  676.   chardone =iconv(_this->sharedData->fromiconv_handle,(char**)source,  (size_t*) &sourceLength,target,(size_t *)&targetLength);
  677.   if (errno!=0)
  678.     if (errno == E2BIG)
  679.       {
  680.   *err = U_BUFFER_OVERFLOW_ERROR;
  681.           return;
  682.       }
  683.     else
  685.       if ((errno ==EBADDATA)|| (errno ==ECONVERT))
  687.        {
  688.         char errno_id[7];
  689.         send_message(NULL,ICONV_CONVERT_PROBLEM,'d');
  690.         convert_errno(errno_id,errno);
  691.         send_message(NULL,errno_id,'d');
  692.         *err = U_INVALID_CHAR_FOUND;
  693. return;
  694. }
  697.   return;
  698.        }
  700. void Convert_toUnicode(UConverter * _this,
  701.   UChar ** target,
  702.   const UChar * targetLimit,
  703.   const char **source,
  704.   const char *sourceLimit,
  705.   int32_t *offsets,
  706.   int flush,
  707.   UErrorCode * err)
  708. {
  709.   char *mySource = (char *) *source;
  710.   UChar *myTarget = *target;
  712.   int32_t targetLength = (targetLimit - myTarget)*2;  /* multiply by 2 */
  713.   int32_t sourceLength = (sourceLimit - (char *) mySource);
  714.   int chardone;
  715.   /* pick up the iconv handle */
  716.   errno = 0;
  717.   chardone =iconv(_this->sharedData->toiconv_handle,(char**)source,  (size_t*) &sourceLength,(char **)target,(size_t *)&targetLength);
  718.   if (errno!=0)
  719.   {
  720.     if (errno == E2BIG)
  721.       {
  722.   *err = U_BUFFER_OVERFLOW_ERROR;
  723.           return;
  724.       }
  725.     else
  727.       if ((errno ==EBADDATA)|| (errno ==ECONVERT))
  729.        {
  730.         char errno_id[7];
  731.         send_message(NULL,ICONV_CONVERT_PROBLEM,'d');
  732.         convert_errno(errno_id,errno);
  733.         send_message(NULL,errno_id,'d');
  734.         *err = U_INVALID_CHAR_FOUND;
  735.         return;
  737. }
  739. }
  742.   return;
  743. }
  745. UChar getNextUChar(UConverter* converter,
  746.        const char** source,
  747.        const char* sourceLimit,
  748.        UErrorCode* err)
  749. {
  750.   UChar myUChar;
  751.   UChar* myUCharptr;
  752.   size_t numberibytes=sizeof(UChar);
  753.   size_t numberobytes=sizeof(UChar);
  754.   int chardone;
  755.   if ((*source)+1 > sourceLimit)
  756.     {
  757.       *err = U_INDEX_OUTOFBOUNDS_ERROR;
  758.       return 0xFFFD;
  759.     }
  762.   /*pick up the iconv handle */
  763.   /* convert the requested character - need to cache characters 6 will do - XMLReader is using this function to get header to process*/
  764.   myUCharptr  = &myUChar;
  765.  chardone =iconv(converter->sharedData->toiconv_handle,(char**)source,  (size_t*) &numberibytes,(char **)&myUCharptr,(size_t *)&numberobytes);
  766.   if (myUChar != 0xFFFD) return myUChar;
  767.   else
  768.     {
  769.       UChar* myUCharPtr = &myUChar;
  770.       const char* sourceFinal = *source;
  772.       *err = U_INVALID_CHAR_FOUND;
  775.       /*makes the internal caching transparent to the user*/
  776.       if (*err == U_INDEX_OUTOFBOUNDS_ERROR) *err = U_ZERO_ERROR;
  778.       return myUChar;
  779.     }
  780. }
  782. XERCES_CPP_NAMESPACE_END