/root/firefox-clang/intl/icu/source/common/ucnv.cpp

Bug Summary

File:	root/firefox-clang/intl/icu/source/common/ucnv.cpp
Warning:	line 1080, column 21 Address of stack memory associated with local variable 'replay' is still referred to by the caller 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-pc-linux-gnu -O2 -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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -D _GLIBCXX_ASSERTIONS=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D U_COMMON_IMPLEMENTATION -D _LIBCPP_DISABLE_DEPRECATION_WARNINGS -D U_USING_ICU_NAMESPACE=0 -D U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1 -D U_HIDE_OBSOLETE_UTF_OLD_H=1 -D UCONFIG_NO_LEGACY_CONVERSION -D UCONFIG_NO_TRANSLITERATION -D UCONFIG_NO_REGULAR_EXPRESSIONS -D UCONFIG_NO_BREAK_ITERATION -D UCONFIG_NO_IDNA -D UCONFIG_NO_MF2 -D UCONFIG_NO_NORMALIZATION -D UCONFIG_NO_COLLATION -D U_CHARSET_IS_UTF8 -D UNISTR_FROM_CHAR_EXPLICIT=explicit -D UNISTR_FROM_STRING_EXPLICIT=explicit -D U_ENABLE_DYLOAD=0 -D U_DEBUG=1 -I /root/firefox-clang/config/external/icu/common -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -I /root/firefox-clang/intl/icu/source/i18n -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/x86_64-linux-gnu/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/c++/16/backward -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-character-conversion -Wno-comma -Wno-implicit-const-int-float-conversion -Wno-macro-redefined -Wno-microsoft-include -Wno-tautological-unsigned-enum-zero-compare -Wno-unreachable-code-loop-increment -Wno-unreachable-code-return -std=gnu++20 -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fno-implicit-modules -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c++ /root/firefox-clang/intl/icu/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 char16_t 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_open (const char *name,
                     UErrorCode * err)
75{
  UConverter *r;

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

  r =  ucnv_createConverter(nullptr, name, err);
  return r;
84}

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

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

  if (err == nullptr || U_FAILURE(*err))
      return nullptr;
  if (name == nullptr)
      return ucnv_open (nullptr, err);
  if (u_strlen(name) >= UCNV_MAX_CONVERTER_NAME_LENGTH60)
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  }
  return ucnv_open(u_austrcpy(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_openCCSID (int32_t codepage,
              UConverterPlatform platform,
              UErrorCode * err)
139{
  char myName[UCNV_MAX_CONVERTER_NAME_LENGTH60];
  int32_t myNameLen;

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

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

  return ucnv_createConverter(nullptr, 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_safeClone(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),
          true,
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          nullptr
  };
  UConverterFromUnicodeArgs fromUArgs = {
      sizeof(UConverterFromUnicodeArgs),
          true,
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          nullptr
  };

  UTRACE_ENTRY_OC(UTRACE_UCNV_CLONE);

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

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

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

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

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

  /* 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 == nullptr)
  {
      /* allocate one here...*/
      localConverter = allocatedConverter = (UConverter *) uprv_malloc (bufferSizeNeeded);

      if(localConverter == nullptr) {
          *status = U_MEMORY_ALLOCATION_ERROR;
          UTRACE_EXIT_STATUS(*status);
          return nullptr;
      }
      // If pBufferSize was nullptr 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 = nullptr;
  }

  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"

 (static_cast <bool> (localConverter != __null) ? void
 (0) : __assert_fail ("localConverter != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (
static_cast <bool> (cnv != __null) ? void (0) : __assert_fail
 ("cnv != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); clang diagnostic pop
 :: memcpy(localConverter
, cnv, sizeof(UConverter)); } while (false);
  localConverter->isCopyLocal = localConverter->isExtraLocal = false;

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

 (static_cast <bool> (localConverter->subChars != __null
) ? void (0) : __assert_fail ("localConverter->subChars != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->subChars != __null) ? void
 (0) : __assert_fail ("cnv->subChars != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 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 != nullptr) {
      /* call the custom safeClone function */
      localConverter = cnv->sharedData->impl->safeClone(cnv, localConverter, pBufferSize, status);
  }

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

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

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

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

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

323U_CAPIextern "C" UConverter* U_EXPORT2
324ucnv_clone(const UConverter* cnv, UErrorCode *status)
325{
  return ucnv_safeClone(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_close (UConverter * converter)
334{
  UErrorCode errorCode = U_ZERO_ERROR;

  UTRACE_ENTRY_OC(UTRACE_UCNV_CLOSE);

  if (converter == nullptr)
  {
      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)) {
      UConverterToUnicodeArgs toUArgs = {
          sizeof(UConverterToUnicodeArgs),
              true,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr
      };

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

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

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

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

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

  UTRACE_EXIT();
401}

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

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

425U_CAPIextern "C" void    U_EXPORT2
426ucnv_getSubstChars (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"

 (static_cast <bool> (mySubChar != __null) ? void (0) :
 __assert_fail ("mySubChar != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (converter->subChars != __null) ? void (0) : __assert_fail
 ("converter->subChars != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); 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_setSubstChars (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"

 (static_cast <bool> (converter->subChars != __null
) ? void (0) : __assert_fail ("converter->subChars != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (mySubChar != __null) ? void (0
) : __assert_fail ("mySubChar != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); 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;
476}

478U_CAPIextern "C" void U_EXPORT2
479ucnv_setSubstString(UConverter *cnv,
                  const char16_t *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_safeClone(cnv, cloneBuffer, &cloneSize, err);
  ucnv_setFromUCallBack(clone, UCNV_FROM_U_CALLBACK_STOP, nullptr, nullptr, nullptr, err);
  length8 = ucnv_fromUChars(clone, chars, (int32_t)sizeof(chars), s, length, err);
  ucnv_close(clone);
  if (U_FAILURE(*err)) {
      return;
  }

  if (cnv->sharedData->impl->writeSub == nullptr
501#if !UCONFIG_NO_LEGACY_CONVERSION1
      || (cnv->sharedData->staticData->conversionType == UCNV_MBCS &&
       ucnv_MBCSGetType(cnv) != UCNV_EBCDIC_STATEFUL)
504#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 char16_t, which means that ucnv_fromUChars() should catch all
           * overflows.
           */
          *err = U_BUFFER_OVERFLOW_ERROR;
          return;
      }
      subChars = (uint8_t *)s;
      if (length < 0) {
          length = u_strlen(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_malloc(UCNV_ERROR_BUFFER_LENGTH32 * U_SIZEOF_UCHAR2);
          if (cnv->subChars == nullptr) {
              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"

 (static_cast <bool> (cnv->subChars != __null) ? void
 (0) : __assert_fail ("cnv->subChars != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (
static_cast <bool> (subChars != __null) ? void (0) : __assert_fail
 ("subChars != __null", __builtin_FILE (), __builtin_LINE (),
 __extension__ __PRETTY_FUNCTION__)); 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;
563}

565/*resets the internal states of a converter
*goal : have the same behaviour than a freshly created converter
*/
568static void _reset(UConverter *converter, UConverterResetChoice choice,
                 UBool callCallback) {
  if(converter == nullptr) {
      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)) {
          UConverterToUnicodeArgs toUArgs = {
              sizeof(UConverterToUnicodeArgs),
              true,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr
          };
          toUArgs.converter = converter;
          errorCode = U_ZERO_ERROR;
          converter->fromCharErrorBehaviour(converter->toUContext, &toUArgs, nullptr, 0, UCNV_RESET, &errorCode);
      }
      if(choice!=UCNV_RESET_TO_UNICODE && converter->fromUCharErrorBehaviour != UCNV_FROM_U_DEFAULT_CALLBACK((UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE)) {
          UConverterFromUnicodeArgs fromUArgs = {
              sizeof(UConverterFromUnicodeArgs),
              true,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr,
              nullptr
          };
          fromUArgs.converter = converter;
          errorCode = U_ZERO_ERROR;
          converter->fromUCharErrorBehaviour(converter->fromUContext, &fromUArgs, nullptr, 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 != nullptr) {
      /* call the custom reset function */
      converter->sharedData->impl->reset(converter, choice);
  }
630}

632U_CAPIextern "C" void  U_EXPORT2
633ucnv_reset(UConverter *converter)
634{
  _reset(converter, UCNV_RESET_BOTH, true);
636}

638U_CAPIextern "C" void  U_EXPORT2
639ucnv_resetToUnicode(UConverter *converter)
640{
  _reset(converter, UCNV_RESET_TO_UNICODE, true);
642}

644U_CAPIextern "C" void  U_EXPORT2
645ucnv_resetFromUnicode(UConverter *converter)
646{
  _reset(converter, UCNV_RESET_FROM_UNICODE, true);
648}

650U_CAPIextern "C" int8_t   U_EXPORT2
651ucnv_getMaxCharSize (const UConverter * converter)
652{
  return converter->maxBytesPerUChar;
654}


657U_CAPIextern "C" int8_t   U_EXPORT2
658ucnv_getMinCharSize (const UConverter * converter)
659{
  return converter->sharedData->staticData->minBytesPerChar;
661}

663U_CAPIextern "C" const char*   U_EXPORT2
664ucnv_getName (const UConverter * converter, UErrorCode * err)
   
666{
  if (U_FAILURE (*err))
      return nullptr;
  if(converter->sharedData->impl->getName){
      const char* temp= converter->sharedData->impl->getName(converter);
      if(temp)
          return temp;
  }
  return converter->sharedData->staticData->name;
675}

677U_CAPIextern "C" int32_t U_EXPORT2
678ucnv_getCCSID(const UConverter * converter,
            UErrorCode * err)
680{
  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_getStandardName(ucnv_getName(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;
698}


701U_CAPIextern "C" UConverterPlatform   U_EXPORT2
702ucnv_getPlatform (const UConverter * converter,
                                    UErrorCode * err)
704{
  if (U_FAILURE (*err))
      return UCNV_UNKNOWN;

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

711U_CAPIextern "C" void U_EXPORT2
  ucnv_getToUCallBack (const UConverter * converter,
                       UConverterToUCallback *action,
                       const void **context)
715{
  *action = converter->fromCharErrorBehaviour;
  *context = converter->toUContext;
718}

720U_CAPIextern "C" void U_EXPORT2
  ucnv_getFromUCallBack (const UConverter * converter,
                         UConverterFromUCallback *action,
                         const void **context)
724{
  *action = converter->fromUCharErrorBehaviour;
  *context = converter->fromUContext;
727}

729U_CAPIextern "C" void    U_EXPORT2
730ucnv_setToUCallBack (UConverter * converter,
                          UConverterToUCallback newAction,
                          const void* newContext,
                          UConverterToUCallback *oldAction,
                          const void** oldContext,
                          UErrorCode * err)
736{
  if (U_FAILURE (*err))
      return;
  if (oldAction) *oldAction = converter->fromCharErrorBehaviour;
  converter->fromCharErrorBehaviour = newAction;
  if (oldContext) *oldContext = converter->toUContext;
  converter->toUContext = newContext;
743}

745U_CAPIextern "C" void  U_EXPORT2
746ucnv_setFromUCallBack (UConverter * converter,
                          UConverterFromUCallback newAction,
                          const void* newContext,
                          UConverterFromUCallback *oldAction,
                          const void** oldContext,
                          UErrorCode * err)
752{
  if (U_FAILURE (*err))
      return;
  if (oldAction) *oldAction = converter->fromUCharErrorBehaviour;
  converter->fromUCharErrorBehaviour = newAction;
  if (oldContext) *oldContext = converter->fromUContext;
  converter->fromUContext = newContext;
759}

761static void
762_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;
      }
  }
804}

806/* ucnv_fromUnicode --------------------------------------------------------- */

808/*
* 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.
*/

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

  /* variables for m:n conversion */
  char16_t replay[UCNV_EXT_MAX_UCHARS19];
  const char16_t *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==nullptr) {
30
←
Taking true branch→
      fromUnicode=cnv->sharedData->impl->fromUnicode;
  } else {
      fromUnicode=cnv->sharedData->impl->fromUnicodeWithOffsets;
      if(fromUnicode==nullptr) {
          /* there is no WithOffsets implementation */
          fromUnicode=cnv->sharedData->impl->fromUnicode;
          /* we will write -1 for each offset */
          sourceIndex=-1;
      }
  }

  if(cnv->preFromULength>=0) {
31
←
Assuming field 'preFromULength' is >= 0→
32
←
Taking true branch→
      /* normal mode */
      realSource=nullptr;

      /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
      realSourceLimit=nullptr;
      realFlush=false;
      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"

 (static_cast <bool> (replay != __null) ? void (0) : __assert_fail
 ("replay != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (cnv->preFromU
 != __null) ? void (0) : __assert_fail ("cnv->preFromU != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(replay, cnv->preFromU,
 -cnv->preFromULength*2); } while (false);
      pArgs->source=replay;
      pArgs->sourceLimit=replay-cnv->preFromULength;
      pArgs->flush=false;
      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(;;) {
33
←
Loop condition is true.  Entering loop body→
      if(U_SUCCESS(*err)) {
34
←
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=
              static_cast<UBool>(U_SUCCESS(*err) &&
                      pArgs->flush && pArgs->source==pArgs->sourceLimit &&
                      cnv->fromUChar32==0);
      } else {
          /* handle error from ucnv_convertEx() */
          converterSawEndOfInput=false;
      }

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

      /* 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(offsets!=nullptr) {
36
←
Taking false branch→
              int32_t length = static_cast<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 += static_cast<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(realSource==nullptr) {
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"

 (static_cast <bool> (replay != __null) ? void (0) : __assert_fail
 ("replay != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (cnv->preFromU
 != __null) ? void (0) : __assert_fail ("cnv->preFromU != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(replay, cnv->preFromU,
 -cnv->preFromULength*2); } while (false);
40
←
'?' condition is true→
41
←
'?' condition is true→
42
←
Loop condition is false.  Exiting loop→
                  pArgs->source=replay;
                  pArgs->sourceLimit=replay-cnv->preFromULength;
                  pArgs->flush=false;
                  if((sourceIndex+=cnv->preFromULength)<0) {
43
←
Taking true branch→
                      sourceIndex=-1;
                  }

                  cnv->preFromULength=0;
              } else {
                  /* see implementation note before _fromUnicodeWithCallback() */
                  U_ASSERT(realSource==nullptr)(static_cast <bool> (realSource==nullptr) ? void (0) : __assert_fail
 ("realSource==nullptr", __builtin_FILE (), __builtin_LINE ()
, __extension__ __PRETTY_FUNCTION__));
                  *err=U_INTERNAL_PROGRAM_ERROR;
              }
          }

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

          if(U_SUCCESS(*err)) {
44
←
Taking false branch→
              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!=nullptr) {
                  /* switch back from replaying to the real source and continue */
                  pArgs->source=realSource;
                  pArgs->sourceLimit=realSourceLimit;
                  pArgs->flush=realFlush;
                  sourceIndex=realSourceIndex;

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

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

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

                  /* done successfully */
                  return;
              }
          }

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

              if( calledCallback44.1
'calledCallback' is 0
 ||
                  (e=*err)==U_BUFFER_OVERFLOW_ERROR ||
45
←
Assuming the condition is true→
                  (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!=nullptr) {
46
←
Assuming the condition is false→
47
←
Taking false branch→
                      int32_t length;

                      U_ASSERT(cnv->preFromULength==0)(static_cast <bool> (cnv->preFromULength==0) ? void (
0) : __assert_fail ("cnv->preFromULength==0", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

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

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

                  return;
48
←
Address of stack memory associated with local variable 'replay' is still referred to by the caller variable 'fromUArgs' upon returning to the caller.  This will be a dangling reference
              }
          }

          /* 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 = static_cast<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=true;
      }
  }
1114}

1116/*
* Output the fromUnicode overflow buffer.
* Call this function if(cnv->charErrorBufferLength>0).
* @return true if overflow
*/
1121static UBool
1122ucnv_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!=nullptr) {
      offsets=*pOffsets;
  } else {
      offsets=nullptr;
  }

  overflow = reinterpret_cast<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 = static_cast<int8_t>(j);
          *target=t;
          if(offsets!=nullptr) {
              *pOffsets=offsets;
          }
          *err=U_BUFFER_OVERFLOW_ERROR;
          return true;
      }

      /* copy the overflow contents to the target */
      *t++=overflow[i++];
      if(offsets!=nullptr) {
          *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!=nullptr) {
      *pOffsets=offsets;
  }
  return false;
1172}

1174U_CAPIextern "C" void U_EXPORT2
1175ucnv_fromUnicode(UConverter *cnv,
               char **target, const char *targetLimit,
               const char16_t **source, const char16_t *sourceLimit,
               int32_t *offsets,
               UBool flush,
               UErrorCode *err) {
  UConverterFromUnicodeArgs args;
  const char16_t *s;
  char *t;

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

  if(cnv==nullptr || target==nullptr || source==nullptr) {
      *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 char16_t * boundary.
      This also prevents the next argument check from failing.
      */
      sourceLimit = (const char16_t *)(((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 char16_t * pointer
   * to a char * pointer and provide an incomplete char16_t 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;
1271}

1273/* ucnv_toUnicode() --------------------------------------------------------- */

1275static void
1276_toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
  UConverterToUnicode toUnicode;
  UConverter *cnv;
  const char *s;
  char16_t *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==nullptr) {
      toUnicode=cnv->sharedData->impl->toUnicode;
  } else {
      toUnicode=cnv->sharedData->impl->toUnicodeWithOffsets;
      if(toUnicode==nullptr) {
          /* 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=nullptr;

      /* avoid compiler warnings - not otherwise necessary, and the values do not matter */
      realSourceLimit=nullptr;
      realFlush=false;
      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"

 (static_cast <bool> (replay != __null) ? void (0) : __assert_fail
 ("replay != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (cnv->preToU
 != __null) ? void (0) : __assert_fail ("cnv->preToU != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(replay, cnv->preToU, -
cnv->preToULength); } while (false);
      pArgs->source=replay;
      pArgs->sourceLimit=replay-cnv->preToULength;
      pArgs->flush=false;
      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=
              static_cast<UBool>(U_SUCCESS(*err) &&
                      pArgs->flush && pArgs->source==pArgs->sourceLimit &&
                      cnv->toULength==0);
      } else {
          /* handle error from getNextUChar() or ucnv_convertEx() */
          converterSawEndOfInput=false;
      }

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

      /* 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!=nullptr) {
              int32_t length = static_cast<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 += static_cast<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==nullptr) {
                  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"

 (static_cast <bool> (replay != __null) ? void (0) : __assert_fail
 ("replay != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (cnv->preToU
 != __null) ? void (0) : __assert_fail ("cnv->preToU != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(replay, cnv->preToU, -
cnv->preToULength); } while (false);
                  pArgs->source=replay;
                  pArgs->sourceLimit=replay-cnv->preToULength;
                  pArgs->flush=false;
                  if((sourceIndex+=cnv->preToULength)<0) {
                      sourceIndex=-1;
                  }

                  cnv->preToULength=0;
              } else {
                  /* see implementation note before _fromUnicodeWithCallback() */
                  U_ASSERT(realSource==nullptr)(static_cast <bool> (realSource==nullptr) ? void (0) : __assert_fail
 ("realSource==nullptr", __builtin_FILE (), __builtin_LINE ()
, __extension__ __PRETTY_FUNCTION__));
                  *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!=nullptr) {
                  /* switch back from replaying to the real source and continue */
                  pArgs->source=realSource;
                  pArgs->sourceLimit=realSourceLimit;
                  pArgs->flush=realFlush;
                  sourceIndex=realSourceIndex;

                  realSource=nullptr;
                  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=false; /* 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, false);
                  }

                  /* 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!=nullptr) {
                      int32_t length;

                      U_ASSERT(cnv->preToULength==0)(static_cast <bool> (cnv->preToULength==0) ? void (0
) : __assert_fail ("cnv->preToULength==0", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

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

 (static_cast <bool> (cnv->preToU != __null) ? void
 (0) : __assert_fail ("cnv->preToU != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (
static_cast <bool> (pArgs->source != __null) ? void (
0) : __assert_fail ("pArgs->source != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(cnv->preToU, pArgs->source, length
); } while (false);
                          cnv->preToULength = static_cast<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"

 (static_cast <bool> (cnv->invalidCharBuffer != __null
) ? void (0) : __assert_fail ("cnv->invalidCharBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->toUBytes != __null) ? void
 (0) : __assert_fail ("cnv->toUBytes != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 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=true;
      }
  }
1560}

1562/*
* Output the toUnicode overflow buffer.
* Call this function if(cnv->UCharErrorBufferLength>0).
* @return true if overflow
*/
1567static UBool
1568ucnv_outputOverflowToUnicode(UConverter *cnv,
                           char16_t **target, const char16_t *targetLimit,
                           int32_t **pOffsets,
                           UErrorCode *err) {
  int32_t *offsets;
  char16_t *overflow, *t;
  int32_t i, length;

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

  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 = static_cast<int8_t>(j);
          *target=t;
          if(offsets!=nullptr) {
              *pOffsets=offsets;
          }
          *err=U_BUFFER_OVERFLOW_ERROR;
          return true;
      }

      /* copy the overflow contents to the target */
      *t++=overflow[i++];
      if(offsets!=nullptr) {
          *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!=nullptr) {
      *pOffsets=offsets;
  }
  return false;
1618}

1620U_CAPIextern "C" void U_EXPORT2
1621ucnv_toUnicode(UConverter *cnv,
             char16_t **target, const char16_t *targetLimit,
             const char **source, const char *sourceLimit,
             int32_t *offsets,
             UBool flush,
             UErrorCode *err) {
  UConverterToUnicodeArgs args;
  const char *s;
  char16_t *t;

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

  if(cnv==nullptr || target==nullptr || source==nullptr) {
      *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 char16_t * boundary.
      This also prevents the next argument check from failing.
      */
      targetLimit = (const char16_t *)(((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 char16_t * pointer
   * to a char * pointer and provide an incomplete char16_t 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;
1717}

1719/* ucnv_to/fromUChars() ----------------------------------------------------- */

1721U_CAPIextern "C" int32_t U_EXPORT2
1722ucnv_fromUChars(UConverter *cnv,
              char *dest, int32_t destCapacity,
              const char16_t *src, int32_t srcLength,
              UErrorCode *pErrorCode) {
  const char16_t *srcLimit;
  char *originalDest, *destLimit;
  int32_t destLength;

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

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

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

      /* perform the conversion */
      UErrorCode bufferStatus = U_ZERO_ERROR;
      ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, nullptr, true, &bufferStatus);
      destLength=(int32_t)(dest-originalDest);

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

          destLimit=buffer+sizeof(buffer);
          do {
              dest=buffer;
              bufferStatus=U_ZERO_ERROR;
              ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, nullptr, true, &bufferStatus);
              destLength+=(int32_t)(dest-buffer);
          } while(bufferStatus==U_BUFFER_OVERFLOW_ERROR);
      }
      if (U_FAILURE(bufferStatus)) {
          *pErrorCode = bufferStatus;
      }
  } else {
      destLength=0;
  }

  return u_terminateChars(originalDest, destCapacity, destLength, pErrorCode);
1779}

1781U_CAPIextern "C" int32_t U_EXPORT2
1782ucnv_toUChars(UConverter *cnv,
            char16_t *dest, int32_t destCapacity,
            const char *src, int32_t srcLength,
            UErrorCode *pErrorCode) {
  const char *srcLimit;
  char16_t *originalDest, *destLimit;
  int32_t destLength;

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

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

  /* initialize */
  ucnv_resetToUnicode(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 */
      UErrorCode bufferStatus = U_ZERO_ERROR;
      ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, nullptr, true, &bufferStatus);
      destLength=(int32_t)(dest-originalDest);

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

          destLimit=buffer+UPRV_LENGTHOF(buffer)(int32_t)(sizeof(buffer)/sizeof((buffer)[0]));
          do {
              dest=buffer;
              bufferStatus=U_ZERO_ERROR;
              ucnv_toUnicode(cnv, &dest, destLimit, &src, srcLimit, nullptr, true, &bufferStatus);
              destLength+=(int32_t)(dest-buffer);
          }
          while(bufferStatus==U_BUFFER_OVERFLOW_ERROR);
      }
      if (U_FAILURE(bufferStatus)) {
          *pErrorCode = bufferStatus;
      }
  } else {
      destLength=0;
  }

  return u_terminateUChars(originalDest, destCapacity, destLength, pErrorCode);
1841}

1843/* ucnv_getNextUChar() ------------------------------------------------------ */

1845U_CAPIextern "C" UChar32 U_EXPORT2
1846ucnv_getNextUChar(UConverter *cnv,
                const char **source, const char *sourceLimit,
                UErrorCode *err) {
  UConverterToUnicodeArgs args;
  char16_t buffer[U16_MAX_LENGTH2];
  const char *s;
  UChar32 c;
  int32_t i, length;

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

  if(cnv==nullptr || source==nullptr) {
      *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) {
      char16_t *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"

 (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer+i != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+i != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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"

 (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer+i != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+i != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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=true;
  args.offsets=nullptr;
  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!=nullptr) {
          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, false);
              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 char16_t 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]=(char16_t)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 */
          char16_t 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"

 (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer+1 != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+1 != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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"

 (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer+1 != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+1 != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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"

 (static_cast <bool> (cnv->UCharErrorBuffer+delta !=
 __null) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+delta != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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"

 (static_cast <bool> (cnv->UCharErrorBuffer+delta !=
 __null) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer+delta != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (cnv->UCharErrorBuffer != __null
) ? void (0) : __assert_fail ("cnv->UCharErrorBuffer != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 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;
2046}

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

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

  UConverterToUnicodeArgs toUArgs;
  UConverterFromUnicodeArgs fromUArgs;
  UConverterConvert convert;

  /* error checking */
  if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) {
1
Assuming the condition is false→
      return;
  }

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

  s=*source;
  t=*target;
  if((sourceLimit!=nullptr && sourceLimit<s) || targetLimit<t) {
10
←
Assuming the condition is false→
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(
      (sourceLimit!=nullptr && ((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s)) ||
12
←
Taking false branch→
      ((size_t)(targetLimit-t)>(size_t)0x7fffffff && targetLimit>t)
13
←
Assuming the condition is false→
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  
  if(pivotStart==nullptr) {
14
←
Assuming the condition is false→
      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=(char16_t **)&myPivotSource;
      pivotTarget=&myPivotTarget;
      pivotLimit=pivotBuffer+CHUNK_SIZE1024;
  } else if(  pivotStart>=pivotLimit ||
15
←
Assuming 'pivotStart' is < 'pivotLimit'→
21
←
Taking false branch→
              pivotSource==nullptr || *pivotSource==nullptr ||
16
←
Assuming the condition is false→
17
←
Assuming the condition is false→
              pivotTarget==nullptr || *pivotTarget==nullptr ||
18
←
Assuming the condition is false→
19
←
Assuming the condition is false→
              pivotLimit==nullptr
20
←
Assuming the condition is false→
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  if(sourceLimit==nullptr) {
22
←
Taking true branch→
      /* get limit of single-byte-NUL-terminated source string */
      sourceLimit=uprv_strchr(*source, 0):: strchr(*source, 0);
  }

  if(reset) {
23
←
Assuming 'reset' is 0→
24
←
Taking false branch→
      ucnv_resetToUnicode(sourceCnv);
      ucnv_resetFromUnicode(targetCnv);
      *pivotSource=*pivotTarget=pivotStart;
  } else if(targetCnv->charErrorBufferLength>0) {
25
←
Assuming field 'charErrorBufferLength' is <= 0→
      /* output the targetCnv overflow buffer */
      if(ucnv_outputOverflowFromUnicode(targetCnv, target, targetLimit, nullptr, 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 &&
26
←
Assuming field 'conversionType' is not equal to UCNV_UTF8→
      targetCnv->sharedData->impl->fromUTF8!=nullptr
  ) {
      convert=targetCnv->sharedData->impl->fromUTF8;
  } else if( targetCnv->sharedData->staticData->conversionType==UCNV_UTF8 &&
27
←
Assuming field 'conversionType' is not equal to UCNV_UTF8→
             sourceCnv->sharedData->impl->toUTF8!=nullptr
  ) {
      convert=sourceCnv->sharedData->impl->toUTF8;
  } else {
      convert=nullptr;
  }

  /*
   * 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(convert!=nullptr && (pivotLimit-pivotStart)>32) {
      pivotLimit=pivotStart+32;
  }

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

  toUArgs.converter=sourceCnv;
  toUArgs.flush=flush;
  toUArgs.offsets=nullptr;
  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=nullptr;

  /*
   * 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 ||
28
←
Assuming the condition is true→
          U_FAILURE(*pErrorCode) ||
          targetCnv->preFromULength<0 ||
          fromUArgs.flush
      ) {
          fromUArgs.source=*pivotSource;
          fromUArgs.sourceLimit=*pivotTarget;
          _fromUnicodeWithCallback(&fromUArgs, pErrorCode);
29
←
Calling '_fromUnicodeWithCallback'→
          if(U_FAILURE(*pErrorCode)) {
              /* target overflow, or conversion error */
              *pivotSource=(char16_t *)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, nullptr, 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!=nullptr && 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, false);
                  _reset(targetCnv, UCNV_RESET_FROM_UNICODE, false);
              }

              /* 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=true;
      }
  }

  /*
   * 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;
      }
  }
2406}

2408/* internal implementation of ucnv_convert() etc. with preflighting */
2409static int32_t
2410ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter,
                   char *target, int32_t targetCapacity,
                   const char *source, int32_t sourceLength,
                   UErrorCode *pErrorCode) {
  char16_t pivotBuffer[CHUNK_SIZE1024];
  char16_t *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_terminateChars(target, targetCapacity, 0, pErrorCode);
  }

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

  if(targetCapacity>0) {
      /* perform real conversion */
      targetLimit=target+targetCapacity;
      ucnv_convertEx(outConverter, inConverter,
                     &myTarget, targetLimit,
                     &source, sourceLimit,
                     pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024,
                     false,
                     true,
                     pErrorCode);
      targetLength = static_cast<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_convertEx(outConverter, inConverter,
                         &myTarget, targetLimit,
                         &source, sourceLimit,
                         pivotBuffer, &pivot, &pivot2, pivotBuffer+CHUNK_SIZE1024,
                         false,
                         true,
                         pErrorCode);
          targetLength += static_cast<int32_t>(myTarget - targetBuffer);
      } while(*pErrorCode==U_BUFFER_OVERFLOW_ERROR);

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

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

2482U_CAPIextern "C" int32_t U_EXPORT2
2483ucnv_convert(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==nullptr || U_FAILURE(*pErrorCode)) {
      return 0;
  }

  if( source==nullptr || sourceLength<-1 ||
      targetCapacity<0 || (targetCapacity>0 && target==nullptr)
  ) {
      *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_terminateChars(target, targetCapacity, 0, pErrorCode);
  }

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

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

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

  ucnv_close(inConverter);
  ucnv_close(outConverter);

  return targetLength;
2528}

2530/* @internal */
2531static int32_t
2532ucnv_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==nullptr || U_FAILURE(*pErrorCode)) {
      return 0;
  }

  if( cnv==nullptr || source==nullptr || sourceLength<-1 ||
      targetCapacity<0 || (targetCapacity>0 && target==nullptr)
  ) {
      *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_terminateChars(target, targetCapacity, 0, pErrorCode);
  }

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

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

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

  ucnv_close(algoConverter);

  return targetLength;
2586}

2588U_CAPIextern "C" int32_t U_EXPORT2
2589ucnv_toAlgorithmic(UConverterType algorithmicType,
                 UConverter *cnv,
                 char *target, int32_t targetCapacity,
                 const char *source, int32_t sourceLength,
                 UErrorCode *pErrorCode) {
  return ucnv_convertAlgorithmic(true, algorithmicType, cnv,
                                 target, targetCapacity,
                                 source, sourceLength,
                                 pErrorCode);
2598}

2600U_CAPIextern "C" int32_t U_EXPORT2
2601ucnv_fromAlgorithmic(UConverter *cnv,
                   UConverterType algorithmicType,
                   char *target, int32_t targetCapacity,
                   const char *source, int32_t sourceLength,
                   UErrorCode *pErrorCode) UPRV_NO_SANITIZE_UNDEFINED__attribute__((no_sanitize("undefined"))) {

  if(algorithmicType<0 || UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES<=algorithmicType) {
      *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  return ucnv_convertAlgorithmic(false, algorithmicType, cnv,
                                 target, targetCapacity,
                                 source, sourceLength,
                                 pErrorCode);
2615}

2617U_CAPIextern "C" UConverterType  U_EXPORT2
2618ucnv_getType(const UConverter* converter)
2619{
  int8_t type = converter->sharedData->staticData->conversionType;
2621#if !UCONFIG_NO_LEGACY_CONVERSION1
  if(type == UCNV_MBCS) {
      return ucnv_MBCSGetType(converter);
  }
2625#endif
  return (UConverterType)type;
2627}

2629U_CAPIextern "C" void  U_EXPORT2
2630ucnv_getStarters(const UConverter* converter, 
               UBool starters[256],
               UErrorCode* err)
2633{
  if (err == nullptr || U_FAILURE(*err)) {
      return;
  }

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

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

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

  errorCode=U_ZERO_ERROR;
  name=ucnv_getName(cnv, &errorCode);
  if(U_FAILURE(errorCode)) {
      return nullptr;
  }

  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 nullptr;
2670}

2672U_CAPIextern "C" void  U_EXPORT2
2673ucnv_fixFileSeparator(const UConverter *cnv, 
                    char16_t* source,
                    int32_t sourceLength) {
  const UAmbiguousConverter *a;
  int32_t i;
  char16_t variant5c;

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

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

2693U_CAPIextern "C" UBool  U_EXPORT2
2694ucnv_isAmbiguous(const UConverter *cnv) {
  return ucnv_getAmbiguous(cnv)!=nullptr;
2696}

2698U_CAPIextern "C" void  U_EXPORT2
2699ucnv_setFallback(UConverter *cnv, UBool usesFallback)
2700{
  cnv->useFallback = usesFallback;
2702}

2704U_CAPIextern "C" UBool  U_EXPORT2
2705ucnv_usesFallback(const UConverter *cnv)
2706{
  return cnv->useFallback;
2708}

2710U_CAPIextern "C" void  U_EXPORT2
2711ucnv_getInvalidChars (const UConverter * converter,
                    char *errBytes,
                    int8_t * len,
                    UErrorCode * err)
2715{
  if (err == nullptr || U_FAILURE(*err))
  {
      return;
  }
  if (len == nullptr || errBytes == nullptr || converter == nullptr)
  {
      *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"

 (static_cast <bool> (errBytes != __null) ? void (0) :
 __assert_fail ("errBytes != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (converter->invalidCharBuffer != __null) ? void (0) :
 __assert_fail ("converter->invalidCharBuffer != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(errBytes, converter->invalidCharBuffer
, *len); } while (false);
  }
2734}

2736U_CAPIextern "C" void  U_EXPORT2
2737ucnv_getInvalidUChars (const UConverter * converter,
                     char16_t *errChars,
                     int8_t * len,
                     UErrorCode * err)
2741{
  if (err == nullptr || U_FAILURE(*err))
  {
      return;
  }
  if (len == nullptr || errChars == nullptr || converter == nullptr)
  {
      *err = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if (*len < converter->invalidUCharLength)
  {
      *err = U_INDEX_OUTOFBOUNDS_ERROR;
      return;
  }
  if ((*len = converter->invalidUCharLength) > 0)
  {
      u_memcpy (errChars, converter->invalidUCharBuffer, *len);
  }
2760}

2762#define SIG_MAX_LEN5 5

2764U_CAPIextern "C" const char* U_EXPORT2
2765ucnv_detectUnicodeSignature( 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==nullptr) || U_FAILURE(*pErrorCode)){
      return nullptr;
  }
  
  if(source == nullptr || sourceLength < -1){
      *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
      return nullptr;
  }

  if(signatureLength == nullptr) {
      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 nullptr;
2851}

2853U_CAPIextern "C" int32_t U_EXPORT2
2854ucnv_fromUCountPending(const UConverter* cnv, UErrorCode* status)
2855{
  if(status == nullptr || U_FAILURE(*status)){
      return -1;
  }
  if(cnv == nullptr){
      *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; 

2873}

2875U_CAPIextern "C" int32_t U_EXPORT2
2876ucnv_toUCountPending(const UConverter* cnv, UErrorCode* status){

  if(status == nullptr || U_FAILURE(*status)){
      return -1;
  }
  if(cnv == nullptr){
      *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;
2894}

2896U_CAPIextern "C" UBool U_EXPORT2
2897ucnv_isFixedWidth(UConverter *cnv, UErrorCode *status){
  if (U_FAILURE(*status)) {
      return false;
  }

  if (cnv == nullptr) {
      *status = U_ILLEGAL_ARGUMENT_ERROR;
      return false;
  }

  switch (ucnv_getType(cnv)) {
      case UCNV_SBCS:
      case UCNV_DBCS:
      case UCNV_UTF32_BigEndian:
      case UCNV_UTF32_LittleEndian:
      case UCNV_UTF32:
      case UCNV_US_ASCII:
          return true;
      default:
          return false;
  }
2918}
2919#endif

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