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

Bug Summary

File:	out/../deps/icu-small/source/common/ucnv.cpp
Warning:	line 1040, column 21 Address of stack memory associated with local variable 'replay' is still referred to by the stack variable 'fromUArgs' 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(offsets28.1
'offsets' is equal to NULL
==NULL__null) {
29
←
Taking true branch→
      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) {
30
←
Assuming field 'preFromULength' is >= 0→
31
←
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->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(;;) {
32
←
Loop condition is true.  Entering loop body→
      if(U_SUCCESS(*err)) {
33
←
Taking true branch→
          /* 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 &&
34
←
Assuming field 'flush' is 0→
                      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(;;) {
35
←
Loop condition is true.  Entering loop body→
          /* update offsets if we write any */
          if(offsets35.1
'offsets' is equal to NULL
!=NULL__null) {
36
←
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->preFromULength<0) {
37
←
Assuming field 'preFromULength' is < 0→
38
←
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(realSource38.1
'realSource' is equal to NULL
==NULL__null) {
39
←
Taking true branch→
                  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);
40
←
Loop condition is false.  Exiting loop→
                  pArgs->source=replay;
                  pArgs->sourceLimit=replay-cnv->preFromULength;
                  pArgs->flush=FALSE0;
                  if((sourceIndex+=cnv->preFromULength)<0) {
41
←
Taking true branch→
                      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)) {
42
←
Taking true branch→
              if(s<pArgs->sourceLimit) {
43
←
Assuming 's' is >= field 'sourceLimit'→
44
←
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) {
45
←
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->flush45.1
Field 'flush' is 0
 && 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->flush45.2
Field 'flush' is 0
) {
46
←
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_FROM_UNICODE, FALSE0);
                  }

                  /* done successfully */
                  return;
47
←
Address of stack memory associated with local variable 'replay' is still referred to by the stack variable 'fromUArgs' 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)
              ) {
                  /*
                   * 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(offsets==NULL__null) {
      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) {
      /* 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(;;) {
      if(U_SUCCESS(*err)) {
          /* 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 &&
                      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(;;) {
          /* 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->preToULength<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->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;
                  if((sourceIndex+=cnv->preToULength)<0) {
                      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)) {
              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->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->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_TO_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 &&
                   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 true→
          U_FAILURE(*pErrorCode) ||
          targetCnv->preFromULength<0 ||
          fromUArgs.flush
      ) {
          fromUArgs.source=*pivotSource;
          fromUArgs.sourceLimit=*pivotTarget;
          _fromUnicodeWithCallback(&fromUArgs, pErrorCode);
28
←
Calling '_fromUnicodeWithCallback'→
          if(U_FAILURE(*pErrorCode)) {
              /* target overflow, or conversion error */
              *pivotSource=(UChar *)fromUArgs.source;
              break;
          }

          /*
           * _fromUnicodeWithCallback() must have consumed the pivot contents
           * (*pivotSource==*pivotTarget) since it returned with U_SUCCESS()
           */
      }

      /* The pivot buffer is empty; reset it so we start at pivotStart. */
      *pivotSource=*pivotTarget=pivotStart;

      /*
       * if(sourceCnv overflow buffer not empty) {
       *     move(sourceCnv overflow buffer -> pivot);
       *     continue;
       * }
       */
      /* output the sourceCnv overflow buffer */
      if(sourceCnv->UCharErrorBufferLength>0) {
          if(ucnv_outputOverflowToUnicode(sourceCnv, pivotTarget, pivotLimit, NULL__null, pErrorCode)) {
              /* U_BUFFER_OVERFLOW_ERROR */
              *pErrorCode=U_ZERO_ERROR;
          }
          continue;
      }

      /*
       * check for end of input and break if done
       *
       * Checking both flush and fromUArgs.flush ensures that the converters
       * have been called with the flush flag set if the ucnv_convertEx()
       * caller set it.
       */
      if( toUArgs.source==sourceLimit &&
          sourceCnv->preToULength>=0 && sourceCnv->toULength==0 &&
          (!flush || fromUArgs.flush)
      ) {
          /* done successfully */
          break;
      }

      /*
       * use direct conversion if available
       * but not if continuing a partial match
       * or flushing the toUnicode replay buffer
       */
      if(convert!=NULL__null && targetCnv->preFromUFirstCP<0 && sourceCnv->preToULength==0) {
          if(*pErrorCode==U_USING_DEFAULT_WARNING) {
              /* remove a warning that may be set by this function */
              *pErrorCode=U_ZERO_ERROR;
          }
          convert(&fromUArgs, &toUArgs, pErrorCode);
          if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
              break;
          } else if(U_FAILURE(*pErrorCode)) {
              if(sourceCnv->toULength>0) {
                  /*
                   * Fall through to calling _toUnicodeWithCallback()
                   * for callback handling.
                   *
                   * The pivot buffer will be reset with
                   *   *pivotSource=*pivotTarget=pivotStart;
                   * which indicates a toUnicode error to the caller
                   * (*pivotSource==pivotStart shows no pivot UChars consumed).
                   */
              } else {
                  /*
                   * Indicate a fromUnicode error to the caller
                   * (*pivotSource>pivotStart shows some pivot UChars consumed).
                   */
                  *pivotSource=*pivotTarget=pivotStart+1;
                  /*
                   * Loop around to calling _fromUnicodeWithCallbacks()
                   * for callback handling.
                   */
                  continue;
              }
          } else if(*pErrorCode==U_USING_DEFAULT_WARNING) {
              /*
               * No error, but the implementation requested to temporarily
               * fall back to pivoting.
               */
              *pErrorCode=U_ZERO_ERROR;
          /*
           * The following else branches are almost identical to the end-of-input
           * handling in _toUnicodeWithCallback().
           * Avoid calling it just for the end of input.
           */
          } else if(flush && sourceCnv->toULength>0) { /* flush==toUArgs.flush */
              /*
               * the entire input stream is consumed
               * and there is a partial, truncated input sequence left
               */

              /* inject an error and continue with callback handling */
              *pErrorCode=U_TRUNCATED_CHAR_FOUND;
          } else {
              /* input consumed */
              if(flush) {
                  /* reset the converters without calling the callback functions */
                  _reset(sourceCnv, UCNV_RESET_TO_UNICODE, FALSE0);
                  _reset(targetCnv, UCNV_RESET_FROM_UNICODE, FALSE0);
              }

              /* done successfully */
              break;
          }
      }
      
      /*
       * toUnicode(source -> pivot);
       *
       * For pivoting conversion; and for direct conversion for
       * error callback handling, continuing partial matches
       * and flushing the replay buffer.
       *
       * The pivot buffer is empty and reset.
       */
      toUArgs.target=pivotStart; /* ==*pivotTarget */
      /* toUArgs.targetLimit=pivotLimit; already set before the loop */
      _toUnicodeWithCallback(&toUArgs, pErrorCode);
      *pivotTarget=toUArgs.target;
      if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
          /* pivot overflow: continue with the conversion loop */
          *pErrorCode=U_ZERO_ERROR;
      } else if(U_FAILURE(*pErrorCode) || (!flush && *pivotTarget==pivotStart)) {
          /* conversion error, or there was nothing left to convert */
          break;
      }
      /*
       * else:
       * _toUnicodeWithCallback() wrote into the pivot buffer,
       * continue with fromUnicode conversion.
       *
       * Set the fromUnicode flush flag if we flush and if toUnicode has
       * processed the end of the input.
       */
      if( flush && toUArgs.source==sourceLimit &&
          sourceCnv->preToULength>=0 &&
          sourceCnv->UCharErrorBufferLength==0
      ) {
          fromUArgs.flush=TRUE1;
      }
  }

  /*
   * The conversion loop is exited when one of the following is true:
   * - the entire source text has been converted successfully to the target buffer
   * - a target buffer overflow occurred
   * - a conversion error occurred
   */

  *source=toUArgs.source;
  *target=fromUArgs.target;

  /* terminate the target buffer if possible */
  if(flush && U_SUCCESS(*pErrorCode)) {
      if(*target!=targetLimit) {
          **target=0;
          if(*pErrorCode==U_STRING_NOT_TERMINATED_WARNING) {
              *pErrorCode=U_ZERO_ERROR;
          }
      } else {
          *pErrorCode=U_STRING_NOT_TERMINATED_WARNING;
      }
  }
2400}

2402/* internal implementation of ucnv_convert() etc. with preflighting */
2403static int32_t
2404ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter,
                   char *target, int32_t targetCapacity,
                   const char *source, int32_t sourceLength,
                   UErrorCode *pErrorCode) {
  UChar pivotBuffer[CHUNK_SIZE1024];
  UChar *pivot, *pivot2;

  char *myTarget;
  const char *sourceLimit;
  const char *targetLimit;
  int32_t targetLength=0;

  /* set up */
  if(sourceLength<0) {
      sourceLimit=uprv_strchr(source, 0):: strchr(source, 0);
  } else {
      sourceLimit=source+sourceLength;
  }

  /* if there is no input data, we're done */
  if(source==sourceLimit) {
      return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode);
  }

  pivot=pivot2=pivotBuffer;
  myTarget=target;
  targetLength=0;

  if(targetCapacity>0) {
      /* perform real conversion */
      targetLimit=target+targetCapacity;
      ucnv_convertExucnv_convertEx_71(outConverter, inConverter,
                     &myTarget, targetLimit,
                     &source, sourceLimit,
                     pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024,
                     FALSE0,
                     TRUE1,
                     pErrorCode);
      targetLength=(int32_t)(myTarget-target);
  }

  /*
   * If the output buffer is exhausted (or we are only "preflighting"), we need to stop writing
   * to it but continue the conversion in order to store in targetCapacity
   * the number of bytes that was required.
   */
  if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR || targetCapacity==0)
  {
      char targetBuffer[CHUNK_SIZE1024];

      targetLimit=targetBuffer+CHUNK_SIZE1024;
      do {
          *pErrorCode=U_ZERO_ERROR;
          myTarget=targetBuffer;
          ucnv_convertExucnv_convertEx_71(outConverter, inConverter,
                         &myTarget, targetLimit,
                         &source, sourceLimit,
                         pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024,
                         FALSE0,
                         TRUE1,
                         pErrorCode);
          targetLength+=(int32_t)(myTarget-targetBuffer);
      } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);

      /* done with preflighting, set warnings and errors as appropriate */
      return u_terminateCharsu_terminateChars_71(target, targetCapacity, targetLength, pErrorCode);
  }

  /* no need to call u_terminateChars() because ucnv_convertEx() took care of that */
  return targetLength;
2474}

2476U_CAPIextern "C" int32_t U_EXPORT2
2477ucnv_convertucnv_convert_71(const char *toConverterName, const char *fromConverterName,
           char *target, int32_t targetCapacity,
           const char *source, int32_t sourceLength,
           UErrorCode *pErrorCode) {
  UConverter in, out; /* stack-allocated */
  UConverter *inConverter, *outConverter;
  int32_t targetLength;

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

  if( source==NULL__null || sourceLength<-1 ||
      targetCapacity<0 || (targetCapacity>0 && target==NULL__null)
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  /* if there is no input data, we're done */
  if(sourceLength==0 || (sourceLength<0 && *source==0)) {
      return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode);
  }

  /* create the converters */
  inConverter=ucnv_createConverterucnv_createConverter_71(&in, fromConverterName, pErrorCode);
  if(U_FAILURE(*pErrorCode)) {
      return 0;
  }

  outConverter=ucnv_createConverterucnv_createConverter_71(&out, toConverterName, pErrorCode);
  if(U_FAILURE(*pErrorCode)) {
      ucnv_closeucnv_close_71(inConverter);
      return 0;
  }

  targetLength=ucnv_internalConvert(outConverter, inConverter,
                                    target, targetCapacity,
                                    source, sourceLength,
                                    pErrorCode);

  ucnv_closeucnv_close_71(inConverter);
  ucnv_closeucnv_close_71(outConverter);

  return targetLength;
2522}

2524/* @internal */
2525static int32_t
2526ucnv_convertAlgorithmic(UBool convertToAlgorithmic,
                      UConverterType algorithmicType,
                      UConverter *cnv,
                      char *target, int32_t targetCapacity,
                      const char *source, int32_t sourceLength,
                      UErrorCode *pErrorCode) {
  UConverter algoConverterStatic; /* stack-allocated */
  UConverter *algoConverter, *to, *from;
  int32_t targetLength;

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

  if( cnv==NULL__null || source==NULL__null || sourceLength<-1 ||
      targetCapacity<0 || (targetCapacity>0 && target==NULL__null)
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  /* if there is no input data, we're done */
  if(sourceLength==0 || (sourceLength<0 && *source==0)) {
      return u_terminateCharsu_terminateChars_71(target, targetCapacity, 0, pErrorCode);
  }

  /* create the algorithmic converter */
  algoConverter=ucnv_createAlgorithmicConverterucnv_createAlgorithmicConverter_71(&algoConverterStatic, algorithmicType,
                                                "", 0, pErrorCode);
  if(U_FAILURE(*pErrorCode)) {
      return 0;
  }

  /* reset the other converter */
  if(convertToAlgorithmic) {
      /* cnv->Unicode->algo */
      ucnv_resetToUnicodeucnv_resetToUnicode_71(cnv);
      to=algoConverter;
      from=cnv;
  } else {
      /* algo->Unicode->cnv */
      ucnv_resetFromUnicodeucnv_resetFromUnicode_71(cnv);
      from=algoConverter;
      to=cnv;
  }

  targetLength=ucnv_internalConvert(to, from,
                                    target, targetCapacity,
                                    source, sourceLength,
                                    pErrorCode);

  ucnv_closeucnv_close_71(algoConverter);

  return targetLength;
2580}

2582U_CAPIextern "C" int32_t U_EXPORT2
2583ucnv_toAlgorithmicucnv_toAlgorithmic_71(UConverterType algorithmicType,
                 UConverter *cnv,
                 char *target, int32_t targetCapacity,
                 const char *source, int32_t sourceLength,
                 UErrorCode *pErrorCode) {
  return ucnv_convertAlgorithmic(TRUE1, algorithmicType, cnv,
                                 target, targetCapacity,
                                 source, sourceLength,
                                 pErrorCode);
2592}

2594U_CAPIextern "C" int32_t U_EXPORT2
2595ucnv_fromAlgorithmicucnv_fromAlgorithmic_71(UConverter *cnv,
                   UConverterType algorithmicType,
                   char *target, int32_t targetCapacity,
                   const char *source, int32_t sourceLength,
                   UErrorCode *pErrorCode) {
  return ucnv_convertAlgorithmic(FALSE0, algorithmicType, cnv,
                                 target, targetCapacity,
                                 source, sourceLength,
                                 pErrorCode);
2604}

2606U_CAPIextern "C" UConverterType  U_EXPORT2
2607ucnv_getTypeucnv_getType_71(const UConverter* converter)
2608{
  int8_t type = converter->sharedData->staticData->conversionType;
2610#if !UCONFIG_NO_LEGACY_CONVERSION0
  if(type == UCNV_MBCS) {
      return ucnv_MBCSGetTypeucnv_MBCSGetType_71(converter);
  }
2614#endif
  return (UConverterType)type;
2616}

2618U_CAPIextern "C" void  U_EXPORT2
2619ucnv_getStartersucnv_getStarters_71(const UConverter* converter, 
               UBool starters[256],
               UErrorCode* err)
2622{
  if (err == NULL__null || U_FAILURE(*err)) {
      return;
  }

  if(converter->sharedData->impl->getStarters != NULL__null) {
      converter->sharedData->impl->getStarters(converter, starters, err);
  } else {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
  }
2632}

2634static const UAmbiguousConverter *ucnv_getAmbiguous(const UConverter *cnv)
2635{
  UErrorCode errorCode;
  const char *name;
  int32_t i;

  if(cnv==NULL__null) {
      return NULL__null;
  }

  errorCode=U_ZERO_ERROR;
  name=ucnv_getNameucnv_getName_71(cnv, &errorCode);
  if(U_FAILURE(errorCode)) {
      return NULL__null;
  }

  for(i=0; i<UPRV_LENGTHOF(ambiguousConverters)(int32_t)(sizeof(ambiguousConverters)/sizeof((ambiguousConverters
)[0])); ++i)
  {
      if(0==uprv_strcmp(name, ambiguousConverters[i].name):: strcmp(name, ambiguousConverters[i].name))
      {
          return ambiguousConverters+i;
      }
  }

  return NULL__null;
2659}

2661U_CAPIextern "C" void  U_EXPORT2
2662ucnv_fixFileSeparatorucnv_fixFileSeparator_71(const UConverter *cnv, 
                    UChar* source, 
                    int32_t sourceLength) {
  const UAmbiguousConverter *a;
  int32_t i;
  UChar variant5c;

  if(cnv==NULL__null || source==NULL__null || sourceLength<=0 || (a=ucnv_getAmbiguous(cnv))==NULL__null)
  {
      return;
  }

  variant5c=a->variant5c;
  for(i=0; i<sourceLength; ++i) {
      if(source[i]==variant5c) {
          source[i]=0x5c;
      }
  }
2680}

2682U_CAPIextern "C" UBool  U_EXPORT2
2683ucnv_isAmbiguousucnv_isAmbiguous_71(const UConverter *cnv) {
  return (UBool)(ucnv_getAmbiguous(cnv)!=NULL__null);
2685}

2687U_CAPIextern "C" void  U_EXPORT2
2688ucnv_setFallbackucnv_setFallback_71(UConverter *cnv, UBool usesFallback)
2689{
  cnv->useFallback = usesFallback;
2691}

2693U_CAPIextern "C" UBool  U_EXPORT2
2694ucnv_usesFallbackucnv_usesFallback_71(const UConverter *cnv)
2695{
  return cnv->useFallback;
2697}

2699U_CAPIextern "C" void  U_EXPORT2
2700ucnv_getInvalidCharsucnv_getInvalidChars_71 (const UConverter * converter,
                    char *errBytes,
                    int8_t * len,
                    UErrorCode * err)
2704{
  if (err == NULL__null || U_FAILURE(*err))
  {
      return;
  }
  if (len == NULL__null || errBytes == NULL__null || converter == NULL__null)
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if (*len < converter->invalidCharLength)
  {
      *err = U_INDEX_OUTOFBOUNDS_ERROR;
      return;
  }
  if ((*len = converter->invalidCharLength) > 0)
  {
      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);
  }
2723}

2725U_CAPIextern "C" void  U_EXPORT2
2726ucnv_getInvalidUCharsucnv_getInvalidUChars_71 (const UConverter * converter,
                     UChar *errChars,
                     int8_t * len,
                     UErrorCode * err)
2730{
  if (err == NULL__null || U_FAILURE(*err))
  {
      return;
  }
  if (len == NULL__null || errChars == NULL__null || converter == NULL__null)
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if (*len < converter->invalidUCharLength)
  {
      *err = U_INDEX_OUTOFBOUNDS_ERROR;
      return;
  }
  if ((*len = converter->invalidUCharLength) > 0)
  {
      u_memcpyu_memcpy_71 (errChars, converter->invalidUCharBuffer, *len);
  }
2749}

2751#define SIG_MAX_LEN5 5

2753U_CAPIextern "C" const char* U_EXPORT2
2754ucnv_detectUnicodeSignatureucnv_detectUnicodeSignature_71( const char* source,
                           int32_t sourceLength,
                           int32_t* signatureLength,
                           UErrorCode* pErrorCode) {
  int32_t dummy;

  /* initial 0xa5 bytes: make sure that if we read <SIG_MAX_LEN
   * bytes we don't misdetect something 
   */
  char start[SIG_MAX_LEN5]={ '\xa5', '\xa5', '\xa5', '\xa5', '\xa5' };
  int i = 0;

  if((pErrorCode==NULL__null) || U_FAILURE(*pErrorCode)){
      return NULL__null;
  }
  
  if(source == NULL__null || sourceLength < -1){
      *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return NULL__null;
  }

  if(signatureLength == NULL__null) {
      signatureLength = &dummy;
  }

  if(sourceLength==-1){
      sourceLength=(int32_t)uprv_strlen(source):: strlen(source);
  }

  
  while(i<sourceLength&& i<SIG_MAX_LEN5){
      start[i]=source[i];
      i++;
  }

  if(start[0] == '\xFE' && start[1] == '\xFF') {
      *signatureLength=2;
      return  "UTF-16BE";
  } else if(start[0] == '\xFF' && start[1] == '\xFE') {
      if(start[2] == '\x00' && start[3] =='\x00') {
          *signatureLength=4;
          return "UTF-32LE";
      } else {
          *signatureLength=2;
          return  "UTF-16LE";
      }
  } else if(start[0] == '\xEF' && start[1] == '\xBB' && start[2] == '\xBF') {
      *signatureLength=3;
      return  "UTF-8";
  } else if(start[0] == '\x00' && start[1] == '\x00' && 
            start[2] == '\xFE' && start[3]=='\xFF') {
      *signatureLength=4;
      return  "UTF-32BE";
  } else if(start[0] == '\x0E' && start[1] == '\xFE' && start[2] == '\xFF') {
      *signatureLength=3;
      return "SCSU";
  } else if(start[0] == '\xFB' && start[1] == '\xEE' && start[2] == '\x28') {
      *signatureLength=3;
      return "BOCU-1";
  } else if(start[0] == '\x2B' && start[1] == '\x2F' && start[2] == '\x76') {
      /*
       * UTF-7: Initial U+FEFF is encoded as +/v8  or  +/v9  or  +/v+  or  +/v/
       * depending on the second UTF-16 code unit.
       * Detect the entire, closed Unicode mode sequence +/v8- for only U+FEFF
       * if it occurs.
       *
       * So far we have +/v
       */
      if(start[3] == '\x38' && start[4] == '\x2D') {
          /* 5 bytes +/v8- */
          *signatureLength=5;
          return "UTF-7";
      } else if(start[3] == '\x38' || start[3] == '\x39' || start[3] == '\x2B' || start[3] == '\x2F') {
          /* 4 bytes +/v8  or  +/v9  or  +/v+  or  +/v/ */
          *signatureLength=4;
          return "UTF-7";
      }
  }else if(start[0]=='\xDD' && start[1]== '\x73'&& start[2]=='\x66' && start[3]=='\x73'){
      *signatureLength=4;
      return "UTF-EBCDIC";
  }


  /* no known Unicode signature byte sequence recognized */
  *signatureLength=0;
  return NULL__null;
2840}

2842U_CAPIextern "C" int32_t U_EXPORT2
2843ucnv_fromUCountPendingucnv_fromUCountPending_71(const UConverter* cnv, UErrorCode* status)
2844{
  if(status == NULL__null || U_FAILURE(*status)){
      return -1;
  }
  if(cnv == NULL__null){
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return -1;
  }

  if(cnv->preFromUFirstCP >= 0){
      return U16_LENGTH(cnv->preFromUFirstCP)((uint32_t)(cnv->preFromUFirstCP)<=0xffff ? 1 : 2)+cnv->preFromULength ;
  }else if(cnv->preFromULength < 0){
      return -cnv->preFromULength ;
  }else if(cnv->fromUChar32 > 0){
      return 1;
  }
  return 0; 

2862}

2864U_CAPIextern "C" int32_t U_EXPORT2
2865ucnv_toUCountPendingucnv_toUCountPending_71(const UConverter* cnv, UErrorCode* status){

  if(status == NULL__null || U_FAILURE(*status)){
      return -1;
  }
  if(cnv == NULL__null){
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return -1;
  }

  if(cnv->preToULength > 0){
      return cnv->preToULength ;
  }else if(cnv->preToULength < 0){
      return -cnv->preToULength;
  }else if(cnv->toULength > 0){
      return cnv->toULength;
  }
  return 0;
2883}

2885U_CAPIextern "C" UBool U_EXPORT2
2886ucnv_isFixedWidthucnv_isFixedWidth_71(UConverter *cnv, UErrorCode *status){
  if (U_FAILURE(*status)) {
      return FALSE0;
  }

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

  switch (ucnv_getTypeucnv_getType_71(cnv)) {
      case UCNV_SBCS:
      case UCNV_DBCS:
      case UCNV_UTF32_BigEndian:
      case UCNV_UTF32_LittleEndian:
      case UCNV_UTF32:
      case UCNV_US_ASCII:
          return TRUE1;
      default:
          return FALSE0;
  }
2907}
2908#endif

2910/*
* Hey, Emacs, please set the following:
*
* Local Variables:
* indent-tabs-mode: nil
* End:
*
*/