/root/firefox-clang/intl/icu/source/common/cmemory.h

Bug Summary

File:	root/firefox-clang/intl/icu/source/common/cmemory.h
Warning:	line 480, column 9 The first element of the 2nd argument is undefined
Note:	line 480, column 9 Other elements might also be undefined

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 measunit_extra.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/i18n -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/i18n -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_I18N_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/i18n -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/i18n -I /root/firefox-clang/intl/icu/source/common -I /root/firefox-clang/mfbt/double-conversion -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/i18n/measunit_extra.cpp

/root/firefox-clang/intl/icu/source/common/cmemory.h

→

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) 1997-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9******************************************************************************
10*
11* File CMEMORY.H
12*
13*  Contains stdlib.h/string.h memory functions
14*
15* @author       Bertrand A. Damiba
16*
17* Modification History:
18*
19*   Date        Name        Description
20*   6/20/98     Bertrand    Created.
21*  05/03/99     stephen     Changed from functions to macros.
22*
23******************************************************************************
24*/

26#ifndef CMEMORY_H
27#define CMEMORY_H

29#include "unicode/utypes.h"

31#include <stddef.h>
32#include <string.h>
33#include "unicode/localpointer.h"
34#include "uassert.h"

36#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
37#include <stdio.h>
38#endif

40// uprv_memcpy and uprv_memmove
41#if defined(__clang__1)
42#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
50} UPRV_BLOCK_MACRO_ENDwhile (false)
51#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
59} UPRV_BLOCK_MACRO_ENDwhile (false)
60#elif defined(__GNUC__4)
61#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
69} UPRV_BLOCK_MACRO_ENDwhile (false)
70#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
78} UPRV_BLOCK_MACRO_ENDwhile (false)
79#else
80#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
84} UPRV_BLOCK_MACRO_ENDwhile (false)
85#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
89} UPRV_BLOCK_MACRO_ENDwhile (false)
90#endif

92/**
* \def UPRV_LENGTHOF
* Convenience macro to determine the length of a fixed array at compile-time.
* @param array A fixed length array
* @return The length of the array, in elements
* @internal
*/
99#define UPRV_LENGTHOF(array)(int32_t)(sizeof(array)/sizeof((array)[0])) (int32_t)(sizeof(array)/sizeof((array)[0]))
100#define uprv_memset(buffer, mark, size):: memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE:: memset(buffer, mark, size)
101#define uprv_memcmp(buffer1, buffer2, size):: memcmp(buffer1, buffer2,size) U_STANDARD_CPP_NAMESPACE:: memcmp(buffer1, buffer2,size)
102#define uprv_memchr(ptr, value, num):: memchr(ptr, value, num) U_STANDARD_CPP_NAMESPACE:: memchr(ptr, value, num)

104U_CAPIextern "C" void * U_EXPORT2
105uprv_malloc(size_t s) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR(1)__attribute__ ((alloc_size(1)));

107U_CAPIextern "C" void * U_EXPORT2
108uprv_realloc(void *mem, size_t size) U_ALLOC_SIZE_ATTR(2)__attribute__ ((alloc_size(2)));

110U_CAPIextern "C" void U_EXPORT2
111uprv_free(void *mem);

113U_CAPIextern "C" void * U_EXPORT2
114uprv_calloc(size_t num, size_t size) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR2(1,2)__attribute__ ((alloc_size(1,2)));

116/**
* Get the least significant bits of a pointer (a memory address).
* For example, with a mask of 3, the macro gets the 2 least significant bits,
* which will be 0 if the pointer is 32-bit (4-byte) aligned.
*
* uintptr_t is the most appropriate integer type to cast to.
*/
123#define U_POINTER_MASK_LSB(ptr, mask)((uintptr_t)(ptr) & (mask)) ((uintptr_t)(ptr) & (mask))

125/**
* Create & return an instance of "type" in statically allocated storage.
* e.g.
*    static std::mutex *myMutex = STATIC_NEW(std::mutex);
* To destroy an object created in this way, invoke the destructor explicitly, e.g.
*    myMutex->~mutex();
* DO NOT use delete.
* DO NOT use with class UMutex, which has specific support for static instances.
*
* STATIC_NEW is intended for use when
*   - We want a static (or global) object.
*   - We don't want it to ever be destructed, or to explicitly control destruction,
*     to avoid use-after-destruction problems.
*   - We want to avoid an ordinary heap allocated object,
*     to avoid the possibility of memory allocation failures, and
*     to avoid memory leak reports, from valgrind, for example.
* This is defined as a macro rather than a template function because each invocation
* must define distinct static storage for the object being returned.
*/
144#define STATIC_NEW(type)[] () { alignas(type) static char storage[sizeof(type)]; return
 new(storage) type();} () [] () { \
  alignas(type) static char storage[sizeof(type)]; \
  return new(storage) type();} ()

148/**
*  Heap clean up function, called from u_cleanup()
*    Clears any user heap functions from u_setMemoryFunctions()
*    Does NOT deallocate any remaining allocated memory.
*/
153U_CFUNCextern "C" UBool 
154cmemory_cleanup(void);

156/**
* A function called by <TT>uhash_remove</TT>,
* <TT>uhash_close</TT>, or <TT>uhash_put</TT> to delete
* an existing key or value.
* @param obj A key or value stored in a hashtable
* @see uprv_deleteUObject
*/
163typedef void U_CALLCONV UObjectDeleter(void* obj);

165/**
* Deleter for UObject instances.
* Works for all subclasses of UObject because it has a virtual destructor.
*/
169U_CAPIextern "C" void U_EXPORT2
170uprv_deleteUObject(void *obj);

172#ifdef __cplusplus202002L

174#include <utility>
175#include "unicode/uobject.h"

177U_NAMESPACE_BEGINnamespace icu_78 {

179/**
* "Smart pointer" class, deletes memory via uprv_free().
* For most methods see the LocalPointerBase base class.
* Adds operator[] for array item access.
*
* @see LocalPointerBase
*/
186template<typename T>
187class LocalMemory : public LocalPointerBase<T> {
188public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an array of T items that is adopted
   */
  explicit LocalMemory(T *p=nullptr) : LocalPointerBase<T>(p) {}
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   */
  LocalMemory(LocalMemory<T> &&src) noexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=nullptr;
  }
  /**
   * Destructor deletes the memory it owns.
   */
  ~LocalMemory() {
      uprv_free(LocalPointerBase<T>::ptr);
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   */
  LocalMemory<T> &operator=(LocalMemory<T> &&src) noexcept {
      uprv_free(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=nullptr;
      return *this;
  }
  /**
   * Swap pointers.
   * @param other other smart pointer
   */
  void swap(LocalMemory<T> &other) noexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalMemory swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   */
  friend inline void swap(LocalMemory<T> &p1, LocalMemory<T> &p2) noexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an array of T items that is adopted
   */
  void adoptInstead(T *p) {
      uprv_free(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the array it owns, allocates a new one and reset its bytes to 0.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity must be >0
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *allocateInsteadAndReset(int32_t newCapacity=1);
  /**
   * Deletes the array it owns and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity must be >0
   * @param length number of T items to be copied from the old array to the new one;
   *               must be no more than the capacity of the old array,
   *               which the caller must track because the LocalMemory does not track it
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *allocateInsteadAndCopy(int32_t newCapacity=1, int32_t length=0);
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }
275};

277template<typename T>
278inline T *LocalMemory<T>::allocateInsteadAndReset(int32_t newCapacity) {
  if(newCapacity>0) {
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          uprv_memset(p, 0, newCapacity*sizeof(T)):: memset(p, 0, newCapacity*sizeof(T));
          uprv_free(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return nullptr;
  }
290}


293template<typename T>
294inline T *LocalMemory<T>::allocateInsteadAndCopy(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length>0) {
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, LocalPointerBase<T>::ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (LocalPointerBase
<T>::ptr != __null) ? void (0) : __assert_fail ("LocalPointerBase<T>::ptr != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(p, LocalPointerBase<T>
::ptr, (size_t)length*sizeof(T)); } while (false);
          }
          uprv_free(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return nullptr;
  }
311}

313/**
* Simple array/buffer management class using uprv_malloc() and uprv_free().
* Provides an internal array with fixed capacity. Can alias another array
* or allocate one.
*
* The array address is properly aligned for type T. It might not be properly
* aligned for types larger than T (or larger than the largest subtype of T).
*
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another array.
*
* WARNING: MaybeStackArray only works with primitive (plain-old data) types.
* It does NOT know how to call a destructor! If you work with classes with
* destructors, consider:
*
* - LocalArray in localpointer.h if you know the length ahead of time
* - MaybeStackVector if you know the length at runtime
*/
331template<typename T, int32_t stackCapacity>
332class MaybeStackArray {
333public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) noexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
  static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;

  /**
   * Default constructor initializes with internal T[stackCapacity] buffer.
   */
  MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Automatically allocates the heap array if the argument is larger than the stack capacity.
   * Intended for use when an approximate capacity is known at compile time but the true
   * capacity is not known until runtime.
   */
  MaybeStackArray(int32_t newCapacity, UErrorCode status) : MaybeStackArray() {
      if (U_FAILURE(status)) {
          return;
      }
      if (capacity < newCapacity) {
          if (resize(newCapacity) == nullptr) {
              status = U_MEMORY_ALLOCATION_ERROR;
          }
      }
  }
  /**
   * Destructor deletes the array (if owned).
   */
  ~MaybeStackArray() { releaseArray(); }
  /**
   * Move constructor: transfers ownership or copies the stack array.
   */
  MaybeStackArray(MaybeStackArray<T, stackCapacity> &&src) noexcept;
  /**
   * Move assignment: transfers ownership or copies the stack array.
   */
  MaybeStackArray<T, stackCapacity> &operator=(MaybeStackArray<T, stackCapacity> &&src) noexcept;
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the array pointer
   */
  T *getAlias() const { return ptr; }
  /**
   * Returns the array limit. Simple convenience method.
   * @return getAlias()+getCapacity()
   */
  T *getArrayLimit() const { return getAlias()+capacity; }
  // No "operator T *() const" because that can make
  // expressions like mbs[index] ambiguous for some compilers.
  /**
   * Array item access (const).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T &operator[](ptrdiff_t i) const { return ptr[i]; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return ptr[i]; }
  /**
   * Deletes the array (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current array is unchanged.
   * @param otherArray must not be nullptr
   * @param otherCapacity must be >0
   */
  void aliasInstead(T *otherArray, int32_t otherCapacity) {
      if(otherArray!=nullptr && otherCapacity>0) {
          releaseArray();
          ptr=otherArray;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the array (if owned) and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the array if owned, or else clones it,
   * copying length T items; resets itself to the internal stack array.
   * Returns nullptr if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the array pointer;
   *         caller becomes responsible for deleting the array
   */
  inline T *orphanOrClone(int32_t length, int32_t &resultCapacity);

438protected:
  // Resizes the array to the size of src, then copies the contents of src.
  void copyFrom(const MaybeStackArray &src, UErrorCode &status) {
      if (U_FAILURE(status)) {
          return;
      }
      if (this->resize(src.capacity, 0) == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return;
      }
      uprv_memcpy(this->ptr, src.ptr, (size_t)capacity * sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (this->ptr != __null) ? void (
0) : __assert_fail ("this->ptr != __null", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (static_cast
 <bool> (src.ptr != __null) ? void (0) : __assert_fail (
"src.ptr != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); clang diagnostic pop
 :: memcpy(this->
ptr, src.ptr, (size_t)capacity * sizeof(T)); } while (false);
  }

451private:
  T *ptr;
  int32_t capacity;
  UBool needToRelease;
  T stackArray[stackCapacity];
  void releaseArray() {
      if(needToRelease) {
          uprv_free(ptr);
      }
  }
  void resetToStackArray() {
      ptr=stackArray;
      capacity=stackCapacity;
      needToRelease=false;
  }
  /* No comparison operators with other MaybeStackArray's. */
  bool operator==(const MaybeStackArray & /*other*/) = delete;
  bool operator!=(const MaybeStackArray & /*other*/) = delete;
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackArray(const MaybeStackArray & /*other*/) = delete;
  void operator=(const MaybeStackArray & /*other*/) = delete;
472};

474template<typename T, int32_t stackCapacity>
475icu::MaybeStackArray<T, stackCapacity>::MaybeStackArray(
      MaybeStackArray <T, stackCapacity>&& src) noexcept
      : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) {
  if (src.ptr7.1
Field 'ptr' is equal to field 'stackArray'
1
Field 'ptr' is equal to field 'stackArray'
 == src.stackArray) {
8
←
Taking true branch→
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (stackArray != __null) ? void (0)
 : __assert_fail ("stackArray != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (src.stackArray != __null) ? void (0) : __assert_fail ("src.stackArray != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(stackArray, src.stackArray
, sizeof(T) * src.capacity); } while (false);
Other elements might also be undefined
9
←
'?' condition is true→
10
←
'?' condition is true→
11
←
The first element of the 2nd argument is undefined
  } else {
      src.resetToStackArray();  // take ownership away from src
  }
484}

486template<typename T, int32_t stackCapacity>
487inline MaybeStackArray <T, stackCapacity>&
488MaybeStackArray<T, stackCapacity>::operator=(MaybeStackArray <T, stackCapacity>&& src) noexcept {
  releaseArray();  // in case this instance had its own memory allocated
  capacity = src.capacity;
  needToRelease = src.needToRelease;
  if (src.ptr == src.stackArray) {
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (stackArray != __null) ? void (0)
 : __assert_fail ("stackArray != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (src.stackArray != __null) ? void (0) : __assert_fail ("src.stackArray != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(stackArray, src.stackArray
, sizeof(T) * src.capacity); } while (false);
  } else {
      ptr = src.ptr;
      src.resetToStackArray();  // take ownership away from src
  }
  return *this;
500}

502template<typename T, int32_t stackCapacity>
503inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
505#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
      ::fprintf(::stderrstderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T));
507#endif
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, (size_t)length*sizeof(T));
 } while (false);
          }
          releaseArray();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return nullptr;
  }
528}

530template<typename T, int32_t stackCapacity>
531inline T *MaybeStackArray<T, stackCapacity>::orphanOrClone(int32_t length, int32_t &resultCapacity) {
  T *p;
  if(needToRelease) {
      p=ptr;
  } else if(length<=0) {
      return nullptr;
  } else {
      if(length>capacity) {
          length=capacity;
      }
      p=(T *)uprv_malloc(length*sizeof(T));
542#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStacArray (orphan) alloc %d * %lu\n", length,sizeof(T));
544#endif
      if(p==nullptr) {
          return nullptr;
      }
      uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, (size_t)length*sizeof(T));
 } while (false);
  }
  resultCapacity=length;
  resetToStackArray();
  return p;
553}

555/**
* Variant of MaybeStackArray that allocates a header struct and an array
* in one contiguous memory block, using uprv_malloc() and uprv_free().
* Provides internal memory with fixed array capacity. Can alias another memory
* block or allocate one.
* The stackCapacity is the number of T items in the internal memory,
* not counting the H header.
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another memory block.
*/
565template<typename H, typename T, int32_t stackCapacity>
566class MaybeStackHeaderAndArray {
567public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) noexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
  static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;

  /**
   * Default constructor initializes with internal H+T[stackCapacity] buffer.
   */
  MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Destructor deletes the memory (if owned).
   */
  ~MaybeStackHeaderAndArray() { releaseMemory(); }
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the header pointer
   */
  H *getAlias() const { return ptr; }
  /**
   * Returns the array start.
   * @return array start, same address as getAlias()+1
   */
  T *getArrayStart() const { return reinterpret_cast<T *>(getAlias()+1); }
  /**
   * Returns the array limit.
   * @return array limit
   */
  T *getArrayLimit() const { return getArrayStart()+capacity; }
  /**
   * Access without ownership change. Same as getAlias().
   * A class instance can be used directly in expressions that take a T *.
   * @return the header pointer
   */
  operator H *() const { return ptr; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return getArrayStart()[i]; }
  /**
   * Deletes the memory block (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current memory is unchanged.
   * @param otherArray must not be nullptr
   * @param otherCapacity must be >0
   */
  void aliasInstead(H *otherMemory, int32_t otherCapacity) {
      if(otherMemory!=nullptr && otherCapacity>0) {
          releaseMemory();
          ptr=otherMemory;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the memory block (if owned) and allocates a new one,
   * copying the header and length T array items.
   * Returns the new header pointer.
   * If the allocation fails, then the current memory is unchanged and
   * this method returns nullptr.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated pointer, or nullptr if the allocation failed
   */
  inline H *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the memory if owned, or else clones it,
   * copying the header and length T array items; resets itself to the internal memory.
   * Returns nullptr if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and array capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the header pointer;
   *         caller becomes responsible for deleting the array
   */
  inline H *orphanOrClone(int32_t length, int32_t &resultCapacity);
651private:
  H *ptr;
  int32_t capacity;
  UBool needToRelease;
  // stackHeader must precede stackArray immediately.
  H stackHeader;
  T stackArray[stackCapacity];
  void releaseMemory() {
      if(needToRelease) {
          uprv_free(ptr);
      }
  }
  /* No comparison operators with other MaybeStackHeaderAndArray's. */
  bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return false;}
  bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return true;}
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackHeaderAndArray(const MaybeStackHeaderAndArray & /*other*/) {}
  void operator=(const MaybeStackHeaderAndArray & /*other*/) {}
669};

671template<typename H, typename T, int32_t stackCapacity>
672inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::resize(int32_t newCapacity,
                                                              int32_t length) {
  if(newCapacity>=0) {
675#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray alloc %d + %d * %ul\n", sizeof(H),newCapacity,sizeof(T));
677#endif
      H *p=(H *)uprv_malloc(sizeof(H)+newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length<0) {
              length=0;
          } else if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
          }
          uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof
(T)); } while (false);
          releaseMemory();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return nullptr;
  }
700}

702template<typename H, typename T, int32_t stackCapacity>
703inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::orphanOrClone(int32_t length,
                                                                     int32_t &resultCapacity) {
  H *p;
  if(needToRelease) {
      p=ptr;
  } else {
      if(length<0) {
          length=0;
      } else if(length>capacity) {
          length=capacity;
      }
714#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray (orphan) alloc %ul + %d * %lu\n", sizeof(H),length,sizeof(T));
716#endif
      p=(H *)uprv_malloc(sizeof(H)+length*sizeof(T));
      if(p==nullptr) {
          return nullptr;
      }
      uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof
(T)); } while (false);
  }
  resultCapacity=length;
  ptr=&stackHeader;
  capacity=stackCapacity;
  needToRelease=false;
  return p;
728}

730/**
* A simple memory management class that creates new heap allocated objects (of
* any class that has a public constructor), keeps track of them and eventually
* deletes them all in its own destructor.
*
* A typical use-case would be code like this:
*
*     MemoryPool<MyType> pool;
*
*     MyType* o1 = pool.create();
*     if (o1 != nullptr) {
*         foo(o1);
*     }
*
*     MyType* o2 = pool.create(1, 2, 3);
*     if (o2 != nullptr) {
*         bar(o2);
*     }
*
*     // MemoryPool will take care of deleting the MyType objects.
*
* It doesn't do anything more than that, and is intentionally kept minimalist.
*/
753template<typename T, int32_t stackCapacity = 8>
754class MemoryPool : public UMemory {
755public:
  MemoryPool() : fCount(0), fPool() {}

  ~MemoryPool() {
      for (int32_t i = 0; i < fCount; ++i) {
          delete fPool[i];
      }
  }

  MemoryPool(const MemoryPool&) = delete;
  MemoryPool& operator=(const MemoryPool&) = delete;

  MemoryPool(MemoryPool&& other) noexcept : fCount(other.fCount),
                                              fPool(std::move(other.fPool)) {
7
←
Calling move constructor for 'MaybeStackArray<icu_78::MeasureUnitImplWithIndex *, 8>'→
      other.fCount = 0;
  }

  MemoryPool& operator=(MemoryPool&& other) noexcept {
      // Since `this` may contain instances that need to be deleted, we can't
      // just throw them away and replace them with `other`. The normal way of
      // dealing with this in C++ is to swap `this` and `other`, rather than
      // simply overwrite: the destruction of `other` can then take care of
      // running MemoryPool::~MemoryPool() over the still-to-be-deallocated
      // instances.
      std::swap(fCount, other.fCount);
      std::swap(fPool, other.fPool);
      return *this;
  }

  /**
   * Creates a new object of typename T, by forwarding any and all arguments
   * to the typename T constructor.
   *
   * @param args Arguments to be forwarded to the typename T constructor.
   * @return A pointer to the newly created object, or nullptr on error.
   */
  template<typename... Args>
  T* create(Args&&... args) {
      int32_t capacity = fPool.getCapacity();
      if (fCount == capacity &&
          fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity,
                       capacity) == nullptr) {
          return nullptr;
      }
      return fPool[fCount++] = new T(std::forward<Args>(args)...);
  }

  template <typename... Args>
  T* createAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      if (U_FAILURE(status)) {
          return nullptr;
      }
      T *pointer = this->create(args...);
      if (U_SUCCESS(status) && pointer == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return pointer;
  }

  /**
   * @return Number of elements that have been allocated.
   */
  int32_t count() const {
      return fCount;
  }

821protected:
  int32_t fCount;
  MaybeStackArray<T*, stackCapacity> fPool;
824};

826/**
* An internal Vector-like implementation based on MemoryPool.
*
* Heap-allocates each element and stores pointers.
*
* To append an item to the vector, use emplaceBack.
*
*     MaybeStackVector<MyType> vector;
*     MyType* element = vector.emplaceBack();
*     if (!element) {
*         status = U_MEMORY_ALLOCATION_ERROR;
*     }
*     // do stuff with element
*
* To loop over the vector, use a for loop with indices:
*
*     for (int32_t i = 0; i < vector.length(); i++) {
*         MyType* element = vector[i];
*     }
*/
846template<typename T, int32_t stackCapacity = 8>
847class MaybeStackVector : protected MemoryPool<T, stackCapacity> {
848public:
  template<typename... Args>
  T* emplaceBack(Args&&... args) {
      return this->create(args...);
  }

  template <typename... Args>
  T *emplaceBackAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      return this->createAndCheckErrorCode(status, args...);
  }

  int32_t length() const {
      return this->fCount;
  }

  T** getAlias() {
      return this->fPool.getAlias();
  }

  const T *const *getAlias() const {
      return this->fPool.getAlias();
  }

  /**
   * Array item access (read-only).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T* operator[](ptrdiff_t i) const {
      return this->fPool[i];
  }

  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T* operator[](ptrdiff_t i) {
      return this->fPool[i];
  }
890};


893U_NAMESPACE_END}

895#endif  /* __cplusplus */
896#endif  /* CMEMORY_H */

←

/root/firefox-clang/intl/icu/source/i18n/measunit_extra.cpp

1// © 2020 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html

4// Extra functions for MeasureUnit not needed for all clients.
5// Separate .o file so that it can be removed for modularity.

7#include "unicode/utypes.h"

9#if !UCONFIG_NO_FORMATTING0

11// Allow implicit conversion from char16_t* to UnicodeString for this file:
12// Helpful in toString methods and elsewhere.
13#define UNISTR_FROM_STRING_EXPLICIT

15#include "charstr.h"
16#include "cmemory.h"
17#include "cstring.h"
18#ifdef JS_HAS_INTL_API1
19#include "double-conversion/string-to-double.h"
20#else
21#include "double-conversion-string-to-double.h"
22#endif
23#include "measunit_impl.h"
24#include "resource.h"
25#include "uarrsort.h"
26#include "uassert.h"
27#include "ucln_in.h"
28#include "umutex.h"
29#include "unicode/bytestrie.h"
30#include "unicode/bytestriebuilder.h"
31#include "unicode/localpointer.h"
32#include "unicode/stringpiece.h"
33#include "unicode/stringtriebuilder.h"
34#include "unicode/ures.h"
35#include "unicode/ustringtrie.h"
36#include "uresimp.h"
37#include "util.h"
38#include <limits.h>
39#include <cstdlib>
40U_NAMESPACE_BEGINnamespace icu_78 {


43namespace {

45#ifdef JS_HAS_INTL_API1
46using double_conversion::StringToDoubleConverter;
47#else
48using icu::double_conversion::StringToDoubleConverter;
49#endif

51// TODO: Propose a new error code for this?
52constexpr UErrorCode kUnitIdentifierSyntaxError = U_ILLEGAL_ARGUMENT_ERROR;

54// Trie value offset for SI or binary prefixes. This is big enough to ensure we only
55// insert positive integers into the trie.
56constexpr int32_t kPrefixOffset = 64;
57static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_BIN > 0,
            "kPrefixOffset is too small for minimum UMeasurePrefix value");
59static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_SI > 0,
            "kPrefixOffset is too small for minimum UMeasurePrefix value");

62// Trie value offset for compound parts, e.g. "-per-", "-", "-and-".
63constexpr int32_t kCompoundPartOffset = 128;
64static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_BIN,
            "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");
66static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_SI,
            "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");

69enum CompoundPart {
  // Represents "-per-"
  COMPOUND_PART_PER = kCompoundPartOffset,
  // Represents "-"
  COMPOUND_PART_TIMES,
  // Represents "-and-"
  COMPOUND_PART_AND,
76};

78// Trie value offset for "per-".
79constexpr int32_t kInitialCompoundPartOffset = 192;

81enum InitialCompoundPart {
  // Represents "per-", the only compound part that can appear at the start of
  // an identifier.
  INITIAL_COMPOUND_PART_PER = kInitialCompoundPartOffset,
85};

87// Trie value offset for powers like "square-", "cubic-", "pow2-" etc.
88constexpr int32_t kPowerPartOffset = 256;

90enum PowerPart {
  POWER_PART_P2 = kPowerPartOffset + 2,
  POWER_PART_P3,
  POWER_PART_P4,
  POWER_PART_P5,
  POWER_PART_P6,
  POWER_PART_P7,
  POWER_PART_P8,
  POWER_PART_P9,
  POWER_PART_P10,
  POWER_PART_P11,
  POWER_PART_P12,
  POWER_PART_P13,
  POWER_PART_P14,
  POWER_PART_P15,
105};

107// Trie value offset for simple units, e.g. "gram", "nautical-mile",
108// "fluid-ounce-imperial".
109constexpr int32_t kSimpleUnitOffset = 512;

111// Trie value offset for aliases, e.g. "portion" replaced by "part"
112constexpr int32_t kAliasOffset = 51200; // This will give a very big space for the units ids.

114const struct UnitPrefixStrings {
  const char* const string;
  UMeasurePrefix value;
117} gUnitPrefixStrings[] = {
  // SI prefixes
  { "quetta", UMEASURE_PREFIX_QUETTA },
  { "ronna", UMEASURE_PREFIX_RONNA },
  { "yotta", UMEASURE_PREFIX_YOTTA },
  { "zetta", UMEASURE_PREFIX_ZETTA },
  { "exa", UMEASURE_PREFIX_EXA },
  { "peta", UMEASURE_PREFIX_PETA },
  { "tera", UMEASURE_PREFIX_TERA },
  { "giga", UMEASURE_PREFIX_GIGA },
  { "mega", UMEASURE_PREFIX_MEGA },
  { "kilo", UMEASURE_PREFIX_KILO },
  { "hecto", UMEASURE_PREFIX_HECTO },
  { "deka", UMEASURE_PREFIX_DEKA },
  { "deci", UMEASURE_PREFIX_DECI },
  { "centi", UMEASURE_PREFIX_CENTI },
  { "milli", UMEASURE_PREFIX_MILLI },
  { "micro", UMEASURE_PREFIX_MICRO },
  { "nano", UMEASURE_PREFIX_NANO },
  { "pico", UMEASURE_PREFIX_PICO },
  { "femto", UMEASURE_PREFIX_FEMTO },
  { "atto", UMEASURE_PREFIX_ATTO },
  { "zepto", UMEASURE_PREFIX_ZEPTO },
  { "yocto", UMEASURE_PREFIX_YOCTO },
  { "ronto", UMEASURE_PREFIX_RONTO },
  { "quecto", UMEASURE_PREFIX_QUECTO },
  // Binary prefixes
  { "yobi", UMEASURE_PREFIX_YOBI },
  { "zebi", UMEASURE_PREFIX_ZEBI },
  { "exbi", UMEASURE_PREFIX_EXBI },
  { "pebi", UMEASURE_PREFIX_PEBI },
  { "tebi", UMEASURE_PREFIX_TEBI },
  { "gibi", UMEASURE_PREFIX_GIBI },
  { "mebi", UMEASURE_PREFIX_MEBI },
  { "kibi", UMEASURE_PREFIX_KIBI },
152};

154/**
* A ResourceSink that collects simple unit identifiers from the keys of the
* convertUnits table into an array, and adds these values to a TrieBuilder,
* with associated values being their index into this array plus a specified
* offset.
*
* Example code:
*
*     UErrorCode status = U_ZERO_ERROR;
*     BytesTrieBuilder b(status);
*     int32_t ARR_SIZE = 200;
*     const char *unitIdentifiers[ARR_SIZE];
*     int32_t *unitCategories[ARR_SIZE];
*     SimpleUnitIdentifiersSink identifierSink(gSerializedUnitCategoriesTrie, unitIdentifiers,
*                                              unitCategories, ARR_SIZE, b, kTrieValueOffset);
*     LocalUResourceBundlePointer unitsBundle(ures_openDirect(nullptr, "units", &status));
*     ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);
*/
172class SimpleUnitIdentifiersSink : public icu::ResourceSink {
public:
  /**
   * Constructor.
   * @param quantitiesTrieData The data for constructing a quantitiesTrie,
   *     which maps from a simple unit identifier to an index into the
   *     gCategories array.
   * @param out Array of char* to which pointers to the simple unit
   *     identifiers will be saved. (Does not take ownership.)
   * @param outCategories Array of int32_t to which category indexes will be
   *     saved: this corresponds to simple unit IDs saved to `out`, mapping
   *     from the ID to the value produced by the quantitiesTrie (which is an
   *     index into the gCategories array).
   * @param outSize The size of `out` and `outCategories`.
   * @param trieBuilder The trie builder to which the simple unit identifier
   *     should be added. The trie builder must outlive this resource sink.
   * @param trieValueOffset This is added to the index of the identifier in
   *     the `out` array, before adding to `trieBuilder` as the value
   *     associated with the identifier.
   */
  explicit SimpleUnitIdentifiersSink(StringPiece quantitiesTrieData, const char **out,
                                     int32_t *outCategories, int32_t outSize,
                                     BytesTrieBuilder &trieBuilder, int32_t trieValueOffset)
      : outArray(out), outCategories(outCategories), outSize(outSize), trieBuilder(trieBuilder),
        trieValueOffset(trieValueOffset), quantitiesTrieData(quantitiesTrieData), outIndex(0) {}

  /**
   * Adds the table keys found in value to the output vector.
   * @param key The key of the resource passed to `value`: the second
   *     parameter of the ures_getAllItemsWithFallback() call.
   * @param value Should be a ResourceTable value, if
   *     ures_getAllItemsWithFallback() was called correctly for this sink.
   * @param noFallback Ignored.
   * @param status The standard ICU error code output parameter.
   */
  void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
      ResourceTable table = value.getTable(status);
      if (U_FAILURE(status)) return;

      if (outIndex + table.getSize() > outSize) {
          status = U_INDEX_OUTOFBOUNDS_ERROR;
          return;
      }

      BytesTrie quantitiesTrie(quantitiesTrieData.data());

      // Collect keys from the table resource.
      const char *simpleUnitID;
      for (int32_t i = 0; table.getKeyAndValue(i, simpleUnitID, value); ++i) {
          U_ASSERT(i < table.getSize())(static_cast <bool> (i < table.getSize()) ? void (0)
 : __assert_fail ("i < table.getSize()", __builtin_FILE ()
, __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          U_ASSERT(outIndex < outSize)(static_cast <bool> (outIndex < outSize) ? void (0) :
 __assert_fail ("outIndex < outSize", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          if (uprv_strcmp(simpleUnitID, "kilogram"):: strcmp(simpleUnitID, "kilogram") == 0) {
              // For parsing, we use "gram", the prefixless metric mass unit. We
              // thus ignore the SI Base Unit of Mass: it exists due to being the
              // mass conversion target unit, but not needed for MeasureUnit
              // parsing.
              continue;
          }
          outArray[outIndex] = simpleUnitID;
          trieBuilder.add(simpleUnitID, trieValueOffset + outIndex, status);

          // Find the base target unit for this simple unit
          ResourceTable table = value.getTable(status);
          if (U_FAILURE(status)) { return; }
          if (!table.findValue("target", value)) {
              status = U_INVALID_FORMAT_ERROR;
              break;
          }
          int32_t len;
          const char16_t* uTarget = value.getString(len, status);
          CharString target;
          target.appendInvariantChars(uTarget, len, status);
          if (U_FAILURE(status)) { return; }
          quantitiesTrie.reset();
          UStringTrieResult result = quantitiesTrie.next(target.data(), target.length());
          if (!USTRINGTRIE_HAS_VALUE(result)((result)>=USTRINGTRIE_FINAL_VALUE)) {
              status = U_INVALID_FORMAT_ERROR;
              break;
          }
          outCategories[outIndex] = quantitiesTrie.getValue();

          outIndex++;
      }
  }

private:
  const char **outArray;
  int32_t *outCategories;
  int32_t outSize;
  BytesTrieBuilder &trieBuilder;
  int32_t trieValueOffset;

  StringPiece quantitiesTrieData;

  int32_t outIndex;
267};

269class UnitAliasesSink : public icu::ResourceSink {
public:
  /**
   * Constructor.
   * @param unitAliases The output vector of unit alias identifiers (CharString).
   * @param unitReplacements The output vector of replacements for the unit aliases (CharString).
   */
  explicit UnitAliasesSink(MaybeStackVector<CharString> &unitAliases,
                           MaybeStackVector<CharString> &unitReplacements)
      : unitAliases(unitAliases), unitReplacements(unitReplacements) {}

  /**
   * Adds the unit alias key and its replacement to the unitAliases and unitReplacements vectors.
   * @param key The unit alias identifier (e.g., "meter-and-liter").
   * @param value Should be a ResourceTable value containing the replacement,
   *     when ures_getAllChildrenWithFallback() is called correctly for this sink.
   * @param noFallback Ignored.
   * @param status The standard ICU error code output parameter.
   */
  void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
           UErrorCode &status) override {
      if (U_FAILURE(status)) return;

      // Add the unit alias key to the unitAliases vector
      int32_t keyLen = static_cast<int32_t>(uprv_strlen(key):: strlen(key));
      unitAliases.emplaceBackAndCheckErrorCode(status)->append(key, keyLen, status);
      if (U_FAILURE(status)) {
          return;
      }

      // Find the replacement for this unit alias from the alias table resource.
      ResourceTable aliasTable = value.getTable(status);
      if (U_FAILURE(status)) {
          return;
      }

      if (!aliasTable.findValue("replacement", value)) {
          status = U_MISSING_RESOURCE_ERROR;
          return;
      }

      int32_t len;
      const char16_t *uReplacement = value.getString(len, status);
      unitReplacements.emplaceBackAndCheckErrorCode(status)->appendInvariantChars(uReplacement,
                                                                                  len, status);
  }

private:
  MaybeStackVector<CharString> &unitAliases;
  MaybeStackVector<CharString> &unitReplacements;
319};

321/**
* A ResourceSink that collects information from `unitQuantities` in the `units`
* resource to provide key->value lookups from base unit to category, as well as
* preserving ordering information for these categories. See `units.txt`.
*
* For example: "kilogram" -> "mass", "meter-per-second" -> "speed".
*
* In C++ unitQuantity values are collected in order into a char16_t* array, while
* unitQuantity keys are added added to a TrieBuilder, with associated values
* being the index into the aforementioned char16_t* array.
*/
332class CategoriesSink : public icu::ResourceSink {
public:
  /**
   * Constructor.
   * @param out Array of char16_t* to which unitQuantity values will be saved.
   *     The pointers returned  not owned: they point directly at the resource
   *     strings in static memory.
   * @param outSize The size of the `out` array.
   * @param trieBuilder The trie builder to which the keys (base units) of
   *     each unitQuantity will be added, each with value being the offset
   *     into `out`.
   */
  explicit CategoriesSink(const char16_t **out, int32_t &outSize, BytesTrieBuilder &trieBuilder)
      : outQuantitiesArray(out), outSize(outSize), trieBuilder(trieBuilder), outIndex(0) {}

  void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
      ResourceArray array = value.getArray(status);
      if (U_FAILURE(status)) {
          return;
      }

      if (outIndex + array.getSize() > outSize) {
          status = U_INDEX_OUTOFBOUNDS_ERROR;
          return;
      }

      for (int32_t i = 0; array.getValue(i, value); ++i) {
          U_ASSERT(outIndex < outSize)(static_cast <bool> (outIndex < outSize) ? void (0) :
 __assert_fail ("outIndex < outSize", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          ResourceTable table = value.getTable(status);
          if (U_FAILURE(status)) {
              return;
          }
          if (table.getSize() != 1) {
              status = U_INVALID_FORMAT_ERROR;
              return;
          }
          const char *key;
          table.getKeyAndValue(0, key, value);
          int32_t uTmpLen;
          outQuantitiesArray[outIndex] = value.getString(uTmpLen, status);
          trieBuilder.add(key, outIndex, status);
          outIndex++;
      }
  }

private:
  const char16_t **outQuantitiesArray;
  int32_t &outSize;
  BytesTrieBuilder &trieBuilder;

  int32_t outIndex;
383};

385icu::UInitOnce gUnitExtrasInitOnce {};

387// Array of unit aliases.
388const char** gUnitReplacements;
389const char* gUnitReplacementStrings;
390int32_t gNumUnitReplacements;

392// Array of simple unit IDs.
393//
394// The array memory itself is owned by this pointer, but the individual char* in
395// that array point at static memory. (Note that these char* are also returned
396// by SingleUnitImpl::getSimpleUnitID().)
397const char **gSimpleUnits = nullptr;

399// Maps from the value associated with each simple unit ID to an index into the
400// gCategories array.
401int32_t *gSimpleUnitCategories = nullptr;

403char *gSerializedUnitExtrasStemTrie = nullptr;

405// Array of char16_t* pointing at the unit categories (aka "quantities", aka
406// "types"), as found in the `unitQuantities` resource. The array memory itself
407// is owned by this pointer, but the individual char16_t* in that array point at
408// static memory.
409const char16_t **gCategories = nullptr;
410// Number of items in `gCategories`.
411int32_t gCategoriesCount = 0;
412// Serialized BytesTrie for mapping from base units to indices into gCategories.
413char *gSerializedUnitCategoriesTrie = nullptr;

415UBool U_CALLCONV cleanupUnitExtras() {
  uprv_free(gSerializedUnitCategoriesTrie);
  gSerializedUnitCategoriesTrie = nullptr;
  uprv_free(gCategories);
  gCategories = nullptr;
  uprv_free(gSerializedUnitExtrasStemTrie);
  gSerializedUnitExtrasStemTrie = nullptr;
  uprv_free(gSimpleUnitCategories);
  gSimpleUnitCategories = nullptr;
  uprv_free(gSimpleUnits);
  gSimpleUnits = nullptr;
  uprv_free((void*)gUnitReplacementStrings);
  gUnitReplacementStrings = nullptr;
  uprv_free(gUnitReplacements);
  gUnitReplacements = nullptr;
  gNumUnitReplacements = 0;
  gUnitExtrasInitOnce.reset();
  return true;
433}

435void U_CALLCONV initUnitExtras(UErrorCode& status) {
  ucln_i18n_registerCleanup(UCLN_I18N_UNIT_EXTRAS, cleanupUnitExtras);
  LocalUResourceBundlePointer unitsBundle(ures_openDirect(nullptr, "units", &status));

  // Collect unitQuantities information into gSerializedUnitCategoriesTrie and gCategories.
  const char *CATEGORY_TABLE_NAME = "unitQuantities";
  LocalUResourceBundlePointer unitQuantities(
      ures_getByKey(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, nullptr, &status));
  if (U_FAILURE(status)) { return; }
  gCategoriesCount = unitQuantities.getAlias()->fSize;
  size_t quantitiesMallocSize = sizeof(char16_t *) * gCategoriesCount;
  gCategories = static_cast<const char16_t **>(uprv_malloc(quantitiesMallocSize));
  if (gCategories == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  uprv_memset(gCategories, 0, quantitiesMallocSize):: memset(gCategories, 0, quantitiesMallocSize);
  BytesTrieBuilder quantitiesBuilder(status);
  CategoriesSink categoriesSink(gCategories, gCategoriesCount, quantitiesBuilder);
  ures_getAllItemsWithFallback(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, categoriesSink, status);
  StringPiece resultQuantities = quantitiesBuilder.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
  if (U_FAILURE(status)) { return; }
  // Copy the result into the global constant pointer
  size_t numBytesQuantities = resultQuantities.length();
  gSerializedUnitCategoriesTrie = static_cast<char *>(uprv_malloc(numBytesQuantities));
  if (gSerializedUnitCategoriesTrie == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  uprv_memcpy(gSerializedUnitCategoriesTrie, resultQuantities.data(), numBytesQuantities)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (gSerializedUnitCategoriesTrie !=
 __null) ? void (0) : __assert_fail ("gSerializedUnitCategoriesTrie != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (resultQuantities.data() != __null
) ? void (0) : __assert_fail ("resultQuantities.data() != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(gSerializedUnitCategoriesTrie
, resultQuantities.data(), numBytesQuantities); } while (false
);

  // Build the BytesTrie that Parser needs for parsing unit identifiers.

  BytesTrieBuilder b(status);
  if (U_FAILURE(status)) { return; }

  // Add SI and binary prefixes
  for (const auto& unitPrefixInfo : gUnitPrefixStrings) {
      b.add(unitPrefixInfo.string, unitPrefixInfo.value + kPrefixOffset, status);
  }
  if (U_FAILURE(status)) { return; }

  // Add syntax parts (compound, power prefixes)
  b.add("-per-", COMPOUND_PART_PER, status);
  b.add("-", COMPOUND_PART_TIMES, status);
  b.add("-and-", COMPOUND_PART_AND, status);
  b.add("per-", INITIAL_COMPOUND_PART_PER, status);
  b.add("square-", POWER_PART_P2, status);
  b.add("cubic-", POWER_PART_P3, status);
  b.add("pow2-", POWER_PART_P2, status);
  b.add("pow3-", POWER_PART_P3, status);
  b.add("pow4-", POWER_PART_P4, status);
  b.add("pow5-", POWER_PART_P5, status);
  b.add("pow6-", POWER_PART_P6, status);
  b.add("pow7-", POWER_PART_P7, status);
  b.add("pow8-", POWER_PART_P8, status);
  b.add("pow9-", POWER_PART_P9, status);
  b.add("pow10-", POWER_PART_P10, status);
  b.add("pow11-", POWER_PART_P11, status);
  b.add("pow12-", POWER_PART_P12, status);
  b.add("pow13-", POWER_PART_P13, status);
  b.add("pow14-", POWER_PART_P14, status);
  b.add("pow15-", POWER_PART_P15, status);
  if (U_FAILURE(status)) { return; }

  // Add sanctioned simple units by offset: simple units all have entries in
  // units/convertUnits resources.
  LocalUResourceBundlePointer convertUnits(
      ures_getByKey(unitsBundle.getAlias(), "convertUnits", nullptr, &status));
  if (U_FAILURE(status)) { return; }

  // Allocate enough space: with identifierSink below skipping kilogram, we're
  // probably allocating one more than needed.
  int32_t simpleUnitsCount = convertUnits.getAlias()->fSize;
  int32_t arrayMallocSize = sizeof(char *) * simpleUnitsCount;
  gSimpleUnits = static_cast<const char **>(uprv_malloc(arrayMallocSize));
  if (gSimpleUnits == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  uprv_memset(gSimpleUnits, 0, arrayMallocSize):: memset(gSimpleUnits, 0, arrayMallocSize);
  arrayMallocSize = sizeof(int32_t) * simpleUnitsCount;
  gSimpleUnitCategories = static_cast<int32_t *>(uprv_malloc(arrayMallocSize));
  if (gSimpleUnitCategories == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  uprv_memset(gSimpleUnitCategories, 0, arrayMallocSize):: memset(gSimpleUnitCategories, 0, arrayMallocSize);

  // Populate gSimpleUnits and build the associated trie.
  SimpleUnitIdentifiersSink identifierSink(resultQuantities, gSimpleUnits, gSimpleUnitCategories,
                                           simpleUnitsCount, b, kSimpleUnitOffset);
  ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);

  // Populate gUnitReplacements and its associated data structures.
  LocalUResourceBundlePointer aliasBundle(ures_open(U_ICUDATA_ALIAS"ICUDATA", "metadata", &status));
  if (U_FAILURE(status)) {
      return;
  }
  MaybeStackVector<CharString> unitAliases;
  MaybeStackVector<CharString> unitReplacements;
  
  UnitAliasesSink aliasSink(unitAliases, unitReplacements);
  ures_getAllChildrenWithFallback(aliasBundle.getAlias(), "alias/unit", aliasSink, status);
  if (U_FAILURE(status)) {
      return;
  }

  for (int32_t i = 0; i < unitAliases.length(); i++) {
      b.add(unitAliases[i]->data(), i + kAliasOffset, status);
      if (U_FAILURE(status)) {
          return;
      }
  }
  
  int32_t unitReplacementStringLength = 0;
  for (int32_t i = 0; i < unitReplacements.length(); i++) {
      unitReplacementStringLength += unitReplacements[i]->length() + 1;
  }
  gUnitReplacementStrings = (const char*)uprv_malloc(unitReplacementStringLength * sizeof(char));
  gUnitReplacements = (const char**)uprv_malloc(unitReplacements.length() * sizeof(const char**));
  if (gUnitReplacementStrings == nullptr || gUnitReplacements == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
  }
  gNumUnitReplacements = unitReplacements.length();
  char* p = const_cast<char*>(gUnitReplacementStrings);
  for (int32_t i = 0; i < unitReplacements.length(); i++) {
      gUnitReplacements[i] = p;
      uprv_strcpy(p, unitReplacements[i]->data()):: strcpy(p, unitReplacements[i]->data());
      p += unitReplacements[i]->length() + 1;
  }
  
  // Build the CharsTrie
  // TODO: Use SLOW or FAST here?
  StringPiece result = b.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
  if (U_FAILURE(status)) { return; }

  // Copy the result into the global constant pointer
  size_t numBytes = result.length();
  gSerializedUnitExtrasStemTrie = static_cast<char *>(uprv_malloc(numBytes));
  if (gSerializedUnitExtrasStemTrie == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  uprv_memcpy(gSerializedUnitExtrasStemTrie, result.data(), numBytes)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (gSerializedUnitExtrasStemTrie !=
 __null) ? void (0) : __assert_fail ("gSerializedUnitExtrasStemTrie != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); (static_cast <bool> (result.data() != __null) ? void
 (0) : __assert_fail ("result.data() != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(gSerializedUnitExtrasStemTrie, result
.data(), numBytes); } while (false);
581}

583class Token {
584public:
Token(int64_t match) : fMatch(match) {
    if (fMatch < kCompoundPartOffset) {
        this->fType = TYPE_PREFIX;
    } else if (fMatch < kInitialCompoundPartOffset) {
        this->fType = TYPE_COMPOUND_PART;
    } else if (fMatch < kPowerPartOffset) {
        this->fType = TYPE_INITIAL_COMPOUND_PART;
    } else if (fMatch < kSimpleUnitOffset) {
        this->fType = TYPE_POWER_PART;
    } else if (fMatch < kAliasOffset) {
        this->fType = TYPE_SIMPLE_UNIT;
    } else {
        this->fType = TYPE_ALIAS;
    }
}

static Token constantToken(StringPiece str, UErrorCode &status) {
    Token result;
    auto value = Token::parseStringToLong(str, status);
    if (U_FAILURE(status)) {
        return result;
    }
    result.fMatch = value;
    result.fType = TYPE_CONSTANT_DENOMINATOR;
    return result;
}

enum Type {
    TYPE_UNDEFINED,
    TYPE_PREFIX,
    // Token type for "-per-", "-", and "-and-".
    TYPE_COMPOUND_PART,
    // Token type for "per-".
    TYPE_INITIAL_COMPOUND_PART,
    TYPE_POWER_PART,
    TYPE_SIMPLE_UNIT,
    TYPE_CONSTANT_DENOMINATOR,
    TYPE_ALIAS,
};

// Calling getType() is invalid, resulting in an assertion failure, if Token
// value isn't positive.
Type getType() const {
    U_ASSERT(fMatch >= 0)(static_cast <bool> (fMatch >= 0) ? void (0) : __assert_fail
 ("fMatch >= 0", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
    return this->fType;
}

// Retrieve the value of the constant denominator if the token is of type TYPE_CONSTANT_DENOMINATOR.
uint64_t getConstantDenominator() const {
    U_ASSERT(getType() == TYPE_CONSTANT_DENOMINATOR)(static_cast <bool> (getType() == TYPE_CONSTANT_DENOMINATOR
) ? void (0) : __assert_fail ("getType() == TYPE_CONSTANT_DENOMINATOR"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    return static_cast<uint64_t>(fMatch);
}

  UMeasurePrefix getUnitPrefix() const {
      U_ASSERT(getType() == TYPE_PREFIX)(static_cast <bool> (getType() == TYPE_PREFIX) ? void (
0) : __assert_fail ("getType() == TYPE_PREFIX", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return static_cast<UMeasurePrefix>(fMatch - kPrefixOffset);
  }

  // Valid only for tokens with type TYPE_COMPOUND_PART.
  int32_t getMatch() const {
      U_ASSERT(getType() == TYPE_COMPOUND_PART)(static_cast <bool> (getType() == TYPE_COMPOUND_PART) ?
 void (0) : __assert_fail ("getType() == TYPE_COMPOUND_PART",
 __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      return fMatch;
  }

  int32_t getInitialCompoundPart() const {
      // Even if there is only one InitialCompoundPart value, we have this
      // function for the simplicity of code consistency.
      U_ASSERT(getType() == TYPE_INITIAL_COMPOUND_PART)(static_cast <bool> (getType() == TYPE_INITIAL_COMPOUND_PART
) ? void (0) : __assert_fail ("getType() == TYPE_INITIAL_COMPOUND_PART"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      // Defensive: if this assert fails, code using this function also needs
      // to change.
      U_ASSERT(fMatch == INITIAL_COMPOUND_PART_PER)(static_cast <bool> (fMatch == INITIAL_COMPOUND_PART_PER
) ? void (0) : __assert_fail ("fMatch == INITIAL_COMPOUND_PART_PER"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      return fMatch;
  }

  int8_t getPower() const {
      U_ASSERT(getType() == TYPE_POWER_PART)(static_cast <bool> (getType() == TYPE_POWER_PART) ? void
 (0) : __assert_fail ("getType() == TYPE_POWER_PART", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return static_cast<int8_t>(fMatch - kPowerPartOffset);
  }

  int32_t getSimpleUnitIndex() const {
      U_ASSERT(getType() == TYPE_SIMPLE_UNIT)(static_cast <bool> (getType() == TYPE_SIMPLE_UNIT) ? void
 (0) : __assert_fail ("getType() == TYPE_SIMPLE_UNIT", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return fMatch - kSimpleUnitOffset;
  }

  int32_t getAliasIndex() const {
      U_ASSERT(getType() == TYPE_ALIAS)(static_cast <bool> (getType() == TYPE_ALIAS) ? void (0
) : __assert_fail ("getType() == TYPE_ALIAS", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return static_cast<int32_t>(fMatch - kAliasOffset);
  }

  // TODO: Consider moving this to a separate utility class.
  // Utility function to parse a string into an unsigned long value.
  // The value must be a positive integer within the range [1, INT64_MAX].
  // The input can be in integer or scientific notation.
  static uint64_t parseStringToLong(const StringPiece strNum, UErrorCode &status) {
      // We are processing well-formed input, so we don't need any special options to
      // StringToDoubleConverter.
      StringToDoubleConverter converter(0, 0, 0, "", "");
      int32_t count;
      double double_result = converter.StringToDouble(strNum.data(), strNum.length(), &count);
      if (count != strNum.length()) {
          status = kUnitIdentifierSyntaxError;
          return 0;
      }

      if (U_FAILURE(status) || double_result < 1.0 || double_result > static_cast<double>(INT64_MAX(9223372036854775807L))) {
          status = kUnitIdentifierSyntaxError;
          return 0;
      }

      // Check if the value is integer.
      uint64_t int_result = static_cast<uint64_t>(double_result);
      const double kTolerance = 1e-9;
      if (abs(double_result - int_result) > kTolerance) {
          status = kUnitIdentifierSyntaxError;
          return 0;
      }

      return int_result;
  }

705private:
Token() = default;
int64_t fMatch;
Type fType = TYPE_UNDEFINED;
709};

711class Parser {
712public:
  /**
   * Factory function for parsing the given identifier.
   *
   * @param source The identifier to parse. This function does not make a copy
   * of source: the underlying string that source points at, must outlive the
   * parser.
   * @param status ICU error code.
   */
  static Parser from(StringPiece source, UErrorCode& status) {
      if (U_FAILURE(status)) {
          return {};
      }
      umtx_initOnce(gUnitExtrasInitOnce, &initUnitExtras, status);
      if (U_FAILURE(status)) {
          return {};
      }
      return {source};
  }

  /**
   * A single unit or a constant denominator.
   */
  struct SingleUnitOrConstant {
      enum ValueType {
          kSingleUnit,
          kConstantDenominator,
      };

      ValueType type = kSingleUnit;
      SingleUnitImpl singleUnit;
      uint64_t constantDenominator;

      static SingleUnitOrConstant singleUnitValue(SingleUnitImpl singleUnit) {
          SingleUnitOrConstant result;
          result.type = kSingleUnit;
          result.singleUnit = singleUnit;
          result.constantDenominator = 0;
          return result;
      }

      static SingleUnitOrConstant constantDenominatorValue(uint64_t constant) {
          SingleUnitOrConstant result;
          result.type = kConstantDenominator;
          result.singleUnit = {};
          result.constantDenominator = constant;
          return result;
      }

      uint64_t getConstantDenominator() const {
          U_ASSERT(type == kConstantDenominator)(static_cast <bool> (type == kConstantDenominator) ? void
 (0) : __assert_fail ("type == kConstantDenominator", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          return constantDenominator;
      }

      SingleUnitImpl getSingleUnit() const {
          U_ASSERT(type == kSingleUnit)(static_cast <bool> (type == kSingleUnit) ? void (0) : __assert_fail
 ("type == kSingleUnit", __builtin_FILE (), __builtin_LINE ()
, __extension__ __PRETTY_FUNCTION__));
          return singleUnit;
      }

      bool isSingleUnit() const { return type == kSingleUnit; }

      bool isConstantDenominator() const { return type == kConstantDenominator; }
  };

  MeasureUnitImpl parse(UErrorCode& status) {
      MeasureUnitImpl result;

      if (U_FAILURE(status)) {
          return result;
      }
      if (fSource.empty()) {
          // The dimenionless unit: nothing to parse. leave result as is.
          return result;
      }

      while (hasNext()) {
          bool sawAnd = false;

          auto singleUnitOrConstant = nextSingleUnitOrConstant(sawAnd, status);
          if (U_FAILURE(status)) {
              return result;
          }

          if (singleUnitOrConstant.isConstantDenominator()) {
              if (result.constantDenominator > 0) {
                  status = kUnitIdentifierSyntaxError;
                  return result;
              }
              result.constantDenominator = singleUnitOrConstant.getConstantDenominator();
              result.complexity = UMEASURE_UNIT_COMPOUND;
              continue;
          }

          U_ASSERT(singleUnitOrConstant.isSingleUnit())(static_cast <bool> (singleUnitOrConstant.isSingleUnit(
)) ? void (0) : __assert_fail ("singleUnitOrConstant.isSingleUnit()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          bool added = result.appendSingleUnit(singleUnitOrConstant.getSingleUnit(), status);
          if (U_FAILURE(status)) {
              return result;
          }

          if (sawAnd && !added) {
              // Two similar units are not allowed in a mixed unit.
              status = kUnitIdentifierSyntaxError;
              return result;
          }

          if (result.singleUnits.length() >= 2) {
              // nextSingleUnit fails appropriately for "per" and "and" in the
              // same identifier. It doesn't fail for other compound units
              // (COMPOUND_PART_TIMES). Consequently we take care of that
              // here.
              UMeasureUnitComplexity complexity =
                  sawAnd ? UMEASURE_UNIT_MIXED : UMEASURE_UNIT_COMPOUND;
              if (result.singleUnits.length() == 2) {
                  // After appending two singleUnits, the complexity will be `UMEASURE_UNIT_COMPOUND`
                  U_ASSERT(result.complexity == UMEASURE_UNIT_COMPOUND)(static_cast <bool> (result.complexity == UMEASURE_UNIT_COMPOUND
) ? void (0) : __assert_fail ("result.complexity == UMEASURE_UNIT_COMPOUND"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
                  result.complexity = complexity;
              } else if (result.complexity != complexity) {
                  // Can't have mixed compound units
                  status = kUnitIdentifierSyntaxError;
                  return result;
              }
          }
      }

      if (result.singleUnits.length() == 0) {
          // The identifier was empty or only had a constant denominator.
          status = kUnitIdentifierSyntaxError;
          return result; // add it for code consistency.
      }

      return result;
  }

845private:
  // Tracks parser progress: the offset into fSource.
  int32_t fIndex = 0;

  // Since we're not owning this memory, whatever is passed to the constructor
  // should live longer than this Parser - and the parser shouldn't return any
  // references to that string.
  StringPiece fSource;
  BytesTrie fTrie;

  // Storage for modified source string when aliases are expanded
  CharString fModifiedSource;

  // Set to true when we've seen a "-per-" or a "per-", after which all units
  // are in the denominator. Until we find an "-and-", at which point the
  // identifier is invalid pending TODO(CLDR-13701).
  bool fAfterPer = false;

  // Set to true when we've just seen a "per-". This is used to determine if
  // the next token can be a constant denominator token.
  bool fJustSawPer = false;

  Parser() : fSource(""), fTrie(u"") {}

  Parser(StringPiece source)
      : fSource(source), fTrie(gSerializedUnitExtrasStemTrie) {}

  inline bool hasNext() const {
      return fIndex < fSource.length();
  }

  // Returns the next Token parsed from fSource, advancing fIndex to the end
  // of that token in fSource. In case of U_FAILURE(status), the token
  // returned will cause an abort if getType() is called on it.
  Token nextToken(UErrorCode& status) {
      fTrie.reset();
      int32_t match = -1;
      // Saves the position in the fSource string for the end of the most
      // recent matching token.
      int32_t previ = -1;

      // Saves the position in the fSource string for later use in case of unit constant found.
      int32_t currentFIndex = fIndex;

      // Find the longest token that matches a value in the trie:
      while (fIndex < fSource.length()) {
          auto result = fTrie.next(fSource.data()[fIndex++]);
          if (result == USTRINGTRIE_NO_MATCH) {
              break;
          } else if (result == USTRINGTRIE_NO_VALUE) {
              continue;
          }
          U_ASSERT(USTRINGTRIE_HAS_VALUE(result))(static_cast <bool> (((result)>=USTRINGTRIE_FINAL_VALUE
)) ? void (0) : __assert_fail ("((result)>=USTRINGTRIE_FINAL_VALUE)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          match = fTrie.getValue();
          previ = fIndex;
          if (result == USTRINGTRIE_FINAL_VALUE) {
              break;
          }
          U_ASSERT(result == USTRINGTRIE_INTERMEDIATE_VALUE)(static_cast <bool> (result == USTRINGTRIE_INTERMEDIATE_VALUE
) ? void (0) : __assert_fail ("result == USTRINGTRIE_INTERMEDIATE_VALUE"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          // continue;
      }

      if (match >= 0) {
          fIndex = previ;
          return {match};
      }

      // If no match was found, we check if the token is a constant denominator.
      // 1. We find the index of the start of the next token or the end of the string.
      int32_t endOfConstantIndex = fSource.find("-", currentFIndex);
      endOfConstantIndex = (endOfConstantIndex == -1) ? fSource.length() : endOfConstantIndex;
      if (endOfConstantIndex <= currentFIndex) {
          status = kUnitIdentifierSyntaxError;
          return {match};
      }

      // 2. We extract the substring from the start of the constant to the end of the constant.
      StringPiece constantDenominatorStr =
          fSource.substr(currentFIndex, endOfConstantIndex - currentFIndex);
      fIndex = endOfConstantIndex;
      return Token::constantToken(constantDenominatorStr, status);
  }

  /**
   * Returns the next "single unit" via result.
   *
   * If a "-per-" was parsed, the result will have appropriate negative
   * dimensionality.
   *
   * Returns an error if we parse both compound units and "-and-", since mixed
   * compound units are not yet supported - TODO(CLDR-13701).
   *
   * @param result Will be overwritten by the result, if status shows success.
   * @param sawAnd If an "-and-" was parsed prior to finding the "single
   * unit", sawAnd is set to true. If not, it is left as is.
   * @param status ICU error code.
   */
  SingleUnitOrConstant nextSingleUnitOrConstant(bool &sawAnd, UErrorCode &status) {
      SingleUnitImpl singleUnitResult;
      if (U_FAILURE(status)) {
          return {};
      }

      // state:
      // 0 = no tokens seen yet (will accept power, SI or binary prefix, or simple unit)
      // 1 = power token seen (will not accept another power token)
      // 2 = SI or binary prefix token seen (will not accept a power, or SI or binary prefix token)
      int32_t state = 0;

      bool atStart = fIndex == 0;
      Token token = nextToken(status);
      if (U_FAILURE(status)) {
          return {};
      }

      // Handles the case where the alias replacement begins with "per-".
      // For example:
      //    if the alias is "permeter" and the replacement is "per-meter".
      // NOTE: This case does not currently exist in CLDR, but this code anticipates possible future
      // additions.
      if (token.getType() == Token::TYPE_ALIAS) {
          processAlias(token, status);
          token = nextToken(status);
          if (U_FAILURE(status)) {
              return {};
          }
      }

      fJustSawPer = false;

      if (atStart) {
          // Identifiers optionally start with "per-".
          if (token.getType() == Token::TYPE_INITIAL_COMPOUND_PART) {
              U_ASSERT(token.getInitialCompoundPart() == INITIAL_COMPOUND_PART_PER)(static_cast <bool> (token.getInitialCompoundPart() == INITIAL_COMPOUND_PART_PER
) ? void (0) : __assert_fail ("token.getInitialCompoundPart() == INITIAL_COMPOUND_PART_PER"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
              fAfterPer = true;
              fJustSawPer = true;
              singleUnitResult.dimensionality = -1;

              token = nextToken(status);
              if (U_FAILURE(status)) {
                  return {};
              }
          }
      } else {
          // All other SingleUnit's are separated from previous SingleUnit's
          // via a compound part:
          if (token.getType() != Token::TYPE_COMPOUND_PART) {
              status = kUnitIdentifierSyntaxError;
              return {};
          }

          switch (token.getMatch()) {
          case COMPOUND_PART_PER:
              if (sawAnd) {
                  // Mixed compound units not yet supported,
                  // TODO(CLDR-13701).
                  status = kUnitIdentifierSyntaxError;
                  return {};
              }
              fAfterPer = true;
              fJustSawPer = true;
              singleUnitResult.dimensionality = -1;
              break;

          case COMPOUND_PART_TIMES:
              if (fAfterPer) {
                  singleUnitResult.dimensionality = -1;
              }
              break;

          case COMPOUND_PART_AND:
              if (fAfterPer) {
                  // Can't start with "-and-", and mixed compound units
                  // not yet supported, TODO(CLDR-13701).
                  status = kUnitIdentifierSyntaxError;
                  return {};
              }
              sawAnd = true;
              break;
          }

          token = nextToken(status);
          if (U_FAILURE(status)) {
              return {};
          }
      }

      if (token.getType() == Token::TYPE_CONSTANT_DENOMINATOR) {
          if (!fJustSawPer) {
              status = kUnitIdentifierSyntaxError;
              return {};
          }

          return SingleUnitOrConstant::constantDenominatorValue(token.getConstantDenominator());
      }

      // Read tokens until we have a complete SingleUnit or we reach the end.
      while (true) {
          switch (token.getType()) {
          case Token::TYPE_POWER_PART:
              if (state > 0) {
                  status = kUnitIdentifierSyntaxError;
                  return {};
              }
              singleUnitResult.dimensionality *= token.getPower();
              state = 1;
              break;

          case Token::TYPE_PREFIX:
              if (state > 1) {
                  status = kUnitIdentifierSyntaxError;
                  return {};
              }
              singleUnitResult.unitPrefix = token.getUnitPrefix();
              state = 2;
              break;

          case Token::TYPE_SIMPLE_UNIT:
              singleUnitResult.index = token.getSimpleUnitIndex();
              break;

          case Token::TYPE_ALIAS:
              processAlias(token, status);
              break;

          default:
              status = kUnitIdentifierSyntaxError;
              return {};
          }

          if (token.getType() == Token::TYPE_SIMPLE_UNIT) {
              break;
          }

          if (!hasNext()) {
              // We ran out of tokens before finding a complete single unit.
              status = kUnitIdentifierSyntaxError;
              return {};
          }
          token = nextToken(status);
          if (U_FAILURE(status)) {
              return {};
          }
      }

      return SingleUnitOrConstant::singleUnitValue(singleUnitResult);
  }

private:
  /**
   * Helper function to process alias replacement.
   *
   * @param token The token of TYPE_ALIAS to process
   * @param status ICU error code
   */
  void processAlias(const Token &token, UErrorCode &status) {
      if (U_FAILURE(status)) {
          return;
      }

      auto aliasIndex = token.getAliasIndex();
      if (aliasIndex < 0 || aliasIndex >= gNumUnitReplacements) {
          status = kUnitIdentifierSyntaxError;
          return;
      }
      const char* replacement = gUnitReplacements[aliasIndex];
      
      // Create new source string: replacement + remaining unparsed portion
      fModifiedSource.clear();
      fModifiedSource.append(StringPiece(replacement), status);
      
      // Add the remaining unparsed portion of fSource which starts from fIndex
      if (fIndex < fSource.length()) {
          StringPiece remaining = fSource.substr(fIndex);
          fModifiedSource.append(remaining.data(), remaining.length(), status);
      }

      if (U_FAILURE(status)) {
          return;
      }

      // Update parser state with new source and reset index
      fSource = StringPiece(fModifiedSource.data(), fModifiedSource.length());
      fIndex = 0;

      return;
  }
1132};

1134// Sorting function wrapping SingleUnitImpl::compareTo for use with uprv_sortArray.
1135int32_t U_CALLCONV
1136compareSingleUnits(const void* /*context*/, const void* left, const void* right) {
  const auto* realLeft = static_cast<const SingleUnitImpl* const*>(left);
  const auto* realRight = static_cast<const SingleUnitImpl* const*>(right);
  return (*realLeft)->compareTo(**realRight);
1140}

1142// Returns an index into the gCategories array, for the "unitQuantity" (aka
1143// "type" or "category") associated with the given base unit identifier. Returns
1144// -1 on failure, together with U_UNSUPPORTED_ERROR.
1145int32_t getUnitCategoryIndex(BytesTrie &trie, StringPiece baseUnitIdentifier, UErrorCode &status) {
  UStringTrieResult result = trie.reset().next(baseUnitIdentifier.data(), baseUnitIdentifier.length());
  if (!USTRINGTRIE_HAS_VALUE(result)((result)>=USTRINGTRIE_FINAL_VALUE)) {
      status = U_UNSUPPORTED_ERROR;
      return -1;
  }

  return trie.getValue();
1153}

1155} // namespace

1157U_CAPIextern "C" int32_t U_EXPORT2
1158umeas_getPrefixPower(UMeasurePrefix unitPrefix) {
  if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
      unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
      return unitPrefix - UMEASURE_PREFIX_INTERNAL_ONE_BIN;
  }
  U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&(static_cast <bool> (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI
 && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)
 ? void (0) : __assert_fail ("unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)(static_cast <bool> (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI
 && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)
 ? void (0) : __assert_fail ("unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  return unitPrefix - UMEASURE_PREFIX_ONE;
1166}

1168U_CAPIextern "C" int32_t U_EXPORT2
1169umeas_getPrefixBase(UMeasurePrefix unitPrefix) {
  if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
      unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
      return 1024;
  }
  U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&(static_cast <bool> (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI
 && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)
 ? void (0) : __assert_fail ("unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)(static_cast <bool> (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI
 && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI)
 ? void (0) : __assert_fail ("unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI && unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  return 10;
1177}

1179CharString U_I18N_API getUnitQuantity(const MeasureUnitImpl &baseMeasureUnitImpl, UErrorCode &status) {
  CharString result;
  MeasureUnitImpl baseUnitImpl = baseMeasureUnitImpl.copy(status);
  UErrorCode localStatus = U_ZERO_ERROR;
  umtx_initOnce(gUnitExtrasInitOnce, &initUnitExtras, status);
  if (U_FAILURE(status)) {
      return result;
  }
  BytesTrie trie(gSerializedUnitCategoriesTrie);

  baseUnitImpl.serialize(status);
  StringPiece identifier = baseUnitImpl.identifier.data();
  int32_t idx = getUnitCategoryIndex(trie, identifier, localStatus);
  if (U_FAILURE(status)) {
      return result;
  }

  // In case the base unit identifier did not match any entry.
  if (U_FAILURE(localStatus)) {
      localStatus = U_ZERO_ERROR;
      baseUnitImpl.takeReciprocal(status);
      baseUnitImpl.serialize(status);
      identifier.set(baseUnitImpl.identifier.data());
      idx = getUnitCategoryIndex(trie, identifier, localStatus);

      if (U_FAILURE(status)) {
          return result;
      }
  }

  // In case the reciprocal of the base unit identifier did not match any entry.
  MeasureUnitImpl simplifiedUnit = baseMeasureUnitImpl.copyAndSimplify(status);
  if (U_FAILURE(status)) {
      return result;
  }
  if (U_FAILURE(localStatus)) {
      localStatus = U_ZERO_ERROR;
      simplifiedUnit.serialize(status);
      identifier.set(simplifiedUnit.identifier.data());
      idx = getUnitCategoryIndex(trie, identifier, localStatus);

      if (U_FAILURE(status)) {
          return result;
      }
  }

  // In case the simplified base unit identifier did not match any entry.
  if (U_FAILURE(localStatus)) {
      localStatus = U_ZERO_ERROR;
      simplifiedUnit.takeReciprocal(status);
      simplifiedUnit.serialize(status);
      identifier.set(simplifiedUnit.identifier.data());
      idx = getUnitCategoryIndex(trie, identifier, localStatus);

      if (U_FAILURE(status)) {
          return result;
      }
  }

  // If there is no match at all, throw an exception.
  if (U_FAILURE(localStatus)) {
      status = U_INVALID_FORMAT_ERROR;
      return result;
  }

  if (idx < 0 || idx >= gCategoriesCount) {
      status = U_INVALID_FORMAT_ERROR;
      return result;
  }

  result.appendInvariantChars(gCategories[idx], u_strlen(gCategories[idx]), status);
  return result;
1251}

1253// In ICU4J, this is MeasureUnit.getSingleUnitImpl().
1254SingleUnitImpl SingleUnitImpl::forMeasureUnit(const MeasureUnit& measureUnit, UErrorCode& status) {
  MeasureUnitImpl temp;
  const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(measureUnit, temp, status);
  if (U_FAILURE(status)) {
      return {};
  }
  if (impl.singleUnits.length() == 0) {
      return {};
  }
  if (impl.singleUnits.length() == 1) {
      return *impl.singleUnits[0];
  }
  status = U_ILLEGAL_ARGUMENT_ERROR;
  return {};
1268}

1270MeasureUnit SingleUnitImpl::build(UErrorCode& status) const {
  MeasureUnitImpl temp;
  temp.appendSingleUnit(*this, status);
  // TODO(icu-units#28): the MeasureUnitImpl::build() method uses
  // findBySubtype, which is relatively slow.
  // - At the time of loading the simple unit IDs, we could also save a
  //   mapping to the builtin MeasureUnit type and subtype they correspond to.
  // - This method could then check dimensionality and index, and if both are
  //   1, directly return MeasureUnit instances very quickly.
  return std::move(temp).build(status);
1280}

1282const char *SingleUnitImpl::getSimpleUnitID() const {
  return gSimpleUnits[index];
1284}

1286void SingleUnitImpl::appendNeutralIdentifier(CharString &result, UErrorCode &status) const UPRV_NO_SANITIZE_UNDEFINED__attribute__((no_sanitize("undefined"))) {
  int32_t absPower = std::abs(this->dimensionality);

  U_ASSERT(absPower > 0)(static_cast <bool> (absPower > 0) ? void (0) : __assert_fail
 ("absPower > 0", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); // "this function does not support the dimensionless single units";
  
  if (absPower == 1) {
      // no-op
  } else if (absPower == 2) {
      result.append(StringPiece("square-"), status);
  } else if (absPower == 3) {
      result.append(StringPiece("cubic-"), status);
  } else if (absPower <= 15) {
      result.append(StringPiece("pow"), status);
      result.appendNumber(absPower, status);
      result.append(StringPiece("-"), status);
  } else {
      status = U_ILLEGAL_ARGUMENT_ERROR; // Unit Identifier Syntax Error
      return;
  }

  if (U_FAILURE(status)) {
      return;
  }

  if (this->unitPrefix != UMEASURE_PREFIX_ONE) {
      bool found = false;
      for (const auto &unitPrefixInfo : gUnitPrefixStrings) {
          // TODO: consider using binary search? If we do this, add a unit
          // test to ensure gUnitPrefixStrings is sorted?
          if (unitPrefixInfo.value == this->unitPrefix) {
              result.append(unitPrefixInfo.string, status);
              found = true;
              break;
          }
      }
      if (!found) {
          status = U_UNSUPPORTED_ERROR;
          return;
      }
  }

  result.append(StringPiece(this->getSimpleUnitID()), status);
1328}

1330int32_t SingleUnitImpl::getUnitCategoryIndex() const {
  return gSimpleUnitCategories[index];
1332}

1334MeasureUnitImpl::MeasureUnitImpl(const SingleUnitImpl &singleUnit, UErrorCode &status) {
  this->appendSingleUnit(singleUnit, status);
1336}

1338MeasureUnitImpl MeasureUnitImpl::forIdentifier(StringPiece identifier, UErrorCode& status) {
  return Parser::from(identifier, status).parse(status);
1340}

1342const MeasureUnitImpl& MeasureUnitImpl::forMeasureUnit(
      const MeasureUnit& measureUnit, MeasureUnitImpl& memory, UErrorCode& status) {
  if (measureUnit.fImpl) {
      return *measureUnit.fImpl;
  } else {
      memory = Parser::from(measureUnit.getIdentifier(), status).parse(status);
      return memory;
  }
1350}

1352MeasureUnitImpl MeasureUnitImpl::forMeasureUnitMaybeCopy(
      const MeasureUnit& measureUnit, UErrorCode& status) {
  if (measureUnit.fImpl) {
      return measureUnit.fImpl->copy(status);
  } else {
      return Parser::from(measureUnit.getIdentifier(), status).parse(status);
  }
1359}

1361void MeasureUnitImpl::takeReciprocal(UErrorCode& /*status*/) {
  identifier.clear();
  for (int32_t i = 0; i < singleUnits.length(); i++) {
      singleUnits[i]->dimensionality *= -1;
  }
1366}

1368MeasureUnitImpl MeasureUnitImpl::copyAndSimplify(UErrorCode &status) const {
  MeasureUnitImpl result;
  for (int32_t i = 0; i < singleUnits.length(); i++) {
      const SingleUnitImpl &singleUnit = *this->singleUnits[i];
      
      // The following `for` loop will cause time complexity to be O(n^2).
      // However, n is very small (number of units, generally, at maximum equal to 10)
      bool unitExist = false;
      for (int32_t j = 0; j < result.singleUnits.length(); j++) {
          if (uprv_strcmp(result.singleUnits[j]->getSimpleUnitID(), singleUnit.getSimpleUnitID()):: strcmp(result.singleUnits[j]->getSimpleUnitID(), singleUnit
.getSimpleUnitID()) ==
                  0 &&
              result.singleUnits[j]->unitPrefix == singleUnit.unitPrefix) {
              unitExist = true;
              result.singleUnits[j]->dimensionality =
                  result.singleUnits[j]->dimensionality + singleUnit.dimensionality;
              break;
          }
      }

      if (!unitExist) {
          result.appendSingleUnit(singleUnit, status);
      }
  }

  return result;
1393}

1395bool MeasureUnitImpl::appendSingleUnit(const SingleUnitImpl &singleUnit, UErrorCode &status) {
  identifier.clear();

  if (singleUnit.isDimensionless()) {
      // Do not append dimensionless units.
      return false;
  }

  // Find a similar unit that already exists, to attempt to coalesce
  SingleUnitImpl *oldUnit = nullptr;
  for (int32_t i = 0; i < this->singleUnits.length(); i++) {
      auto *candidate = this->singleUnits[i];
      if (candidate->isCompatibleWith(singleUnit)) {
          oldUnit = candidate;
      }
  }

  if (oldUnit) {
      // Both dimensionalities will be positive, or both will be negative, by
      // virtue of isCompatibleWith().
      oldUnit->dimensionality += singleUnit.dimensionality;

      return false;
  }

  // Add a copy of singleUnit
  // NOTE: MaybeStackVector::emplaceBackAndCheckErrorCode creates new copy of  singleUnit.
  this->singleUnits.emplaceBackAndCheckErrorCode(status, singleUnit);
  if (U_FAILURE(status)) {
      return false;
  }

  // If the MeasureUnitImpl is `UMEASURE_UNIT_SINGLE` and after the appending a unit, the `singleUnits`
  // contains more than one. thus means the complexity should be `UMEASURE_UNIT_COMPOUND`
  if (this->singleUnits.length() > 1 &&
      this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_SINGLE) {
      this->complexity = UMeasureUnitComplexity::UMEASURE_UNIT_COMPOUND;
  }

  return true;
1435}

1437MaybeStackVector<MeasureUnitImplWithIndex>
1438MeasureUnitImpl::extractIndividualUnitsWithIndices(UErrorCode &status) const {
  MaybeStackVector<MeasureUnitImplWithIndex> result;

  if (this->complexity != UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
1
Assuming field 'complexity' is equal to UMEASURE_UNIT_MIXED→
2
←
Taking false branch→
      result.emplaceBackAndCheckErrorCode(status, 0, *this, status);
      return result;
  }

  for (int32_t i = 0; i < singleUnits.length(); ++i) {
3
←
Assuming the condition is false→
4
←
Loop condition is false. Execution continues on line 1453→
      result.emplaceBackAndCheckErrorCode(status, i, *singleUnits[i], status);
      if (U_FAILURE(status)) {
          return result;
      }
  }

  return result;
5
←
Calling implicit move constructor for 'MaybeStackVector<icu_78::MeasureUnitImplWithIndex, 8>'→
6
←
Calling move constructor for 'MemoryPool<icu_78::MeasureUnitImplWithIndex, 8>'→
1454}

1456int32_t countCharacter(const CharString &str, char c) {
  int32_t count = 0;
  for (int32_t i = 0, n = str.length(); i < n; i++) {
      if (str[i] == c) {
          count++;
      }
  }
  return count;
1464}

1466/**
* Internal function that returns a string of the constants in the correct
* format.
*
* Example:
* 1000 --> "-per-1000"
* 1000000 --> "-per-1e6"
*
* NOTE: this function is only used when the constant denominator is greater
* than 0.
*/
1477CharString getConstantsString(uint64_t constantDenominator, UErrorCode &status) {
  U_ASSERT(constantDenominator > 0 && constantDenominator <= LLONG_MAX)(static_cast <bool> (constantDenominator > 0 &&
 constantDenominator <= 9223372036854775807LL) ? void (0) :
 __assert_fail ("constantDenominator > 0 && constantDenominator <= 9223372036854775807LL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  CharString result;
  result.appendNumber(constantDenominator, status);
  if (U_FAILURE(status)) {
      return result;
  }

  if (constantDenominator <= 1000) {
      return result;
  }

  // Check if the constant is a power of 10.
  int32_t zeros = countCharacter(result, '0');
  if (zeros == result.length() - 1 && result[0] == '1') {
      result.clear();
      result.append(StringPiece("1e"), status);
      result.appendNumber(zeros, status);
  }

  return result;
1499}

1501/**
* Normalize a MeasureUnitImpl and generate the identifier string in place.
*/
1504void MeasureUnitImpl::serialize(UErrorCode &status) {
  if (U_FAILURE(status)) {
      return;
  }

  if (this->singleUnits.length() == 0 && this->constantDenominator == 0) {
      // Dimensionless, constructed by the default constructor.
      return;
  }

  if (this->complexity == UMEASURE_UNIT_COMPOUND) {
      // Note: don't sort a MIXED unit
      uprv_sortArray(this->singleUnits.getAlias(), this->singleUnits.length(),
                     sizeof(this->singleUnits[0]), compareSingleUnits, nullptr, false, &status);
      if (U_FAILURE(status)) {
          return;
      }
  }

  CharString result;
  bool beforePer = true;
  bool firstTimeNegativeDimension = false;
  bool constantDenominatorAppended = false;
  for (int32_t i = 0; i < this->singleUnits.length(); i++) {
      if (beforePer && (*this->singleUnits[i]).dimensionality < 0) {
          beforePer = false;
          firstTimeNegativeDimension = true;
      } else if ((*this->singleUnits[i]).dimensionality < 0) {
          firstTimeNegativeDimension = false;
      }

      if (U_FAILURE(status)) {
          return;
      }

      if (this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
          if (result.length() != 0) {
              result.append(StringPiece("-and-"), status);
          }
      } else {
          if (firstTimeNegativeDimension) {
              if (result.length() == 0) {
                  result.append(StringPiece("per-"), status);
              } else {
                  result.append(StringPiece("-per-"), status);
              }

              if (this->constantDenominator > 0) {
                  result.append(getConstantsString(this->constantDenominator, status), status);
                  result.append(StringPiece("-"), status);
                  constantDenominatorAppended = true;
              }

          } else if (result.length() != 0) {
              result.append(StringPiece("-"), status);
          }
      }

      this->singleUnits[i]->appendNeutralIdentifier(result, status);
  }

  if (!constantDenominatorAppended && this->constantDenominator > 0) {
      result.append(StringPiece("-per-"), status);
      result.append(getConstantsString(this->constantDenominator, status), status);
  }

  if (U_FAILURE(status)) {
      return;
  }
  this->identifier = result.toStringPiece();
  if (this->identifier.isEmpty() != result.isEmpty()) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }
1577}

1579MeasureUnit MeasureUnitImpl::build(UErrorCode &status) && {
  this->serialize(status);
  return MeasureUnit(std::move(*this));
1582}

1584MeasureUnit MeasureUnit::forIdentifier(StringPiece identifier, UErrorCode &status) {
  return Parser::from(identifier, status).parse(status).build(status);
1586}

1588UMeasureUnitComplexity MeasureUnit::getComplexity(UErrorCode &status) const {
  MeasureUnitImpl temp;
  return MeasureUnitImpl::forMeasureUnit(*this, temp, status).complexity;
1591}

1593UMeasurePrefix MeasureUnit::getPrefix(UErrorCode &status) const {
  return SingleUnitImpl::forMeasureUnit(*this, status).unitPrefix;
1595}

1597MeasureUnit MeasureUnit::withPrefix(UMeasurePrefix prefix,
                                  UErrorCode &status) const UPRV_NO_SANITIZE_UNDEFINED__attribute__((no_sanitize("undefined"))) {
  SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
  singleUnit.unitPrefix = prefix;
  return singleUnit.build(status);
1602}

1604uint64_t MeasureUnit::getConstantDenominator(UErrorCode &status) const {
  // TODO(ICU-23219)
  auto measureUnitImpl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
  if (U_FAILURE(status)) {
      return 0;
  }

  auto complexity = measureUnitImpl.complexity;

  if (complexity != UMEASURE_UNIT_SINGLE && complexity != UMEASURE_UNIT_COMPOUND) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }


  return measureUnitImpl.constantDenominator;
1620}

1622MeasureUnit MeasureUnit::withConstantDenominator(uint64_t denominator, UErrorCode &status) const {
  // To match the behavior of the Java API, we do not allow a constant denominator
  // bigger than LONG_MAX.
  if (denominator > LONG_MAX9223372036854775807L) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return {};
  }

  auto complexity = this->getComplexity(status);
  if (U_FAILURE(status)) {
      return {};
  }
  if (complexity != UMEASURE_UNIT_SINGLE && complexity != UMEASURE_UNIT_COMPOUND) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return {};
  }

  MeasureUnitImpl impl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
  if (U_FAILURE(status)) {
      return {};
  }

  impl.constantDenominator = denominator;
  impl.complexity = (impl.singleUnits.length() < 2 && denominator == 0) ? UMEASURE_UNIT_SINGLE
                                                                        : UMEASURE_UNIT_COMPOUND;
  return std::move(impl).build(status);
1648}

1650int32_t MeasureUnit::getDimensionality(UErrorCode& status) const {
  SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
  if (U_FAILURE(status)) { return 0; }
  if (singleUnit.isDimensionless()) {
      return 0;
  }
  return singleUnit.dimensionality;
1657}

1659MeasureUnit MeasureUnit::withDimensionality(int32_t dimensionality, UErrorCode& status) const {
  SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
  singleUnit.dimensionality = dimensionality;
  return singleUnit.build(status);
1663}

1665MeasureUnit MeasureUnit::reciprocal(UErrorCode& status) const {
  MeasureUnitImpl impl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
  // The reciprocal of a unit that has a constant denominator is not allowed.
  if (impl.constantDenominator != 0) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return {};
  }
  impl.takeReciprocal(status);
  return std::move(impl).build(status);
1674}

1676MeasureUnit MeasureUnit::product(const MeasureUnit& other, UErrorCode& status) const {
  MeasureUnitImpl impl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
  MeasureUnitImpl temp;
  const MeasureUnitImpl& otherImpl = MeasureUnitImpl::forMeasureUnit(other, temp, status);
  if (impl.complexity == UMEASURE_UNIT_MIXED || otherImpl.complexity == UMEASURE_UNIT_MIXED) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return {};
  }
  for (int32_t i = 0; i < otherImpl.singleUnits.length(); i++) {
      impl.appendSingleUnit(*otherImpl.singleUnits[i], status);
  }

  uint64_t currentConstatDenominator = impl.constantDenominator;
  uint64_t otherConstantDenominator = otherImpl.constantDenominator;

  // TODO: we can also multiply the constant denominators instead of returning an error.
  if (currentConstatDenominator != 0 && otherConstantDenominator != 0) {
      // There is only `one` constant denominator in a compound unit.
      // Therefore, we Cannot multiply units that both of them have a constant denominator
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return {};
  }

  // Because either one of the constant denominators is zero, we can use the maximum of them.
  impl.constantDenominator = uprv_max(currentConstatDenominator, otherConstantDenominator);

  if (impl.singleUnits.length() > 1 || impl.constantDenominator > 0) {
      impl.complexity = UMEASURE_UNIT_COMPOUND;
  }

  return std::move(impl).build(status);
1707}

1709LocalArray<MeasureUnit> MeasureUnit::splitToSingleUnitsImpl(int32_t& outCount, UErrorCode& status) const {
  MeasureUnitImpl temp;
  const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(*this, temp, status);
  outCount = impl.singleUnits.length();
  MeasureUnit* arr = new MeasureUnit[outCount];
  if (arr == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return LocalArray<MeasureUnit>();
  }
  for (int32_t i = 0; i < outCount; i++) {
      arr[i] = impl.singleUnits[i]->build(status);
  }
  return LocalArray<MeasureUnit>(arr, status);
1722}


1725U_NAMESPACE_END}

1727#endif /* !UNCONFIG_NO_FORMATTING */