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

Bug Summary

File:	out/../deps/icu-small/source/common/unames.cpp
Warning:	line 1029, column 44 The left operand of '+' is a garbage value due to array index out of bounds
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name unames.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/unames.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5*
6*   Copyright (C) 1999-2014, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9******************************************************************************
10*   file name:  unames.c
11*   encoding:   UTF-8
12*   tab size:   8 (not used)
13*   indentation:4
14*
15*   created on: 1999oct04
16*   created by: Markus W. Scherer
17*/

19#include "unicode/utypes.h"
20#include "unicode/putil.h"
21#include "unicode/uchar.h"
22#include "unicode/udata.h"
23#include "unicode/utf.h"
24#include "unicode/utf16.h"
25#include "uassert.h"
26#include "ustr_imp.h"
27#include "umutex.h"
28#include "cmemory.h"
29#include "cstring.h"
30#include "ucln_cmn.h"
31#include "udataswp.h"
32#include "uprops.h"

34U_NAMESPACE_BEGINnamespace icu_71 {

36/* prototypes ------------------------------------------------------------- */

38static const char DATA_NAME[] = "unames";
39static const char DATA_TYPE[] = "icu";

41#define GROUP_SHIFT5 5
42#define LINES_PER_GROUP(1L<<5) (1L<<GROUP_SHIFT5)
43#define GROUP_MASK((1L<<5)-1) (LINES_PER_GROUP(1L<<5)-1)

45/*
* This struct was replaced by explicitly accessing equivalent
* fields from triples of uint16_t.
* The Group struct was padded to 8 bytes on compilers for early ARM CPUs,
* which broke the assumption that sizeof(Group)==6 and that the ++ operator
* would advance by 6 bytes (3 uint16_t).
*
* We can't just change the data structure because it's loaded from a data file,
* and we don't want to make it less compact, so we changed the access code.
*
* For details see ICU tickets 6331 and 6008.
56typedef struct {
  uint16_t groupMSB,
           offsetHigh, offsetLow; / * avoid padding * /
59} Group;
*/
61enum {
  GROUP_MSB,
  GROUP_OFFSET_HIGH,
  GROUP_OFFSET_LOW,
  GROUP_LENGTH
66};

68/*
* Get the 32-bit group offset.
* @param group (const uint16_t *) pointer to a Group triple of uint16_t
* @return group offset (int32_t)
*/
73#define GET_GROUP_OFFSET(group)((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW
]) ((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW])

75#define NEXT_GROUP(group)((group)+GROUP_LENGTH) ((group)+GROUP_LENGTH)
76#define PREV_GROUP(group)((group)-GROUP_LENGTH) ((group)-GROUP_LENGTH)

78typedef struct {
  uint32_t start, end;
  uint8_t type, variant;
  uint16_t size;
82} AlgorithmicRange;

84typedef struct {
  uint32_t tokenStringOffset, groupsOffset, groupStringOffset, algNamesOffset;
86} UCharNames;

88/*
* Get the groups table from a UCharNames struct.
* The groups table consists of one uint16_t groupCount followed by
* groupCount groups. Each group is a triple of uint16_t, see GROUP_LENGTH
* and the comment for the old struct Group above.
*
* @param names (const UCharNames *) pointer to the UCharNames indexes
* @return (const uint16_t *) pointer to the groups table
*/
97#define GET_GROUPS(names)(const uint16_t *)((const char *)names+names->groupsOffset
) (const uint16_t *)((const char *)names+names->groupsOffset)

99typedef struct {
  const char *otherName;
  UChar32 code;
102} FindName;

104#define DO_FIND_NAME__null NULL__null

106static UDataMemory *uCharNamesData=NULL__null;
107static UCharNames *uCharNames=NULL__null;
108static icu::UInitOnce gCharNamesInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};

110/*
* Maximum length of character names (regular & 1.0).
*/
113static int32_t gMaxNameLength=0;

115/*
* Set of chars used in character names (regular & 1.0).
* Chars are platform-dependent (can be EBCDIC).
*/
119static uint32_t gNameSet[8]={ 0 };

121#define U_NONCHARACTER_CODE_POINTU_CHAR_CATEGORY_COUNT U_CHAR_CATEGORY_COUNT
122#define U_LEAD_SURROGATEU_CHAR_CATEGORY_COUNT + 1 U_CHAR_CATEGORY_COUNT + 1
123#define U_TRAIL_SURROGATEU_CHAR_CATEGORY_COUNT + 2 U_CHAR_CATEGORY_COUNT + 2

125#define U_CHAR_EXTENDED_CATEGORY_COUNT(U_CHAR_CATEGORY_COUNT + 3) (U_CHAR_CATEGORY_COUNT + 3)

127static const char * const charCatNames[U_CHAR_EXTENDED_CATEGORY_COUNT(U_CHAR_CATEGORY_COUNT + 3)] = {
  "unassigned",
  "uppercase letter",
  "lowercase letter",
  "titlecase letter",
  "modifier letter",
  "other letter",
  "non spacing mark",
  "enclosing mark",
  "combining spacing mark",
  "decimal digit number",
  "letter number",
  "other number",
  "space separator",
  "line separator",
  "paragraph separator",
  "control",
  "format",
  "private use area",
  "surrogate",
  "dash punctuation",   
  "start punctuation",
  "end punctuation",
  "connector punctuation",
  "other punctuation",
  "math symbol",
  "currency symbol",
  "modifier symbol",
  "other symbol",
  "initial punctuation",
  "final punctuation",
  "noncharacter",
  "lead surrogate",
  "trail surrogate"
161};

163/* implementation ----------------------------------------------------------- */

165static UBool U_CALLCONV unames_cleanup(void)
166{
  if(uCharNamesData) {
      udata_closeudata_close_71(uCharNamesData);
      uCharNamesData = NULL__null;
  }
  if(uCharNames) {
      uCharNames = NULL__null;
  }
  gCharNamesInitOnce.reset();
  gMaxNameLength=0;
  return TRUE1;
177}

179static UBool U_CALLCONV
180isAcceptable(void * /*context*/,
           const char * /*type*/, const char * /*name*/,
           const UDataInfo *pInfo) {
  return (UBool)(
      pInfo->size>=20 &&
      pInfo->isBigEndian==U_IS_BIG_ENDIAN(1234 == 4321) &&
      pInfo->charsetFamily==U_CHARSET_FAMILY0 &&
      pInfo->dataFormat[0]==0x75 &&   /* dataFormat="unam" */
      pInfo->dataFormat[1]==0x6e &&
      pInfo->dataFormat[2]==0x61 &&
      pInfo->dataFormat[3]==0x6d &&
      pInfo->formatVersion[0]==1);
192}

194static void U_CALLCONV
195loadCharNames(UErrorCode &status) {
  U_ASSERT(uCharNamesData == NULL)(void)0;
  U_ASSERT(uCharNames == NULL)(void)0;

  uCharNamesData = udata_openChoiceudata_openChoice_71(NULL__null, DATA_TYPE, DATA_NAME, isAcceptable, NULL__null, &status);
  if(U_FAILURE(status)) {
      uCharNamesData = NULL__null;
  } else {
      uCharNames = (UCharNames *)udata_getMemoryudata_getMemory_71(uCharNamesData);
  }
  ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_UNAMES, unames_cleanup);
206}


209static UBool
210isDataLoaded(UErrorCode *pErrorCode) {
  umtx_initOnce(gCharNamesInitOnce, &loadCharNames, *pErrorCode);
  return U_SUCCESS(*pErrorCode);
213}

215#define WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  if((bufferLength)>0) { \
      *(buffer)++=c; \
      --(bufferLength); \
  } \
  ++(bufferPos); \
221} UPRV_BLOCK_MACRO_ENDwhile (false)

223#define U_ISO_COMMENTU_CHAR_NAME_CHOICE_COUNT U_CHAR_NAME_CHOICE_COUNT

225/*
* Important: expandName() and compareName() are almost the same -
* apply fixes to both.
*
* UnicodeData.txt uses ';' as a field separator, so no
* field can contain ';' as part of its contents.
* In unames.dat, it is marked as token[';']==-1 only if the
* semicolon is used in the data file - which is iff we
* have Unicode 1.0 names or ISO comments or aliases.
* So, it will be token[';']==-1 if we store U1.0 names/ISO comments/aliases
* although we know that it will never be part of a name.
*/
237static uint16_t
238expandName(UCharNames *names,
         const uint8_t *name, uint16_t nameLength, UCharNameChoice nameChoice,
         char *buffer, uint16_t bufferLength) {
  uint16_t *tokens=(uint16_t *)names+8;
  uint16_t token, tokenCount=*tokens++, bufferPos=0;
  uint8_t *tokenStrings=(uint8_t *)names+names->tokenStringOffset;
  uint8_t c;

  if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
      /*
       * skip the modern name if it is not requested _and_
       * if the semicolon byte value is a character, not a token number
       */
      if((uint8_t)';'>=tokenCount || tokens[(uint8_t)';']==(uint16_t)(-1)) {
          int fieldIndex= nameChoice==U_ISO_COMMENTU_CHAR_NAME_CHOICE_COUNT ? 2 : nameChoice;
          do {
              while(nameLength>0) {
                  --nameLength;
                  if(*name++==';') {
                      break;
                  }
              }
          } while(--fieldIndex>0);
      } else {
          /*
           * the semicolon byte value is a token number, therefore
           * only modern names are stored in unames.dat and there is no
           * such requested alternate name here
           */
          nameLength=0;
      }
  }

  /* write each letter directly, and write a token word per token */
  while(nameLength>0) {
      --nameLength;
      c=*name++;

      if(c>=tokenCount) {
          if(c!=';') {
              /* implicit letter */
              WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
          } else {
              /* finished */
              break;
          }
      } else {
          token=tokens[c];
          if(token==(uint16_t)(-2)) {
              /* this is a lead byte for a double-byte token */
              token=tokens[c<<8|*name++];
              --nameLength;
          }
          if(token==(uint16_t)(-1)) {
              if(c!=';') {
                  /* explicit letter */
                  WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
              } else {
                  /* stop, but skip the semicolon if we are seeking
                     extended names and there was no 2.0 name but there
                     is a 1.0 name. */
                  if(!bufferPos && nameChoice == U_EXTENDED_CHAR_NAME) {
                      if ((uint8_t)';'>=tokenCount || tokens[(uint8_t)';']==(uint16_t)(-1)) {
                          continue;
                      }
                  }
                  /* finished */
                  break;
              }
          } else {
              /* write token word */
              uint8_t *tokenString=tokenStrings+token;
              while((c=*tokenString++)!=0) {
                  WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
              }
          }
      }
  }

  /* zero-terminate */
  if(bufferLength>0) {
      *buffer=0;
  }

  return bufferPos;
323}

325/*
* compareName() is almost the same as expandName() except that it compares
* the currently expanded name to an input name.
* It returns the match/no match result as soon as possible.
*/
330static UBool
331compareName(UCharNames *names,
          const uint8_t *name, uint16_t nameLength, UCharNameChoice nameChoice,
          const char *otherName) {
  uint16_t *tokens=(uint16_t *)names+8;
  uint16_t token, tokenCount=*tokens++;
  uint8_t *tokenStrings=(uint8_t *)names+names->tokenStringOffset;
  uint8_t c;
  const char *origOtherName = otherName;

  if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
      /*
       * skip the modern name if it is not requested _and_
       * if the semicolon byte value is a character, not a token number
       */
      if((uint8_t)';'>=tokenCount || tokens[(uint8_t)';']==(uint16_t)(-1)) {
          int fieldIndex= nameChoice==U_ISO_COMMENTU_CHAR_NAME_CHOICE_COUNT ? 2 : nameChoice;
          do {
              while(nameLength>0) {
                  --nameLength;
                  if(*name++==';') {
                      break;
                  }
              }
          } while(--fieldIndex>0);
      } else {
          /*
           * the semicolon byte value is a token number, therefore
           * only modern names are stored in unames.dat and there is no
           * such requested alternate name here
           */
          nameLength=0;
      }
  }

  /* compare each letter directly, and compare a token word per token */
  while(nameLength>0) {
      --nameLength;
      c=*name++;

      if(c>=tokenCount) {
          if(c!=';') {
              /* implicit letter */
              if((char)c!=*otherName++) {
                  return FALSE0;
              }
          } else {
              /* finished */
              break;
          }
      } else {
          token=tokens[c];
          if(token==(uint16_t)(-2)) {
              /* this is a lead byte for a double-byte token */
              token=tokens[c<<8|*name++];
              --nameLength;
          }
          if(token==(uint16_t)(-1)) {
              if(c!=';') {
                  /* explicit letter */
                  if((char)c!=*otherName++) {
                      return FALSE0;
                  }
              } else {
                  /* stop, but skip the semicolon if we are seeking
                     extended names and there was no 2.0 name but there
                     is a 1.0 name. */
                  if(otherName == origOtherName && nameChoice == U_EXTENDED_CHAR_NAME) {
                      if ((uint8_t)';'>=tokenCount || tokens[(uint8_t)';']==(uint16_t)(-1)) {
                          continue;
                      }
                  }
                  /* finished */
                  break;
              }
          } else {
              /* write token word */
              uint8_t *tokenString=tokenStrings+token;
              while((c=*tokenString++)!=0) {
                  if((char)c!=*otherName++) {
                      return FALSE0;
                  }
              }
          }
      }
  }

  /* complete match? */
  return (UBool)(*otherName==0);
419}

421static uint8_t getCharCat(UChar32 cp) {
  uint8_t cat;

  if (U_IS_UNICODE_NONCHAR(cp)((cp)>=0xfdd0 && ((cp)<=0xfdef || ((cp)&0xfffe
)==0xfffe) && (cp)<=0x10ffff)) {
      return U_NONCHARACTER_CODE_POINTU_CHAR_CATEGORY_COUNT;
  }

  if ((cat = u_charTypeu_charType_71(cp)) == U_SURROGATE) {
      cat = U_IS_LEAD(cp)(((cp)&0xfffffc00)==0xd800) ? U_LEAD_SURROGATEU_CHAR_CATEGORY_COUNT + 1 : U_TRAIL_SURROGATEU_CHAR_CATEGORY_COUNT + 2;
  }

  return cat;
433}

435static const char *getCharCatName(UChar32 cp) {
  uint8_t cat = getCharCat(cp);

  /* Return unknown if the table of names above is not up to
     date. */

  if (cat >= UPRV_LENGTHOF(charCatNames)(int32_t)(sizeof(charCatNames)/sizeof((charCatNames)[0]))) {
      return "unknown";
  } else {
      return charCatNames[cat];
  }
446}

448static uint16_t getExtName(uint32_t code, char *buffer, uint16_t bufferLength) {
  const char *catname = getCharCatName(code);
  uint16_t length = 0;

  UChar32 cp;
  int ndigits, i;
  
  WRITE_CHAR(buffer, bufferLength, length, '<')do { if((bufferLength)>0) { *(buffer)++='<'; --(bufferLength
); } ++(length); } while (false);
  while (catname[length - 1]) {
      WRITE_CHAR(buffer, bufferLength, length, catname[length - 1])do { if((bufferLength)>0) { *(buffer)++=catname[length - 1
]; --(bufferLength); } ++(length); } while (false);
  }
  WRITE_CHAR(buffer, bufferLength, length, '-')do { if((bufferLength)>0) { *(buffer)++='-'; --(bufferLength
); } ++(length); } while (false);
  for (cp = code, ndigits = 0; cp; ++ndigits, cp >>= 4)
      ;
  if (ndigits < 4)
      ndigits = 4;
  for (cp = code, i = ndigits; (cp || i > 0) && bufferLength; cp >>= 4, bufferLength--) {
      uint8_t v = (uint8_t)(cp & 0xf);
      buffer[--i] = (v < 10 ? '0' + v : 'A' + v - 10);
  }
  buffer += ndigits;
  length += static_cast<uint16_t>(ndigits);
  WRITE_CHAR(buffer, bufferLength, length, '>')do { if((bufferLength)>0) { *(buffer)++='>'; --(bufferLength
); } ++(length); } while (false);

  return length;
473}

475/*
* getGroup() does a binary search for the group that contains the
* Unicode code point "code".
* The return value is always a valid Group* that may contain "code"
* or else is the highest group before "code".
* If the lowest group is after "code", then that one is returned.
*/
482static const uint16_t *
483getGroup(UCharNames *names, uint32_t code) {
  const uint16_t *groups=GET_GROUPS(names)(const uint16_t *)((const char *)names+names->groupsOffset
);
  uint16_t groupMSB=(uint16_t)(code>>GROUP_SHIFT5),
           start=0,
           limit=*groups++,
           number;

  /* binary search for the group of names that contains the one for code */
  while(start<limit-1) {
      number=(uint16_t)((start+limit)/2);
      if(groupMSB<groups[number*GROUP_LENGTH+GROUP_MSB]) {
          limit=number;
      } else {
          start=number;
      }
  }

  /* return this regardless of whether it is an exact match */
  return groups+start*GROUP_LENGTH;
502}

504/*
* expandGroupLengths() reads a block of compressed lengths of 32 strings and
* expands them into offsets and lengths for each string.
* Lengths are stored with a variable-width encoding in consecutive nibbles:
* If a nibble<0xc, then it is the length itself (0=empty string).
* If a nibble>=0xc, then it forms a length value with the following nibble.
* Calculation see below.
* The offsets and lengths arrays must be at least 33 (one more) long because
* there is no check here at the end if the last nibble is still used.
*/
514static const uint8_t *
515expandGroupLengths(const uint8_t *s,
                 uint16_t offsets[LINES_PER_GROUP(1L<<5)+1], uint16_t lengths[LINES_PER_GROUP(1L<<5)+1]) {
  /* read the lengths of the 32 strings in this group and get each string's offset */
  uint16_t i=0, offset=0, length=0;
  uint8_t lengthByte;

  /* all 32 lengths must be read to get the offset of the first group string */
  while(i<LINES_PER_GROUP(1L<<5)) {
      lengthByte=*s++;

      /* read even nibble - MSBs of lengthByte */
      if(length>=12) {
          /* double-nibble length spread across two bytes */
          length=(uint16_t)(((length&0x3)<<4|lengthByte>>4)+12);
          lengthByte&=0xf;
      } else if((lengthByte /* &0xf0 */)>=0xc0) {
          /* double-nibble length spread across this one byte */
          length=(uint16_t)((lengthByte&0x3f)+12);
      } else {
          /* single-nibble length in MSBs */
          length=(uint16_t)(lengthByte>>4);
          lengthByte&=0xf;
      }

      *offsets++=offset;
      *lengths++=length;

      offset+=length;
      ++i;

      /* read odd nibble - LSBs of lengthByte */
      if((lengthByte&0xf0)==0) {
          /* this nibble was not consumed for a double-nibble length above */
          length=lengthByte;
          if(length<12) {
              /* single-nibble length in LSBs */
              *offsets++=offset;
              *lengths++=length;

              offset+=length;
              ++i;
          }
      } else {
          length=0;   /* prevent double-nibble detection in the next iteration */
      }
  }

  /* now, s is at the first group string */
  return s;
564}

566static uint16_t
567expandGroupName(UCharNames *names, const uint16_t *group,
              uint16_t lineNumber, UCharNameChoice nameChoice,
              char *buffer, uint16_t bufferLength) {
  uint16_t offsets[LINES_PER_GROUP(1L<<5)+2], lengths[LINES_PER_GROUP(1L<<5)+2];
  const uint8_t *s=(uint8_t *)names+names->groupStringOffset+GET_GROUP_OFFSET(group)((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW
]);
  s=expandGroupLengths(s, offsets, lengths);
  return expandName(names, s+offsets[lineNumber], lengths[lineNumber], nameChoice,
                    buffer, bufferLength);
575}

577static uint16_t
578getName(UCharNames *names, uint32_t code, UCharNameChoice nameChoice,
      char *buffer, uint16_t bufferLength) {
  const uint16_t *group=getGroup(names, code);
  if((uint16_t)(code>>GROUP_SHIFT5)==group[GROUP_MSB]) {
      return expandGroupName(names, group, (uint16_t)(code&GROUP_MASK((1L<<5)-1)), nameChoice,
                             buffer, bufferLength);
  } else {
      /* group not found */
      /* zero-terminate */
      if(bufferLength>0) {
          *buffer=0;
      }
      return 0;
  }
592}

594/*
* enumGroupNames() enumerates all the names in a 32-group
* and either calls the enumerator function or finds a given input name.
*/
598static UBool
599enumGroupNames(UCharNames *names, const uint16_t *group,
             UChar32 start, UChar32 end,
             UEnumCharNamesFn *fn, void *context,
             UCharNameChoice nameChoice) {
  uint16_t offsets[LINES_PER_GROUP(1L<<5)+2], lengths[LINES_PER_GROUP(1L<<5)+2];
  const uint8_t *s=(uint8_t *)names+names->groupStringOffset+GET_GROUP_OFFSET(group)((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW
]);

  s=expandGroupLengths(s, offsets, lengths);
  if(fn!=DO_FIND_NAME__null) {
      char buffer[200];
      uint16_t length;

      while(start<=end) {
          length=expandName(names, s+offsets[start&GROUP_MASK((1L<<5)-1)], lengths[start&GROUP_MASK((1L<<5)-1)], nameChoice, buffer, sizeof(buffer));
          if (!length && nameChoice == U_EXTENDED_CHAR_NAME) {
              buffer[length = getExtName(start, buffer, sizeof(buffer))] = 0;
          }
          /* here, we assume that the buffer is large enough */
          if(length>0) {
              if(!fn(context, start, nameChoice, buffer, length)) {
                  return FALSE0;
              }
          }
          ++start;
      }
  } else {
      const char *otherName=((FindName *)context)->otherName;
      while(start<=end) {
          if(compareName(names, s+offsets[start&GROUP_MASK((1L<<5)-1)], lengths[start&GROUP_MASK((1L<<5)-1)], nameChoice, otherName)) {
              ((FindName *)context)->code=start;
              return FALSE0;
          }
          ++start;
      }
  }
  return TRUE1;
635}

637/*
* enumExtNames enumerate extended names.
* It only needs to do it if it is called with a real function and not
* with the dummy DO_FIND_NAME, because u_charFromName() does a check
* for extended names by itself.
*/ 
643static UBool
644enumExtNames(UChar32 start, UChar32 end,
           UEnumCharNamesFn *fn, void *context)
646{
  if(fn!=DO_FIND_NAME__null) {
      char buffer[200];
      uint16_t length;
      
      while(start<=end) {
          buffer[length = getExtName(start, buffer, sizeof(buffer))] = 0;
          /* here, we assume that the buffer is large enough */
          if(length>0) {
              if(!fn(context, start, U_EXTENDED_CHAR_NAME, buffer, length)) {
                  return FALSE0;
              }
          }
          ++start;
      }
  }

  return TRUE1;
664}

666static UBool
667enumNames(UCharNames *names,
        UChar32 start, UChar32 limit,
        UEnumCharNamesFn *fn, void *context,
        UCharNameChoice nameChoice) {
  uint16_t startGroupMSB, endGroupMSB, groupCount;
  const uint16_t *group, *groupLimit;

  startGroupMSB=(uint16_t)(start>>GROUP_SHIFT5);
  endGroupMSB=(uint16_t)((limit-1)>>GROUP_SHIFT5);

  /* find the group that contains start, or the highest before it */
  group=getGroup(names, start);

  if(startGroupMSB<group[GROUP_MSB] && nameChoice==U_EXTENDED_CHAR_NAME) {
      /* enumerate synthetic names between start and the group start */
      UChar32 extLimit=((UChar32)group[GROUP_MSB]<<GROUP_SHIFT5);
      if(extLimit>limit) {
          extLimit=limit;
      }
      if(!enumExtNames(start, extLimit-1, fn, context)) {
          return FALSE0;
      }
      start=extLimit;
  }

  if(startGroupMSB==endGroupMSB) {
      if(startGroupMSB==group[GROUP_MSB]) {
          /* if start and limit-1 are in the same group, then enumerate only in that one */
          return enumGroupNames(names, group, start, limit-1, fn, context, nameChoice);
      }
  } else {
      const uint16_t *groups=GET_GROUPS(names)(const uint16_t *)((const char *)names+names->groupsOffset
);
      groupCount=*groups++;
      groupLimit=groups+groupCount*GROUP_LENGTH;

      if(startGroupMSB==group[GROUP_MSB]) {
          /* enumerate characters in the partial start group */
          if((start&GROUP_MASK((1L<<5)-1))!=0) {
              if(!enumGroupNames(names, group,
                                 start, ((UChar32)startGroupMSB<<GROUP_SHIFT5)+LINES_PER_GROUP(1L<<5)-1,
                                 fn, context, nameChoice)) {
                  return FALSE0;
              }
              group=NEXT_GROUP(group)((group)+GROUP_LENGTH); /* continue with the next group */
          }
      } else if(startGroupMSB>group[GROUP_MSB]) {
          /* make sure that we start enumerating with the first group after start */
          const uint16_t *nextGroup=NEXT_GROUP(group)((group)+GROUP_LENGTH);
          if (nextGroup < groupLimit && nextGroup[GROUP_MSB] > startGroupMSB && nameChoice == U_EXTENDED_CHAR_NAME) {
              UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT5;
              if (end > limit) {
                  end = limit;
              }
              if (!enumExtNames(start, end - 1, fn, context)) {
                  return FALSE0;
              }
          }
          group=nextGroup;
      }

      /* enumerate entire groups between the start- and end-groups */
      while(group<groupLimit && group[GROUP_MSB]<endGroupMSB) {
          const uint16_t *nextGroup;
          start=(UChar32)group[GROUP_MSB]<<GROUP_SHIFT5;
          if(!enumGroupNames(names, group, start, start+LINES_PER_GROUP(1L<<5)-1, fn, context, nameChoice)) {
              return FALSE0;
          }
          nextGroup=NEXT_GROUP(group)((group)+GROUP_LENGTH);
          if (nextGroup < groupLimit && nextGroup[GROUP_MSB] > group[GROUP_MSB] + 1 && nameChoice == U_EXTENDED_CHAR_NAME) {
              UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT5;
              if (end > limit) {
                  end = limit;
              }
              if (!enumExtNames((group[GROUP_MSB] + 1) << GROUP_SHIFT5, end - 1, fn, context)) {
                  return FALSE0;
              }
          }
          group=nextGroup;
      }

      /* enumerate within the end group (group[GROUP_MSB]==endGroupMSB) */
      if(group<groupLimit && group[GROUP_MSB]==endGroupMSB) {
          return enumGroupNames(names, group, (limit-1)&~GROUP_MASK((1L<<5)-1), limit-1, fn, context, nameChoice);
      } else if (nameChoice == U_EXTENDED_CHAR_NAME && group == groupLimit) {
          UChar32 next = (PREV_GROUP(group)((group)-GROUP_LENGTH)[GROUP_MSB] + 1) << GROUP_SHIFT5;
          if (next > start) {
              start = next;
          }
      } else {
          return TRUE1;
      }
  }

  /* we have not found a group, which means everything is made of
     extended names. */
  if (nameChoice == U_EXTENDED_CHAR_NAME) {
      if (limit > UCHAR_MAX_VALUE0x10ffff + 1) {
          limit = UCHAR_MAX_VALUE0x10ffff + 1;
      }
      return enumExtNames(start, limit - 1, fn, context);
  }
  
  return TRUE1;
770}

772static uint16_t
773writeFactorSuffix(const uint16_t *factors, uint16_t count,
                const char *s, /* suffix elements */
                uint32_t code,
                uint16_t indexes[8], /* output fields from here */
                const char *elementBases[8], const char *elements[8],
                char *buffer, uint16_t bufferLength) {
  uint16_t i, factor, bufferPos=0;
  char c;

  /* write elements according to the factors */

  /*
   * the factorized elements are determined by modulo arithmetic
   * with the factors of this algorithm
   *
   * note that for fewer operations, count is decremented here
   */
  --count;
  for(i=count; i>0; --i) {
24
←
Assuming 'i' is <= 0→
25
←
Loop condition is false. Execution continues on line 800→
      factor=factors[i];
      indexes[i]=(uint16_t)(code%factor);
      code/=factor;
  }
  /*
   * we don't need to calculate the last modulus because start<=code<=end
   * guarantees here that code<=factors[0]
   */
  indexes[0]=(uint16_t)code;

  /* write each element */
  for(;;) {
26
←
Loop condition is true.  Entering loop body→
      if(elementBases26.1
'elementBases' is not equal to NULL
!=NULL__null) {
27
←
Taking true branch→
          *elementBases++=s;
      }

      /* skip indexes[i] strings */
      factor=indexes[i];
      while(factor>0) {
28
←
Assuming 'factor' is <= 0→
29
←
Loop condition is false. Execution continues on line 814→
          while(*s++!=0) {}
          --factor;
      }
      if(elements29.1
'elements' is not equal to NULL
!=NULL__null) {
30
←
Taking true branch→
          *elements++=s;
      }

      /* write element */
      while((c=*s++)!=0) {
31
←
Assuming the condition is false→
32
←
Loop condition is false. Execution continues on line 824→
          WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
      }

      /* we do not need to perform the rest of this loop for i==count - break here */
      if(i32.1
'i' is >= 'count'
>=count) {
33
←
Taking true branch→
          break;
      }

      /* skip the rest of the strings for this factors[i] */
      factor=(uint16_t)(factors[i]-indexes[i]-1);
      while(factor>0) {
          while(*s++!=0) {}
          --factor;
      }

      ++i;
  }

  /* zero-terminate */
  if(bufferLength34.1
'bufferLength' is > 0
>0) {
34
←
 Execution continues on line 839→
35
←
Taking true branch→
      *buffer=0;
  }

  return bufferPos;
844}

846/*
* Important:
* Parts of findAlgName() are almost the same as some of getAlgName().
* Fixes must be applied to both.
*/
851static uint16_t
852getAlgName(AlgorithmicRange *range, uint32_t code, UCharNameChoice nameChoice,
      char *buffer, uint16_t bufferLength) {
  uint16_t bufferPos=0;

  /* Only the normative character name can be algorithmic. */
  if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
      /* zero-terminate */
      if(bufferLength>0) {
          *buffer=0;
      }
      return 0;
  }

  switch(range->type) {
  case 0: {
      /* name = prefix hex-digits */
      const char *s=(const char *)(range+1);
      char c;

      uint16_t i, count;

      /* copy prefix */
      while((c=*s++)!=0) {
          WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
      }

      /* write hexadecimal code point value */
      count=range->variant;

      /* zero-terminate */
      if(count<bufferLength) {
          buffer[count]=0;
      }

      for(i=count; i>0;) {
          if(--i<bufferLength) {
              c=(char)(code&0xf);
              if(c<10) {
                  c+='0';
              } else {
                  c+='A'-10;
              }
              buffer[i]=c;
          }
          code>>=4;
      }

      bufferPos+=count;
      break;
  }
  case 1: {
      /* name = prefix factorized-elements */
      uint16_t indexes[8];
      const uint16_t *factors=(const uint16_t *)(range+1);
      uint16_t count=range->variant;
      const char *s=(const char *)(factors+count);
      char c;

      /* copy prefix */
      while((c=*s++)!=0) {
          WRITE_CHAR(buffer, bufferLength, bufferPos, c)do { if((bufferLength)>0) { *(buffer)++=c; --(bufferLength
); } ++(bufferPos); } while (false);
      }

      bufferPos+=writeFactorSuffix(factors, count,
                                   s, code-range->start, indexes, NULL__null, NULL__null, buffer, bufferLength);
      break;
  }
  default:
      /* undefined type */
      /* zero-terminate */
      if(bufferLength>0) {
          *buffer=0;
      }
      break;
  }

  return bufferPos;
929}

931/*
* Important: enumAlgNames() and findAlgName() are almost the same.
* Any fix must be applied to both.
*/
935static UBool
936enumAlgNames(AlgorithmicRange *range,
           UChar32 start, UChar32 limit,
           UEnumCharNamesFn *fn, void *context,
           UCharNameChoice nameChoice) {
  char buffer[200];
  uint16_t length;

  if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
19
←
Assuming 'nameChoice' is equal to U_UNICODE_CHAR_NAME→
      return TRUE1;
  }

  switch(range->type) {
20
←
Control jumps to 'case 1:'  at line 992→
  case 0: {
      char *s, *end;
      char c;

      /* get the full name of the start character */
      length=getAlgName(range, (uint32_t)start, nameChoice, buffer, sizeof(buffer));
      if(length<=0) {
          return TRUE1;
      }

      /* call the enumerator function with this first character */
      if(!fn(context, start, nameChoice, buffer, length)) {
          return FALSE0;
      }

      /* go to the end of the name; all these names have the same length */
      end=buffer;
      while(*end!=0) {
          ++end;
      }

      /* enumerate the rest of the names */
      while(++start<limit) {
          /* increment the hexadecimal number on a character-basis */
          s=end;
          for (;;) {
              c=*--s;
              if(('0'<=c && c<'9') || ('A'<=c && c<'F')) {
                  *s=(char)(c+1);
                  break;
              } else if(c=='9') {
                  *s='A';
                  break;
              } else if(c=='F') {
                  *s='0';
              }
          }

          if(!fn(context, start, nameChoice, buffer, length)) {
              return FALSE0;
          }
      }
      break;
  }
  case 1: {
      uint16_t indexes[8];
      const char *elementBases[8], *elements[8];
      const uint16_t *factors=(const uint16_t *)(range+1);
      uint16_t count=range->variant;
      const char *s=(const char *)(factors+count);
      char *suffix, *t;
      uint16_t prefixLength, i, idx;

      char c;

      /* name = prefix factorized-elements */

      /* copy prefix */
      suffix=buffer;
      prefixLength=0;
      while((c=*s++)!=0) {
21
←
Assuming the condition is false→
22
←
Loop condition is false. Execution continues on line 1014→
          *suffix++=c;
          ++prefixLength;
      }

      /* append the suffix of the start character */
      length=(uint16_t)(prefixLength+writeFactorSuffix(factors, count,
23
←
Calling 'writeFactorSuffix'→
36
←
Returning from 'writeFactorSuffix'→
                                            s, (uint32_t)start-range->start,
                                            indexes, elementBases, elements,
                                            suffix, (uint16_t)(sizeof(buffer)-prefixLength)));

      /* call the enumerator function with this first character */
      if(!fn(context, start, nameChoice, buffer, length)) {
37
←
Assuming the condition is false→
38
←
Taking false branch→
          return FALSE0;
      }

      /* enumerate the rest of the names */
      while(++start<limit) {
39
←
Assuming the condition is true→
40
←
Loop condition is true.  Entering loop body→
          /* increment the indexes in lexical order bound by the factors */
          i=count;
          for (;;) {
41
←
Loop condition is true.  Entering loop body→
44
←
Loop condition is true.  Entering loop body→
              idx=(uint16_t)(indexes[--i]+1);
45
←
The value 65535 is assigned to 'i'→
46
←
The left operand of '+' is a garbage value due to array index out of bounds
              if(idx<factors[i]) {
42
←
Assuming the condition is false→
43
←
Taking false branch→
                  /* skip one index and its element string */
                  indexes[i]=idx;
                  s=elements[i];
                  while(*s++!=0) {
                  }
                  elements[i]=s;
                  break;
              } else {
                  /* reset this index to 0 and its element string to the first one */
                  indexes[i]=0;
                  elements[i]=elementBases[i];
              }
          }

          /* to make matters a little easier, just append all elements to the suffix */
          t=suffix;
          length=prefixLength;
          for(i=0; i<count; ++i) {
              s=elements[i];
              while((c=*s++)!=0) {
                  *t++=c;
                  ++length;
              }
          }
          /* zero-terminate */
          *t=0;

          if(!fn(context, start, nameChoice, buffer, length)) {
              return FALSE0;
          }
      }
      break;
  }
  default:
      /* undefined type */
      break;
  }

  return TRUE1;
1070}

1072/*
* findAlgName() is almost the same as enumAlgNames() except that it
* returns the code point for a name if it fits into the range.
* It returns 0xffff otherwise.
*/
1077static UChar32
1078findAlgName(AlgorithmicRange *range, UCharNameChoice nameChoice, const char *otherName) {
  UChar32 code;

  if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
      return 0xffff;
  }

  switch(range->type) {
  case 0: {
      /* name = prefix hex-digits */
      const char *s=(const char *)(range+1);
      char c;

      uint16_t i, count;

      /* compare prefix */
      while((c=*s++)!=0) {
          if((char)c!=*otherName++) {
              return 0xffff;
          }
      }

      /* read hexadecimal code point value */
      count=range->variant;
      code=0;
      for(i=0; i<count; ++i) {
          c=*otherName++;
          if('0'<=c && c<='9') {
              code=(code<<4)|(c-'0');
          } else if('A'<=c && c<='F') {
              code=(code<<4)|(c-'A'+10);
          } else {
              return 0xffff;
          }
      }

      /* does it fit into the range? */
      if(*otherName==0 && range->start<=(uint32_t)code && (uint32_t)code<=range->end) {
          return code;
      }
      break;
  }
  case 1: {
      char buffer[64];
      uint16_t indexes[8];
      const char *elementBases[8], *elements[8];
      const uint16_t *factors=(const uint16_t *)(range+1);
      uint16_t count=range->variant;
      const char *s=(const char *)(factors+count), *t;
      UChar32 start, limit;
      uint16_t i, idx;

      char c;

      /* name = prefix factorized-elements */

      /* compare prefix */
      while((c=*s++)!=0) {
          if((char)c!=*otherName++) {
              return 0xffff;
          }
      }

      start=(UChar32)range->start;
      limit=(UChar32)(range->end+1);

      /* initialize the suffix elements for enumeration; indexes should all be set to 0 */
      writeFactorSuffix(factors, count, s, 0,
                        indexes, elementBases, elements, buffer, sizeof(buffer));

      /* compare the first suffix */
      if(0==uprv_strcmp(otherName, buffer):: strcmp(otherName, buffer)) {
          return start;
      }

      /* enumerate and compare the rest of the suffixes */
      while(++start<limit) {
          /* increment the indexes in lexical order bound by the factors */
          i=count;
          for (;;) {
              idx=(uint16_t)(indexes[--i]+1);
              if(idx<factors[i]) {
                  /* skip one index and its element string */
                  indexes[i]=idx;
                  s=elements[i];
                  while(*s++!=0) {}
                  elements[i]=s;
                  break;
              } else {
                  /* reset this index to 0 and its element string to the first one */
                  indexes[i]=0;
                  elements[i]=elementBases[i];
              }
          }

          /* to make matters a little easier, just compare all elements of the suffix */
          t=otherName;
          for(i=0; i<count; ++i) {
              s=elements[i];
              while((c=*s++)!=0) {
                  if(c!=*t++) {
                      s=""; /* does not match */
                      i=99;
                  }
              }
          }
          if(i<99 && *t==0) {
              return start;
          }
      }
      break;
  }
  default:
      /* undefined type */
      break;
  }

  return 0xffff;
1196}

1198/* sets of name characters, maximum name lengths ---------------------------- */

1200#define SET_ADD(set, c)((set)[(uint8_t)c>>5]|=((uint32_t)1<<((uint8_t)c&
0x1f))) ((set)[(uint8_t)c>>5]|=((uint32_t)1<<((uint8_t)c&0x1f)))
1201#define SET_CONTAINS(set, c)(((set)[(uint8_t)c>>5]&((uint32_t)1<<((uint8_t
)c&0x1f)))!=0) (((set)[(uint8_t)c>>5]&((uint32_t)1<<((uint8_t)c&0x1f)))!=0)

1203static int32_t
1204calcStringSetLength(uint32_t set[8], const char *s) {
  int32_t length=0;
  char c;

  while((c=*s++)!=0) {
      SET_ADD(set, c)((set)[(uint8_t)c>>5]|=((uint32_t)1<<((uint8_t)c&
0x1f)));
      ++length;
  }
  return length;
1213}

1215static int32_t
1216calcAlgNameSetsLengths(int32_t maxNameLength) {
  AlgorithmicRange *range;
  uint32_t *p;
  uint32_t rangeCount;
  int32_t length;

  /* enumerate algorithmic ranges */
  p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset);
  rangeCount=*p;
  range=(AlgorithmicRange *)(p+1);
  while(rangeCount>0) {
      switch(range->type) {
      case 0:
          /* name = prefix + (range->variant times) hex-digits */
          /* prefix */
          length=calcStringSetLength(gNameSet, (const char *)(range+1))+range->variant;
          if(length>maxNameLength) {
              maxNameLength=length;
          }
          break;
      case 1: {
          /* name = prefix factorized-elements */
          const uint16_t *factors=(const uint16_t *)(range+1);
          const char *s;
          int32_t i, count=range->variant, factor, factorLength, maxFactorLength;

          /* prefix length */
          s=(const char *)(factors+count);
          length=calcStringSetLength(gNameSet, s);
          s+=length+1; /* start of factor suffixes */

          /* get the set and maximum factor suffix length for each factor */
          for(i=0; i<count; ++i) {
              maxFactorLength=0;
              for(factor=factors[i]; factor>0; --factor) {
                  factorLength=calcStringSetLength(gNameSet, s);
                  s+=factorLength+1;
                  if(factorLength>maxFactorLength) {
                      maxFactorLength=factorLength;
                  }
              }
              length+=maxFactorLength;
          }

          if(length>maxNameLength) {
              maxNameLength=length;
          }
          break;
      }
      default:
          /* unknown type */
          break;
      }

      range=(AlgorithmicRange *)((uint8_t *)range+range->size);
      --rangeCount;
  }
  return maxNameLength;
1274}

1276static int32_t
1277calcExtNameSetsLengths(int32_t maxNameLength) {
  int32_t i, length;

  for(i=0; i<UPRV_LENGTHOF(charCatNames)(int32_t)(sizeof(charCatNames)/sizeof((charCatNames)[0])); ++i) {
      /*
       * for each category, count the length of the category name
       * plus 9=
       * 2 for <>
       * 1 for -
       * 6 for most hex digits per code point
       */
      length=9+calcStringSetLength(gNameSet, charCatNames[i]);
      if(length>maxNameLength) {
          maxNameLength=length;
      }
  }
  return maxNameLength;
1294}

1296static int32_t
1297calcNameSetLength(const uint16_t *tokens, uint16_t tokenCount, const uint8_t *tokenStrings, int8_t *tokenLengths,
                uint32_t set[8],
                const uint8_t **pLine, const uint8_t *lineLimit) {
  const uint8_t *line=*pLine;
  int32_t length=0, tokenLength;
  uint16_t c, token;

  while(line!=lineLimit && (c=*line++)!=(uint8_t)';') {
      if(c>=tokenCount) {
          /* implicit letter */
          SET_ADD(set, c)((set)[(uint8_t)c>>5]|=((uint32_t)1<<((uint8_t)c&
0x1f)));
          ++length;
      } else {
          token=tokens[c];
          if(token==(uint16_t)(-2)) {
              /* this is a lead byte for a double-byte token */
              c=c<<8|*line++;
              token=tokens[c];
          }
          if(token==(uint16_t)(-1)) {
              /* explicit letter */
              SET_ADD(set, c)((set)[(uint8_t)c>>5]|=((uint32_t)1<<((uint8_t)c&
0x1f)));
              ++length;
          } else {
              /* count token word */
              if(tokenLengths!=NULL__null) {
                  /* use cached token length */
                  tokenLength=tokenLengths[c];
                  if(tokenLength==0) {
                      tokenLength=calcStringSetLength(set, (const char *)tokenStrings+token);
                      tokenLengths[c]=(int8_t)tokenLength;
                  }
              } else {
                  tokenLength=calcStringSetLength(set, (const char *)tokenStrings+token);
              }
              length+=tokenLength;
          }
      }
  }

  *pLine=line;
  return length;
1339}

1341static void
1342calcGroupNameSetsLengths(int32_t maxNameLength) {
  uint16_t offsets[LINES_PER_GROUP(1L<<5)+2], lengths[LINES_PER_GROUP(1L<<5)+2];

  uint16_t *tokens=(uint16_t *)uCharNames+8;
  uint16_t tokenCount=*tokens++;
  uint8_t *tokenStrings=(uint8_t *)uCharNames+uCharNames->tokenStringOffset;

  int8_t *tokenLengths;

  const uint16_t *group;
  const uint8_t *s, *line, *lineLimit;

  int32_t groupCount, lineNumber, length;

  tokenLengths=(int8_t *)uprv_mallocuprv_malloc_71(tokenCount);
  if(tokenLengths!=NULL__null) {
      uprv_memset(tokenLengths, 0, tokenCount):: memset(tokenLengths, 0, tokenCount);
  }

  group=GET_GROUPS(uCharNames)(const uint16_t *)((const char *)uCharNames+uCharNames->groupsOffset
);
  groupCount=*group++;

  /* enumerate all groups */
  while(groupCount>0) {
      s=(uint8_t *)uCharNames+uCharNames->groupStringOffset+GET_GROUP_OFFSET(group)((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW
]);
      s=expandGroupLengths(s, offsets, lengths);

      /* enumerate all lines in each group */
      for(lineNumber=0; lineNumber<LINES_PER_GROUP(1L<<5); ++lineNumber) {
          line=s+offsets[lineNumber];
          length=lengths[lineNumber];
          if(length==0) {
              continue;
          }

          lineLimit=line+length;

          /* read regular name */
          length=calcNameSetLength(tokens, tokenCount, tokenStrings, tokenLengths, gNameSet, &line, lineLimit);
          if(length>maxNameLength) {
              maxNameLength=length;
          }
          if(line==lineLimit) {
              continue;
          }

          /* read Unicode 1.0 name */
          length=calcNameSetLength(tokens, tokenCount, tokenStrings, tokenLengths, gNameSet, &line, lineLimit);
          if(length>maxNameLength) {
              maxNameLength=length;
          }
          if(line==lineLimit) {
              continue;
          }

          /* read ISO comment */
          /*length=calcNameSetLength(tokens, tokenCount, tokenStrings, tokenLengths, gISOCommentSet, &line, lineLimit);*/
      }

      group=NEXT_GROUP(group)((group)+GROUP_LENGTH);
      --groupCount;
  }

  if(tokenLengths!=NULL__null) {
      uprv_freeuprv_free_71(tokenLengths);
  }

  /* set gMax... - name length last for threading */
  gMaxNameLength=maxNameLength;
1411}

1413static UBool
1414calcNameSetsLengths(UErrorCode *pErrorCode) {
  static const char extChars[]="0123456789ABCDEF<>-";
  int32_t i, maxNameLength;

  if(gMaxNameLength!=0) {
      return TRUE1;
  }

  if(!isDataLoaded(pErrorCode)) {
      return FALSE0;
  }

  /* set hex digits, used in various names, and <>-, used in extended names */
  for(i=0; i<(int32_t)sizeof(extChars)-1; ++i) {
      SET_ADD(gNameSet, extChars[i])((gNameSet)[(uint8_t)extChars[i]>>5]|=((uint32_t)1<<
((uint8_t)extChars[i]&0x1f)));
  }

  /* set sets and lengths from algorithmic names */
  maxNameLength=calcAlgNameSetsLengths(0);

  /* set sets and lengths from extended names */
  maxNameLength=calcExtNameSetsLengths(maxNameLength);

  /* set sets and lengths from group names, set global maximum values */
  calcGroupNameSetsLengths(maxNameLength);

  return TRUE1;
1441}

1443U_NAMESPACE_END}

1445/* public API --------------------------------------------------------------- */

1447U_NAMESPACE_USEusing namespace icu_71;

1449U_CAPIextern "C" int32_t U_EXPORT2
1450u_charNameu_charName_71(UChar32 code, UCharNameChoice nameChoice,
         char *buffer, int32_t bufferLength,
         UErrorCode *pErrorCode) {
   AlgorithmicRange *algRange;
  uint32_t *p;
  uint32_t i;
  int32_t length;

  /* check the argument values */
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
      return 0;
  } else if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT ||
            bufferLength<0 || (bufferLength>0 && buffer==NULL__null)
  ) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  if((uint32_t)code>UCHAR_MAX_VALUE0x10ffff || !isDataLoaded(pErrorCode)) {
      return u_terminateCharsu_terminateChars_71(buffer, bufferLength, 0, pErrorCode);
  }

  length=0;

  /* try algorithmic names first */
  p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset);
  i=*p;
  algRange=(AlgorithmicRange *)(p+1);
  while(i>0) {
      if(algRange->start<=(uint32_t)code && (uint32_t)code<=algRange->end) {
          length=getAlgName(algRange, (uint32_t)code, nameChoice, buffer, (uint16_t)bufferLength);
          break;
      }
      algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size);
      --i;
  }

  if(i==0) {
      if (nameChoice == U_EXTENDED_CHAR_NAME) {
          length = getName(uCharNames, (uint32_t )code, U_EXTENDED_CHAR_NAME, buffer, (uint16_t) bufferLength);
          if (!length) {
              /* extended character name */
              length = getExtName((uint32_t) code, buffer, (uint16_t) bufferLength);
          }
      } else {
          /* normal character name */
          length=getName(uCharNames, (uint32_t)code, nameChoice, buffer, (uint16_t)bufferLength);
      }
  }

  return u_terminateCharsu_terminateChars_71(buffer, bufferLength, length, pErrorCode);
1501}

1503U_CAPIextern "C" int32_t U_EXPORT2
1504u_getISOCommentu_getISOComment_71(UChar32 /*c*/,
              char *dest, int32_t destCapacity,
              UErrorCode *pErrorCode) {
  /* check the argument values */
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
      return 0;
  } else if(destCapacity<0 || (destCapacity>0 && dest==NULL__null)) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

  return u_terminateCharsu_terminateChars_71(dest, destCapacity, 0, pErrorCode);
1516}

1518U_CAPIextern "C" UChar32 U_EXPORT2
1519u_charFromNameu_charFromName_71(UCharNameChoice nameChoice,
             const char *name,
             UErrorCode *pErrorCode) {
  char upper[120] = {0};
  char lower[120] = {0};
  FindName findName;
  AlgorithmicRange *algRange;
  uint32_t *p;
  uint32_t i;
  UChar32 cp = 0;
  char c0;
  static constexpr UChar32 error = 0xffff;     /* Undefined, but use this for backwards compatibility. */

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

  if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT || name==NULL__null || *name==0) {
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return error;
  }

  if(!isDataLoaded(pErrorCode)) {
      return error;
  }

  /* construct the uppercase and lowercase of the name first */
  for(i=0; i<sizeof(upper); ++i) {
      if((c0=*name++)!=0) {
          upper[i]=uprv_toupperuprv_toupper_71(c0);
          lower[i]=uprv_toloweruprv_asciitolower_71(c0);
      } else {
          upper[i]=lower[i]=0;
          break;
      }
  }
  if(i==sizeof(upper)) {
      /* name too long, there is no such character */
      *pErrorCode = U_ILLEGAL_CHAR_FOUND;
      return error;
  }
  // i==strlen(name)==strlen(lower)==strlen(upper)

  /* try extended names first */
  if (lower[0] == '<') {
      if (nameChoice == U_EXTENDED_CHAR_NAME && lower[--i] == '>') {
          // Parse a string like "<category-HHHH>" where HHHH is a hex code point.
          uint32_t limit = i;
          while (i >= 3 && lower[--i] != '-') {}

          // There should be 1 to 8 hex digits.
          int32_t hexLength = limit - (i + 1);
          if (i >= 2 && lower[i] == '-' && 1 <= hexLength && hexLength <= 8) {
              uint32_t cIdx;

              lower[i] = 0;

              for (++i; i < limit; ++i) {
                  if (lower[i] >= '0' && lower[i] <= '9') {
                      cp = (cp << 4) + lower[i] - '0';
                  } else if (lower[i] >= 'a' && lower[i] <= 'f') {
                      cp = (cp << 4) + lower[i] - 'a' + 10;
                  } else {
                      *pErrorCode = U_ILLEGAL_CHAR_FOUND;
                      return error;
                  }
                  // Prevent signed-integer overflow and out-of-range code points.
                  if (cp > UCHAR_MAX_VALUE0x10ffff) {
                      *pErrorCode = U_ILLEGAL_CHAR_FOUND;
                      return error;
                  }
              }

              /* Now validate the category name.
                 We could use a binary search, or a trie, if
                 we really wanted to. */
              uint8_t cat = getCharCat(cp);
              for (lower[i] = 0, cIdx = 0; cIdx < UPRV_LENGTHOF(charCatNames)(int32_t)(sizeof(charCatNames)/sizeof((charCatNames)[0])); ++cIdx) {

                  if (!uprv_strcmp(lower + 1, charCatNames[cIdx]):: strcmp(lower + 1, charCatNames[cIdx])) {
                      if (cat == cIdx) {
                          return cp;
                      }
                      break;
                  }
              }
          }
      }

      *pErrorCode = U_ILLEGAL_CHAR_FOUND;
      return error;
  }

  /* try algorithmic names now */
  p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset);
  i=*p;
  algRange=(AlgorithmicRange *)(p+1);
  while(i>0) {
      if((cp=findAlgName(algRange, nameChoice, upper))!=0xffff) {
          return cp;
      }
      algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size);
      --i;
  }

  /* normal character name */
  findName.otherName=upper;
  findName.code=error;
  enumNames(uCharNames, 0, UCHAR_MAX_VALUE0x10ffff + 1, DO_FIND_NAME__null, &findName, nameChoice);
  if (findName.code == error) {
       *pErrorCode = U_ILLEGAL_CHAR_FOUND;
  }
  return findName.code;
1632}

1634U_CAPIextern "C" void U_EXPORT2
1635u_enumCharNamesu_enumCharNames_71(UChar32 start, UChar32 limit,
              UEnumCharNamesFn *fn,
              void *context,
              UCharNameChoice nameChoice,
              UErrorCode *pErrorCode) {
  AlgorithmicRange *algRange;
  uint32_t *p;
  uint32_t i;

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

  if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT || fn==NULL__null) {
2
←
Assuming 'nameChoice' is < U_CHAR_NAME_CHOICE_COUNT→
3
←
Assuming 'fn' is not equal to NULL→
4
←
Taking false branch→
      *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  if((uint32_t) limit > UCHAR_MAX_VALUE0x10ffff + 1) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      limit = UCHAR_MAX_VALUE0x10ffff + 1;
  }
  if((uint32_t)start>=(uint32_t)limit) {
7
←
Assuming 'start' is < 'limit'→
8
←
Taking false branch→
      return;
  }

  if(!isDataLoaded(pErrorCode)) {
9
←
Taking false branch→
      return;
  }

  /* interleave the data-driven ones with the algorithmic ones */
  /* iterate over all algorithmic ranges; assume that they are in ascending order */
  p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset);
  i=*p;
  algRange=(AlgorithmicRange *)(p+1);
  while(i>0) {
10
←
Assuming 'i' is > 0→
11
←
Loop condition is true.  Entering loop body→
      /* enumerate the character names before the current algorithmic range */
      /* here: start<limit */
      if((uint32_t)start<algRange->start) {
12
←
Assuming 'start' is >= field 'start'→
13
←
Taking false branch→
          if((uint32_t)limit<=algRange->start) {
              enumNames(uCharNames, start, limit, fn, context, nameChoice);
              return;
          }
          if(!enumNames(uCharNames, start, (UChar32)algRange->start, fn, context, nameChoice)) {
              return;
          }
          start=(UChar32)algRange->start;
      }
      /* enumerate the character names in the current algorithmic range */
      /* here: algRange->start<=start<limit */
      if((uint32_t)start<=algRange->end) {
14
←
Assuming 'start' is <= field 'end'→
15
←
Taking true branch→
          if((uint32_t)limit<=(algRange->end+1)) {
16
←
Assuming the condition is true→
17
←
Taking true branch→
              enumAlgNames(algRange, start, limit, fn, context, nameChoice);
18
←
Calling 'enumAlgNames'→
              return;
          }
          if(!enumAlgNames(algRange, start, (UChar32)algRange->end+1, fn, context, nameChoice)) {
              return;
          }
          start=(UChar32)algRange->end+1;
      }
      /* continue to the next algorithmic range (here: start<limit) */
      algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size);
      --i;
  }
  /* enumerate the character names after the last algorithmic range */
  enumNames(uCharNames, start, limit, fn, context, nameChoice);
1700}

1702U_CAPIextern "C" int32_t U_EXPORT2
1703uprv_getMaxCharNameLengthuprv_getMaxCharNameLength_71() {
  UErrorCode errorCode=U_ZERO_ERROR;
  if(calcNameSetsLengths(&errorCode)) {
      return gMaxNameLength;
  } else {
      return 0;
  }
1710}

1712/**
* Converts the char set cset into a Unicode set uset.
* @param cset Set of 256 bit flags corresponding to a set of chars.
* @param uset USet to receive characters. Existing contents are deleted.
*/
1717static void
1718charSetToUSet(uint32_t cset[8], const USetAdder *sa) {
  UChar us[256];
  char cs[256];

  int32_t i, length;
  UErrorCode errorCode;

  errorCode=U_ZERO_ERROR;

  if(!calcNameSetsLengths(&errorCode)) {
      return;
  }

  /* build a char string with all chars that are used in character names */
  length=0;
  for(i=0; i<256; ++i) {
      if(SET_CONTAINS(cset, i)(((cset)[(uint8_t)i>>5]&((uint32_t)1<<((uint8_t
)i&0x1f)))!=0)) {
          cs[length++]=(char)i;
      }
  }

  /* convert the char string to a UChar string */
  u_charsToUCharsu_charsToUChars_71(cs, us, length);

  /* add each UChar to the USet */
  for(i=0; i<length; ++i) {
      if(us[i]!=0 || cs[i]==0) { /* non-invariant chars become (UChar)0 */
          sa->add(sa->set, us[i]);
      }
  }
1748}

1750/**
* Fills set with characters that are used in Unicode character names.
* @param set USet to receive characters.
*/
1754U_CAPIextern "C" void U_EXPORT2
1755uprv_getCharNameCharactersuprv_getCharNameCharacters_71(const USetAdder *sa) {
  charSetToUSet(gNameSet, sa);
1757}

1759/* data swapping ------------------------------------------------------------ */

1761/*
* The token table contains non-negative entries for token bytes,
* and -1 for bytes that represent themselves in the data file's charset.
* -2 entries are used for lead bytes.
*
* Direct bytes (-1 entries) must be translated from the input charset family
* to the output charset family.
* makeTokenMap() writes a permutation mapping for this.
* Use it once for single-/lead-byte tokens and once more for all trail byte
* tokens. (';' is an unused trail byte marked with -1.)
*/
1772static void
1773makeTokenMap(const UDataSwapper *ds,
           int16_t tokens[], uint16_t tokenCount,
           uint8_t map[256],
           UErrorCode *pErrorCode) {
  UBool usedOutChar[256];
  uint16_t i, j;
  uint8_t c1, c2;

  if(U_FAILURE(*pErrorCode)) {
      return;
  }

  if(ds->inCharset==ds->outCharset) {
      /* Same charset family: identity permutation */
      for(i=0; i<256; ++i) {
          map[i]=(uint8_t)i;
      }
  } else {
      uprv_memset(map, 0, 256):: memset(map, 0, 256);
      uprv_memset(usedOutChar, 0, 256):: memset(usedOutChar, 0, 256);

      if(tokenCount>256) {
          tokenCount=256;
      }

      /* set the direct bytes (byte 0 always maps to itself) */
      for(i=1; i<tokenCount; ++i) {
          if(tokens[i]==-1) {
              /* convert the direct byte character */
              c1=(uint8_t)i;
              ds->swapInvChars(ds, &c1, 1, &c2, pErrorCode);
              if(U_FAILURE(*pErrorCode)) {
                  udata_printErrorudata_printError_71(ds, "unames/makeTokenMap() finds variant character 0x%02x used (input charset family %d)\n",
                                   i, ds->inCharset);
                  return;
              }

              /* enter the converted character into the map and mark it used */
              map[c1]=c2;
              usedOutChar[c2]=TRUE1;
          }
      }

      /* set the mappings for the rest of the permutation */
      for(i=j=1; i<tokenCount; ++i) {
          /* set mappings that were not set for direct bytes */
          if(map[i]==0) {
              /* set an output byte value that was not used as an output byte above */
              while(usedOutChar[j]) {
                  ++j;
              }
              map[i]=(uint8_t)j++;
          }
      }

      /*
       * leave mappings at tokenCount and above unset if tokenCount<256
       * because they won't be used
       */
  }
1833}

1835U_CAPIextern "C" int32_t U_EXPORT2
1836uchar_swapNamesuchar_swapNames_71(const UDataSwapper *ds,
              const void *inData, int32_t length, void *outData,
              UErrorCode *pErrorCode) {
  const UDataInfo *pInfo;
  int32_t headerSize;

  const uint8_t *inBytes;
  uint8_t *outBytes;

  uint32_t tokenStringOffset, groupsOffset, groupStringOffset, algNamesOffset,
           offset, i, count, stringsCount;

  const AlgorithmicRange *inRange;
  AlgorithmicRange *outRange;

  /* udata_swapDataHeader checks the arguments */
  headerSize=udata_swapDataHeaderudata_swapDataHeader_71(ds, inData, length, outData, pErrorCode);
  if(pErrorCode==NULL__null || U_FAILURE(*pErrorCode)) {
      return 0;
  }

  /* check data format and format version */
  pInfo=(const UDataInfo *)((const char *)inData+4);
  if(!(
      pInfo->dataFormat[0]==0x75 &&   /* dataFormat="unam" */
      pInfo->dataFormat[1]==0x6e &&
      pInfo->dataFormat[2]==0x61 &&
      pInfo->dataFormat[3]==0x6d &&
      pInfo->formatVersion[0]==1
  )) {
      udata_printErrorudata_printError_71(ds, "uchar_swapNames(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as unames.icu\n",
                       pInfo->dataFormat[0], pInfo->dataFormat[1],
                       pInfo->dataFormat[2], pInfo->dataFormat[3],
                       pInfo->formatVersion[0]);
      *pErrorCode=U_UNSUPPORTED_ERROR;
      return 0;
  }

  inBytes=(const uint8_t *)inData+headerSize;
  outBytes=(uint8_t *)outData+headerSize;
  if(length<0) {
      algNamesOffset=ds->readUInt32(((const uint32_t *)inBytes)[3]);
  } else {
      length-=headerSize;
      if( length<20 ||
          (uint32_t)length<(algNamesOffset=ds->readUInt32(((const uint32_t *)inBytes)[3]))
      ) {
          udata_printErrorudata_printError_71(ds, "uchar_swapNames(): too few bytes (%d after header) for unames.icu\n",
                           length);
          *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
          return 0;
      }
  }

  if(length<0) {
      /* preflighting: iterate through algorithmic ranges */
      offset=algNamesOffset;
      count=ds->readUInt32(*((const uint32_t *)(inBytes+offset)));
      offset+=4;

      for(i=0; i<count; ++i) {
          inRange=(const AlgorithmicRange *)(inBytes+offset);
          offset+=ds->readUInt16(inRange->size);
      }
  } else {
      /* swap data */
      const uint16_t *p;
      uint16_t *q, *temp;

      int16_t tokens[512];
      uint16_t tokenCount;

      uint8_t map[256], trailMap[256];

      /* copy the data for inaccessible bytes */
      if(inBytes!=outBytes) {
          uprv_memcpy(outBytes, inBytes, length)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(outBytes,
 inBytes, length); } while (false);
      }

      /* the initial 4 offsets first */
      tokenStringOffset=ds->readUInt32(((const uint32_t *)inBytes)[0]);
      groupsOffset=ds->readUInt32(((const uint32_t *)inBytes)[1]);
      groupStringOffset=ds->readUInt32(((const uint32_t *)inBytes)[2]);
      ds->swapArray32(ds, inBytes, 16, outBytes, pErrorCode);

      /*
       * now the tokens table
       * it needs to be permutated along with the compressed name strings
       */
      p=(const uint16_t *)(inBytes+16);
      q=(uint16_t *)(outBytes+16);

      /* read and swap the tokenCount */
      tokenCount=ds->readUInt16(*p);
      ds->swapArray16(ds, p, 2, q, pErrorCode);
      ++p;
      ++q;

      /* read the first 512 tokens and make the token maps */
      if(tokenCount<=512) {
          count=tokenCount;
      } else {
          count=512;
      }
      for(i=0; i<count; ++i) {
          tokens[i]=udata_readInt16udata_readInt16_71(ds, p[i]);
      }
      for(; i<512; ++i) {
          tokens[i]=0; /* fill the rest of the tokens array if tokenCount<512 */
      }
      makeTokenMap(ds, tokens, tokenCount, map, pErrorCode);
      makeTokenMap(ds, tokens+256, (uint16_t)(tokenCount>256 ? tokenCount-256 : 0), trailMap, pErrorCode);
      if(U_FAILURE(*pErrorCode)) {
          return 0;
      }

      /*
       * swap and permutate the tokens
       * go through a temporary array to support in-place swapping
       */
      temp=(uint16_t *)uprv_mallocuprv_malloc_71(tokenCount*2);
      if(temp==NULL__null) {
          udata_printErrorudata_printError_71(ds, "out of memory swapping %u unames.icu tokens\n",
                           tokenCount);
          *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
          return 0;
      }

      /* swap and permutate single-/lead-byte tokens */
      for(i=0; i<tokenCount && i<256; ++i) {
          ds->swapArray16(ds, p+i, 2, temp+map[i], pErrorCode);
      }

      /* swap and permutate trail-byte tokens */
      for(; i<tokenCount; ++i) {
          ds->swapArray16(ds, p+i, 2, temp+(i&0xffffff00)+trailMap[i&0xff], pErrorCode);
      }

      /* copy the result into the output and free the temporary array */
      uprv_memcpy(q, temp, tokenCount*2)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(q, temp, tokenCount
*2); } while (false);
      uprv_freeuprv_free_71(temp);

      /*
       * swap the token strings but not a possible padding byte after
       * the terminating NUL of the last string
       */
      udata_swapInvStringBlockudata_swapInvStringBlock_71(ds, inBytes+tokenStringOffset, (int32_t)(groupsOffset-tokenStringOffset),
                                  outBytes+tokenStringOffset, pErrorCode);
      if(U_FAILURE(*pErrorCode)) {
          udata_printErrorudata_printError_71(ds, "uchar_swapNames(token strings) failed\n");
          return 0;
      }

      /* swap the group table */
      count=ds->readUInt16(*((const uint16_t *)(inBytes+groupsOffset)));
      ds->swapArray16(ds, inBytes+groupsOffset, (int32_t)((1+count*3)*2),
                         outBytes+groupsOffset, pErrorCode);

      /*
       * swap the group strings
       * swap the string bytes but not the nibble-encoded string lengths
       */
      if(ds->inCharset!=ds->outCharset) {
          uint16_t offsets[LINES_PER_GROUP(1L<<5)+1], lengths[LINES_PER_GROUP(1L<<5)+1];

          const uint8_t *inStrings, *nextInStrings;
          uint8_t *outStrings;

          uint8_t c;

          inStrings=inBytes+groupStringOffset;
          outStrings=outBytes+groupStringOffset;

          stringsCount=algNamesOffset-groupStringOffset;

          /* iterate through string groups until only a few padding bytes are left */
          while(stringsCount>32) {
              nextInStrings=expandGroupLengths(inStrings, offsets, lengths);

              /* move past the length bytes */
              stringsCount-=(uint32_t)(nextInStrings-inStrings);
              outStrings+=nextInStrings-inStrings;
              inStrings=nextInStrings;

              count=offsets[31]+lengths[31]; /* total number of string bytes in this group */
              stringsCount-=count;

              /* swap the string bytes using map[] and trailMap[] */
              while(count>0) {
                  c=*inStrings++;
                  *outStrings++=map[c];
                  if(tokens[c]!=-2) {
                      --count;
                  } else {
                      /* token lead byte: swap the trail byte, too */
                      *outStrings++=trailMap[*inStrings++];
                      count-=2;
                  }
              }
          }
      }

      /* swap the algorithmic ranges */
      offset=algNamesOffset;
      count=ds->readUInt32(*((const uint32_t *)(inBytes+offset)));
      ds->swapArray32(ds, inBytes+offset, 4, outBytes+offset, pErrorCode);
      offset+=4;

      for(i=0; i<count; ++i) {
          if(offset>(uint32_t)length) {
              udata_printErrorudata_printError_71(ds, "uchar_swapNames(): too few bytes (%d after header) for unames.icu algorithmic range %u\n",
                               length, i);
              *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
              return 0;
          }

          inRange=(const AlgorithmicRange *)(inBytes+offset);
          outRange=(AlgorithmicRange *)(outBytes+offset);
          offset+=ds->readUInt16(inRange->size);

          ds->swapArray32(ds, inRange, 8, outRange, pErrorCode);
          ds->swapArray16(ds, &inRange->size, 2, &outRange->size, pErrorCode);
          switch(inRange->type) {
          case 0:
              /* swap prefix string */
              ds->swapInvChars(ds, inRange+1, (int32_t)uprv_strlen((const char *)(inRange+1)):: strlen((const char *)(inRange+1)),
                                  outRange+1, pErrorCode);
              if(U_FAILURE(*pErrorCode)) {
                  udata_printErrorudata_printError_71(ds, "uchar_swapNames(prefix string of algorithmic range %u) failed\n",
                                   i);
                  return 0;
              }
              break;
          case 1:
              {
                  /* swap factors and the prefix and factor strings */
                  uint32_t factorsCount;

                  factorsCount=inRange->variant;
                  p=(const uint16_t *)(inRange+1);
                  q=(uint16_t *)(outRange+1);
                  ds->swapArray16(ds, p, (int32_t)(factorsCount*2), q, pErrorCode);

                  /* swap the strings, up to the last terminating NUL */
                  p+=factorsCount;
                  q+=factorsCount;
                  stringsCount=(uint32_t)((inBytes+offset)-(const uint8_t *)p);
                  while(stringsCount>0 && ((const uint8_t *)p)[stringsCount-1]!=0) {
                      --stringsCount;
                  }
                  ds->swapInvChars(ds, p, (int32_t)stringsCount, q, pErrorCode);
              }
              break;
          default:
              udata_printErrorudata_printError_71(ds, "uchar_swapNames(): unknown type %u of algorithmic range %u\n",
                               inRange->type, i);
              *pErrorCode=U_UNSUPPORTED_ERROR;
              return 0;
          }
      }
  }

  return headerSize+(int32_t)offset;
2099}

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