../deps/icu-small/source/i18n/dtitvfmt.cpp

Bug Summary

File:	out/../deps/icu-small/source/i18n/dtitvfmt.cpp
Warning:	line 389, column 20 The left operand of '!=' is a garbage value
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 dtitvfmt.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_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_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 -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -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/i18n/dtitvfmt.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*******************************************************************************
4* Copyright (C) 2008-2016, International Business Machines Corporation and
5* others. All Rights Reserved.
6*******************************************************************************
7*
8* File DTITVFMT.CPP
9*
10*******************************************************************************
11*/

13#include "utypeinfo.h"  // for 'typeid' to work

15#include "unicode/dtitvfmt.h"

17#if !UCONFIG_NO_FORMATTING0

19//TODO: put in compilation
20//#define DTITVFMT_DEBUG 1

22#include "unicode/calendar.h"
23#include "unicode/dtptngen.h"
24#include "unicode/dtitvinf.h"
25#include "unicode/simpleformatter.h"
26#include "unicode/udisplaycontext.h"
27#include "cmemory.h"
28#include "cstring.h"
29#include "dtitv_impl.h"
30#include "mutex.h"
31#include "uresimp.h"
32#include "formattedval_impl.h"

34#ifdef DTITVFMT_DEBUG
35#include <iostream>
36#endif

38U_NAMESPACE_BEGINnamespace icu_71 {



42#ifdef DTITVFMT_DEBUG
43#define PRINTMESG(msg) { std::cout << "(" << __FILE__"../deps/icu-small/source/i18n/dtitvfmt.cpp" << ":" << __LINE__43 << ") " << msg << "\n"; }
44#endif


47static const UChar gDateFormatSkeleton[][11] = {
48//yMMMMEEEEd
49{LOW_Y((UChar)0x0079), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_E((UChar)0x0045), CAP_E((UChar)0x0045), CAP_E((UChar)0x0045), CAP_E((UChar)0x0045), LOW_D((UChar)0x0064), 0},
50//yMMMMd
51{LOW_Y((UChar)0x0079), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), LOW_D((UChar)0x0064), 0},
52//yMMMd
53{LOW_Y((UChar)0x0079), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), CAP_M((UChar)0x004D), LOW_D((UChar)0x0064), 0},
54//yMd
55{LOW_Y((UChar)0x0079), CAP_M((UChar)0x004D), LOW_D((UChar)0x0064), 0} };


58static const char gCalendarTag[] = "calendar";
59static const char gGregorianTag[] = "gregorian";
60static const char gDateTimePatternsTag[] = "DateTimePatterns";


63// latestFirst:
64static const UChar gLaterFirstPrefix[] = {LOW_L((UChar)0x006C), LOW_A((UChar)0x0061), LOW_T((UChar)0x0074), LOW_E((UChar)0x0065), LOW_S((UChar)0x0073),LOW_T((UChar)0x0074), CAP_F((UChar)0x0046), LOW_I((UChar)0x0069), LOW_R((UChar)0x0072), LOW_S((UChar)0x0073), LOW_T((UChar)0x0074), COLON((UChar)0x003A)};

66// earliestFirst:
67static const UChar gEarlierFirstPrefix[] = {LOW_E((UChar)0x0065), LOW_A((UChar)0x0061), LOW_R((UChar)0x0072), LOW_L((UChar)0x006C), LOW_I((UChar)0x0069), LOW_E((UChar)0x0065), LOW_S((UChar)0x0073), LOW_T((UChar)0x0074), CAP_F((UChar)0x0046), LOW_I((UChar)0x0069), LOW_R((UChar)0x0072), LOW_S((UChar)0x0073), LOW_T((UChar)0x0074), COLON((UChar)0x003A)};


70class FormattedDateIntervalData : public FormattedValueFieldPositionIteratorImpl {
71public:
  FormattedDateIntervalData(UErrorCode& status) : FormattedValueFieldPositionIteratorImpl(5, status) {}
  virtual ~FormattedDateIntervalData();
74};

76FormattedDateIntervalData::~FormattedDateIntervalData() = default;

78UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedDateInterval)FormattedDateInterval::FormattedDateInterval(FormattedDateInterval
&& src) noexcept : fData(src.fData), fErrorCode(src.fErrorCode
) { src.fData = nullptr; src.fErrorCode = U_INVALID_STATE_ERROR
; } FormattedDateInterval::~FormattedDateInterval() { delete fData
; fData = nullptr; } FormattedDateInterval& FormattedDateInterval
::operator=(FormattedDateInterval&& src) noexcept { delete
 fData; fData = src.fData; src.fData = nullptr; fErrorCode = src
.fErrorCode; src.fErrorCode = U_INVALID_STATE_ERROR; return *
this; } UnicodeString FormattedDateInterval::toString(UErrorCode
& status) const { if (U_FAILURE(status)) { return ICU_Utility
::makeBogusString(); } if (fData == nullptr) { status = fErrorCode
; return ICU_Utility::makeBogusString(); } return fData->toString
(status); } UnicodeString FormattedDateInterval::toTempString
(UErrorCode& status) const { if (U_FAILURE(status)) { return
 ICU_Utility::makeBogusString(); } if (fData == nullptr) { status
 = fErrorCode; return ICU_Utility::makeBogusString(); } return
 fData->toTempString(status); } Appendable& FormattedDateInterval
::appendTo(Appendable& appendable, UErrorCode& status
) const { if (U_FAILURE(status)) { return appendable; } if (fData
 == nullptr) { status = fErrorCode; return appendable; } return
 fData->appendTo(appendable, status); } UBool FormattedDateInterval
::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode
& status) const { if (U_FAILURE(status)) { return false; }
 if (fData == nullptr) { status = fErrorCode; return false; }
 return fData->nextPosition(cfpos, status); }


81UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)UClassID DateIntervalFormat::getStaticClassID() { static char
 classID = 0; return (UClassID)&classID; } UClassID DateIntervalFormat
::getDynamicClassID() const { return DateIntervalFormat::getStaticClassID
(); }

83// Mutex, protects access to fDateFormat, fFromCalendar and fToCalendar.
84//        Needed because these data members are modified by const methods of DateIntervalFormat.

86static UMutex gFormatterMutex;

88DateIntervalFormat* U_EXPORT2
89DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                 UErrorCode& status) {
  return createInstance(skeleton, Locale::getDefault(), status);
92}


95DateIntervalFormat* U_EXPORT2
96DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                 const Locale& locale,
                                 UErrorCode& status) {
99#ifdef DTITVFMT_DEBUG
  char result[1000];
  char result_1[1000];
  char mesg[2000];
  skeleton.extract(0,  skeleton.length(), result, "UTF-8");
  UnicodeString pat;
  ((SimpleDateFormat*)dtfmt)->toPattern(pat);
  pat.extract(0,  pat.length(), result_1, "UTF-8");
  sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1);
  PRINTMESG(mesg)
109#endif

  DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
  if (dtitvinf == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return nullptr;
  }
  return create(locale, dtitvinf, &skeleton, status);
117}



121DateIntervalFormat* U_EXPORT2
122DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                 const DateIntervalInfo& dtitvinf,
                                 UErrorCode& status) {
  return createInstance(skeleton, Locale::getDefault(), dtitvinf, status);
126}


129DateIntervalFormat* U_EXPORT2
130DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                 const Locale& locale,
                                 const DateIntervalInfo& dtitvinf,
                                 UErrorCode& status) {
  DateIntervalInfo* ptn = dtitvinf.clone();
  return create(locale, ptn, &skeleton, status);
136}


139DateIntervalFormat::DateIntervalFormat()
  fInfo(nullptr),
  fDateFormat(nullptr),
  fFromCalendar(nullptr),
  fToCalendar(nullptr),
  fLocale(Locale::getRoot()),
  fDatePattern(nullptr),
  fTimePattern(nullptr),
  fDateTimeFormat(nullptr),
  fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
149{}


152DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
  Format(itvfmt),
  fInfo(nullptr),
  fDateFormat(nullptr),
  fFromCalendar(nullptr),
  fToCalendar(nullptr),
  fLocale(itvfmt.fLocale),
  fDatePattern(nullptr),
  fTimePattern(nullptr),
  fDateTimeFormat(nullptr),
  fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE) {
  *this = itvfmt;
164}


167DateIntervalFormat&
168DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
  if ( this != &itvfmt ) {
      delete fDateFormat;
      delete fInfo;
      delete fFromCalendar;
      delete fToCalendar;
      delete fDatePattern;
      delete fTimePattern;
      delete fDateTimeFormat;
      {
          Mutex lock(&gFormatterMutex);
          if ( itvfmt.fDateFormat ) {
              fDateFormat = itvfmt.fDateFormat->clone();
          } else {
              fDateFormat = nullptr;
          }
          if ( itvfmt.fFromCalendar ) {
              fFromCalendar = itvfmt.fFromCalendar->clone();
          } else {
              fFromCalendar = nullptr;
          }
          if ( itvfmt.fToCalendar ) {
              fToCalendar = itvfmt.fToCalendar->clone();
          } else {
              fToCalendar = nullptr;
          }
      }
      if ( itvfmt.fInfo ) {
          fInfo = itvfmt.fInfo->clone();
      } else {
          fInfo = nullptr;
      }
      fSkeleton = itvfmt.fSkeleton;
      int8_t i;
      for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
          fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i];
      }
      fLocale = itvfmt.fLocale;
      fDatePattern    = (itvfmt.fDatePattern)?    itvfmt.fDatePattern->clone(): nullptr;
      fTimePattern    = (itvfmt.fTimePattern)?    itvfmt.fTimePattern->clone(): nullptr;
      fDateTimeFormat = (itvfmt.fDateTimeFormat)? itvfmt.fDateTimeFormat->clone(): nullptr;
      fCapitalizationContext = itvfmt.fCapitalizationContext;
  }
  return *this;
212}


215DateIntervalFormat::~DateIntervalFormat() {
  delete fInfo;
  delete fDateFormat;
  delete fFromCalendar;
  delete fToCalendar;
  delete fDatePattern;
  delete fTimePattern;
  delete fDateTimeFormat;
223}


226DateIntervalFormat*
227DateIntervalFormat::clone() const {
  return new DateIntervalFormat(*this);
229}


232bool
233DateIntervalFormat::operator==(const Format& other) const {
  if (typeid(*this) != typeid(other)) {return false;}
  const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
  if (this == fmt) {return true;}
  if (!Format::operator==(other)) {return false;}
  if ((fInfo != fmt->fInfo) && (fInfo == nullptr || fmt->fInfo == nullptr)) {return false;}
  if (fInfo && fmt->fInfo && (*fInfo != *fmt->fInfo )) {return false;}
  {
      Mutex lock(&gFormatterMutex);
      if (fDateFormat != fmt->fDateFormat && (fDateFormat == nullptr || fmt->fDateFormat == nullptr)) {return false;}
      if (fDateFormat && fmt->fDateFormat && (*fDateFormat != *fmt->fDateFormat)) {return false;}
  }
  // note: fFromCalendar and fToCalendar hold no persistent state, and therefore do not participate in operator ==.
  //       fDateFormat has the primary calendar for the DateIntervalFormat.
  if (fSkeleton != fmt->fSkeleton) {return false;}
  if (fDatePattern != fmt->fDatePattern && (fDatePattern == nullptr || fmt->fDatePattern == nullptr)) {return false;}
  if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return false;}
  if (fTimePattern != fmt->fTimePattern && (fTimePattern == nullptr || fmt->fTimePattern == nullptr)) {return false;}
  if (fTimePattern && fmt->fTimePattern && (*fTimePattern != *fmt->fTimePattern)) {return false;}
  if (fDateTimeFormat != fmt->fDateTimeFormat && (fDateTimeFormat == nullptr || fmt->fDateTimeFormat == nullptr)) {return false;}
  if (fDateTimeFormat && fmt->fDateTimeFormat && (*fDateTimeFormat != *fmt->fDateTimeFormat)) {return false;}
  if (fLocale != fmt->fLocale) {return false;}

  for (int32_t i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
      if (fIntervalPatterns[i].firstPart != fmt->fIntervalPatterns[i].firstPart) {return false;}
      if (fIntervalPatterns[i].secondPart != fmt->fIntervalPatterns[i].secondPart ) {return false;}
      if (fIntervalPatterns[i].laterDateFirst != fmt->fIntervalPatterns[i].laterDateFirst) {return false;}
  }
  if (fCapitalizationContext != fmt->fCapitalizationContext) {return false;}
  return true;
263}


266UnicodeString&
267DateIntervalFormat::format(const Formattable& obj,
                         UnicodeString& appendTo,
                         FieldPosition& fieldPosition,
                         UErrorCode& status) const {
  if ( U_FAILURE(status) ) {
      return appendTo;
  }

  if ( obj.getType() == Formattable::kObject ) {
      const UObject* formatObj = obj.getObject();
      const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj);
      if (interval != nullptr) {
          return format(interval, appendTo, fieldPosition, status);
      }
  }
  status = U_ILLEGAL_ARGUMENT_ERROR;
  return appendTo;
284}


287UnicodeString&
288DateIntervalFormat::format(const DateInterval* dtInterval,
                         UnicodeString& appendTo,
                         FieldPosition& fieldPosition,
                         UErrorCode& status) const {
  if ( U_FAILURE(status) ) {
      return appendTo;
  }
  if (fDateFormat == nullptr || fInfo == nullptr) {
      status = U_INVALID_STATE_ERROR;
      return appendTo;
  }

  FieldPositionOnlyHandler handler(fieldPosition);
  handler.setAcceptFirstOnly(TRUE1);
  int8_t ignore;

  Mutex lock(&gFormatterMutex);
  return formatIntervalImpl(*dtInterval, appendTo, ignore, handler, status);
306}


309FormattedDateInterval DateIntervalFormat::formatToValue(
      const DateInterval& dtInterval,
      UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return FormattedDateInterval(status);
  }
  // LocalPointer only sets OOM status if U_SUCCESS is true.
  LocalPointer<FormattedDateIntervalData> result(new FormattedDateIntervalData(status), status);
  if (U_FAILURE(status)) {
      return FormattedDateInterval(status);
  }
  UnicodeString string;
  int8_t firstIndex;
  auto handler = result->getHandler(status);
  handler.setCategory(UFIELD_CATEGORY_DATE);
  {
      Mutex lock(&gFormatterMutex);
      formatIntervalImpl(dtInterval, string, firstIndex, handler, status);
  }
  handler.getError(status);
  result->appendString(string, status);
  if (U_FAILURE(status)) {
      return FormattedDateInterval(status);
  }

  // Compute the span fields and sort them into place:
  if (firstIndex != -1) {
      result->addOverlapSpans(UFIELD_CATEGORY_DATE_INTERVAL_SPAN, firstIndex, status);
      if (U_FAILURE(status)) {
          return FormattedDateInterval(status);
      }
      result->sort();
  }

  return FormattedDateInterval(result.orphan());
344}


347UnicodeString&
348DateIntervalFormat::format(Calendar& fromCalendar,
                         Calendar& toCalendar,
                         UnicodeString& appendTo,
                         FieldPosition& pos,
                         UErrorCode& status) const {
  FieldPositionOnlyHandler handler(pos);
  handler.setAcceptFirstOnly(TRUE1);
  int8_t ignore;

  Mutex lock(&gFormatterMutex);
  return formatImpl(fromCalendar, toCalendar, appendTo, ignore, handler, status);
359}


362FormattedDateInterval DateIntervalFormat::formatToValue(
      Calendar& fromCalendar,
      Calendar& toCalendar,
      UErrorCode& status) const {
  if (U_FAILURE(status)) {
1
Taking false branch→
      return FormattedDateInterval(status);
  }
  // LocalPointer only sets OOM status if U_SUCCESS is true.
  LocalPointer<FormattedDateIntervalData> result(new FormattedDateIntervalData(status), status);
  if (U_FAILURE(status)) {
2
←
Taking false branch→
      return FormattedDateInterval(status);
  }
  UnicodeString string;
  int8_t firstIndex;
3
←
'firstIndex' declared without an initial value→
  auto handler = result->getHandler(status);
  handler.setCategory(UFIELD_CATEGORY_DATE);
  {
      Mutex lock(&gFormatterMutex);
      formatImpl(fromCalendar, toCalendar, string, firstIndex, handler, status);
4
←
Calling 'DateIntervalFormat::formatImpl'→
7
←
Returning from 'DateIntervalFormat::formatImpl'→
  }
  handler.getError(status);
  result->appendString(string, status);
  if (U_FAILURE(status)) {
8
←
Taking false branch→
      return FormattedDateInterval(status);
  }

  // Compute the span fields and sort them into place:
  if (firstIndex != -1) {
9
←
The left operand of '!=' is a garbage value
      result->addOverlapSpans(UFIELD_CATEGORY_DATE_INTERVAL_SPAN, firstIndex, status);
      result->sort();
  }

  return FormattedDateInterval(result.orphan());
395}


398UnicodeString& DateIntervalFormat::formatIntervalImpl(
      const DateInterval& dtInterval,
      UnicodeString& appendTo,
      int8_t& firstIndex,
      FieldPositionHandler& fphandler,
      UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return appendTo;
  }
  if (fFromCalendar == nullptr || fToCalendar == nullptr) {
      status = U_INVALID_STATE_ERROR;
      return appendTo;
  }
  fFromCalendar->setTime(dtInterval.getFromDate(), status);
  fToCalendar->setTime(dtInterval.getToDate(), status);
  return formatImpl(*fFromCalendar, *fToCalendar, appendTo, firstIndex, fphandler, status);
414}


417// The following is only called from within the gFormatterMutex lock
418UnicodeString&
419DateIntervalFormat::formatImpl(Calendar& fromCalendar,
                         Calendar& toCalendar,
                         UnicodeString& appendTo,
                         int8_t& firstIndex,
                         FieldPositionHandler& fphandler,
                         UErrorCode& status) const {
  if ( U_FAILURE(status) ) {
5
←
Taking true branch→
      return appendTo;
6
←
Returning without writing to 'firstIndex'→
  }

  // Initialize firstIndex to -1 (single date, no range)
  firstIndex = -1;

  // not support different calendar types and time zones
  //if ( fromCalendar.getType() != toCalendar.getType() ) {
  if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return appendTo;
  }

  // First, find the largest different calendar field.
  UCalendarDateFields field = UCAL_FIELD_COUNT;

  if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
      field = UCAL_ERA;
  } else if ( fromCalendar.get(UCAL_YEAR, status) !=
              toCalendar.get(UCAL_YEAR, status) ) {
      field = UCAL_YEAR;
  } else if ( fromCalendar.get(UCAL_MONTH, status) !=
              toCalendar.get(UCAL_MONTH, status) ) {
      field = UCAL_MONTH;
  } else if ( fromCalendar.get(UCAL_DATE, status) !=
              toCalendar.get(UCAL_DATE, status) ) {
      field = UCAL_DATE;
  } else if ( fromCalendar.get(UCAL_AM_PM, status) !=
              toCalendar.get(UCAL_AM_PM, status) ) {
      field = UCAL_AM_PM;
  } else if ( fromCalendar.get(UCAL_HOUR, status) !=
              toCalendar.get(UCAL_HOUR, status) ) {
      field = UCAL_HOUR;
  } else if ( fromCalendar.get(UCAL_MINUTE, status) !=
              toCalendar.get(UCAL_MINUTE, status) ) {
      field = UCAL_MINUTE;
  } else if ( fromCalendar.get(UCAL_SECOND, status) !=
              toCalendar.get(UCAL_SECOND, status) ) {
      field = UCAL_SECOND;
  } else if ( fromCalendar.get(UCAL_MILLISECOND, status) !=
              toCalendar.get(UCAL_MILLISECOND, status) ) {
      field = UCAL_MILLISECOND;
  }

  if ( U_FAILURE(status) ) {
      return appendTo;
  }
  UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
  // Set up fDateFormat to handle the first or only part of the interval
  // (override later for any second part). Inside lock, OK to modify fDateFormat.
  fDateFormat->setContext(fCapitalizationContext, tempStatus);

  if ( field == UCAL_FIELD_COUNT ) {
      /* ignore the millisecond etc. small fields' difference.
       * use single date when all the above are the same.
       */
      return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
  }
  UBool fromToOnSameDay = (field==UCAL_AM_PM || field==UCAL_HOUR || field==UCAL_MINUTE || field==UCAL_SECOND || field==UCAL_MILLISECOND);

  // following call should not set wrong status,
  // all the pass-in fields are valid till here
  int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
                                                                      status);
  const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex];

  if ( intervalPattern.firstPart.isEmpty() &&
       intervalPattern.secondPart.isEmpty() ) {
      if ( fDateFormat->isFieldUnitIgnored(field) ) {
          /* the largest different calendar field is small than
           * the smallest calendar field in pattern,
           * return single date format.
           */
          return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
      }
      return fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
  }
  // If the first part in interval pattern is empty,
  // the 2nd part of it saves the full-pattern used in fall-back.
  // For a 'real' interval pattern, the first part will never be empty.
  if ( intervalPattern.firstPart.isEmpty() ) {
      // fall back
      UnicodeString originalPattern;
      fDateFormat->toPattern(originalPattern);
      fDateFormat->applyPattern(intervalPattern.secondPart);
      appendTo = fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
      fDateFormat->applyPattern(originalPattern);
      return appendTo;
  }
  Calendar* firstCal;
  Calendar* secondCal;
  if ( intervalPattern.laterDateFirst ) {
      firstCal = &toCalendar;
      secondCal = &fromCalendar;
      firstIndex = 1;
  } else {
      firstCal = &fromCalendar;
      secondCal = &toCalendar;
      firstIndex = 0;
  }
  // break the interval pattern into 2 parts,
  // first part should not be empty,
  UnicodeString originalPattern;
  fDateFormat->toPattern(originalPattern);
  fDateFormat->applyPattern(intervalPattern.firstPart);
  fDateFormat->_format(*firstCal, appendTo, fphandler, status);

  if ( !intervalPattern.secondPart.isEmpty() ) {
      fDateFormat->applyPattern(intervalPattern.secondPart);
      // No capitalization for second part of interval
      tempStatus = U_ZERO_ERROR;
      fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
      fDateFormat->_format(*secondCal, appendTo, fphandler, status);
  }
  fDateFormat->applyPattern(originalPattern);
  return appendTo;
542}



546void
547DateIntervalFormat::parseObject(const UnicodeString& /* source */,
                              Formattable& /* result */,
                              ParsePosition& /* parse_pos */) const {
  // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
  // will set status as U_INVALID_FORMAT_ERROR if
  // parse_pos is still 0
553}




558const DateIntervalInfo*
559DateIntervalFormat::getDateIntervalInfo() const {
  return fInfo;
561}


564void
565DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
                                      UErrorCode& status) {
  delete fInfo;
  fInfo = new DateIntervalInfo(newItvPattern);
  if (fInfo == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }

  // Delete patterns that get reset by initializePattern
  delete fDatePattern;
  fDatePattern = nullptr;
  delete fTimePattern;
  fTimePattern = nullptr;
  delete fDateTimeFormat;
  fDateTimeFormat = nullptr;

  if (fDateFormat) {
      initializePattern(status);
  }
584}



588const DateFormat*
589DateIntervalFormat::getDateFormat() const {
  return fDateFormat;
591}


594void
595DateIntervalFormat::adoptTimeZone(TimeZone* zone)
596{
  if (fDateFormat != nullptr) {
      fDateFormat->adoptTimeZone(zone);
  }
  // The fDateFormat has the primary calendar for the DateIntervalFormat and has
  // ownership of any adopted TimeZone; fFromCalendar and fToCalendar are internal
  // work clones of that calendar (and should not also be given ownership of the
  // adopted TimeZone).
  if (fFromCalendar) {
      fFromCalendar->setTimeZone(*zone);
  }
  if (fToCalendar) {
      fToCalendar->setTimeZone(*zone);
  }
610}

612void
613DateIntervalFormat::setTimeZone(const TimeZone& zone)
614{
  if (fDateFormat != nullptr) {
      fDateFormat->setTimeZone(zone);
  }
  // The fDateFormat has the primary calendar for the DateIntervalFormat;
  // fFromCalendar and fToCalendar are internal work clones of that calendar.
  if (fFromCalendar) {
      fFromCalendar->setTimeZone(zone);
  }
  if (fToCalendar) {
      fToCalendar->setTimeZone(zone);
  }
626}

628const TimeZone&
629DateIntervalFormat::getTimeZone() const
630{
  if (fDateFormat != nullptr) {
      Mutex lock(&gFormatterMutex);
      return fDateFormat->getTimeZone();
  }
  // If fDateFormat is nullptr (unexpected), create default timezone.
  return *(TimeZone::createDefault());
637}

639void
640DateIntervalFormat::setContext(UDisplayContext value, UErrorCode& status)
641{
  if (U_FAILURE(status))
      return;
  if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
      fCapitalizationContext = value;
  } else {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
649}

651UDisplayContext
652DateIntervalFormat::getContext(UDisplayContextType type, UErrorCode& status) const
653{
  if (U_FAILURE(status))
      return (UDisplayContext)0;
  if (type != UDISPCTX_TYPE_CAPITALIZATION) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return (UDisplayContext)0;
  }
  return fCapitalizationContext;
661}

663DateIntervalFormat::DateIntervalFormat(const Locale& locale,
                                     DateIntervalInfo* dtItvInfo,
                                     const UnicodeString* skeleton,
                                     UErrorCode& status)
  fInfo(nullptr),
  fDateFormat(nullptr),
  fFromCalendar(nullptr),
  fToCalendar(nullptr),
  fLocale(locale),
  fDatePattern(nullptr),
  fTimePattern(nullptr),
  fDateTimeFormat(nullptr),
  fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
676{
  LocalPointer<DateIntervalInfo> info(dtItvInfo, status);
  LocalPointer<SimpleDateFormat> dtfmt(static_cast<SimpleDateFormat *>(
          DateFormat::createInstanceForSkeleton(*skeleton, locale, status)), status);
  if (U_FAILURE(status)) {
      return;
  }

  if ( skeleton ) {
      fSkeleton = *skeleton;
  }
  fInfo = info.orphan();
  fDateFormat = dtfmt.orphan();
  if ( fDateFormat->getCalendar() ) {
      fFromCalendar = fDateFormat->getCalendar()->clone();
      fToCalendar = fDateFormat->getCalendar()->clone();
  }
  initializePattern(status);
694}

696DateIntervalFormat* U_EXPORT2
697DateIntervalFormat::create(const Locale& locale,
                         DateIntervalInfo* dtitvinf,
                         const UnicodeString* skeleton,
                         UErrorCode& status) {
  DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
                                                 skeleton, status);
  if ( f == nullptr ) {
      status = U_MEMORY_ALLOCATION_ERROR;
      delete dtitvinf;
  } else if ( U_FAILURE(status) ) {
      // safe to delete f, although nothing actually is saved
      delete f;
      f = 0;
  }
  return f;
712}



716/**
* Initialize interval patterns locale to this formatter
*
* This code is a bit complicated since
* 1. the interval patterns saved in resource bundle files are interval
*    patterns based on date or time only.
*    It does not have interval patterns based on both date and time.
*    Interval patterns on both date and time are algorithm generated.
*
*    For example, it has interval patterns on skeleton "dMy" and "hm",
*    but it does not have interval patterns on skeleton "dMyhm".
*
*    The rule to genearte interval patterns for both date and time skeleton are
*    1) when the year, month, or day differs, concatenate the two original
*    expressions with a separator between,
*    For example, interval pattern from "Jan 10, 2007 10:10 am"
*    to "Jan 11, 2007 10:10am" is
*    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
*
*    2) otherwise, present the date followed by the range expression
*    for the time.
*    For example, interval pattern from "Jan 10, 2007 10:10 am"
*    to "Jan 10, 2007 11:10am" is
*    "Jan 10, 2007 10:10 am - 11:10am"
*
* 2. even a pattern does not request a certion calendar field,
*    the interval pattern needs to include such field if such fields are
*    different between 2 dates.
*    For example, a pattern/skeleton is "hm", but the interval pattern
*    includes year, month, and date when year, month, and date differs.
*
* @param status          output param set to success/failure code on exit
* @stable ICU 4.0
*/
750void
751DateIntervalFormat::initializePattern(UErrorCode& status) {
  if ( U_FAILURE(status) ) {
      return;
  }
  const Locale& locale = fDateFormat->getSmpFmtLocale();
  if ( fSkeleton.isEmpty() ) {
      UnicodeString fullPattern;
      fDateFormat->toPattern(fullPattern);
759#ifdef DTITVFMT_DEBUG
  char result[1000];
  char result_1[1000];
  char mesg[2000];
  fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
  sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
  PRINTMESG(mesg)
766#endif
      // fSkeleton is already set by createDateIntervalInstance()
      // or by createInstance(UnicodeString skeleton, .... )
      fSkeleton = DateTimePatternGenerator::staticGetSkeleton(
              fullPattern, status);
      if ( U_FAILURE(status) ) {
          return;
      }
  }

  // initialize the fIntervalPattern ordering
  int8_t i;
  for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
      fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder();
  }

  /* Check whether the skeleton is a combination of date and time.
   * For the complication reason 1 explained above.
   */
  UnicodeString dateSkeleton;
  UnicodeString timeSkeleton;
  UnicodeString normalizedTimeSkeleton;
  UnicodeString normalizedDateSkeleton;


  /* the difference between time skeleton and normalizedTimeSkeleton are:
   * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
   * 2. (Formerly, 'a' was omitted in normalized time skeleton; this is now handled elsewhere)
   * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized
   *    time skeleton
   *
   * The difference between date skeleton and normalizedDateSkeleton are:
   * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton
   * 2. 'E' and 'EE' are normalized into 'EEE'
   * 3. 'MM' is normalized into 'M'
   */
  UnicodeString convertedSkeleton = normalizeHourMetacharacters(fSkeleton);
  getDateTimeSkeleton(convertedSkeleton, dateSkeleton, normalizedDateSkeleton,
                      timeSkeleton, normalizedTimeSkeleton);

806#ifdef DTITVFMT_DEBUG
  char result[1000];
  char result_1[1000];
  char mesg[2000];
  fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
  sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
  PRINTMESG(mesg)
813#endif

  // move this up here since we need it for fallbacks
  if ( timeSkeleton.length() > 0 && dateSkeleton.length() > 0 ) {
      // Need the Date/Time pattern for concatenation of the date
      // with the time interval.
      // The date/time pattern ( such as {0} {1} ) is saved in
      // calendar, that is why need to get the CalendarData here.
      LocalUResourceBundlePointer dateTimePatternsRes(ures_openures_open_71(nullptr, locale.getBaseName(), &status));
      ures_getByKeyures_getByKey_71(dateTimePatternsRes.getAlias(), gCalendarTag,
                    dateTimePatternsRes.getAlias(), &status);
      ures_getByKeyWithFallbackures_getByKeyWithFallback_71(dateTimePatternsRes.getAlias(), gGregorianTag,
                                dateTimePatternsRes.getAlias(), &status);
      ures_getByKeyWithFallbackures_getByKeyWithFallback_71(dateTimePatternsRes.getAlias(), gDateTimePatternsTag,
                                dateTimePatternsRes.getAlias(), &status);

      int32_t dateTimeFormatLength;
      const UChar* dateTimeFormat = ures_getStringByIndexures_getStringByIndex_71(
                                          dateTimePatternsRes.getAlias(),
                                          (int32_t)DateFormat::kDateTime,
                                          &dateTimeFormatLength, &status);
      if ( U_SUCCESS(status) && dateTimeFormatLength >= 3 ) {
          fDateTimeFormat = new UnicodeString(dateTimeFormat, dateTimeFormatLength);
          if (fDateTimeFormat == nullptr) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
      }
  }

  UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
                                       normalizedTimeSkeleton);

  // for skeletons with seconds, found is false and we enter this block
  if ( found == false ) {
      // use fallback
      // TODO: if user asks "m"(minute), but "d"(day) differ
      if ( timeSkeleton.length() != 0 ) {
          if ( dateSkeleton.length() == 0 ) {
              // prefix with yMd
              timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
              UnicodeString pattern = DateFormat::getBestPattern(
                      locale, timeSkeleton, status);
              if ( U_FAILURE(status) ) {
                  return;
              }
              // for fall back interval patterns,
              // the first part of the pattern is empty,
              // the second part of the pattern is the full-pattern
              // should be used in fall-back.
              setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
              setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
              setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());

              timeSkeleton.insert(0, CAP_G((UChar)0x0047));
              pattern = DateFormat::getBestPattern(
                      locale, timeSkeleton, status);
              if ( U_FAILURE(status) ) {
                  return;
              }
              setPatternInfo(UCAL_ERA, nullptr, &pattern, fInfo->getDefaultOrder());
          } else {
              // TODO: fall back
          }
      } else {
          // TODO: fall back
      }
      return;
  } // end of skeleton not found
  // interval patterns for skeleton are found in resource
  if ( timeSkeleton.length() == 0 ) {
      // done
  } else if ( dateSkeleton.length() == 0 ) {
      // prefix with yMd
      timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
      UnicodeString pattern = DateFormat::getBestPattern(
              locale, timeSkeleton, status);
      if ( U_FAILURE(status) ) {
          return;
      }
      // for fall back interval patterns,
      // the first part of the pattern is empty,
      // the second part of the pattern is the full-pattern
      // should be used in fall-back.
      setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
      setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
      setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());

      timeSkeleton.insert(0, CAP_G((UChar)0x0047));
      pattern = DateFormat::getBestPattern(
              locale, timeSkeleton, status);
      if ( U_FAILURE(status) ) {
          return;
      }
      setPatternInfo(UCAL_ERA, nullptr, &pattern, fInfo->getDefaultOrder());
  } else {
      /* if both present,
       * 1) when the era, year, month, or day differs,
       * concatenate the two original expressions with a separator between,
       * 2) otherwise, present the date followed by the
       * range expression for the time.
       */
      /*
       * 1) when the era, year, month, or day differs,
       * concatenate the two original expressions with a separator between,
       */
      // if field exists, use fall back
      UnicodeString skeleton = fSkeleton;
      if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) {
          // prefix skeleton with 'd'
          skeleton.insert(0, LOW_D((UChar)0x0064));
          setFallbackPattern(UCAL_DATE, skeleton, status);
      }
      if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
          // then prefix skeleton with 'M'
          skeleton.insert(0, CAP_M((UChar)0x004D));
          setFallbackPattern(UCAL_MONTH, skeleton, status);
      }
      if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
          // then prefix skeleton with 'y'
          skeleton.insert(0, LOW_Y((UChar)0x0079));
          setFallbackPattern(UCAL_YEAR, skeleton, status);
      }
      if ( !fieldExistsInSkeleton(UCAL_ERA, dateSkeleton) ) {
          // then prefix skeleton with 'G'
          skeleton.insert(0, CAP_G((UChar)0x0047));
          setFallbackPattern(UCAL_ERA, skeleton, status);
      }

      /*
       * 2) otherwise, present the date followed by the
       * range expression for the time.
       */

      if ( fDateTimeFormat == nullptr ) {
          // earlier failure getting dateTimeFormat
          return;
      }

      UnicodeString datePattern = DateFormat::getBestPattern(
              locale, dateSkeleton, status);

      concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_AM_PM, status);
      concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_HOUR, status);
      concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_MINUTE, status);
  }
959}



963UnicodeString
964DateIntervalFormat::normalizeHourMetacharacters(const UnicodeString& skeleton) const {
  UnicodeString result = skeleton;
  
  UChar hourMetachar = u'\0';
  UChar dayPeriodChar = u'\0';
  int32_t metacharStart = 0;
  int32_t metacharCount = 0;
  for (int32_t i = 0; i < result.length(); i++) {
      UChar c = result[i];
      if (c == LOW_J((UChar)0x006a) || c == CAP_J((UChar)0x004A) || c == CAP_C((UChar)0x0043) || c == LOW_H((UChar)0x0068) || c == CAP_H((UChar)0x0048) || c == LOW_K((UChar)0x006B) || c == CAP_K((UChar)0x004B)) {
          if (hourMetachar == u'\0') {
              hourMetachar = c;
              metacharStart = i;
          }
          ++metacharCount;
      } else if (c == LOW_A((UChar)0x0061) || c == LOW_B((UChar)0x0062) || c == CAP_B((UChar)0x0042)) {
          if (dayPeriodChar == u'\0') {
              dayPeriodChar = c;
          }
          ++metacharCount;
      } else {
          if (hourMetachar != u'\0') {
              break;
          }
      }
  }
  
  if (hourMetachar != u'\0') {
      UErrorCode err = U_ZERO_ERROR;
      UChar hourChar = CAP_H((UChar)0x0048);
      UnicodeString convertedPattern = DateFormat::getBestPattern(fLocale, UnicodeString(hourMetachar), err);

      if (U_SUCCESS(err)) {
          // strip literal text from the pattern (so literal characters don't get mistaken for pattern
          // characters-- such as the 'h' in 'Uhr' in Germam)
          int32_t firstQuotePos;
          while ((firstQuotePos = convertedPattern.indexOf(u'\'')) != -1) {
              int32_t secondQuotePos = convertedPattern.indexOf(u'\'', firstQuotePos + 1);
              if (secondQuotePos == -1) {
                  secondQuotePos = firstQuotePos;
              }
              convertedPattern.replace(firstQuotePos, (secondQuotePos - firstQuotePos) + 1, UnicodeString());
          }
      
          if (convertedPattern.indexOf(LOW_H((UChar)0x0068)) != -1) {
              hourChar = LOW_H((UChar)0x0068);
          } else if (convertedPattern.indexOf(CAP_K((UChar)0x004B)) != -1) {
              hourChar = CAP_K((UChar)0x004B);
          } else if (convertedPattern.indexOf(LOW_K((UChar)0x006B)) != -1) {
              hourChar = LOW_K((UChar)0x006B);
          }
          
          if (convertedPattern.indexOf(LOW_B((UChar)0x0062)) != -1) {
              dayPeriodChar = LOW_B((UChar)0x0062);
          } else if (convertedPattern.indexOf(CAP_B((UChar)0x0042)) != -1) {
              dayPeriodChar = CAP_B((UChar)0x0042);
          } else if (dayPeriodChar == u'\0') {
              dayPeriodChar = LOW_A((UChar)0x0061);
          }
      }
      
      if (hourChar == CAP_H((UChar)0x0048) || hourChar == LOW_K((UChar)0x006B)) {
          result.replace(metacharStart, metacharCount, hourChar);
      } else {
          UnicodeString hourAndDayPeriod(hourChar);
          switch (metacharCount) {
              case 1:
              case 2:
              default:
                  hourAndDayPeriod.append(UnicodeString(dayPeriodChar));
                  break;
              case 3:
              case 4:
                  for (int32_t i = 0; i < 4; i++) {
                      hourAndDayPeriod.append(dayPeriodChar);
                  }
                  break;
              case 5:
              case 6:
                  for (int32_t i = 0; i < 5; i++) {
                      hourAndDayPeriod.append(dayPeriodChar);
                  }
                  break;
          }
          result.replace(metacharStart, metacharCount, hourAndDayPeriod);
      }
  }
  return result;
1052}


1055void  U_EXPORT2
1056DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
                                      UnicodeString& dateSkeleton,
                                      UnicodeString& normalizedDateSkeleton,
                                      UnicodeString& timeSkeleton,
                                      UnicodeString& normalizedTimeSkeleton) {
  // dateSkeleton follows the sequence of y*M*E*d*
  // timeSkeleton follows the sequence of hm*[v|z]?
  int32_t ECount = 0;
  int32_t dCount = 0;
  int32_t MCount = 0;
  int32_t yCount = 0;
  int32_t mCount = 0;
  int32_t vCount = 0;
  int32_t zCount = 0;
  UChar hourChar = u'\0';
  int32_t i;

  for (i = 0; i < skeleton.length(); ++i) {
      UChar ch = skeleton[i];
      switch ( ch ) {
        case CAP_E((UChar)0x0045):
          dateSkeleton.append(ch);
          ++ECount;
          break;
        case LOW_D((UChar)0x0064):
          dateSkeleton.append(ch);
          ++dCount;
          break;
        case CAP_M((UChar)0x004D):
          dateSkeleton.append(ch);
          ++MCount;
          break;
        case LOW_Y((UChar)0x0079):
          dateSkeleton.append(ch);
          ++yCount;
          break;
        case CAP_G((UChar)0x0047):
        case CAP_Y((UChar)0x0059):
        case LOW_U((UChar)0x0075):
        case CAP_Q((UChar)0x0051):
        case LOW_Q((UChar)0x0071):
        case CAP_L((UChar)0x004C):
        case LOW_L((UChar)0x006C):
        case CAP_W((UChar)0x0057):
        case LOW_W((UChar)0x0077):
        case CAP_D((UChar)0x0044):
        case CAP_F((UChar)0x0046):
        case LOW_G((UChar)0x0067):
        case LOW_E((UChar)0x0065):
        case LOW_C((UChar)0x0063):
        case CAP_U((UChar)0x0055):
        case LOW_R((UChar)0x0072):
          normalizedDateSkeleton.append(ch);
          dateSkeleton.append(ch);
          break;
        case LOW_H((UChar)0x0068):
        case CAP_H((UChar)0x0048):
        case LOW_K((UChar)0x006B):
        case CAP_K((UChar)0x004B):
          timeSkeleton.append(ch);
          if (hourChar == u'\0') {
              hourChar = ch;
          }
          break;
        case LOW_M((UChar)0x006D):
          timeSkeleton.append(ch);
          ++mCount;
          break;
        case LOW_Z((UChar)0x007A):
          ++zCount;
          timeSkeleton.append(ch);
          break;
        case LOW_V((UChar)0x0076):
          ++vCount;
          timeSkeleton.append(ch);
          break;
        case LOW_A((UChar)0x0061):
        case CAP_V((UChar)0x0056):
        case CAP_Z((UChar)0x005A):
        case LOW_J((UChar)0x006a):
        case LOW_S((UChar)0x0073):
        case CAP_S((UChar)0x0053):
        case CAP_A((UChar)0x0041):
        case LOW_B((UChar)0x0062):
        case CAP_B((UChar)0x0042):
          timeSkeleton.append(ch);
          normalizedTimeSkeleton.append(ch);
          break;
      }
  }

  /* generate normalized form for date*/
  if ( yCount != 0 ) {
      for (i = 0; i < yCount; ++i) {
          normalizedDateSkeleton.append(LOW_Y((UChar)0x0079));
      }
  }
  if ( MCount != 0 ) {
      if ( MCount < 3 ) {
          normalizedDateSkeleton.append(CAP_M((UChar)0x004D));
      } else {
          for ( int32_t j = 0; j < MCount && j < MAX_M_COUNT5; ++j) {
               normalizedDateSkeleton.append(CAP_M((UChar)0x004D));
          }
      }
  }
  if ( ECount != 0 ) {
      if ( ECount <= 3 ) {
          normalizedDateSkeleton.append(CAP_E((UChar)0x0045));
      } else {
          for ( int32_t j = 0; j < ECount && j < MAX_E_COUNT5; ++j ) {
               normalizedDateSkeleton.append(CAP_E((UChar)0x0045));
          }
      }
  }
  if ( dCount != 0 ) {
      normalizedDateSkeleton.append(LOW_D((UChar)0x0064));
  }

  /* generate normalized form for time */
  if ( hourChar != u'\0' ) {
      normalizedTimeSkeleton.append(hourChar);
  }
  if ( mCount != 0 ) {
      normalizedTimeSkeleton.append(LOW_M((UChar)0x006D));
  }
  if ( zCount != 0 ) {
      normalizedTimeSkeleton.append(LOW_Z((UChar)0x007A));
  }
  if ( vCount != 0 ) {
      normalizedTimeSkeleton.append(LOW_V((UChar)0x0076));
  }
1188}


1191/**
* Generate date or time interval pattern from resource,
* and set them into the interval pattern locale to this formatter.
*
* It needs to handle the following:
* 1. need to adjust field width.
*    For example, the interval patterns saved in DateIntervalInfo
*    includes "dMMMy", but not "dMMMMy".
*    Need to get interval patterns for dMMMMy from dMMMy.
*    Another example, the interval patterns saved in DateIntervalInfo
*    includes "hmv", but not "hmz".
*    Need to get interval patterns for "hmz' from 'hmv'
*
* 2. there might be no pattern for 'y' differ for skeleton "Md",
*    in order to get interval patterns for 'y' differ,
*    need to look for it from skeleton 'yMd'
*
* @param dateSkeleton   normalized date skeleton
* @param timeSkeleton   normalized time skeleton
* @return               whether the resource is found for the skeleton.
*                       TRUE if interval pattern found for the skeleton,
*                       FALSE otherwise.
* @stable ICU 4.0
*/
1215UBool
1216DateIntervalFormat::setSeparateDateTimePtn(
                               const UnicodeString& dateSkeleton,
                               const UnicodeString& timeSkeleton) {
  const UnicodeString* skeleton;
  // if both date and time skeleton present,
  // the final interval pattern might include time interval patterns
  // ( when, am_pm, hour, minute differ ),
  // but not date interval patterns ( when year, month, day differ ).
  // For year/month/day differ, it falls back to fall-back pattern.
  if ( timeSkeleton.length() != 0  ) {
      skeleton = &timeSkeleton;
  } else {
      skeleton = &dateSkeleton;
  }

  /* interval patterns for skeleton "dMMMy" (but not "dMMMMy")
   * are defined in resource,
   * interval patterns for skeleton "dMMMMy" are calculated by
   * 1. get the best match skeleton for "dMMMMy", which is "dMMMy"
   * 2. get the interval patterns for "dMMMy",
   * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy"
   * getBestSkeleton() is step 1.
   */
  // best skeleton, and the difference information
  int8_t differenceInfo = 0;
  const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
                                                             differenceInfo);
  /* best skeleton could be nullptr.
     For example: in "ca" resource file,
     interval format is defined as following
         intervalFormats{
              fallback{"{0} - {1}"}
          }
     there is no skeletons/interval patterns defined,
     and the best skeleton match could be nullptr
   */
  if ( bestSkeleton == nullptr ) {
      return false;
  }

  // Set patterns for fallback use, need to do this
  // before returning if differenceInfo == -1
  UErrorCode status;
  if ( dateSkeleton.length() != 0) {
      status = U_ZERO_ERROR;
      fDatePattern = new UnicodeString(DateFormat::getBestPattern(
              fLocale, dateSkeleton, status));
      // no way to report OOM. :(
  }
  if ( timeSkeleton.length() != 0) {
      status = U_ZERO_ERROR;
      fTimePattern = new UnicodeString(DateFormat::getBestPattern(
              fLocale, timeSkeleton, status));
      // no way to report OOM. :(
  }

  // difference:
  // 0 means the best matched skeleton is the same as input skeleton
  // 1 means the fields are the same, but field width are different
  // 2 means the only difference between fields are v/z,
  // -1 means there are other fields difference
  // (this will happen, for instance, if the supplied skeleton has seconds,
  //  but no skeletons in the intervalFormats data do)
  if ( differenceInfo == -1 ) {
      // skeleton has different fields, not only  v/z difference
      return false;
  }

  if ( timeSkeleton.length() == 0 ) {
      UnicodeString extendedSkeleton;
      UnicodeString extendedBestSkeleton;
      // only has date skeleton
      setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
                         &extendedSkeleton, &extendedBestSkeleton);

      UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
                                   differenceInfo,
                                   &extendedSkeleton, &extendedBestSkeleton);

      if ( extended ) {
          bestSkeleton = &extendedBestSkeleton;
          skeleton = &extendedSkeleton;
      }
      setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo,
                         &extendedSkeleton, &extendedBestSkeleton);
      setIntervalPattern(UCAL_ERA, skeleton, bestSkeleton, differenceInfo,
                         &extendedSkeleton, &extendedBestSkeleton);
   } else {
      setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
      setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
      setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo);
  }
  return true;
1309}



1313void
1314DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
                                     const UnicodeString& skeleton,
                                     UErrorCode& status) {
  if ( U_FAILURE(status) ) {
      return;
  }
  UnicodeString pattern = DateFormat::getBestPattern(
          fLocale, skeleton, status);
  if ( U_FAILURE(status) ) {
      return;
  }
  setPatternInfo(field, nullptr, &pattern, fInfo->getDefaultOrder());
1326}




1331void
1332DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
                                 const UnicodeString* firstPart,
                                 const UnicodeString* secondPart,
                                 UBool laterDateFirst) {
  // for fall back interval patterns,
  // the first part of the pattern is empty,
  // the second part of the pattern is the full-pattern
  // should be used in fall-back.
  UErrorCode status = U_ZERO_ERROR;
  // following should not set any wrong status.
  int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
                                                                      status);
  if ( U_FAILURE(status) ) {
      return;
  }
  PatternInfo& ptn = fIntervalPatterns[itvPtnIndex];
  if ( firstPart ) {
      ptn.firstPart = *firstPart;
  }
  if ( secondPart ) {
      ptn.secondPart = *secondPart;
  }
  ptn.laterDateFirst = laterDateFirst;
1355}

1357void
1358DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                                     const UnicodeString& intervalPattern) {
  UBool order = fInfo->getDefaultOrder();
  setIntervalPattern(field, intervalPattern, order);
1362}


1365void
1366DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                                     const UnicodeString& intervalPattern,
                                     UBool laterDateFirst) {
  const UnicodeString* pattern = &intervalPattern;
  UBool order = laterDateFirst;
  // check for "latestFirst:" or "earliestFirst:" prefix
  int8_t prefixLength = UPRV_LENGTHOF(gLaterFirstPrefix)(int32_t)(sizeof(gLaterFirstPrefix)/sizeof((gLaterFirstPrefix
)[0]));
  int8_t earliestFirstLength = UPRV_LENGTHOF(gEarlierFirstPrefix)(int32_t)(sizeof(gEarlierFirstPrefix)/sizeof((gEarlierFirstPrefix
)[0]));
  UnicodeString realPattern;
  if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
      order = true;
      intervalPattern.extract(prefixLength,
                              intervalPattern.length() - prefixLength,
                              realPattern);
      pattern = &realPattern;
  } else if ( intervalPattern.startsWith(gEarlierFirstPrefix,
                                         earliestFirstLength) ) {
      order = false;
      intervalPattern.extract(earliestFirstLength,
                              intervalPattern.length() - earliestFirstLength,
                              realPattern);
      pattern = &realPattern;
  }

  int32_t splitPoint = splitPatternInto2Part(*pattern);

  UnicodeString firstPart;
  UnicodeString secondPart;
  pattern->extract(0, splitPoint, firstPart);
  if ( splitPoint < pattern->length() ) {
      pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart);
  }
  setPatternInfo(field, &firstPart, &secondPart, order);
1399}




1404/**
* Generate interval pattern from existing resource
*
* It not only save the interval patterns,
* but also return the extended skeleton and its best match skeleton.
*
* @param field           largest different calendar field
* @param skeleton        skeleton
* @param bestSkeleton    the best match skeleton which has interval pattern
*                        defined in resource
* @param differenceInfo  the difference between skeleton and best skeleton
*         0 means the best matched skeleton is the same as input skeleton
*         1 means the fields are the same, but field width are different
*         2 means the only difference between fields are v/z,
*        -1 means there are other fields difference
*
* @param extendedSkeleton      extended skeleton
* @param extendedBestSkeleton  extended best match skeleton
* @return                      whether the interval pattern is found
*                              through extending skeleton or not.
*                              TRUE if interval pattern is found by
*                              extending skeleton, FALSE otherwise.
* @stable ICU 4.0
*/
1428UBool
1429DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                                     const UnicodeString* skeleton,
                                     const UnicodeString* bestSkeleton,
                                     int8_t differenceInfo,
                                     UnicodeString* extendedSkeleton,
                                     UnicodeString* extendedBestSkeleton) {
  UErrorCode status = U_ZERO_ERROR;
  // following getIntervalPattern() should not generate error status
  UnicodeString pattern;
  fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status);
  if ( pattern.isEmpty() ) {
      // single date
      if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) {
          // do nothing, format will handle it
          return false;
      }

      // for 24 hour system, interval patterns in resource file
      // might not include pattern when am_pm differ,
      // which should be the same as hour differ.
      // add it here for simplicity
      if ( field == UCAL_AM_PM ) {
          fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status);
          if ( !pattern.isEmpty() ) {
              UBool suppressDayPeriodField = fSkeleton.indexOf(CAP_J((UChar)0x004A)) != -1;
              UnicodeString adjustIntervalPattern;
              adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
                               suppressDayPeriodField, adjustIntervalPattern);
              setIntervalPattern(field, adjustIntervalPattern);
          }
          return false;
      }
      // else, looking for pattern when 'y' differ for 'dMMMM' skeleton,
      // first, get best match pattern "MMMd",
      // since there is no pattern for 'y' differs for skeleton 'MMMd',
      // need to look for it from skeleton 'yMMMd',
      // if found, adjust field width in interval pattern from
      // "MMM" to "MMMM".
      UChar fieldLetter = fgCalendarFieldToPatternLetter[field];
      if ( extendedSkeleton ) {
          *extendedSkeleton = *skeleton;
          *extendedBestSkeleton = *bestSkeleton;
          extendedSkeleton->insert(0, fieldLetter);
          extendedBestSkeleton->insert(0, fieldLetter);
          // for example, looking for patterns when 'y' differ for
          // skeleton "MMMM".
          fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status);
          if ( pattern.isEmpty() && differenceInfo == 0 ) {
              // if there is no skeleton "yMMMM" defined,
              // look for the best match skeleton, for example: "yMMM"
              const UnicodeString* tmpBest = fInfo->getBestSkeleton(
                                      *extendedBestSkeleton, differenceInfo);
              if ( tmpBest != 0 && differenceInfo != -1 ) {
                  fInfo->getIntervalPattern(*tmpBest, field, pattern, status);
                  bestSkeleton = tmpBest;
              }
          }
      }
  }
  if ( !pattern.isEmpty() ) {
      UBool suppressDayPeriodField = fSkeleton.indexOf(CAP_J((UChar)0x004A)) != -1;
      if ( differenceInfo != 0 || suppressDayPeriodField) {
          UnicodeString adjustIntervalPattern;
          adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
                            suppressDayPeriodField, adjustIntervalPattern);
          setIntervalPattern(field, adjustIntervalPattern);
      } else {
          setIntervalPattern(field, pattern);
      }
      if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) {
          return TRUE1;
      }
  }
  return FALSE0;
1503}



1507int32_t  U_EXPORT2
1508DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
  UBool inQuote = false;
  UChar prevCh = 0;
  int32_t count = 0;

  /* repeatedPattern used to record whether a pattern has already seen.
     It is a pattern applies to first calendar if it is first time seen,
     otherwise, it is a pattern applies to the second calendar
   */
  UBool patternRepeated[] =
  {
  //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   P   Q   R   S   T   U   V   W   X   Y   Z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
  //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   p   q   r   s   t   u   v   w   x   y   z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  };

  int8_t PATTERN_CHAR_BASE = 0x41;

  /* loop through the pattern string character by character looking for
   * the first repeated pattern letter, which breaks the interval pattern
   * into 2 parts.
   */
  int32_t i;
  UBool foundRepetition = false;
  for (i = 0; i < intervalPattern.length(); ++i) {
      UChar ch = intervalPattern.charAt(i);

      if (ch != prevCh && count > 0) {
          // check the repeativeness of pattern letter
          UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)];
          if ( repeated == FALSE0 ) {
              patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE1;
          } else {
              foundRepetition = true;
              break;
          }
          count = 0;
      }
      if (ch == 0x0027 /*'*/) {
          // Consecutive single quotes are a single quote literal,
          // either outside of quotes or between quotes
          if ((i+1) < intervalPattern.length() &&
              intervalPattern.charAt(i+1) == 0x0027 /*'*/) {
              ++i;
          } else {
              inQuote = ! inQuote;
          }
      }
      else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
                  || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
          // ch is a date-time pattern character
          prevCh = ch;
          ++count;
      }
  }
  // check last pattern char, distinguish
  // "dd MM" ( no repetition ),
  // "d-d"(last char repeated ), and
  // "d-d MM" ( repetition found )
  if ( count > 0 && foundRepetition == FALSE0 ) {
      if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE0 ) {
          count = 0;
      }
  }
  return (i - count);
1578}

1580// The following is only called from fallbackFormat, i.e. within the gFormatterMutex lock
1581void DateIntervalFormat::fallbackFormatRange(
      Calendar& fromCalendar,
      Calendar& toCalendar,
      UnicodeString& appendTo,
      int8_t& firstIndex,
      FieldPositionHandler& fphandler,
      UErrorCode& status) const {
  UnicodeString fallbackPattern;
  fInfo->getFallbackIntervalPattern(fallbackPattern);
  SimpleFormatter sf(fallbackPattern, 2, 2, status);
  if (U_FAILURE(status)) {
      return;
  }
  int32_t offsets[2];
  UnicodeString patternBody = sf.getTextWithNoArguments(offsets, 2);

  UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
  // TODO(ICU-20406): Use SimpleFormatter Iterator interface when available.
  if (offsets[0] < offsets[1]) {
      firstIndex = 0;
      appendTo.append(patternBody.tempSubStringBetween(0, offsets[0]));
      fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
      appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
      // No capitalization for second part of interval
      fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
      fDateFormat->_format(toCalendar, appendTo, fphandler, status);
      appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
  } else {
      firstIndex = 1;
      appendTo.append(patternBody.tempSubStringBetween(0, offsets[1]));
      fDateFormat->_format(toCalendar, appendTo, fphandler, status);
      appendTo.append(patternBody.tempSubStringBetween(offsets[1], offsets[0]));
      // No capitalization for second part of interval
      fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
      fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
      appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
  }
1618}

1620// The following is only called from formatImpl, i.e. within the gFormatterMutex lock
1621UnicodeString&
1622DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                 Calendar& toCalendar,
                                 UBool fromToOnSameDay, // new
                                 UnicodeString& appendTo,
                                 int8_t& firstIndex,
                                 FieldPositionHandler& fphandler,
                                 UErrorCode& status) const {
  if ( U_FAILURE(status) ) {
      return appendTo;
  }

  UBool formatDatePlusTimeRange = (fromToOnSameDay && fDatePattern && fTimePattern);
  if (formatDatePlusTimeRange) {
      SimpleFormatter sf(*fDateTimeFormat, 2, 2, status);
      if (U_FAILURE(status)) {
          return appendTo;
      }
      int32_t offsets[2];
      UnicodeString patternBody = sf.getTextWithNoArguments(offsets, 2);

      UnicodeString fullPattern; // for saving the pattern in fDateFormat
      fDateFormat->toPattern(fullPattern); // save current pattern, restore later

      UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
      // {0} is time range
      // {1} is single date portion
      // TODO(ICU-20406): Use SimpleFormatter Iterator interface when available.
      if (offsets[0] < offsets[1]) {
          appendTo.append(patternBody.tempSubStringBetween(0, offsets[0]));
          fDateFormat->applyPattern(*fTimePattern);
          fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
          appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
          fDateFormat->applyPattern(*fDatePattern);
          // No capitalization for second portion
          fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
          fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
          appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
      } else {
          appendTo.append(patternBody.tempSubStringBetween(0, offsets[1]));
          fDateFormat->applyPattern(*fDatePattern);
          fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
          appendTo.append(patternBody.tempSubStringBetween(offsets[1], offsets[0]));
          fDateFormat->applyPattern(*fTimePattern);
          // No capitalization for second portion
          fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
          fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
          appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
      }

      // restore full pattern
      fDateFormat->applyPattern(fullPattern);
  } else {
      fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
  }
  return appendTo;
1677}




1682UBool  U_EXPORT2
1683DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
                                        const UnicodeString& skeleton)
1685{
  const UChar fieldChar = fgCalendarFieldToPatternLetter[field];
  return ( (skeleton.indexOf(fieldChar) == -1)?FALSE0:TRUE1 ) ;
1688}



1692void  U_EXPORT2
1693DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
               const UnicodeString& bestMatchSkeleton,
               const UnicodeString& bestIntervalPattern,
               int8_t differenceInfo,
               UBool suppressDayPeriodField,
               UnicodeString& adjustedPtn) {
  adjustedPtn = bestIntervalPattern;
  int32_t inputSkeletonFieldWidth[] =
  {
  //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   P   Q   R   S   T   U   V   W   X   Y   Z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
  //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   p   q   r   s   t   u   v   w   x   y   z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  };

  int32_t bestMatchSkeletonFieldWidth[] =
  {
  //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   P   Q   R   S   T   U   V   W   X   Y   Z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
  //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  //   p   q   r   s   t   u   v   w   x   y   z
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  };

  const int8_t PATTERN_CHAR_BASE = 0x41;

  DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
  DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
  if (suppressDayPeriodField) {
      findReplaceInPattern(adjustedPtn, UnicodeString(LOW_A((UChar)0x0061)), UnicodeString());
      findReplaceInPattern(adjustedPtn, UnicodeString("  "), UnicodeString(" "));
      adjustedPtn.trim();
  }
  if ( differenceInfo == 2 ) {
      if (inputSkeleton.indexOf(LOW_Z((UChar)0x007A)) != -1) {
           findReplaceInPattern(adjustedPtn, UnicodeString(LOW_V((UChar)0x0076)), UnicodeString(LOW_Z((UChar)0x007A)));
       }
       if (inputSkeleton.indexOf(CAP_K((UChar)0x004B)) != -1) {
           findReplaceInPattern(adjustedPtn, UnicodeString(LOW_H((UChar)0x0068)), UnicodeString(CAP_K((UChar)0x004B)));
       }
       if (inputSkeleton.indexOf(LOW_K((UChar)0x006B)) != -1) {
           findReplaceInPattern(adjustedPtn, UnicodeString(CAP_H((UChar)0x0048)), UnicodeString(LOW_K((UChar)0x006B)));
       }
       if (inputSkeleton.indexOf(LOW_B((UChar)0x0062)) != -1) {
           findReplaceInPattern(adjustedPtn, UnicodeString(LOW_A((UChar)0x0061)), UnicodeString(LOW_B((UChar)0x0062)));
       }
  }
  if (adjustedPtn.indexOf(LOW_A((UChar)0x0061)) != -1 && bestMatchSkeletonFieldWidth[LOW_A((UChar)0x0061) - PATTERN_CHAR_BASE] == 0) {
      bestMatchSkeletonFieldWidth[LOW_A((UChar)0x0061) - PATTERN_CHAR_BASE] = 1;
  }
  if (adjustedPtn.indexOf(LOW_B((UChar)0x0062)) != -1 && bestMatchSkeletonFieldWidth[LOW_B((UChar)0x0062) - PATTERN_CHAR_BASE] == 0) {
      bestMatchSkeletonFieldWidth[LOW_B((UChar)0x0062) - PATTERN_CHAR_BASE] = 1;
   }

  UBool inQuote = false;
  UChar prevCh = 0;
  int32_t count = 0;

  // loop through the pattern string character by character
  int32_t adjustedPtnLength = adjustedPtn.length();
  int32_t i;
  for (i = 0; i < adjustedPtnLength; ++i) {
      UChar ch = adjustedPtn.charAt(i);
      if (ch != prevCh && count > 0) {
          // check the repeativeness of pattern letter
          UChar skeletonChar = prevCh;
          if ( skeletonChar ==  CAP_L((UChar)0x004C) ) {
              // there is no "L" (always be "M") in skeleton,
              // but there is "L" in pattern.
              // for skeleton "M+", the pattern might be "...L..."
              skeletonChar = CAP_M((UChar)0x004D);
          }
          int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
          int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
          if ( fieldCount == count && inputFieldCount > fieldCount ) {
              count = inputFieldCount - fieldCount;
              int32_t j;
              for ( j = 0; j < count; ++j ) {
                  adjustedPtn.insert(i, prevCh);
              }
              i += count;
              adjustedPtnLength += count;
          }
          count = 0;
      }
      if (ch == 0x0027 /*'*/) {
          // Consecutive single quotes are a single quote literal,
          // either outside of quotes or between quotes
          if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == 0x0027 /* ' */) {
              ++i;
          } else {
              inQuote = ! inQuote;
          }
      }
      else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
                  || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
          // ch is a date-time pattern character
          prevCh = ch;
          ++count;
      }
  }
  if ( count > 0 ) {
      // last item
      // check the repeativeness of pattern letter
      UChar skeletonChar = prevCh;
      if ( skeletonChar == CAP_L((UChar)0x004C) ) {
          // there is no "L" (always be "M") in skeleton,
          // but there is "L" in pattern.
          // for skeleton "M+", the pattern might be "...L..."
          skeletonChar = CAP_M((UChar)0x004D);
      }
      int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
      int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
      if ( fieldCount == count && inputFieldCount > fieldCount ) {
          count = inputFieldCount - fieldCount;
          int32_t j;
          for ( j = 0; j < count; ++j ) {
              adjustedPtn.append(prevCh);
          }
      }
  }
1821}

1823void
1824DateIntervalFormat::findReplaceInPattern(UnicodeString& targetString,
                                       const UnicodeString& strToReplace,
                                       const UnicodeString& strToReplaceWith) {
  int32_t firstQuoteIndex = targetString.indexOf(u'\'');
  if (firstQuoteIndex == -1) {
      targetString.findAndReplace(strToReplace, strToReplaceWith);
  } else {
      UnicodeString result;
      UnicodeString source = targetString;
      
      while (firstQuoteIndex >= 0) {
          int32_t secondQuoteIndex = source.indexOf(u'\'', firstQuoteIndex + 1);
          if (secondQuoteIndex == -1) {
              secondQuoteIndex = source.length() - 1;
          }
          
          UnicodeString unquotedText(source, 0, firstQuoteIndex);
          UnicodeString quotedText(source, firstQuoteIndex, secondQuoteIndex - firstQuoteIndex + 1);
          
          unquotedText.findAndReplace(strToReplace, strToReplaceWith);
          result += unquotedText;
          result += quotedText;
          
          source.remove(0, secondQuoteIndex + 1);
          firstQuoteIndex = source.indexOf(u'\'');
      }
      source.findAndReplace(strToReplace, strToReplaceWith);
      result += source;
      targetString = result;
  }
1854}



1858void
1859DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format,
                                            const UnicodeString& datePattern,
                                            UCalendarDateFields field,
                                            UErrorCode& status) {
  // following should not set wrong status
  int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
                                                                      status);
  if ( U_FAILURE(status) ) {
      return;
  }
  PatternInfo&  timeItvPtnInfo = fIntervalPatterns[itvPtnIndex];
  if ( !timeItvPtnInfo.firstPart.isEmpty() ) {
      UnicodeString timeIntervalPattern(timeItvPtnInfo.firstPart);
      timeIntervalPattern.append(timeItvPtnInfo.secondPart);
      UnicodeString combinedPattern;
      SimpleFormatter(format, 2, 2, status).
              format(timeIntervalPattern, datePattern, combinedPattern, status);
      if ( U_FAILURE(status) ) {
          return;
      }
      setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
  }
  // else: fall back
  // it should not happen if the interval format defined is valid
1883}



1887const UChar
1888DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
1889{
  /*GyM*/ CAP_G((UChar)0x0047), LOW_Y((UChar)0x0079), CAP_M((UChar)0x004D),
  /*wWd*/ LOW_W((UChar)0x0077), CAP_W((UChar)0x0057), LOW_D((UChar)0x0064),
  /*DEF*/ CAP_D((UChar)0x0044), CAP_E((UChar)0x0045), CAP_F((UChar)0x0046),
  /*ahH*/ LOW_A((UChar)0x0061), LOW_H((UChar)0x0068), CAP_H((UChar)0x0048),
  /*msS*/ LOW_M((UChar)0x006D), LOW_S((UChar)0x0073), CAP_S((UChar)0x0053), // MINUTE, SECOND, MILLISECOND
  /*z.Y*/ LOW_Z((UChar)0x007A), SPACE((UChar)0x0020), CAP_Y((UChar)0x0059), // ZONE_OFFSET, DST_OFFSET, YEAR_WOY,
  /*eug*/ LOW_E((UChar)0x0065), LOW_U((UChar)0x0075), LOW_G((UChar)0x0067), // DOW_LOCAL, EXTENDED_YEAR, JULIAN_DAY,
  /*A..*/ CAP_A((UChar)0x0041), SPACE((UChar)0x0020), SPACE((UChar)0x0020), // MILLISECONDS_IN_DAY, IS_LEAP_MONTH, FIELD_COUNT
1898};



1902U_NAMESPACE_END}

1904#endif