../deps/icu-small/source/common/ucnv.cpp

Bug Summary

File:	out/../deps/icu-small/source/common/ucnv.cpp
Warning:	line 1485, column 21 Address of stack memory associated with local variable 'replay' is still referred to by the stack variable 'toUArgs' upon returning to the caller. This will be a dangling reference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ucnv.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/ucnv.cpp

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5*
6*   Copyright (C) 1998-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9******************************************************************************
10*
11*  ucnv.c:
12*  Implements APIs for the ICU's codeset conversion library;
13*  mostly calls through internal functions;
14*  created by Bertrand A. Damiba
15*
16* Modification History:
17*
18*   Date        Name        Description
19*   04/04/99    helena      Fixed internal header inclusion.
20*   05/09/00    helena      Added implementation to handle fallback mappings.
21*   06/20/2000  helena      OS/400 port changes; mostly typecast.
22*/

24#include "unicode/utypes.h"

26#if !UCONFIG_NO_CONVERSION0

28#include <memory>

30#include "unicode/ustring.h"
31#include "unicode/ucnv.h"
32#include "unicode/ucnv_err.h"
33#include "unicode/uset.h"
34#include "unicode/utf.h"
35#include "unicode/utf16.h"
36#include "putilimp.h"
37#include "cmemory.h"
38#include "cstring.h"
39#include "uassert.h"
40#include "utracimp.h"
41#include "ustr_imp.h"
42#include "ucnv_imp.h"
43#include "ucnv_cnv.h"
44#include "ucnv_bld.h"

46/* size of intermediate and preflighting buffers in ucnv_convert() */
47#define CHUNK_SIZE1024 1024

49typedef struct UAmbiguousConverter {
  const char *name;
  const UChar variant5c;
52} UAmbiguousConverter;

54static const UAmbiguousConverter ambiguousConverters[]={
  { "ibm-897_P100-1995", 0xa5 },
  { "ibm-942_P120-1999", 0xa5 },
  { "ibm-943_P130-1999", 0xa5 },
  { "ibm-946_P100-1995", 0xa5 },
  { "ibm-33722_P120-1999", 0xa5 },
  { "ibm-1041_P100-1995", 0xa5 },
  /*{ "ibm-54191_P100-2006", 0xa5 },*/
  /*{ "ibm-62383_P100-2007", 0xa5 },*/
  /*{ "ibm-891_P100-1995", 0x20a9 },*/
  { "ibm-944_P100-1995", 0x20a9 },
  { "ibm-949_P110-1999", 0x20a9 },
  { "ibm-1363_P110-1997", 0x20a9 },
  { "ISO_2022,locale=ko,version=0", 0x20a9 },
  { "ibm-1088_P100-1995", 0x20a9 }
69};

71/*Calls through createConverter */
72U_CAPIextern "C" UConverter* U_EXPORT2
73ucnv_openucnv_open_71 (const char *name,
                     UErrorCode * err)
75{
  UConverter *r;

  if (err == NULL__null || U_FAILURE (*err)) {
      return NULL__null;
  }

  r =  ucnv_createConverterucnv_createConverter_71(NULL__null, name, err);
  return r;
84}

86U_CAPIextern "C" UConverter* U_EXPORT2 
87ucnv_openPackageucnv_openPackage_71   (const char *packageName, const char *converterName, UErrorCode * err)
88{
  return ucnv_createConverterFromPackageucnv_createConverterFromPackage_71(packageName, converterName,  err);
90}

92/*Extracts the UChar* to a char* and calls through createConverter */
93U_CAPIextern "C" UConverter*   U_EXPORT2
94ucnv_openUucnv_openU_71 (const UChar * name,
                       UErrorCode * err)
96{
  char asciiName[UCNV_MAX_CONVERTER_NAME_LENGTH60];

  if (err == NULL__null || U_FAILURE(*err))
      return NULL__null;
  if (name == NULL__null)
      return ucnv_openucnv_open_71 (NULL__null, err);
  if (u_strlenu_strlen_71(name) >= UCNV_MAX_CONVERTER_NAME_LENGTH60)
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }
  return ucnv_openucnv_open_71(u_austrcpyu_austrcpy_71(asciiName, name), err);
109}

111/* Copy the string that is represented by the UConverterPlatform enum
* @param platformString An output buffer
* @param platform An enum representing a platform
* @return the length of the copied string.
*/
116static int32_t
117ucnv_copyPlatformString(char *platformString, UConverterPlatform pltfrm)
118{
  switch (pltfrm)
  {
  case UCNV_IBM:
      uprv_strcpy(platformString, "ibm-"):: strcpy(platformString, "ibm-");
      return 4;
  case UCNV_UNKNOWN:
      break;
  }

  /* default to empty string */
  *platformString = 0;
  return 0;
131}

133/*Assumes a $platform-#codepage.$CONVERTER_FILE_EXTENSION scheme and calls
*through createConverter*/
135U_CAPIextern "C" UConverter*   U_EXPORT2
136ucnv_openCCSIDucnv_openCCSID_71 (int32_t codepage,
              UConverterPlatform platform,
              UErrorCode * err)
139{
  char myName[UCNV_MAX_CONVERTER_NAME_LENGTH60];
  int32_t myNameLen;

  if (err == NULL__null || U_FAILURE (*err))
      return NULL__null;

  /* ucnv_copyPlatformString could return "ibm-" or "cp" */
  myNameLen = ucnv_copyPlatformString(myName, platform);
  T_CString_integerToStringT_CString_integerToString_71(myName + myNameLen, codepage, 10);

  return ucnv_createConverterucnv_createConverter_71(NULL__null, myName, err);
151}

153/* Creating a temporary stack-based object that can be used in one thread, 
154and created from a converter that is shared across threads.
155*/

157U_CAPIextern "C" UConverter* U_EXPORT2
158ucnv_safeCloneucnv_safeClone_71(const UConverter* cnv, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status)
159{
  UConverter *localConverter, *allocatedConverter;
  int32_t stackBufferSize;
  int32_t bufferSizeNeeded;
  UErrorCode cbErr;
  UConverterToUnicodeArgs toUArgs = {
      sizeof(UConverterToUnicodeArgs),
          TRUE1,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null
  };
  UConverterFromUnicodeArgs fromUArgs = {
      sizeof(UConverterFromUnicodeArgs),
          TRUE1,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null,
          NULL__null
  };

  UTRACE_ENTRY_OC(UTRACE_UCNV_CLONE);

  if (status == NULL__null || U_FAILURE(*status)){
      UTRACE_EXIT_STATUS(status? *status: U_ILLEGAL_ARGUMENT_ERROR);
      return NULL__null;
  }

  if (cnv == NULL__null) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      UTRACE_EXIT_STATUS(*status);
      return NULL__null;
  }

  UTRACE_DATA3(UTRACE_OPEN_CLOSE, "clone converter %s at %p into stackBuffer %p",
                                  ucnv_getName(cnv, status), cnv, stackBuffer);

  if (cnv->sharedData->impl->safeClone != NULL__null) {
      /* call the custom safeClone function for sizing */
      bufferSizeNeeded = 0;
      cnv->sharedData->impl->safeClone(cnv, NULL__null, &bufferSizeNeeded, status);
      if (U_FAILURE(*status)) {
          UTRACE_EXIT_STATUS(*status);
          return NULL__null;
      }
  }
  else
  {
      /* inherent sizing */
      bufferSizeNeeded = sizeof(UConverter);
  }

  if (pBufferSize == NULL__null) {
      stackBufferSize = 1;
      pBufferSize = &stackBufferSize;
  } else {
      stackBufferSize = *pBufferSize;
      if (stackBufferSize <= 0){ /* 'preflighting' request - set needed size into *pBufferSize */
          *pBufferSize = bufferSizeNeeded;
          UTRACE_EXIT_VALUE(bufferSizeNeeded);
          return NULL__null;
      }
  }

  /* Adjust (if necessary) the stackBuffer pointer to be aligned correctly for a UConverter.
   * TODO(Jira ICU-20736) Redo this using std::align() once g++4.9 compatibility is no longer needed.
   */
  if (stackBuffer) {
      uintptr_t p = reinterpret_cast<uintptr_t>(stackBuffer);
      uintptr_t aligned_p = (p + alignof(UConverter) - 1) & ~(alignof(UConverter) - 1);
      ptrdiff_t pointerAdjustment = aligned_p - p;
      if (bufferSizeNeeded + pointerAdjustment <= stackBufferSize) {
          stackBuffer = reinterpret_cast<void *>(aligned_p);
          stackBufferSize -= static_cast<int32_t>(pointerAdjustment);
      } else {
          /* prevent using the stack buffer but keep the size > 0 so that we do not just preflight */
          stackBufferSize = 1;
      }
  }

  /* Now, see if we must allocate any memory */
  if (stackBufferSize < bufferSizeNeeded || stackBuffer == NULL__null)
  {
      /* allocate one here...*/
      localConverter = allocatedConverter = (UConverter *) uprv_mallocuprv_malloc_71 (bufferSizeNeeded);

      if(localConverter == NULL__null) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          UTRACE_EXIT_STATUS(*status);
          return NULL__null;
      }
      // If pBufferSize was NULL as the input, pBufferSize is set to &stackBufferSize in this function.
      if (pBufferSize != &stackBufferSize) {
          *status = U_SAFECLONE_ALLOCATED_WARNING;
      }

      /* record the fact that memory was allocated */
      *pBufferSize = bufferSizeNeeded;
  } else {
      /* just use the stack buffer */
      localConverter = (UConverter*) stackBuffer;
      allocatedConverter = NULL__null;
  }

  uprv_memset(localConverter, 0, bufferSizeNeeded):: memset(localConverter, 0, bufferSizeNeeded);

  /* Copy initial state */
  uprv_memcpy(localConverter, cnv, sizeof(UConverter))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(localConverter
, cnv, sizeof(UConverter)); } while (false);
  localConverter->isCopyLocal = localConverter->isExtraLocal = FALSE0;

  /* copy the substitution string */
  if (cnv->subChars == (uint8_t *)cnv->subUChars) {
      localConverter->subChars = (uint8_t *)localConverter->subUChars;
  } else {
      localConverter->subChars = (uint8_t *)uprv_mallocuprv_malloc_71(UCNV_ERROR_BUFFER_LENGTH32 * U_SIZEOF_UCHAR2);
      if (localConverter->subChars == NULL__null) {
          uprv_freeuprv_free_71(allocatedConverter);
          UTRACE_EXIT_STATUS(*status);
          return NULL__null;
      }
      uprv_memcpy(localConverter->subChars, cnv->subChars, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(localConverter
->subChars, cnv->subChars, 32 * 2); } while (false);
  }

  /* now either call the safeclone fcn or not */
  if (cnv->sharedData->impl->safeClone != NULL__null) {
      /* call the custom safeClone function */
      localConverter = cnv->sharedData->impl->safeClone(cnv, localConverter, pBufferSize, status);
  }

  if(localConverter==NULL__null || U_FAILURE(*status)) {
      if (allocatedConverter != NULL__null && allocatedConverter->subChars != (uint8_t *)allocatedConverter->subUChars) {
          uprv_freeuprv_free_71(allocatedConverter->subChars);
      }
      uprv_freeuprv_free_71(allocatedConverter);
      UTRACE_EXIT_STATUS(*status);
      return NULL__null;
  }

  /* increment refcount of shared data if needed */
  if (cnv->sharedData->isReferenceCounted) {
      ucnv_incrementRefCountucnv_incrementRefCount_71(cnv->sharedData);
  }

  if(localConverter == (UConverter*)stackBuffer) {
      /* we're using user provided data - set to not destroy */
      localConverter->isCopyLocal = TRUE1;
  }

  /* allow callback functions to handle any memory allocation */
  toUArgs.converter = fromUArgs.converter = localConverter;
  cbErr = U_ZERO_ERROR;
  cnv->fromCharErrorBehaviour(cnv->toUContext, &toUArgs, NULL__null, 0, UCNV_CLONE, &cbErr);
  cbErr = U_ZERO_ERROR;
  cnv->fromUCharErrorBehaviour(cnv->fromUContext, &fromUArgs, NULL__null, 0, 0, UCNV_CLONE, &cbErr);

  UTRACE_EXIT_PTR_STATUS(localConverter, *status);
  return localConverter;
321}

323U_CAPIextern "C" UConverter* U_EXPORT2
324ucnv_cloneucnv_clone_71(const UConverter* cnv, UErrorCode *status)
325{
  return ucnv_safeCloneucnv_safeClone_71(cnv, nullptr, nullptr, status);
327}

329/*Decreases the reference counter in the shared immutable section of the object
*and frees the mutable part*/

332U_CAPIextern "C" void  U_EXPORT2
333ucnv_closeucnv_close_71 (UConverter * converter)
334{
  UErrorCode errorCode = U_ZERO_ERROR;

  UTRACE_ENTRY_OC(UTRACE_UCNV_CLOSE);

  if (converter == NULL__null)
  {
      UTRACE_EXIT();
      return;
  }

  UTRACE_DATA3(UTRACE_OPEN_CLOSE, "close converter %s at %p, isCopyLocal=%b",
      ucnv_getName(converter, &errorCode), converter, converter->isCopyLocal);

  /* In order to speed up the close, only call the callbacks when they have been changed.
  This performance check will only work when the callbacks are set within a shared library
  or from user code that statically links this code. */
  /* first, notify the callback functions that the converter is closed */
  if (converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK((UConverterToUCallback) UCNV_TO_U_CALLBACK_SUBSTITUTE_71)) {
      UConverterToUnicodeArgs toUArgs = {
          sizeof(UConverterToUnicodeArgs),
              TRUE1,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null
      };

      toUArgs.converter = converter;
      errorCode = U_ZERO_ERROR;
      converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL__null, 0, UCNV_CLOSE, &errorCode);
  }
  if (converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK((UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE_71
)) {
      UConverterFromUnicodeArgs fromUArgs = {
          sizeof(UConverterFromUnicodeArgs),
              TRUE1,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null
      };
      fromUArgs.converter = converter;
      errorCode = U_ZERO_ERROR;
      converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL__null, 0, 0, UCNV_CLOSE, &errorCode);
  }

  if (converter->sharedData->impl->close != NULL__null) {
      converter->sharedData->impl->close(converter);
  }

  if (converter->subChars != (uint8_t *)converter->subUChars) {
      uprv_freeuprv_free_71(converter->subChars);
  }

  if (converter->sharedData->isReferenceCounted) {
      ucnv_unloadSharedDataIfReadyucnv_unloadSharedDataIfReady_71(converter->sharedData);
  }

  if(!converter->isCopyLocal){
      uprv_freeuprv_free_71(converter);
  }

  UTRACE_EXIT();
401}

403/*returns a single Name from the list, will return NULL if out of bounds
*/
405U_CAPIextern "C" const char*   U_EXPORT2
406ucnv_getAvailableNameucnv_getAvailableName_71 (int32_t n)
407{
  if (0 <= n && n <= 0xffff) {
      UErrorCode err = U_ZERO_ERROR;
      const char *name = ucnv_bld_getAvailableConverterucnv_bld_getAvailableConverter_71((uint16_t)n, &err);
      if (U_SUCCESS(err)) {
          return name;
      }
  }
  return NULL__null;
416}

418U_CAPIextern "C" int32_t   U_EXPORT2
419ucnv_countAvailableucnv_countAvailable_71 ()
420{
  UErrorCode err = U_ZERO_ERROR;
  return ucnv_bld_countAvailableConvertersucnv_bld_countAvailableConverters_71(&err);
423}

425U_CAPIextern "C" void    U_EXPORT2
426ucnv_getSubstCharsucnv_getSubstChars_71 (const UConverter * converter,
                  char *mySubChar,
                  int8_t * len,
                  UErrorCode * err)
430{
  if (U_FAILURE (*err))
      return;

  if (converter->subCharLen <= 0) {
      /* Unicode string or empty string from ucnv_setSubstString(). */
      *len = 0;
      return;
  }

  if (*len < converter->subCharLen) /*not enough space in subChars */
  {
      *err = U_INDEX_OUTOFBOUNDS_ERROR;
      return;
  }

  uprv_memcpy (mySubChar, converter->subChars, converter->subCharLen)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(mySubChar
, converter->subChars, converter->subCharLen); } while (
false);   /*fills in the subchars */
  *len = converter->subCharLen; /*store # of bytes copied to buffer */
448}

450U_CAPIextern "C" void    U_EXPORT2
451ucnv_setSubstCharsucnv_setSubstChars_71 (UConverter * converter,
                  const char *mySubChar,
                  int8_t len,
                  UErrorCode * err)
455{
  if (U_FAILURE (*err))
      return;
  
  /*Makes sure that the subChar is within the codepages char length boundaries */
  if ((len > converter->sharedData->staticData->maxBytesPerChar)
   || (len < converter->sharedData->staticData->minBytesPerChar))
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  
  uprv_memcpy (converter->subChars, mySubChar, len)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(converter
->subChars, mySubChar, len); } while (false); /*copies the subchars */
  converter->subCharLen = len;  /*sets the new len */

  /*
  * There is currently (2001Feb) no separate API to set/get subChar1.
  * In order to always have subChar written after it is explicitly set,
  * we set subChar1 to 0.
  */
  converter->subChar1 = 0;
  
  return;
478}

480U_CAPIextern "C" void U_EXPORT2
481ucnv_setSubstStringucnv_setSubstString_71(UConverter *cnv,
                  const UChar *s,
                  int32_t length,
                  UErrorCode *err) {
  alignas(UConverter) char cloneBuffer[U_CNV_SAFECLONE_BUFFERSIZE1024];
  char chars[UCNV_ERROR_BUFFER_LENGTH32];

  UConverter *clone;
  uint8_t *subChars;
  int32_t cloneSize, length8;

  /* Let the following functions check all arguments. */
  cloneSize = sizeof(cloneBuffer);
  clone = ucnv_safeCloneucnv_safeClone_71(cnv, cloneBuffer, &cloneSize, err);
  ucnv_setFromUCallBackucnv_setFromUCallBack_71(clone, UCNV_FROM_U_CALLBACK_STOPUCNV_FROM_U_CALLBACK_STOP_71, NULL__null, NULL__null, NULL__null, err);
  length8 = ucnv_fromUCharsucnv_fromUChars_71(clone, chars, (int32_t)sizeof(chars), s, length, err);
  ucnv_closeucnv_close_71(clone);
  if (U_FAILURE(*err)) {
      return;
  }

  if (cnv->sharedData->impl->writeSub == NULL__null
503#if !UCONFIG_NO_LEGACY_CONVERSION0
      || (cnv->sharedData->staticData->conversionType == UCNV_MBCS &&
       ucnv_MBCSGetTypeucnv_MBCSGetType_71(cnv) != UCNV_EBCDIC_STATEFUL)
506#endif
  ) {
      /* The converter is not stateful. Store the charset bytes as a fixed string. */
      subChars = (uint8_t *)chars;
  } else {
      /*
       * The converter has a non-default writeSub() function, indicating
       * that it is stateful.
       * Store the Unicode string for on-the-fly conversion for correct
       * state handling.
       */
      if (length > UCNV_ERROR_BUFFER_LENGTH32) {
          /*
           * Should not occur. The converter should output at least one byte
           * per UChar, which means that ucnv_fromUChars() should catch all
           * overflows.
           */
          *err = U_BUFFER_OVERFLOW_ERROR;
          return;
      }
      subChars = (uint8_t *)s;
      if (length < 0) {
          length = u_strlenu_strlen_71(s);
      }
      length8 = length * U_SIZEOF_UCHAR2;
  }

  /*
   * For storing the substitution string, select either the small buffer inside
   * UConverter or allocate a subChars buffer.
   */
  if (length8 > UCNV_MAX_SUBCHAR_LEN4) {
      /* Use a separate buffer for the string. Outside UConverter to not make it too large. */
      if (cnv->subChars == (uint8_t *)cnv->subUChars) {
          /* Allocate a new buffer for the string. */
          cnv->subChars = (uint8_t *)uprv_mallocuprv_malloc_71(UCNV_ERROR_BUFFER_LENGTH32 * U_SIZEOF_UCHAR2);
          if (cnv->subChars == NULL__null) {
              cnv->subChars = (uint8_t *)cnv->subUChars;
              *err = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          uprv_memset(cnv->subChars, 0, UCNV_ERROR_BUFFER_LENGTH * U_SIZEOF_UCHAR):: memset(cnv->subChars, 0, 32 * 2);
      }
  }

  /* Copy the substitution string into the UConverter or its subChars buffer. */
  if (length8 == 0) {
      cnv->subCharLen = 0;
  } else {
      uprv_memcpy(cnv->subChars, subChars, length8)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(cnv->subChars
, subChars, length8); } while (false);
      if (subChars == (uint8_t *)chars) {
          cnv->subCharLen = (int8_t)length8;
      } else /* subChars == s */ {
          cnv->subCharLen = (int8_t)-length;
      }
  }

  /* See comment in ucnv_setSubstChars(). */
  cnv->subChar1 = 0;
565}

567/*resets the internal states of a converter
*goal : have the same behaviour than a freshly created converter
*/
570static void _reset(UConverter *converter, UConverterResetChoice choice,
                 UBool callCallback) {
  if(converter == NULL__null) {
      return;
  }

  if(callCallback) {
      /* first, notify the callback functions that the converter is reset */
      UErrorCode errorCode;

      if(choice<=UCNV_RESET_TO_UNICODE && converter->fromCharErrorBehaviour != UCNV_TO_U_DEFAULT_CALLBACK((UConverterToUCallback) UCNV_TO_U_CALLBACK_SUBSTITUTE_71)) {
          UConverterToUnicodeArgs toUArgs = {
              sizeof(UConverterToUnicodeArgs),
              TRUE1,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null
          };
          toUArgs.converter = converter;
          errorCode = U_ZERO_ERROR;
          converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, NULL__null, 0, UCNV_RESET, &errorCode);
      }
      if(choice!=UCNV_RESET_TO_UNICODE && converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK((UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE_71
)) {
          UConverterFromUnicodeArgs fromUArgs = {
              sizeof(UConverterFromUnicodeArgs),
              TRUE1,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null,
              NULL__null
          };
          fromUArgs.converter = converter;
          errorCode = U_ZERO_ERROR;
          converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, NULL__null, 0, 0, UCNV_RESET, &errorCode);
      }
  }

  /* now reset the converter itself */
  if(choice<=UCNV_RESET_TO_UNICODE) {
      converter->toUnicodeStatus = converter->sharedData->toUnicodeStatus;
      converter->mode = 0;
      converter->toULength = 0;
      converter->invalidCharLength = converter->UCharErrorBufferLength = 0;
      converter->preToULength = 0;
  }
  if(choice!=UCNV_RESET_TO_UNICODE) {
      converter->fromUnicodeStatus = 0;
      converter->fromUChar32 = 0;
      converter->invalidUCharLength = converter->charErrorBufferLength = 0;
      converter->preFromUFirstCP = U_SENTINEL(-1);
      converter->preFromULength = 0;
  }

  if (converter->sharedData->impl->reset != NULL__null) {
      /* call the custom reset function */
      converter->sharedData->impl->reset(converter, choice);
  }
632}

634U_CAPIextern "C" void  U_EXPORT2
635ucnv_resetucnv_reset_71(UConverter *converter)
636{
  _reset(converter, UCNV_RESET_BOTH, TRUE1);
638}

640U_CAPIextern "C" void  U_EXPORT2
641ucnv_resetToUnicodeucnv_resetToUnicode_71(UConverter *converter)
642{
  _reset(converter, UCNV_RESET_TO_UNICODE, TRUE1);
644}

646U_CAPIextern "C" void  U_EXPORT2
647ucnv_resetFromUnicodeucnv_resetFromUnicode_71(UConverter *converter)
648{
  _reset(converter, UCNV_RESET_FROM_UNICODE, TRUE1);
650}

652U_CAPIextern "C" int8_t   U_EXPORT2
653ucnv_getMaxCharSizeucnv_getMaxCharSize_71 (const UConverter * converter)
654{
  return converter->maxBytesPerUChar;
656}


659U_CAPIextern "C" int8_t   U_EXPORT2
660ucnv_getMinCharSizeucnv_getMinCharSize_71 (const UConverter * converter)
661{
  return converter->sharedData->staticData->minBytesPerChar;
663}

665U_CAPIextern "C" const char*   U_EXPORT2
666ucnv_getNameucnv_getName_71 (const UConverter * converter, UErrorCode * err)
   
668{
  if (U_FAILURE (*err))
      return NULL__null;
  if(converter->sharedData->impl->getName){
      const char* temp= converter->sharedData->impl->getName(converter);
      if(temp)
          return temp;
  }
  return converter->sharedData->staticData->name;
677}

679U_CAPIextern "C" int32_t U_EXPORT2
680ucnv_getCCSIDucnv_getCCSID_71(const UConverter * converter,
            UErrorCode * err)
682{
  int32_t ccsid;
  if (U_FAILURE (*err))
      return -1;

  ccsid = converter->sharedData->staticData->codepage;
  if (ccsid == 0) {
      /* Rare case. This is for cases like gb18030,
      which doesn't have an IBM canonical name, but does have an IBM alias. */
      const char *standardName = ucnv_getStandardNameucnv_getStandardName_71(ucnv_getNameucnv_getName_71(converter, err), "IBM", err);
      if (U_SUCCESS(*err) && standardName) {
          const char *ccsidStr = uprv_strchr(standardName, '-'):: strchr(standardName, '-');
          if (ccsidStr) {
              ccsid = (int32_t)atol(ccsidStr+1);  /* +1 to skip '-' */
          }
      }
  }
  return ccsid;
700}


703U_CAPIextern "C" UConverterPlatform   U_EXPORT2
704ucnv_getPlatformucnv_getPlatform_71 (const UConverter * converter,
                                    UErrorCode * err)
706{
  if (U_FAILURE (*err))
      return UCNV_UNKNOWN;

  return (UConverterPlatform)converter->sharedData->staticData->platform;
711}

713U_CAPIextern "C" void U_EXPORT2
  ucnv_getToUCallBackucnv_getToUCallBack_71 (const UConverter * converter,
                       UConverterToUCallback *action,
                       const void **context)
717{
  *action = converter->fromCharErrorBehaviour;
  *context = converter->toUContext;
720}

722U_CAPIextern "C" void U_EXPORT2
  ucnv_getFromUCallBackucnv_getFromUCallBack_71 (const UConverter * converter,
                         UConverterFromUCallback *action,
                         const void **context)
726{
  *action = converter->fromUCharErrorBehaviour;
  *context = converter->fromUContext;
729}

731U_CAPIextern "C" void    U_EXPORT2
732ucnv_setToUCallBackucnv_setToUCallBack_71 (UConverter * converter,
                          UConverterToUCallback newAction,
                          const void* newContext,
                          UConverterToUCallback *oldAction,
                          const void** oldContext,
                          UErrorCode * err)
738{
  if (U_FAILURE (*err))
      return;
  if (oldAction) *oldAction = converter->fromCharErrorBehaviour;
  converter->fromCharErrorBehaviour = newAction;
  if (oldContext) *oldContext = converter->toUContext;
  converter->toUContext = newContext;
745}

747U_CAPIextern "C" void  U_EXPORT2
748ucnv_setFromUCallBackucnv_setFromUCallBack_71 (UConverter * converter,
                          UConverterFromUCallback newAction,
                          const void* newContext,
                          UConverterFromUCallback *oldAction,
                          const void** oldContext,
                          UErrorCode * err)
754{
  if (U_FAILURE (*err))
      return;
  if (oldAction) *oldAction = converter->fromUCharErrorBehaviour;
  converter->fromUCharErrorBehaviour = newAction;
  if (oldContext) *oldContext = converter->fromUContext;
  converter->fromUContext = newContext;
761}

763static void
764_updateOffsets(int32_t *offsets, int32_t length,
             int32_t sourceIndex, int32_t errorInputLength) {
  int32_t *limit;
  int32_t delta, offset;

  if(sourceIndex>=0) {
      /*
       * adjust each offset by adding the previous sourceIndex
       * minus the length of the input sequence that caused an
       * error, if any
       */
      delta=sourceIndex-errorInputLength;
  } else {
      /*
       * set each offset to -1 because this conversion function
       * does not handle offsets
       */
      delta=-1;
  }

  limit=offsets+length;
  if(delta==0) {
      /* most common case, nothing to do */
  } else if(delta>0) {
      /* add the delta to each offset (but not if the offset is <0) */
      while(offsets<limit) {
          offset=*offsets;
          if(offset>=0) {
              *offsets=offset+delta;
          }
          ++offsets;
      }
  } else /* delta<0 */ {
      /*
       * set each offset to -1 because this conversion function
       * does not handle offsets
       * or the error input sequence started in a previous buffer
       */
      while(offsets<limit) {
          *offsets++=-1;
      }
  }
806}

808/* ucnv_fromUnicode --------------------------------------------------------- */

810/*
* Implementation note for m:n conversions
*
* While collecting source units to find the longest match for m:n conversion,
* some source units may need to be stored for a partial match.
* When a second buffer does not yield a match on all of the previously stored
* source units, then they must be "replayed", i.e., fed back into the converter.
*
* The code relies on the fact that replaying will not nest -
* converting a replay buffer will not result in a replay.
* This is because a replay is necessary only after the _continuation_ of a
* partial match failed, but a replay buffer is converted as a whole.
* It may result in some of its units being stored again for a partial match,
* but there will not be a continuation _during_ the replay which could fail.
*
* It is conceivable that a callback function could call the converter
* recursively in a way that causes another replay to be stored, but that
* would be an error in the callback function.
* Such violations will cause assertion failures in a debug build,
* and wrong output, but they will not cause a crash.
*/

832static void
833_fromUnicodeWithCallback(UConverterFromUnicodeArgs *pArgs, UErrorCode *err) {
  UConverterFromUnicode fromUnicode;
  UConverter *cnv;
  const UChar *s;
  char *t;
  int32_t *offsets;
  int32_t sourceIndex;
  int32_t errorInputLength;
  UBool converterSawEndOfInput, calledCallback;

  /* variables for m:n conversion */
  UChar replay[UCNV_EXT_MAX_UCHARS19];
  const UChar *realSource, *realSourceLimit;
  int32_t realSourceIndex;
  UBool realFlush;

  cnv=pArgs->converter;
  s=pArgs->source;
  t=pArgs->target;
  offsets=pArgs->offsets;

  /* get the converter implementation function */
  sourceIndex=0;
  if(offsets==NULL__null) {
      fromUnicode=cnv->sharedData->impl->fromUnicode;
  } else {
      fromUnicode=cnv->sharedData->impl->fromUnicodeWithOffsets;
      if(fromUnicode==NULL__null) {
          /* there is no WithOffsets implementation */
          fromUnicode=cnv->sharedData->impl->fromUnicode;
          /* we will write -1 for each offset */
          sourceIndex=-1;
      }
  }

  if(cnv->preFromULength>=0) {
      /* normal mode */
      realSource=NULL__null;

      /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
      realSourceLimit=NULL__null;
      realFlush=FALSE0;
      realSourceIndex=0;
  } else {
      /*
       * Previous m:n conversion stored source units from a partial match
       * and failed to consume all of them.
       * We need to "replay" them from a temporary buffer and convert them first.
       */
      realSource=pArgs->source;
      realSourceLimit=pArgs->sourceLimit;
      realFlush=pArgs->flush;
      realSourceIndex=sourceIndex;

      uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(replay, cnv
->preFromU, -cnv->preFromULength*2); } while (false);
      pArgs->source=replay;
      pArgs->sourceLimit=replay-cnv->preFromULength;
      pArgs->flush=FALSE0;
      sourceIndex=-1;

      cnv->preFromULength=0;
  }

  /*
   * loop for conversion and error handling
   *
   * loop {
   *   convert
   *   loop {
   *     update offsets
   *     handle end of input
   *     handle errors/call callback
   *   }
   * }
   */
  for(;;) {
      if(U_SUCCESS(*err)) {
          /* convert */
          fromUnicode(pArgs, err);

          /*
           * set a flag for whether the converter
           * successfully processed the end of the input
           *
           * need not check cnv->preFromULength==0 because a replay (<0) will cause
           * s<sourceLimit before converterSawEndOfInput is checked
           */
          converterSawEndOfInput=
              (UBool)(U_SUCCESS(*err) &&
                      pArgs->flush && pArgs->source==pArgs->sourceLimit &&
                      cnv->fromUChar32==0);
      } else {
          /* handle error from ucnv_convertEx() */
          converterSawEndOfInput=FALSE0;
      }

      /* no callback called yet for this iteration */
      calledCallback=FALSE0;

      /* no sourceIndex adjustment for conversion, only for callback output */
      errorInputLength=0;

      /*
       * loop for offsets and error handling
       *
       * iterates at most 3 times:
       * 1. to clean up after the conversion function
       * 2. after the callback
       * 3. after the callback again if there was truncated input
       */
      for(;;) {
          /* update offsets if we write any */
          if(offsets!=NULL__null) {
              int32_t length=(int32_t)(pArgs->target-t);
              if(length>0) {
                  _updateOffsets(offsets, length, sourceIndex, errorInputLength);

                  /*
                   * if a converter handles offsets and updates the offsets
                   * pointer at the end, then pArgs->offset should not change
                   * here;
                   * however, some converters do not handle offsets at all
                   * (sourceIndex<0) or may not update the offsets pointer
                   */
                  pArgs->offsets=offsets+=length;
              }

              if(sourceIndex>=0) {
                  sourceIndex+=(int32_t)(pArgs->source-s);
              }
          }

          if(cnv->preFromULength<0) {
              /*
               * switch the source to new replay units (cannot occur while replaying)
               * after offset handling and before end-of-input and callback handling
               */
              if(realSource==NULL__null) {
                  realSource=pArgs->source;
                  realSourceLimit=pArgs->sourceLimit;
                  realFlush=pArgs->flush;
                  realSourceIndex=sourceIndex;

                  uprv_memcpy(replay, cnv->preFromU, -cnv->preFromULength*U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(replay, cnv
->preFromU, -cnv->preFromULength*2); } while (false);
                  pArgs->source=replay;
                  pArgs->sourceLimit=replay-cnv->preFromULength;
                  pArgs->flush=FALSE0;
                  if((sourceIndex+=cnv->preFromULength)<0) {
                      sourceIndex=-1;
                  }

                  cnv->preFromULength=0;
              } else {
                  /* see implementation note before _fromUnicodeWithCallback() */
                  U_ASSERT(realSource==NULL)(void)0;
                  *err=U_INTERNAL_PROGRAM_ERROR;
              }
          }

          /* update pointers */
          s=pArgs->source;
          t=pArgs->target;

          if(U_SUCCESS(*err)) {
              if(s<pArgs->sourceLimit) {
                  /*
                   * continue with the conversion loop while there is still input left
                   * (continue converting by breaking out of only the inner loop)
                   */
                  break;
              } else if(realSource!=NULL__null) {
                  /* switch back from replaying to the real source and continue */
                  pArgs->source=realSource;
                  pArgs->sourceLimit=realSourceLimit;
                  pArgs->flush=realFlush;
                  sourceIndex=realSourceIndex;

                  realSource=NULL__null;
                  break;
              } else if(pArgs->flush && cnv->fromUChar32!=0) {
                  /*
                   * the entire input stream is consumed
                   * and there is a partial, truncated input sequence left
                   */

                  /* inject an error and continue with callback handling */
                  *err=U_TRUNCATED_CHAR_FOUND;
                  calledCallback=FALSE0; /* new error condition */
              } else {
                  /* input consumed */
                  if(pArgs->flush) {
                      /*
                       * return to the conversion loop once more if the flush
                       * flag is set and the conversion function has not
                       * successfully processed the end of the input yet
                       *
                       * (continue converting by breaking out of only the inner loop)
                       */
                      if(!converterSawEndOfInput) {
                          break;
                      }

                      /* reset the converter without calling the callback function */
                      _reset(cnv, UCNV_RESET_FROM_UNICODE, FALSE0);
                  }

                  /* done successfully */
                  return;
              }
          }

          /* U_FAILURE(*err) */
          {
              UErrorCode e;

              if( calledCallback ||
                  (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
                  (e!=U_INVALID_CHAR_FOUND &&
                   e!=U_ILLEGAL_CHAR_FOUND &&
                   e!=U_TRUNCATED_CHAR_FOUND)
              ) {
                  /*
                   * the callback did not or cannot resolve the error:
                   * set output pointers and return
                   *
                   * the check for buffer overflow is redundant but it is
                   * a high-runner case and hopefully documents the intent
                   * well
                   *
                   * if we were replaying, then the replay buffer must be
                   * copied back into the UConverter
                   * and the real arguments must be restored
                   */
                  if(realSource!=NULL__null) {
                      int32_t length;

                      U_ASSERT(cnv->preFromULength==0)(void)0;

                      length=(int32_t)(pArgs->sourceLimit-pArgs->source);
                      if(length>0) {
                          u_memcpyu_memcpy_71(cnv->preFromU, pArgs->source, length);
                          cnv->preFromULength=(int8_t)-length;
                      }

                      pArgs->source=realSource;
                      pArgs->sourceLimit=realSourceLimit;
                      pArgs->flush=realFlush;
                  }

                  return;
              }
          }

          /* callback handling */
          {
              UChar32 codePoint;

              /* get and write the code point */
              codePoint=cnv->fromUChar32;
              errorInputLength=0;
              U16_APPEND_UNSAFE(cnv->invalidUCharBuffer, errorInputLength, codePoint)do { if((uint32_t)(codePoint)<=0xffff) { (cnv->invalidUCharBuffer
)[(errorInputLength)++]=(uint16_t)(codePoint); } else { (cnv->
invalidUCharBuffer)[(errorInputLength)++]=(uint16_t)(((codePoint
)>>10)+0xd7c0); (cnv->invalidUCharBuffer)[(errorInputLength
)++]=(uint16_t)(((codePoint)&0x3ff)|0xdc00); } } while (false
);
              cnv->invalidUCharLength=(int8_t)errorInputLength;

              /* set the converter state to deal with the next character */
              cnv->fromUChar32=0;

              /* call the callback function */
              cnv->fromUCharErrorBehaviour(cnv->fromUContext, pArgs,
                  cnv->invalidUCharBuffer, errorInputLength, codePoint,
                  *err==U_INVALID_CHAR_FOUND ? UCNV_UNASSIGNED : UCNV_ILLEGAL,
                  err);
          }

          /*
           * loop back to the offset handling
           *
           * this flag will indicate after offset handling
           * that a callback was called;
           * if the callback did not resolve the error, then we return
           */
          calledCallback=TRUE1;
      }
  }
1116}

1118/*
* Output the fromUnicode overflow buffer.
* Call this function if(cnv->charErrorBufferLength>0).
* @return TRUE if overflow
*/
1123static UBool
1124ucnv_outputOverflowFromUnicode(UConverter *cnv,
                             char **target, const char *targetLimit,
                             int32_t **pOffsets,
                             UErrorCode *err) {
  int32_t *offsets;
  char *overflow, *t;
  int32_t i, length;

  t=*target;
  if(pOffsets!=NULL__null) {
      offsets=*pOffsets;
  } else {
      offsets=NULL__null;
  }

  overflow=(char *)cnv->charErrorBuffer;
  length=cnv->charErrorBufferLength;
  i=0;
  while(i<length) {
      if(t==targetLimit) {
          /* the overflow buffer contains too much, keep the rest */
          int32_t j=0;

          do {
              overflow[j++]=overflow[i++];
          } while(i<length);

          cnv->charErrorBufferLength=(int8_t)j;
          *target=t;
          if(offsets!=NULL__null) {
              *pOffsets=offsets;
          }
          *err=U_BUFFER_OVERFLOW_ERROR;
          return TRUE1;
      }

      /* copy the overflow contents to the target */
      *t++=overflow[i++];
      if(offsets!=NULL__null) {
          *offsets++=-1; /* no source index available for old output */
      }
  }

  /* the overflow buffer is completely copied to the target */
  cnv->charErrorBufferLength=0;
  *target=t;
  if(offsets!=NULL__null) {
      *pOffsets=offsets;
  }
  return FALSE0;
1174}

1176U_CAPIextern "C" void U_EXPORT2
1177ucnv_fromUnicodeucnv_fromUnicode_71(UConverter *cnv,
               char **target, const char *targetLimit,
               const UChar **source, const UChar *sourceLimit,
               int32_t *offsets,
               UBool flush,
               UErrorCode *err) {
  UConverterFromUnicodeArgs args;
  const UChar *s;
  char *t;

  /* check parameters */
  if(err==NULL__null || U_FAILURE(*err)) {
      return;
  }

  if(cnv==NULL__null || target==NULL__null || source==NULL__null) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  s=*source;
  t=*target;

  if ((const void *)U_MAX_PTR(sourceLimit)((void *)(((uintptr_t)(sourceLimit)+0x7fffffffu) > (uintptr_t
)(sourceLimit) ? ((uintptr_t)(sourceLimit)+0x7fffffffu) : (uintptr_t
)-1)) == (const void *)sourceLimit) {
      /*
      Prevent code from going into an infinite loop in case we do hit this
      limit. The limit pointer is expected to be on a UChar * boundary.
      This also prevents the next argument check from failing.
      */
      sourceLimit = (const UChar *)(((const char *)sourceLimit) - 1);
  }

  /*
   * All these conditions should never happen.
   *
   * 1) Make sure that the limits are >= to the address source or target
   *
   * 2) Make sure that the buffer sizes do not exceed the number range for
   * int32_t because some functions use the size (in units or bytes)
   * rather than comparing pointers, and because offsets are int32_t values.
   *
   * size_t is guaranteed to be unsigned and large enough for the job.
   *
   * Return with an error instead of adjusting the limits because we would
   * not be able to maintain the semantics that either the source must be
   * consumed or the target filled (unless an error occurs).
   * An adjustment would be targetLimit=t+0x7fffffff; for example.
   *
   * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
   * to a char * pointer and provide an incomplete UChar code unit.
   */
  if (sourceLimit<s || targetLimit<t ||
      ((size_t)(sourceLimit-s)>(size_t)0x3fffffff && sourceLimit>s) ||
      ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t) ||
      (((const char *)sourceLimit-(const char *)s) & 1) != 0)
  {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  
  /* output the target overflow buffer */
  if( cnv->charErrorBufferLength>0 &&
      ucnv_outputOverflowFromUnicode(cnv, target, targetLimit, &offsets, err)
  ) {
      /* U_BUFFER_OVERFLOW_ERROR */
      return;
  }
  /* *target may have moved, therefore stop using t */

  if(!flush && s==sourceLimit && cnv->preFromULength>=0) {
      /* the overflow buffer is emptied and there is no new input: we are done */
      return;
  }

  /*
   * Do not simply return with a buffer overflow error if
   * !flush && t==targetLimit
   * because it is possible that the source will not generate any output.
   * For example, the skip callback may be called;
   * it does not output anything.
   */

  /* prepare the converter arguments */
  args.converter=cnv;
  args.flush=flush;
  args.offsets=offsets;
  args.source=s;
  args.sourceLimit=sourceLimit;
  args.target=*target;
  args.targetLimit=targetLimit;
  args.size=sizeof(args);

  _fromUnicodeWithCallback(&args, err);

  *source=args.source;
  *target=args.target;
1273}

1275/* ucnv_toUnicode() --------------------------------------------------------- */

1277static void
1278_toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
  UConverterToUnicode toUnicode;
  UConverter *cnv;
  const char *s;
  UChar *t;
  int32_t *offsets;
  int32_t sourceIndex;
  int32_t errorInputLength;
  UBool converterSawEndOfInput, calledCallback;

  /* variables for m:n conversion */
  char replay[UCNV_EXT_MAX_BYTES0x1f];
  const char *realSource, *realSourceLimit;
  int32_t realSourceIndex;
  UBool realFlush;

  cnv=pArgs->converter;
  s=pArgs->source;
  t=pArgs->target;
  offsets=pArgs->offsets;

  /* get the converter implementation function */
  sourceIndex=0;
  if(offsets32.1
'offsets' is equal to NULL
==NULL__null) {
33
←
Taking true branch→
      toUnicode=cnv->sharedData->impl->toUnicode;
  } else {
      toUnicode=cnv->sharedData->impl->toUnicodeWithOffsets;
      if(toUnicode==NULL__null) {
          /* there is no WithOffsets implementation */
          toUnicode=cnv->sharedData->impl->toUnicode;
          /* we will write -1 for each offset */
          sourceIndex=-1;
      }
  }

  if(cnv->preToULength>=0) {
34
←
Assuming field 'preToULength' is >= 0→
35
←
Taking true branch→
      /* normal mode */
      realSource=NULL__null;

      /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
      realSourceLimit=NULL__null;
      realFlush=FALSE0;
      realSourceIndex=0;
  } else {
      /*
       * Previous m:n conversion stored source units from a partial match
       * and failed to consume all of them.
       * We need to "replay" them from a temporary buffer and convert them first.
       */
      realSource=pArgs->source;
      realSourceLimit=pArgs->sourceLimit;
      realFlush=pArgs->flush;
      realSourceIndex=sourceIndex;

      uprv_memcpy(replay, cnv->preToU, -cnv->preToULength)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(replay, cnv
->preToU, -cnv->preToULength); } while (false);
      pArgs->source=replay;
      pArgs->sourceLimit=replay-cnv->preToULength;
      pArgs->flush=FALSE0;
      sourceIndex=-1;

      cnv->preToULength=0;
  }

  /*
   * loop for conversion and error handling
   *
   * loop {
   *   convert
   *   loop {
   *     update offsets
   *     handle end of input
   *     handle errors/call callback
   *   }
   * }
   */
  for(;;) {
36
←
Loop condition is true.  Entering loop body→
      if(U_SUCCESS(*err)) {
37
←
Taking true branch→
          /* convert */
          toUnicode(pArgs, err);

          /*
           * set a flag for whether the converter
           * successfully processed the end of the input
           *
           * need not check cnv->preToULength==0 because a replay (<0) will cause
           * s<sourceLimit before converterSawEndOfInput is checked
           */
          converterSawEndOfInput=
              (UBool)(U_SUCCESS(*err) &&
                      pArgs->flush && pArgs->source==pArgs->sourceLimit &&
38
←
Assuming field 'flush' is 0→
                      cnv->toULength==0);
      } else {
          /* handle error from getNextUChar() or ucnv_convertEx() */
          converterSawEndOfInput=FALSE0;
      }

      /* no callback called yet for this iteration */
      calledCallback=FALSE0;

      /* no sourceIndex adjustment for conversion, only for callback output */
      errorInputLength=0;

      /*
       * loop for offsets and error handling
       *
       * iterates at most 3 times:
       * 1. to clean up after the conversion function
       * 2. after the callback
       * 3. after the callback again if there was truncated input
       */
      for(;;) {
39
←
Loop condition is true.  Entering loop body→
          /* update offsets if we write any */
          if(offsets39.1
'offsets' is equal to NULL
!=NULL__null) {
40
←
Taking false branch→
              int32_t length=(int32_t)(pArgs->target-t);
              if(length>0) {
                  _updateOffsets(offsets, length, sourceIndex, errorInputLength);

                  /*
                   * if a converter handles offsets and updates the offsets
                   * pointer at the end, then pArgs->offset should not change
                   * here;
                   * however, some converters do not handle offsets at all
                   * (sourceIndex<0) or may not update the offsets pointer
                   */
                  pArgs->offsets=offsets+=length;
              }

              if(sourceIndex>=0) {
                  sourceIndex+=(int32_t)(pArgs->source-s);
              }
          }

          if(cnv->preToULength<0) {
41
←
Assuming field 'preToULength' is < 0→
42
←
Taking true branch→
              /*
               * switch the source to new replay units (cannot occur while replaying)
               * after offset handling and before end-of-input and callback handling
               */
              if(realSource42.1
'realSource' is equal to NULL
==NULL__null) {
43
←
Taking true branch→
                  realSource=pArgs->source;
                  realSourceLimit=pArgs->sourceLimit;
                  realFlush=pArgs->flush;
                  realSourceIndex=sourceIndex;

                  uprv_memcpy(replay, cnv->preToU, -cnv->preToULength)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(replay, cnv
->preToU, -cnv->preToULength); } while (false);
44
←
Loop condition is false.  Exiting loop→
                  pArgs->source=replay;
                  pArgs->sourceLimit=replay-cnv->preToULength;
                  pArgs->flush=FALSE0;
                  if((sourceIndex+=cnv->preToULength)<0) {
45
←
Taking true branch→
                      sourceIndex=-1;
                  }

                  cnv->preToULength=0;
              } else {
                  /* see implementation note before _fromUnicodeWithCallback() */
                  U_ASSERT(realSource==NULL)(void)0;
                  *err=U_INTERNAL_PROGRAM_ERROR;
              }
          }

          /* update pointers */
          s=pArgs->source;
          t=pArgs->target;

          if(U_SUCCESS(*err)) {
46
←
Taking true branch→
              if(s<pArgs->sourceLimit) {
47
←
Assuming 's' is >= field 'sourceLimit'→
48
←
Taking false branch→
                  /*
                   * continue with the conversion loop while there is still input left
                   * (continue converting by breaking out of only the inner loop)
                   */
                  break;
              } else if(realSource!=NULL__null) {
49
←
Assuming 'realSource' is equal to NULL→
                  /* switch back from replaying to the real source and continue */
                  pArgs->source=realSource;
                  pArgs->sourceLimit=realSourceLimit;
                  pArgs->flush=realFlush;
                  sourceIndex=realSourceIndex;

                  realSource=NULL__null;
                  break;
              } else if(pArgs->flush49.1
Field 'flush' is 0
 && cnv->toULength>0) {
                  /*
                   * the entire input stream is consumed
                   * and there is a partial, truncated input sequence left
                   */

                  /* inject an error and continue with callback handling */
                  *err=U_TRUNCATED_CHAR_FOUND;
                  calledCallback=FALSE0; /* new error condition */
              } else {
                  /* input consumed */
                  if(pArgs->flush49.2
Field 'flush' is 0
) {
50
←
Taking false branch→
                      /*
                       * return to the conversion loop once more if the flush
                       * flag is set and the conversion function has not
                       * successfully processed the end of the input yet
                       *
                       * (continue converting by breaking out of only the inner loop)
                       */
                      if(!converterSawEndOfInput) {
                          break;
                      }

                      /* reset the converter without calling the callback function */
                      _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE0);
                  }

                  /* done successfully */
                  return;
51
←
Address of stack memory associated with local variable 'replay' is still referred to by the stack variable 'toUArgs' upon returning to the caller.  This will be a dangling reference
              }
          }

          /* U_FAILURE(*err) */
          {
              UErrorCode e;

              if( calledCallback ||
                  (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
                  (e!=U_INVALID_CHAR_FOUND &&
                   e!=U_ILLEGAL_CHAR_FOUND &&
                   e!=U_TRUNCATED_CHAR_FOUND &&
                   e!=U_ILLEGAL_ESCAPE_SEQUENCE &&
                   e!=U_UNSUPPORTED_ESCAPE_SEQUENCE)
              ) {
                  /*
                   * the callback did not or cannot resolve the error:
                   * set output pointers and return
                   *
                   * the check for buffer overflow is redundant but it is
                   * a high-runner case and hopefully documents the intent
                   * well
                   *
                   * if we were replaying, then the replay buffer must be
                   * copied back into the UConverter
                   * and the real arguments must be restored
                   */
                  if(realSource!=NULL__null) {
                      int32_t length;

                      U_ASSERT(cnv->preToULength==0)(void)0;

                      length=(int32_t)(pArgs->sourceLimit-pArgs->source);
                      if(length>0) {
                          uprv_memcpy(cnv->preToU, pArgs->source, length)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(cnv->preToU
, pArgs->source, length); } while (false);
                          cnv->preToULength=(int8_t)-length;
                      }

                      pArgs->source=realSource;
                      pArgs->sourceLimit=realSourceLimit;
                      pArgs->flush=realFlush;
                  }

                  return;
              }
          }

          /* copy toUBytes[] to invalidCharBuffer[] */
          errorInputLength=cnv->invalidCharLength=cnv->toULength;
          if(errorInputLength>0) {
              uprv_memcpy(cnv->invalidCharBuffer, cnv->toUBytes, errorInputLength)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(cnv->invalidCharBuffer
, cnv->toUBytes, errorInputLength); } while (false);
          }

          /* set the converter state to deal with the next character */
          cnv->toULength=0;

          /* call the callback function */
          if(cnv->toUCallbackReason==UCNV_ILLEGAL && *err==U_INVALID_CHAR_FOUND) {
              cnv->toUCallbackReason = UCNV_UNASSIGNED;
          }
          cnv->fromCharErrorBehaviour(cnv->toUContext, pArgs,
              cnv->invalidCharBuffer, errorInputLength,
              cnv->toUCallbackReason,
              err);
          cnv->toUCallbackReason = UCNV_ILLEGAL; /* reset to default value */

          /*
           * loop back to the offset handling
           *
           * this flag will indicate after offset handling
           * that a callback was called;
           * if the callback did not resolve the error, then we return
           */
          calledCallback=TRUE1;
      }
  }
1562}

1564/*
* Output the toUnicode overflow buffer.
* Call this function if(cnv->UCharErrorBufferLength>0).
* @return TRUE if overflow
*/
1569static UBool
1570ucnv_outputOverflowToUnicode(UConverter *cnv,
                           UChar **target, const UChar *targetLimit,
                           int32_t **pOffsets,
                           UErrorCode *err) {
  int32_t *offsets;
  UChar *overflow, *t;
  int32_t i, length;

  t=*target;
  if(pOffsets!=NULL__null) {
      offsets=*pOffsets;
  } else {
      offsets=NULL__null;
  }

  overflow=cnv->UCharErrorBuffer;
  length=cnv->UCharErrorBufferLength;
  i=0;
  while(i<length) {
      if(t==targetLimit) {
          /* the overflow buffer contains too much, keep the rest */
          int32_t j=0;

          do {
              overflow[j++]=overflow[i++];
          } while(i<length);

          cnv->UCharErrorBufferLength=(int8_t)j;
          *target=t;
          if(offsets!=NULL__null) {
              *pOffsets=offsets;
          }
          *err=U_BUFFER_OVERFLOW_ERROR;
          return TRUE1;
      }

      /* copy the overflow contents to the target */
      *t++=overflow[i++];
      if(offsets!=NULL__null) {
          *offsets++=-1; /* no source index available for old output */
      }
  }

  /* the overflow buffer is completely copied to the target */
  cnv->UCharErrorBufferLength=0;
  *target=t;
  if(offsets!=NULL__null) {
      *pOffsets=offsets;
  }
  return FALSE0;
1620}

1622U_CAPIextern "C" void U_EXPORT2
1623ucnv_toUnicodeucnv_toUnicode_71(UConverter *cnv,
             UChar **target, const UChar *targetLimit,
             const char **source, const char *sourceLimit,
             int32_t *offsets,
             UBool flush,
             UErrorCode *err) {
  UConverterToUnicodeArgs args;
  const char *s;
  UChar *t;

  /* check parameters */
  if(err==NULL__null || U_FAILURE(*err)) {
      return;
  }

  if(cnv==NULL__null || target==NULL__null || source==NULL__null) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  s=*source;
  t=*target;

  if ((const void *)U_MAX_PTR(targetLimit)((void *)(((uintptr_t)(targetLimit)+0x7fffffffu) > (uintptr_t
)(targetLimit) ? ((uintptr_t)(targetLimit)+0x7fffffffu) : (uintptr_t
)-1)) == (const void *)targetLimit) {
      /*
      Prevent code from going into an infinite loop in case we do hit this
      limit. The limit pointer is expected to be on a UChar * boundary.
      This also prevents the next argument check from failing.
      */
      targetLimit = (const UChar *)(((const char *)targetLimit) - 1);
  }

  /*
   * All these conditions should never happen.
   *
   * 1) Make sure that the limits are >= to the address source or target
   *
   * 2) Make sure that the buffer sizes do not exceed the number range for
   * int32_t because some functions use the size (in units or bytes)
   * rather than comparing pointers, and because offsets are int32_t values.
   *
   * size_t is guaranteed to be unsigned and large enough for the job.
   *
   * Return with an error instead of adjusting the limits because we would
   * not be able to maintain the semantics that either the source must be
   * consumed or the target filled (unless an error occurs).
   * An adjustment would be sourceLimit=t+0x7fffffff; for example.
   *
   * 3) Make sure that the user didn't incorrectly cast a UChar * pointer
   * to a char * pointer and provide an incomplete UChar code unit.
   */
  if (sourceLimit<s || targetLimit<t ||
      ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s) ||
      ((size_t)(targetLimit-t)>(size_t)0x3fffffff && targetLimit>t) ||
      (((const char *)targetLimit-(const char *)t) & 1) != 0
  ) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  
  /* output the target overflow buffer */
  if( cnv->UCharErrorBufferLength>0 &&
      ucnv_outputOverflowToUnicode(cnv, target, targetLimit, &offsets, err)
  ) {
      /* U_BUFFER_OVERFLOW_ERROR */
      return;
  }
  /* *target may have moved, therefore stop using t */

  if(!flush && s==sourceLimit && cnv->preToULength>=0) {
      /* the overflow buffer is emptied and there is no new input: we are done */
      return;
  }

  /*
   * Do not simply return with a buffer overflow error if
   * !flush && t==targetLimit
   * because it is possible that the source will not generate any output.
   * For example, the skip callback may be called;
   * it does not output anything.
   */

  /* prepare the converter arguments */
  args.converter=cnv;
  args.flush=flush;
  args.offsets=offsets;
  args.source=s;
  args.sourceLimit=sourceLimit;
  args.target=*target;
  args.targetLimit=targetLimit;
  args.size=sizeof(args);

  _toUnicodeWithCallback(&args, err);

  *source=args.source;
  *target=args.target;
1719}

1721/* ucnv_to/fromUChars() ----------------------------------------------------- */

1723U_CAPIextern "C" int32_t U_EXPORT2
1724ucnv_fromUCharsucnv_fromUChars_71(UConverter *cnv,
              char *dest, int32_t destCapacity,
              const UChar *src, int32_t srcLength,
              UErrorCode *pErrorCode) {
  const UChar *srcLimit;
  char *originalDest, *destLimit;
  int32_t destLength;

  /* check arguments */
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
      return 0;
  }

  if( cnv==NULL__null ||
      destCapacity<0 || (destCapacity>0 && dest==NULL__null) ||
      srcLength<-1 || (srcLength!=0 && src==NULL__null)
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  /* initialize */
  ucnv_resetFromUnicodeucnv_resetFromUnicode_71(cnv);
  originalDest=dest;
  if(srcLength==-1) {
      srcLength=u_strlenu_strlen_71(src);
  }
  if(srcLength>0) {
      srcLimit=src+srcLength;
      destCapacity=pinCapacity(dest, destCapacity);
      destLimit=dest+destCapacity;

      /* perform the conversion */
      ucnv_fromUnicodeucnv_fromUnicode_71(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE1, pErrorCode);
      destLength=(int32_t)(dest-originalDest);

      /* if an overflow occurs, then get the preflighting length */
      if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
          char buffer[1024];

          destLimit=buffer+sizeof(buffer);
          do {
              dest=buffer;
              *pErrorCode=U_ZERO_ERROR;
              ucnv_fromUnicodeucnv_fromUnicode_71(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE1, pErrorCode);
              destLength+=(int32_t)(dest-buffer);
          } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
      }
  } else {
      destLength=0;
  }

  return u_terminateCharsu_terminateChars_71(originalDest, destCapacity, destLength, pErrorCode);
1777}

1779U_CAPIextern "C" int32_t U_EXPORT2
1780ucnv_toUCharsucnv_toUChars_71(UConverter *cnv,
            UChar *dest, int32_t destCapacity,
            const char *src, int32_t srcLength,
            UErrorCode *pErrorCode) {
  const char *srcLimit;
  UChar *originalDest, *destLimit;
  int32_t destLength;

  /* check arguments */
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
      return 0;
  }

  if( cnv==NULL__null ||
      destCapacity<0 || (destCapacity>0 && dest==NULL__null) ||
      srcLength<-1 || (srcLength!=0 && src==NULL__null))
  {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  /* initialize */
  ucnv_resetToUnicodeucnv_resetToUnicode_71(cnv);
  originalDest=dest;
  if(srcLength==-1) {
      srcLength=(int32_t)uprv_strlen(src):: strlen(src);
  }
  if(srcLength>0) {
      srcLimit=src+srcLength;
      destCapacity=pinCapacity(dest, destCapacity);
      destLimit=dest+destCapacity;

      /* perform the conversion */
      ucnv_toUnicodeucnv_toUnicode_71(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE1, pErrorCode);
      destLength=(int32_t)(dest-originalDest);

      /* if an overflow occurs, then get the preflighting length */
      if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR)
      {
          UChar buffer[1024];

          destLimit=buffer+UPRV_LENGTHOF(buffer)(int32_t)(sizeof(buffer)/sizeof((buffer)[0]));
          do {
              dest=buffer;
              *pErrorCode=U_ZERO_ERROR;
              ucnv_toUnicodeucnv_toUnicode_71(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE1, pErrorCode);
              destLength+=(int32_t)(dest-buffer);
          }
          while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);
      }
  } else {
      destLength=0;
  }

  return u_terminateUCharsu_terminateUChars_71(originalDest, destCapacity, destLength, pErrorCode);
1835}

1837/* ucnv_getNextUChar() ------------------------------------------------------ */

1839U_CAPIextern "C" UChar32 U_EXPORT2
1840ucnv_getNextUCharucnv_getNextUChar_71(UConverter *cnv,
                const char **source, const char *sourceLimit,
                UErrorCode *err) {
  UConverterToUnicodeArgs args;
  UChar buffer[U16_MAX_LENGTH2];
  const char *s;
  UChar32 c;
  int32_t i, length;

  /* check parameters */
  if(err==NULL__null || U_FAILURE(*err)) {
      return 0xffff;
  }

  if(cnv==NULL__null || source==NULL__null) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return 0xffff;
  }

  s=*source;
  if(sourceLimit<s) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return 0xffff;
  }

  /*
   * Make sure that the buffer sizes do not exceed the number range for
   * int32_t because some functions use the size (in units or bytes)
   * rather than comparing pointers, and because offsets are int32_t values.
   *
   * size_t is guaranteed to be unsigned and large enough for the job.
   *
   * Return with an error instead of adjusting the limits because we would
   * not be able to maintain the semantics that either the source must be
   * consumed or the target filled (unless an error occurs).
   * An adjustment would be sourceLimit=t+0x7fffffff; for example.
   */
  if(((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) {
      *err=U_ILLEGAL_ARGUMENT_ERROR;
      return 0xffff;
  }

  c=U_SENTINEL(-1);

  /* flush the target overflow buffer */
  if(cnv->UCharErrorBufferLength>0) {
      UChar *overflow;

      overflow=cnv->UCharErrorBuffer;
      i=0;
      length=cnv->UCharErrorBufferLength;
      U16_NEXT(overflow, i, length, c)do { (c)=(overflow)[(i)++]; if((((c)&0xfffffc00)==0xd800)
) { uint16_t __c2; if((i)!=(length) && (((__c2=(overflow
)[(i)])&0xfffffc00)==0xdc00)) { ++(i); (c)=(((UChar32)((c
))<<10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-
0x10000)); } } } while (false);

      /* move the remaining overflow contents up to the beginning */
      if((cnv->UCharErrorBufferLength=(int8_t)(length-i))>0) {
          uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+i,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer, cnv->UCharErrorBuffer+i, cnv->UCharErrorBufferLength
*2); } while (false)
                       cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer, cnv->UCharErrorBuffer+i, cnv->UCharErrorBufferLength
*2); } while (false);
      }

      if(!U16_IS_LEAD(c)(((c)&0xfffffc00)==0xd800) || i<length) {
          return c;
      }
      /*
       * Continue if the overflow buffer contained only a lead surrogate,
       * in case the converter outputs single surrogates from complete
       * input sequences.
       */
  }

  /*
   * flush==TRUE is implied for ucnv_getNextUChar()
   *
   * do not simply return even if s==sourceLimit because the converter may
   * not have seen flush==TRUE before
   */

  /* prepare the converter arguments */
  args.converter=cnv;
  args.flush=TRUE1;
  args.offsets=NULL__null;
  args.source=s;
  args.sourceLimit=sourceLimit;
  args.target=buffer;
  args.targetLimit=buffer+1;
  args.size=sizeof(args);

  if(c<0) {
      /*
       * call the native getNextUChar() implementation if we are
       * at a character boundary (toULength==0)
       *
       * unlike with _toUnicode(), getNextUChar() implementations must set
       * U_TRUNCATED_CHAR_FOUND for truncated input,
       * in addition to setting toULength/toUBytes[]
       */
      if(cnv->toULength==0 && cnv->sharedData->impl->getNextUChar!=NULL__null) {
          c=cnv->sharedData->impl->getNextUChar(&args, err);
          *source=s=args.source;
          if(*err==U_INDEX_OUTOFBOUNDS_ERROR) {
              /* reset the converter without calling the callback function */
              _reset(cnv, UCNV_RESET_TO_UNICODE, FALSE0);
              return 0xffff; /* no output */
          } else if(U_SUCCESS(*err) && c>=0) {
              return c;
          /*
           * else fall through to use _toUnicode() because
           *   UCNV_GET_NEXT_UCHAR_USE_TO_U: the native function did not want to handle it after all
           *   U_FAILURE: call _toUnicode() for callback handling (do not output c)
           */
          }
      }

      /* convert to one UChar in buffer[0], or handle getNextUChar() errors */
      _toUnicodeWithCallback(&args, err);

      if(*err==U_BUFFER_OVERFLOW_ERROR) {
          *err=U_ZERO_ERROR;
      }

      i=0;
      length=(int32_t)(args.target-buffer);
  } else {
      /* write the lead surrogate from the overflow buffer */
      buffer[0]=(UChar)c;
      args.target=buffer+1;
      i=0;
      length=1;
  }

  /* buffer contents starts at i and ends before length */

  if(U_FAILURE(*err)) {
      c=0xffff; /* no output */
  } else if(length==0) {
      /* no input or only state changes */
      *err=U_INDEX_OUTOFBOUNDS_ERROR;
      /* no need to reset explicitly because _toUnicodeWithCallback() did it */
      c=0xffff; /* no output */
  } else {
      c=buffer[0];
      i=1;
      if(!U16_IS_LEAD(c)(((c)&0xfffffc00)==0xd800)) {
          /* consume c=buffer[0], done */
      } else {
          /* got a lead surrogate, see if a trail surrogate follows */
          UChar c2;

          if(cnv->UCharErrorBufferLength>0) {
              /* got overflow output from the conversion */
              if(U16_IS_TRAIL(c2=cnv->UCharErrorBuffer[0])(((c2=cnv->UCharErrorBuffer[0])&0xfffffc00)==0xdc00)) {
                  /* got a trail surrogate, too */
                  c=U16_GET_SUPPLEMENTARY(c, c2)(((UChar32)(c)<<10UL)+(UChar32)(c2)-((0xd800<<10UL
)+0xdc00-0x10000));

                  /* move the remaining overflow contents up to the beginning */
                  if((--cnv->UCharErrorBufferLength)>0) {
                      uprv_memmove(cnv->UCharErrorBuffer, cnv->UCharErrorBuffer+1,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer, cnv->UCharErrorBuffer+1, cnv->UCharErrorBufferLength
*2); } while (false)
                                   cnv->UCharErrorBufferLength*U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer, cnv->UCharErrorBuffer+1, cnv->UCharErrorBufferLength
*2); } while (false);
                  }
              } else {
                  /* c is an unpaired lead surrogate, just return it */
              }
          } else if(args.source<sourceLimit) {
              /* convert once more, to buffer[1] */
              args.targetLimit=buffer+2;
              _toUnicodeWithCallback(&args, err);
              if(*err==U_BUFFER_OVERFLOW_ERROR) {
                  *err=U_ZERO_ERROR;
              }

              length=(int32_t)(args.target-buffer);
              if(U_SUCCESS(*err) && length==2 && U16_IS_TRAIL(c2=buffer[1])(((c2=buffer[1])&0xfffffc00)==0xdc00)) {
                  /* got a trail surrogate, too */
                  c=U16_GET_SUPPLEMENTARY(c, c2)(((UChar32)(c)<<10UL)+(UChar32)(c2)-((0xd800<<10UL
)+0xdc00-0x10000));
                  i=2;
              }
          }
      }
  }

  /*
   * move leftover output from buffer[i..length[
   * into the beginning of the overflow buffer
   */
  if(i<length) {
      /* move further overflow back */
      int32_t delta=length-i;
      if((length=cnv->UCharErrorBufferLength)>0) {
          uprv_memmove(cnv->UCharErrorBuffer+delta, cnv->UCharErrorBuffer,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer+delta, cnv->UCharErrorBuffer, length*2); }
 while (false)
                       length*U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(cnv->
UCharErrorBuffer+delta, cnv->UCharErrorBuffer, length*2); }
 while (false);
      }
      cnv->UCharErrorBufferLength=(int8_t)(length+delta);

      cnv->UCharErrorBuffer[0]=buffer[i++];
      if(delta>1) {
          cnv->UCharErrorBuffer[1]=buffer[i];
      }
  }

  *source=args.source;
  return c;
2040}

2042/* ucnv_convert() and siblings ---------------------------------------------- */

2044U_CAPIextern "C" void U_EXPORT2
2045ucnv_convertExucnv_convertEx_71(UConverter *targetCnv, UConverter *sourceCnv,
             char **target, const char *targetLimit,
             const char **source, const char *sourceLimit,
             UChar *pivotStart, UChar **pivotSource,
             UChar **pivotTarget, const UChar *pivotLimit,
             UBool reset, UBool flush,
             UErrorCode *pErrorCode) {
  UChar pivotBuffer[CHUNK_SIZE1024];
  const UChar *myPivotSource;
  UChar *myPivotTarget;
  const char *s;
  char *t;

  UConverterToUnicodeArgs toUArgs;
  UConverterFromUnicodeArgs fromUArgs;
  UConverterConvert convert;

  /* error checking */
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
1
Assuming 'pErrorCode' is not equal to NULL→
      return;
  }

  if( targetCnv==NULL__null || sourceCnv==NULL__null ||
2
←
Assuming 'targetCnv' is not equal to NULL→
3
←
Assuming 'sourceCnv' is not equal to NULL→
9
←
Taking false branch→
      source==NULL__null || *source==NULL__null ||
4
←
Assuming 'source' is not equal to NULL→
5
←
Assuming the condition is false→
      target==NULL__null || *target==NULL__null || targetLimit==NULL__null
6
←
Assuming 'target' is not equal to NULL→
7
←
Assuming the condition is false→
8
←
Assuming 'targetLimit' is not equal to NULL→
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  s=*source;
  t=*target;
  if((sourceLimit!=NULL__null && sourceLimit<s) || targetLimit<t) {
10
←
Assuming 'sourceLimit' is equal to NULL→
11
←
Assuming 'targetLimit' is >= 't'→
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  /*
   * Make sure that the buffer sizes do not exceed the number range for
   * int32_t. See ucnv_toUnicode() for a more detailed comment.
   */
  if(
      (sourceLimit11.1
'sourceLimit' is equal to NULL
!=NULL__null && ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) ||
      ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t)
12
←
Assuming the condition is false→
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  
  if(pivotStart==NULL__null) {
13
←
Assuming 'pivotStart' is not equal to NULL→
      if(!flush) {
          /* streaming conversion requires an explicit pivot buffer */
          *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }

      /* use the stack pivot buffer */
      myPivotSource=myPivotTarget=pivotStart=pivotBuffer;
      pivotSource=(UChar **)&myPivotSource;
      pivotTarget=&myPivotTarget;
      pivotLimit=pivotBuffer+CHUNK_SIZE1024;
  } else if(  pivotStart>=pivotLimit ||
14
←
Assuming 'pivotStart' is < 'pivotLimit'→
20
←
Taking false branch→
              pivotSource==NULL__null || *pivotSource==NULL__null ||
15
←
Assuming 'pivotSource' is not equal to NULL→
16
←
Assuming the condition is false→
              pivotTarget==NULL__null || *pivotTarget==NULL__null ||
17
←
Assuming 'pivotTarget' is not equal to NULL→
18
←
Assuming the condition is false→
              pivotLimit==NULL__null
19
←
Assuming 'pivotLimit' is not equal to NULL→
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  if(sourceLimit20.1
'sourceLimit' is equal to NULL
==NULL__null) {
21
←
Taking true branch→
      /* get limit of single-byte-NUL-terminated source string */
      sourceLimit=uprv_strchr(*source, 0):: strchr(*source, 0);
  }

  if(reset) {
22
←
Assuming 'reset' is 0→
23
←
Taking false branch→
      ucnv_resetToUnicodeucnv_resetToUnicode_71(sourceCnv);
      ucnv_resetFromUnicodeucnv_resetFromUnicode_71(targetCnv);
      *pivotSource=*pivotTarget=pivotStart;
  } else if(targetCnv->charErrorBufferLength>0) {
24
←
Assuming field 'charErrorBufferLength' is <= 0→
      /* output the targetCnv overflow buffer */
      if(ucnv_outputOverflowFromUnicode(targetCnv, target, targetLimit, NULL__null, pErrorCode)) {
          /* U_BUFFER_OVERFLOW_ERROR */
          return;
      }
      /* *target has moved, therefore stop using t */

      if( !flush &&
          targetCnv->preFromULength>=0 && *pivotSource==*pivotTarget &&
          sourceCnv->UCharErrorBufferLength==0 && sourceCnv->preToULength>=0 && s==sourceLimit
      ) {
          /* the fromUnicode overflow buffer is emptied and there is no new input: we are done */
          return;
      }
  }

  /* Is direct-UTF-8 conversion available? */
  if( sourceCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
25
←
Assuming field 'conversionType' is not equal to UCNV_UTF8→
      targetCnv->sharedData->impl->fromUTF8!=NULL__null
  ) {
      convert=targetCnv->sharedData->impl->fromUTF8;
  } else if( targetCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
26
←
Assuming field 'conversionType' is not equal to UCNV_UTF8→
             sourceCnv->sharedData->impl->toUTF8!=NULL__null
  ) {
      convert=sourceCnv->sharedData->impl->toUTF8;
  } else {
      convert=NULL__null;
  }

  /*
   * If direct-UTF-8 conversion is available, then we use a smaller
   * pivot buffer for error handling and partial matches
   * so that we quickly return to direct conversion.
   *
   * 32 is large enough for UCNV_EXT_MAX_UCHARS and UCNV_ERROR_BUFFER_LENGTH.
   *
   * We could reduce the pivot buffer size further, at the cost of
   * buffer overflows from callbacks.
   * The pivot buffer should not be smaller than the maximum number of
   * fromUnicode extension table input UChars
   * (for m:n conversion, see
   * targetCnv->sharedData->mbcs.extIndexes[UCNV_EXT_COUNT_UCHARS])
   * or 2 for surrogate pairs.
   *
   * Too small a buffer can cause thrashing between pivoting and direct
   * conversion, with function call overhead outweighing the benefits
   * of direct conversion.
   */
  if(convert26.1
'convert' is equal to NULL
!=NULL__null && (pivotLimit-pivotStart)>32) {
      pivotLimit=pivotStart+32;
  }

  /* prepare the converter arguments */
  fromUArgs.converter=targetCnv;
  fromUArgs.flush=FALSE0;
  fromUArgs.offsets=NULL__null;
  fromUArgs.target=*target;
  fromUArgs.targetLimit=targetLimit;
  fromUArgs.size=sizeof(fromUArgs);

  toUArgs.converter=sourceCnv;
  toUArgs.flush=flush;
  toUArgs.offsets=NULL__null;
  toUArgs.source=s;
  toUArgs.sourceLimit=sourceLimit;
  toUArgs.targetLimit=pivotLimit;
  toUArgs.size=sizeof(toUArgs);

  /*
   * TODO: Consider separating this function into two functions,
   * extracting exactly the conversion loop,
   * for readability and to reduce the set of visible variables.
   *
   * Otherwise stop using s and t from here on.
   */
  s=t=NULL__null;

  /*
   * conversion loop
   *
   * The sequence of steps in the loop may appear backward,
   * but the principle is simple:
   * In the chain of
   *   source - sourceCnv overflow - pivot - targetCnv overflow - target
   * empty out later buffers before refilling them from earlier ones.
   *
   * The targetCnv overflow buffer is flushed out only once before the loop.
   */
  for(;;) {
      /*
       * if(pivot not empty or error or replay or flush fromUnicode) {
       *   fromUnicode(pivot -> target);
       * }
       *
       * For pivoting conversion; and for direct conversion for
       * error callback handling and flushing the replay buffer.
       */
      if( *pivotSource<*pivotTarget ||
27
←
Assuming the condition is false→
29
←
Taking false branch→
          U_FAILURE(*pErrorCode) ||
          targetCnv->preFromULength<0 ||
28
←
Assuming field 'preFromULength' is >= 0→
          fromUArgs.flush

28.1	Field 'flush' is 0

2226 ) { 2227 fromUArgs.source=*pivotSource; 2228 fromUArgs.sourceLimit=*pivotTarget; 2229 _fromUnicodeWithCallback(&fromUArgs, pErrorCode); 2230 if(U_FAILURE(*pErrorCode)) { 2231 /* target overflow, or conversion error */ 2232 *pivotSource=(UChar *)fromUArgs.source; 2233 break; 2234 } 2235 2236 /* 2237 * _fromUnicodeWithCallback() must have consumed the pivot contents 2238 * (*pivotSource==*pivotTarget) since it returned with U_SUCCESS() 2239 */ 2240 } 2241 2242 /* The pivot buffer is empty; reset it so we start at pivotStart. */ 2243 *pivotSource=*pivotTarget=pivotStart; 2244 2245 /* 2246 * if(sourceCnv overflow buffer not empty) { 2247 * move(sourceCnv overflow buffer -> pivot); 2248 * continue; 2249 * } 2250 */ 2251 /* output the sourceCnv overflow buffer */ 2252 if(sourceCnv->UCharErrorBufferLength>0) {

←

Assuming field 'UCharErrorBufferLength' is <= 0

→

2253 if(ucnv_outputOverflowToUnicode(sourceCnv, pivotTarget, pivotLimit, NULL__null, pErrorCode)) { 2254 /* U_BUFFER_OVERFLOW_ERROR */ 2255 *pErrorCode=U_ZERO_ERROR; 2256 } 2257 continue; 2258 } 2259 2260 /* 2261 * check for end of input and break if done 2262 * 2263 * Checking both flush and fromUArgs.flush ensures that the converters 2264 * have been called with the flush flag set if the ucnv_convertEx() 2265 * caller set it. 2266 */ 2267 if( toUArgs.source==sourceLimit &&

←

Assuming 'sourceLimit' is not equal to field 'source'

→

2268 sourceCnv->preToULength>=0 && sourceCnv->toULength==0 && 2269 (!flush || fromUArgs.flush) 2270 ) { 2271 /* done successfully */ 2272 break; 2273 } 2274 2275 /* 2276 * use direct conversion if available 2277 * but not if continuing a partial match 2278 * or flushing the toUnicode replay buffer 2279 */ 2280 if(convert

31.1	'convert' is equal to NULL

!=NULL__null && targetCnv->preFromUFirstCP<0 && sourceCnv->preToULength==0) { 2281 if(*pErrorCode==U_USING_DEFAULT_WARNING) { 2282 /* remove a warning that may be set by this function */ 2283 *pErrorCode=U_ZERO_ERROR; 2284 } 2285 convert(&fromUArgs, &toUArgs, pErrorCode); 2286 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) { 2287 break; 2288 } else if(U_FAILURE(*pErrorCode)) { 2289 if(sourceCnv->toULength>0) { 2290 /* 2291 * Fall through to calling _toUnicodeWithCallback() 2292 * for callback handling. 2293 * 2294 * The pivot buffer will be reset with 2295 * *pivotSource=*pivotTarget=pivotStart; 2296 * which indicates a toUnicode error to the caller 2297 * (*pivotSource==pivotStart shows no pivot UChars consumed). 2298 */ 2299 } else { 2300 /* 2301 * Indicate a fromUnicode error to the caller 2302 * (*pivotSource>pivotStart shows some pivot UChars consumed). 2303 */ 2304 *pivotSource=*pivotTarget=pivotStart+1; 2305 /* 2306 * Loop around to calling _fromUnicodeWithCallbacks() 2307 * for callback handling. 2308 */ 2309 continue; 2310 } 2311 } else if(*pErrorCode==U_USING_DEFAULT_WARNING) { 2312 /* 2313 * No error, but the implementation requested to temporarily 2314 * fall back to pivoting. 2315 */ 2316 *pErrorCode=U_ZERO_ERROR; 2317 /* 2318 * The following else branches are almost identical to the end-of-input 2319 * handling in _toUnicodeWithCallback(). 2320 * Avoid calling it just for the end of input. 2321 */ 2322 } else if(flush && sourceCnv->toULength>0) { /* flush==toUArgs.flush */ 2323 /* 2324 * the entire input stream is consumed 2325 * and there is a partial, truncated input sequence left 2326 */ 2327 2328 /* inject an error and continue with callback handling */ 2329 *pErrorCode=U_TRUNCATED_CHAR_FOUND; 2330 } else { 2331 /* input consumed */ 2332 if(flush) { 2333 /* reset the converters without calling the callback functions */ 2334 _reset(sourceCnv, UCNV_RESET_TO_UNICODE, FALSE0); 2335 _reset(targetCnv, UCNV_RESET_FROM_UNICODE, FALSE0); 2336 } 2337 2338 /* done successfully */ 2339 break; 2340 } 2341 } 2342 2343 /* 2344 * toUnicode(source -> pivot); 2345 * 2346 * For pivoting conversion; and for direct conversion for 2347 * error callback handling, continuing partial matches 2348 * and flushing the replay buffer. 2349 * 2350 * The pivot buffer is empty and reset. 2351 */ 2352 toUArgs.target=pivotStart; /* ==*pivotTarget */ 2353 /* toUArgs.targetLimit=pivotLimit; already set before the loop */ 2354 _toUnicodeWithCallback(&toUArgs, pErrorCode);

←

Calling '_toUnicodeWithCallback'

→

2355 *pivotTarget=toUArgs.target; 2356 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) { 2357 /* pivot overflow: continue with the conversion loop */ 2358 *pErrorCode=U_ZERO_ERROR; 2359 } else if(U_FAILURE(*pErrorCode) || (!flush && *pivotTarget==pivotStart)) { 2360 /* conversion error, or there was nothing left to convert */ 2361 break; 2362 } 2363 /* 2364 * else: 2365 * _toUnicodeWithCallback() wrote into the pivot buffer, 2366 * continue with fromUnicode conversion. 2367 * 2368 * Set the fromUnicode flush flag if we flush and if toUnicode has 2369 * processed the end of the input. 2370 */ 2371 if( flush && toUArgs.source==sourceLimit && 2372 sourceCnv->preToULength>=0 && 2373 sourceCnv->UCharErrorBufferLength==0 2374 ) { 2375 fromUArgs.flush=TRUE1; 2376 } 2377 } 2378 2379 /* 2380 * The conversion loop is exited when one of the following is true: 2381 * - the entire source text has been converted successfully to the target buffer 2382 * - a target buffer overflow occurred 2383 * - a conversion error occurred 2384 */ 2385 2386 *source=toUArgs.source; 2387 *target=fromUArgs.target; 2388 2389 /* terminate the target buffer if possible */ 2390 if(flush && U_SUCCESS(*pErrorCode)) { 2391 if(*target!=targetLimit) { 2392 **target=0; 2393 if(*pErrorCode==U_STRING_NOT_TERMINATED_WARNING) { 2394 *pErrorCode=U_ZERO_ERROR; 2395 } 2396 } else { 2397 *pErrorCode=U_STRING_NOT_TERMINATED_WARNING; 2398 } 2399 } 2400} 2401 2402/* internal implementation of ucnv_convert() etc. with preflighting */ 2403static int32_t 2404ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter, 2405 char *target, int32_t targetCapacity, 2406 const char *source, int32_t sourceLength, 2407 UErrorCode *pErrorCode) { 2408 UChar pivotBuffer[CHUNK_SIZE1024]; 2409 UChar *pivot, *pivot2; 2410 2411 char *myTarget; 2412 const char *sourceLimit; 2413 const char *targetLimit; 2414 int32_t targetLength=0; 2415 2416 /* set up */ 2417 if(sourceLength<0) { 2418 sourceLimit=uprv_strchr(source, 0):: strchr(source, 0); 2419 } else { 2420 sourceLimit=source+sourceLength; 2421 } 2422 2423 /* if there is no input data, we're done */ 2424 if(source==sourceLimit) { 2425 return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode); 2426 } 2427 2428 pivot=pivot2=pivotBuffer; 2429 myTarget=target; 2430 targetLength=0; 2431 2432 if(targetCapacity>0) { 2433 /* perform real conversion */ 2434 targetLimit=target+targetCapacity; 2435 ucnv_convertExucnv_convertEx_71(outConverter, inConverter, 2436 &myTarget, targetLimit, 2437 &source, sourceLimit, 2438 pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024, 2439 FALSE0, 2440 TRUE1, 2441 pErrorCode); 2442 targetLength=(int32_t)(myTarget-target); 2443 } 2444 2445 /* 2446 * If the output buffer is exhausted (or we are only "preflighting"), we need to stop writing 2447 * to it but continue the conversion in order to store in targetCapacity 2448 * the number of bytes that was required. 2449 */ 2450 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR || targetCapacity==0) 2451 { 2452 char targetBuffer[CHUNK_SIZE1024]; 2453 2454 targetLimit=targetBuffer+CHUNK_SIZE1024; 2455 do { 2456 *pErrorCode=U_ZERO_ERROR; 2457 myTarget=targetBuffer; 2458 ucnv_convertExucnv_convertEx_71(outConverter, inConverter, 2459 &myTarget, targetLimit, 2460 &source, sourceLimit, 2461 pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024, 2462 FALSE0, 2463 TRUE1, 2464 pErrorCode); 2465 targetLength+=(int32_t)(myTarget-targetBuffer); 2466 } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR); 2467 2468 /* done with preflighting, set warnings and errors as appropriate */ 2469 return u_terminateCharsu_terminateChars_71(target, targetCapacity, targetLength, pErrorCode); 2470 } 2471 2472 /* no need to call u_terminateChars() because ucnv_convertEx() took care of that */ 2473 return targetLength; 2474} 2475 2476U_CAPIextern "C" int32_t U_EXPORT2 2477ucnv_convertucnv_convert_71(const char *toConverterName, const char *fromConverterName, 2478 char *target, int32_t targetCapacity, 2479 const char *source, int32_t sourceLength, 2480 UErrorCode *pErrorCode) { 2481 UConverter in, out; /* stack-allocated */ 2482 UConverter *inConverter, *outConverter; 2483 int32_t targetLength; 2484 2485 if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) { 2486 return 0; 2487 } 2488 2489 if( source==NULL__null || sourceLength<-1 || 2490 targetCapacity<0 || (targetCapacity>0 && target==NULL__null) 2491 ) { 2492 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 2493 return 0; 2494 } 2495 2496 /* if there is no input data, we're done */ 2497 if(sourceLength==0 || (sourceLength<0 && *source==0)) { 2498 return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode); 2499 } 2500 2501 /* create the converters */ 2502 inConverter=ucnv_createConverterucnv_createConverter_71(&in, fromConverterName, pErrorCode); 2503 if(U_FAILURE(*pErrorCode)) { 2504 return 0; 2505 } 2506 2507 outConverter=ucnv_createConverterucnv_createConverter_71(&out, toConverterName, pErrorCode); 2508 if(U_FAILURE(*pErrorCode)) { 2509 ucnv_closeucnv_close_71(inConverter); 2510 return 0; 2511 } 2512 2513 targetLength=ucnv_internalConvert(outConverter, inConverter, 2514 target, targetCapacity, 2515 source, sourceLength, 2516 pErrorCode); 2517 2518 ucnv_closeucnv_close_71(inConverter); 2519 ucnv_closeucnv_close_71(outConverter); 2520 2521 return targetLength; 2522} 2523 2524/* @internal */ 2525static int32_t 2526ucnv_convertAlgorithmic(UBool convertToAlgorithmic, 2527 UConverterType algorithmicType, 2528 UConverter *cnv, 2529 char *target, int32_t targetCapacity, 2530 const char *source, int32_t sourceLength, 2531 UErrorCode *pErrorCode) { 2532 UConverter algoConverterStatic; /* stack-allocated */ 2533 UConverter *algoConverter, *to, *from; 2534 int32_t targetLength; 2535 2536 if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) { 2537 return 0; 2538 } 2539 2540 if( cnv==NULL__null || source==NULL__null || sourceLength<-1 || 2541 targetCapacity<0 || (targetCapacity>0 && target==NULL__null) 2542 ) { 2543 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 2544 return 0; 2545 } 2546 2547 /* if there is no input data, we're done */ 2548 if(sourceLength==0 || (sourceLength<0 && *source==0)) { 2549 return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode); 2550 } 2551 2552 /* create the algorithmic converter */ 2553 algoConverter=ucnv_createAlgorithmicConverterucnv_createAlgorithmicConverter_71(&algoConverterStatic, algorithmicType, 2554 "", 0, pErrorCode); 2555 if(U_FAILURE(*pErrorCode)) { 2556 return 0; 2557 } 2558 2559 /* reset the other converter */ 2560 if(convertToAlgorithmic) { 2561 /* cnv->Unicode->algo */ 2562 ucnv_resetToUnicodeucnv_resetToUnicode_71(cnv); 2563 to=algoConverter; 2564 from=cnv; 2565 } else { 2566 /* algo->Unicode->cnv */ 2567 ucnv_resetFromUnicodeucnv_resetFromUnicode_71(cnv); 2568 from=algoConverter; 2569 to=cnv; 2570 } 2571 2572 targetLength=ucnv_internalConvert(to, from, 2573 target, targetCapacity, 2574 source, sourceLength, 2575 pErrorCode); 2576 2577 ucnv_closeucnv_close_71(algoConverter); 2578 2579 return targetLength; 2580} 2581 2582U_CAPIextern "C" int32_t U_EXPORT2 2583ucnv_toAlgorithmicucnv_toAlgorithmic_71(UConverterType algorithmicType, 2584 UConverter *cnv, 2585 char *target, int32_t targetCapacity, 2586 const char *source, int32_t sourceLength, 2587 UErrorCode *pErrorCode) { 2588 return ucnv_convertAlgorithmic(TRUE1, algorithmicType, cnv, 2589 target, targetCapacity, 2590 source, sourceLength, 2591 pErrorCode); 2592} 2593 2594U_CAPIextern "C" int32_t U_EXPORT2 2595ucnv_fromAlgorithmicucnv_fromAlgorithmic_71(UConverter *cnv, 2596 UConverterType algorithmicType, 2597 char *target, int32_t targetCapacity, 2598 const char *source, int32_t sourceLength, 2599 UErrorCode *pErrorCode) { 2600 return ucnv_convertAlgorithmic(FALSE0, algorithmicType, cnv, 2601 target, targetCapacity, 2602 source, sourceLength, 2603 pErrorCode); 2604} 2605 2606U_CAPIextern "C" UConverterType U_EXPORT2 2607ucnv_getTypeucnv_getType_71(const UConverter* converter) 2608{ 2609 int8_t type = converter->sharedData->staticData->conversionType; 2610#if !UCONFIG_NO_LEGACY_CONVERSION0 2611 if(type == UCNV_MBCS) { 2612 return ucnv_MBCSGetTypeucnv_MBCSGetType_71(converter); 2613 } 2614#endif 2615 return (UConverterType)type; 2616} 2617 2618U_CAPIextern "C" void U_EXPORT2 2619ucnv_getStartersucnv_getStarters_71(const UConverter* converter, 2620 UBool starters[256], 2621 UErrorCode* err) 2622{ 2623 if (err == NULL__null || U_FAILURE(*err)) { 2624 return; 2625 } 2626 2627 if(converter->sharedData->impl->getStarters != NULL__null) { 2628 converter->sharedData->impl->getStarters(converter, starters, err); 2629 } else { 2630 *err = U_ILLEGAL_ARGUMENT_ERROR; 2631 } 2632} 2633 2634static const UAmbiguousConverter *ucnv_getAmbiguous(const UConverter *cnv) 2635{ 2636 UErrorCode errorCode; 2637 const char *name; 2638 int32_t i; 2639 2640 if(cnv==NULL__null) { 2641 return NULL__null; 2642 } 2643 2644 errorCode=U_ZERO_ERROR; 2645 name=ucnv_getNameucnv_getName_71(cnv, &errorCode); 2646 if(U_FAILURE(errorCode)) { 2647 return NULL__null; 2648 } 2649 2650 for(i=0; i<UPRV_LENGTHOF(ambiguousConverters)(int32_t)(sizeof(ambiguousConverters)/sizeof((ambiguousConverters
)[0])); ++i) 2651 { 2652 if(0==uprv_strcmp(name, ambiguousConverters[i].name):: strcmp(name, ambiguousConverters[i].name)) 2653 { 2654 return ambiguousConverters+i; 2655 } 2656 } 2657 2658 return NULL__null; 2659} 2660 2661U_CAPIextern "C" void U_EXPORT2 2662ucnv_fixFileSeparatorucnv_fixFileSeparator_71(const UConverter *cnv, 2663 UChar* source, 2664 int32_t sourceLength) { 2665 const UAmbiguousConverter *a; 2666 int32_t i; 2667 UChar variant5c; 2668 2669 if(cnv==NULL__null || source==NULL__null || sourceLength<=0 || (a=ucnv_getAmbiguous(cnv))==NULL__null) 2670 { 2671 return; 2672 } 2673 2674 variant5c=a->variant5c; 2675 for(i=0; i<sourceLength; ++i) { 2676 if(source[i]==variant5c) { 2677 source[i]=0x5c; 2678 } 2679 } 2680} 2681 2682U_CAPIextern "C" UBool U_EXPORT2 2683ucnv_isAmbiguousucnv_isAmbiguous_71(const UConverter *cnv) { 2684 return (UBool)(ucnv_getAmbiguous(cnv)!=NULL__null); 2685} 2686 2687U_CAPIextern "C" void U_EXPORT2 2688ucnv_setFallbackucnv_setFallback_71(UConverter *cnv, UBool usesFallback) 2689{ 2690 cnv->useFallback = usesFallback; 2691} 2692 2693U_CAPIextern "C" UBool U_EXPORT2 2694ucnv_usesFallbackucnv_usesFallback_71(const UConverter *cnv) 2695{ 2696 return cnv->useFallback; 2697} 2698 2699U_CAPIextern "C" void U_EXPORT2 2700ucnv_getInvalidCharsucnv_getInvalidChars_71 (const UConverter * converter, 2701 char *errBytes, 2702 int8_t * len, 2703 UErrorCode * err) 2704{ 2705 if (err == NULL__null || U_FAILURE(*err)) 2706 { 2707 return; 2708 } 2709 if (len == NULL__null || errBytes == NULL__null || converter == NULL__null) 2710 { 2711 *err = U_ILLEGAL_ARGUMENT_ERROR; 2712 return; 2713 } 2714 if (*len < converter->invalidCharLength) 2715 { 2716 *err = U_INDEX_OUTOFBOUNDS_ERROR; 2717 return; 2718 } 2719 if ((*len = converter->invalidCharLength) > 0) 2720 { 2721 uprv_memcpy (errBytes, converter->invalidCharBuffer, *len)do { clang diagnostic push clang diagnostic ignored "-Waddress"
(void)0; (void)0; clang diagnostic pop :: memcpy(errBytes,
converter->invalidCharBuffer, *len); } while (false); 2722 } 2723} 2724 2725U_CAPIextern "C" void U_EXPORT2 2726ucnv_getInvalidUCharsucnv_getInvalidUChars_71 (const UConverter * converter, 2727 UChar *errChars, 2728 int8_t * len, 2729 UErrorCode * err) 2730{ 2731 if (err == NULL__null || U_FAILURE(*err)) 2732 { 2733 return; 2734 } 2735 if (len == NULL__null || errChars == NULL__null || converter == NULL__null) 2736 { 2737 *err = U_ILLEGAL_ARGUMENT_ERROR; 2738 return; 2739 } 2740 if (*len < converter->invalidUCharLength) 2741 { 2742 *err = U_INDEX_OUTOFBOUNDS_ERROR; 2743 return; 2744 } 2745 if ((*len = converter->invalidUCharLength) > 0) 2746 { 2747 u_memcpyu_memcpy_71 (errChars, converter->invalidUCharBuffer, *len); 2748 } 2749} 2750 2751#define SIG_MAX_LEN5 5 2752 2753U_CAPIextern "C" const char* U_EXPORT2 2754ucnv_detectUnicodeSignatureucnv_detectUnicodeSignature_71( const char* source, 2755 int32_t sourceLength, 2756 int32_t* signatureLength, 2757 UErrorCode* pErrorCode) { 2758 int32_t dummy; 2759 2760 /* initial 0xa5 bytes: make sure that if we read <SIG_MAX_LEN 2761 * bytes we don't misdetect something 2762 */ 2763 char start[SIG_MAX_LEN5]={ '\xa5', '\xa5', '\xa5', '\xa5', '\xa5' }; 2764 int i = 0; 2765 2766 if((pErrorCode==NULL__null) || U_FAILURE(*pErrorCode)){ 2767 return NULL__null; 2768 } 2769 2770 if(source == NULL__null || sourceLength < -1){ 2771 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 2772 return NULL__null; 2773 } 2774 2775 if(signatureLength == NULL__null) { 2776 signatureLength = &dummy; 2777 } 2778 2779 if(sourceLength==-1){ 2780 sourceLength=(int32_t)uprv_strlen(source):: strlen(source); 2781 } 2782 2783 2784 while(i<sourceLength&& i<SIG_MAX_LEN5){ 2785 start[i]=source[i]; 2786 i++; 2787 } 2788 2789 if(start[0] == '\xFE' && start[1] == '\xFF') { 2790 *signatureLength=2; 2791 return "UTF-16BE"; 2792 } else if(start[0] == '\xFF' && start[1] == '\xFE') { 2793 if(start[2] == '\x00' && start[3] =='\x00') { 2794 *signatureLength=4; 2795 return "UTF-32LE"; 2796 } else { 2797 *signatureLength=2; 2798 return "UTF-16LE"; 2799 } 2800 } else if(start[0] == '\xEF' && start[1] == '\xBB' && start[2] == '\xBF') { 2801 *signatureLength=3; 2802 return "UTF-8"; 2803 } else if(start[0] == '\x00' && start[1] == '\x00' && 2804 start[2] == '\xFE' && start[3]=='\xFF') { 2805 *signatureLength=4; 2806 return "UTF-32BE"; 2807 } else if(start[0] == '\x0E' && start[1] == '\xFE' && start[2] == '\xFF') { 2808 *signatureLength=3; 2809 return "SCSU"; 2810 } else if(start[0] == '\xFB' && start[1] == '\xEE' && start[2] == '\x28') { 2811 *signatureLength=3; 2812 return "BOCU-1"; 2813 } else if(start[0] == '\x2B' && start[1] == '\x2F' && start[2] == '\x76') { 2814 /* 2815 * UTF-7: Initial U+FEFF is encoded as +/v8 or +/v9 or +/v+ or +/v/ 2816 * depending on the second UTF-16 code unit. 2817 * Detect the entire, closed Unicode mode sequence +/v8- for only U+FEFF 2818 * if it occurs. 2819 * 2820 * So far we have +/v 2821 */ 2822 if(start[3] == '\x38' && start[4] == '\x2D') { 2823 /* 5 bytes +/v8- */ 2824 *signatureLength=5; 2825 return "UTF-7"; 2826 } else if(start[3] == '\x38' || start[3] == '\x39' || start[3] == '\x2B' || start[3] == '\x2F') { 2827 /* 4 bytes +/v8 or +/v9 or +/v+ or +/v/ */ 2828 *signatureLength=4; 2829 return "UTF-7"; 2830 } 2831 }else if(start[0]=='\xDD' && start[1]== '\x73'&& start[2]=='\x66' && start[3]=='\x73'){ 2832 *signatureLength=4; 2833 return "UTF-EBCDIC"; 2834 } 2835 2836 2837 /* no known Unicode signature byte sequence recognized */ 2838 *signatureLength=0; 2839 return NULL__null; 2840} 2841 2842U_CAPIextern "C" int32_t U_EXPORT2 2843ucnv_fromUCountPendingucnv_fromUCountPending_71(const UConverter* cnv, UErrorCode* status) 2844{ 2845 if(status == NULL__null || U_FAILURE(*status)){ 2846 return -1; 2847 } 2848 if(cnv == NULL__null){ 2849 *status = U_ILLEGAL_ARGUMENT_ERROR; 2850 return -1; 2851 } 2852 2853 if(cnv->preFromUFirstCP >= 0){ 2854 return U16_LENGTH(cnv->preFromUFirstCP)((uint32_t)(cnv->preFromUFirstCP)<=0xffff ? 1 : 2)+cnv->preFromULength ; 2855 }else if(cnv->preFromULength < 0){ 2856 return -cnv->preFromULength ; 2857 }else if(cnv->fromUChar32 > 0){ 2858 return 1; 2859 } 2860 return 0; 2861 2862} 2863 2864U_CAPIextern "C" int32_t U_EXPORT2 2865ucnv_toUCountPendingucnv_toUCountPending_71(const UConverter* cnv, UErrorCode* status){ 2866 2867 if(status == NULL__null || U_FAILURE(*status)){ 2868 return -1; 2869 } 2870 if(cnv == NULL__null){ 2871 *status = U_ILLEGAL_ARGUMENT_ERROR; 2872 return -1; 2873 } 2874 2875 if(cnv->preToULength > 0){ 2876 return cnv->preToULength ; 2877 }else if(cnv->preToULength < 0){ 2878 return -cnv->preToULength; 2879 }else if(cnv->toULength > 0){ 2880 return cnv->toULength; 2881 } 2882 return 0; 2883} 2884 2885U_CAPIextern "C" UBool U_EXPORT2 2886ucnv_isFixedWidthucnv_isFixedWidth_71(UConverter *cnv, UErrorCode *status){ 2887 if (U_FAILURE(*status)) { 2888 return FALSE0; 2889 } 2890 2891 if (cnv == NULL__null) { 2892 *status = U_ILLEGAL_ARGUMENT_ERROR; 2893 return FALSE0; 2894 } 2895 2896 switch (ucnv_getTypeucnv_getType_71(cnv)) { 2897 case UCNV_SBCS: 2898 case UCNV_DBCS: 2899 case UCNV_UTF32_BigEndian: 2900 case UCNV_UTF32_LittleEndian: 2901 case UCNV_UTF32: 2902 case UCNV_US_ASCII: 2903 return TRUE1; 2904 default: 2905 return FALSE0; 2906 } 2907} 2908#endif 2909 2910/* 2911 * Hey, Emacs, please set the following: 2912 * 2913 * Local Variables: 2914 * indent-tabs-mode: nil 2915 * End: 2916 * 2917 */