The Tor Browser: intl/icu/source/i18n/dtitvfmt.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/dtitvfmt.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/dtitvfmt.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*******************************************************************************
 * Copyright (C) 2008-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File DTITVFMT.CPP
 *
 *******************************************************************************
 */
 #include "utypeinfo.h"  // for 'typeid' to work
 #include "unicode/dtitvfmt.h"
 #if !UCONFIG_NO_FORMATTING
 //TODO: put in compilation
 //#define DTITVFMT_DEBUG 1
 #include "cstring.h"
 #include "unicode/msgfmt.h"
 #include "unicode/dtptngen.h"
 #include "unicode/dtitvinf.h"
 #include "unicode/calendar.h"
 #include "dtitv_impl.h"
 #ifdef DTITVFMT_DEBUG
 #include <iostream>
 #include "cstring.h"
 #endif
 #include "gregoimp.h"
 U_NAMESPACE_BEGIN
 #ifdef DTITVFMT_DEBUG
 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
 #endif
 static const UChar gDateFormatSkeleton[][11] = {
 //yMMMMEEEEd
 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0},
 //yMMMMd
 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0},
 //yMMMd
 {LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0},
 //yMd
 {LOW_Y, CAP_M, LOW_D, 0} };
 static const char gDateTimePatternsTag[]="DateTimePatterns";
 // latestFirst:
 static const UChar gLaterFirstPrefix[] = {LOW_L, LOW_A, LOW_T, LOW_E, LOW_S,LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
 // earliestFirst:
 static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, LOW_E, LOW_S, LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    UErrorCode& status) {
     return createInstance(skeleton, Locale::getDefault(), status);
 }
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    const Locale& locale,
                                    UErrorCode& status) {
 #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)
 #endif
     DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
     return create(locale, dtitvinf, &skeleton, status);
 }
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    const DateIntervalInfo& dtitvinf,
                                    UErrorCode& status) {
     return createInstance(skeleton, Locale::getDefault(), dtitvinf, status);
 }
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    const Locale& locale,
                                    const DateIntervalInfo& dtitvinf,
                                    UErrorCode& status) {
     DateIntervalInfo* ptn = dtitvinf.clone();
     return create(locale, ptn, &skeleton, status);
 }
 DateIntervalFormat::DateIntervalFormat()
 :   fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fToCalendar(NULL),
     fDtpng(NULL)
 {}
 DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
 :   Format(itvfmt),
     fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fToCalendar(NULL),
     fDtpng(NULL) {
     *this = itvfmt;
 }
 DateIntervalFormat&
 DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
     if ( this != &itvfmt ) {
         delete fDateFormat;
         delete fInfo;
         delete fFromCalendar;
         delete fToCalendar;
         delete fDtpng;
         if ( itvfmt.fDateFormat ) {
             fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone();
         } else {
             fDateFormat = NULL;
         }
         if ( itvfmt.fInfo ) {
             fInfo = itvfmt.fInfo->clone();
         } else {
             fInfo = NULL;
         }
         if ( itvfmt.fFromCalendar ) {
             fFromCalendar = itvfmt.fFromCalendar->clone();
         } else {
             fFromCalendar = NULL;
         }
         if ( itvfmt.fToCalendar ) {
             fToCalendar = itvfmt.fToCalendar->clone();
         } else {
             fToCalendar = NULL;
         }
         fSkeleton = itvfmt.fSkeleton;
         int8_t i;
         for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
             fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i];
         }
         if (itvfmt.fDtpng) {
             fDtpng = itvfmt.fDtpng->clone();
         }
     }
     return *this;
 }
 DateIntervalFormat::~DateIntervalFormat() {
     delete fInfo;
     delete fDateFormat;
     delete fFromCalendar;
     delete fToCalendar;
     delete fDtpng;
 }
 Format*
 DateIntervalFormat::clone(void) const {
     return new DateIntervalFormat(*this);
 }
 UBool
 DateIntervalFormat::operator==(const Format& other) const {
     if (typeid(*this) == typeid(other)) {
         const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
 #ifdef DTITVFMT_DEBUG
     UBool equal;
     equal = (this == fmt);
     equal = (*fInfo == *fmt->fInfo);
     equal = (*fDateFormat == *fmt->fDateFormat);
     equal = fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) ;
     equal = fToCalendar->isEquivalentTo(*fmt->fToCalendar) ;
     equal = (fSkeleton == fmt->fSkeleton);
 #endif
         UBool res;
         res =  ( this == fmt ) ||
                ( Format::operator==(other) &&
                  fInfo &&
                  ( *fInfo == *fmt->fInfo ) &&
                  fDateFormat &&
                  ( *fDateFormat == *fmt->fDateFormat ) &&
                  fFromCalendar &&
                  fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) &&
                  fToCalendar &&
                  fToCalendar->isEquivalentTo(*fmt->fToCalendar) &&
                  fSkeleton == fmt->fSkeleton &&
                  fDtpng &&
                  (*fDtpng == *fmt->fDtpng) );
         int8_t i;
         for (i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX && res == TRUE; ++i ) {
             res =   ( fIntervalPatterns[i].firstPart ==
                       fmt->fIntervalPatterns[i].firstPart) &&
                     ( fIntervalPatterns[i].secondPart ==
                       fmt->fIntervalPatterns[i].secondPart ) &&
                     ( fIntervalPatterns[i].laterDateFirst ==
                       fmt->fIntervalPatterns[i].laterDateFirst) ;
         }
         return res;
     }
     return FALSE;
 }
 UnicodeString&
 DateIntervalFormat::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 != NULL){
             return format(interval, appendTo, fieldPosition, status);
         }
     }
     status = U_ILLEGAL_ARGUMENT_ERROR;
     return appendTo;
 }
 UnicodeString&
 DateIntervalFormat::format(const DateInterval* dtInterval,
                            UnicodeString& appendTo,
                            FieldPosition& fieldPosition,
                            UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     if ( fFromCalendar != NULL && fToCalendar != NULL &&
          fDateFormat != NULL && fInfo != NULL ) {
         fFromCalendar->setTime(dtInterval->getFromDate(), status);
         fToCalendar->setTime(dtInterval->getToDate(), status);
         if ( U_SUCCESS(status) ) {
             return format(*fFromCalendar, *fToCalendar, appendTo,fieldPosition, status);
         }
     }
     return appendTo;
 }
 UnicodeString&
 DateIntervalFormat::format(Calendar& fromCalendar,
                            Calendar& toCalendar,
                            UnicodeString& appendTo,
                            FieldPosition& pos,
                            UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     // 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;
     }
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     if ( field == UCAL_FIELD_COUNT ) {
         /* ignore the second/millisecond etc. small fields' difference.
          * use single date when all the above are the same.
          */
         return fDateFormat->format(fromCalendar, appendTo, pos);
     }
     // 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, pos);
         }
         return fallbackFormat(fromCalendar, toCalendar, appendTo, pos, 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, appendTo, pos, status);
         fDateFormat->applyPattern(originalPattern);
         return appendTo;
     }
     Calendar* firstCal;
     Calendar* secondCal;
     if ( intervalPattern.laterDateFirst ) {
         firstCal = &toCalendar;
         secondCal = &fromCalendar;
     } else {
         firstCal = &fromCalendar;
         secondCal = &toCalendar;
     }
     // 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, pos);
     if ( !intervalPattern.secondPart.isEmpty() ) {
         fDateFormat->applyPattern(intervalPattern.secondPart);
         fDateFormat->format(*secondCal, appendTo, pos);
     }
     fDateFormat->applyPattern(originalPattern);
     return appendTo;
 }
 void
 DateIntervalFormat::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
 }
 const DateIntervalInfo*
 DateIntervalFormat::getDateIntervalInfo() const {
     return fInfo;
 }
 void
 DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
                                         UErrorCode& status) {
     delete fInfo;
     fInfo = new DateIntervalInfo(newItvPattern);
     if ( fDateFormat ) {
         initializePattern(status);
     }
 }
 const DateFormat*
 DateIntervalFormat::getDateFormat() const {
     return fDateFormat;
 }
 void
 DateIntervalFormat::adoptTimeZone(TimeZone* zone)
 {
     if (fDateFormat != NULL) {
         fDateFormat->adoptTimeZone(zone);
     }
     // The fDateFormat has the master 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);
     }
 }
 void
 DateIntervalFormat::setTimeZone(const TimeZone& zone)
 {
     if (fDateFormat != NULL) {
         fDateFormat->setTimeZone(zone);
     }
     // The fDateFormat has the master calendar for the DateIntervalFormat;
     // fFromCalendar and fToCalendar are internal work clones of that calendar.
     if (fFromCalendar) {
     	fFromCalendar->setTimeZone(zone);
     }
     if (fToCalendar) {
     	fToCalendar->setTimeZone(zone);
     }
 }
 const TimeZone&
 DateIntervalFormat::getTimeZone() const
 {
     if (fDateFormat != NULL) {
         return fDateFormat->getTimeZone();
     }
     // If fDateFormat is NULL (unexpected), create default timezone.
     return *(TimeZone::createDefault());
 }
 DateIntervalFormat::DateIntervalFormat(const Locale& locale,
                                        DateIntervalInfo* dtItvInfo,
                                        const UnicodeString* skeleton,
                                        UErrorCode& status)
 :   fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fToCalendar(NULL),
     fDtpng(NULL)
 {
     if ( U_FAILURE(status) ) {
         delete dtItvInfo;
         return;
     }
     fDtpng = DateTimePatternGenerator::createInstance(locale, status);
     SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale,
                                                     fDtpng, status);
     if ( U_FAILURE(status) ) {
         delete dtItvInfo;
         delete fDtpng;
         delete dtfmt;
         return;
     }
     if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) {
         status = U_MEMORY_ALLOCATION_ERROR;
         // safe to delete NULL
         delete dtfmt;
         delete dtItvInfo;
         delete fDtpng;
         return;
     }
     if ( skeleton ) {
         fSkeleton = *skeleton;
     }
     fInfo = dtItvInfo;
     fDateFormat = dtfmt;
     if ( dtfmt->getCalendar() ) {
         fFromCalendar = dtfmt->getCalendar()->clone();
         fToCalendar = dtfmt->getCalendar()->clone();
     } else {
         fFromCalendar = NULL;
         fToCalendar = NULL;
     }
     initializePattern(status);
 }
 SimpleDateFormat* U_EXPORT2
 DateIntervalFormat::createSDFPatternInstance(const UnicodeString& skeleton,
                                              const Locale& locale,
                                              DateTimePatternGenerator* dtpng,
                                              UErrorCode& status)
 {
     if ( U_FAILURE(status) ) {
         return NULL;
     }
     const UnicodeString pattern = dtpng->getBestPattern(skeleton, status);
     if ( U_FAILURE(status) ) {
         return NULL;
     }
     SimpleDateFormat* dtfmt = new SimpleDateFormat(pattern, locale, status);
     if ( U_FAILURE(status) ) {
         delete dtfmt;
         return NULL;
     }
     return dtfmt;
 }
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat::create(const Locale& locale,
                            DateIntervalInfo* dtitvinf,
                            const UnicodeString* skeleton,
                            UErrorCode& status) {
     DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
                                                    skeleton, status);
     if ( f == NULL ) {
         status = U_MEMORY_ALLOCATION_ERROR;
         delete dtitvinf;
     } else if ( U_FAILURE(status) ) {
         // safe to delete f, although nothing acutally is saved
         delete f;
         f = 0;
     }
     return f;
 }
 /**
  * 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
  */
 void
 DateIntervalFormat::initializePattern(UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
     const Locale& locale = fDateFormat->getSmpFmtLocale();
     if ( fSkeleton.isEmpty() ) {
         UnicodeString fullPattern;
         fDateFormat->toPattern(fullPattern);
 #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)
 #endif
         // fSkeleton is already set by createDateIntervalInstance()
         // or by createInstance(UnicodeString skeleton, .... )
         fSkeleton = fDtpng->getSkeleton(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. 'a' is omitted in normalized time skeleton.
      * 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'
      */
     getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton,
                         timeSkeleton, normalizedTimeSkeleton);
 #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)
 #endif
     UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
                                          normalizedTimeSkeleton);
     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 = fDtpng->getBestPattern(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, NULL, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_YEAR, NULL, &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 = fDtpng->getBestPattern(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, NULL, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder());
     } else {
         /* if both present,
          * 1) when the 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 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);
             setFallbackPattern(UCAL_DATE, skeleton, status);
         }
         if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
             // then prefix skeleton with 'M'
             skeleton.insert(0, CAP_M);
             setFallbackPattern(UCAL_MONTH, skeleton, status);
         }
         if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
             // then prefix skeleton with 'y'
             skeleton.insert(0, LOW_Y);
             setFallbackPattern(UCAL_YEAR, skeleton, status);
         }
         /*
          * 2) otherwise, present the date followed by the
          * range expression for the time.
          */
         // Need the Date/Time pattern for concatnation 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.
         CalendarData* calData = new CalendarData(locale, NULL, status);
         if ( U_FAILURE(status) ) {
             delete calData;
             return;
         }
         if ( calData == NULL ) {
             status = U_MEMORY_ALLOCATION_ERROR;
             return;
         }
         const UResourceBundle* dateTimePatternsRes = calData->getByKey(
                                            gDateTimePatternsTag, status);
         int32_t dateTimeFormatLength;
         const UChar* dateTimeFormat = ures_getStringByIndex(
                                             dateTimePatternsRes,
                                             (int32_t)DateFormat::kDateTime,
                                             &dateTimeFormatLength, &status);
         if ( U_FAILURE(status) ) {
             return;
         }
         UnicodeString datePattern = fDtpng->getBestPattern(dateSkeleton, status);
         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
                                       datePattern, UCAL_AM_PM, status);
         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
                                       datePattern, UCAL_HOUR, status);
         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
                                       datePattern, UCAL_MINUTE, status);
         delete calData;
     }
 }
 void  U_EXPORT2
 DateIntervalFormat::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 hCount = 0;
     int32_t HCount = 0;
     int32_t mCount = 0;
     int32_t vCount = 0;
     int32_t zCount = 0;
     int32_t i;
     for (i = 0; i < skeleton.length(); ++i) {
         UChar ch = skeleton[i];
         switch ( ch ) {
           case CAP_E:
             dateSkeleton.append(ch);
             ++ECount;
             break;
           case LOW_D:
             dateSkeleton.append(ch);
             ++dCount;
             break;
           case CAP_M:
             dateSkeleton.append(ch);
             ++MCount;
             break;
           case LOW_Y:
             dateSkeleton.append(ch);
             ++yCount;
             break;
           case CAP_G:
           case CAP_Y:
           case LOW_U:
           case CAP_Q:
           case LOW_Q:
           case CAP_L:
           case LOW_L:
           case CAP_W:
           case LOW_W:
           case CAP_D:
           case CAP_F:
           case LOW_G:
           case LOW_E:
           case LOW_C:
             normalizedDateSkeleton.append(ch);
             dateSkeleton.append(ch);
             break;
           case LOW_A:
             // 'a' is implicitly handled
             timeSkeleton.append(ch);
             break;
           case LOW_H:
             timeSkeleton.append(ch);
             ++hCount;
             break;
           case CAP_H:
             timeSkeleton.append(ch);
             ++HCount;
             break;
           case LOW_M:
             timeSkeleton.append(ch);
             ++mCount;
             break;
           case LOW_Z:
             ++zCount;
             timeSkeleton.append(ch);
             break;
           case LOW_V:
             ++vCount;
             timeSkeleton.append(ch);
             break;
           case CAP_V:
           case CAP_Z:
           case LOW_K:
           case CAP_K:
           case LOW_J:
           case LOW_S:
           case CAP_S:
           case CAP_A:
             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);
         }
     }
     if ( MCount != 0 ) {
         if ( MCount < 3 ) {
             normalizedDateSkeleton.append(CAP_M);
         } else {
             int32_t i;
             for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) {
                  normalizedDateSkeleton.append(CAP_M);
             }
         }
     }
     if ( ECount != 0 ) {
         if ( ECount <= 3 ) {
             normalizedDateSkeleton.append(CAP_E);
         } else {
             int32_t i;
             for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) {
                  normalizedDateSkeleton.append(CAP_E);
             }
         }
     }
     if ( dCount != 0 ) {
         normalizedDateSkeleton.append(LOW_D);
     }
     /* generate normalized form for time */
     if ( HCount != 0 ) {
         normalizedTimeSkeleton.append(CAP_H);
     }
     else if ( hCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_H);
     }
     if ( mCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_M);
     }
     if ( zCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_Z);
     }
     if ( vCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_V);
     }
 }
 /**
  * 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
  */
 UBool
 DateIntervalFormat::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 NULL.
        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 NULL
      */
     if ( bestSkeleton == NULL ) {
         return false;
     }
     // 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
     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);
     } else {
         setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
         setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
         setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo);
     }
     return true;
 }
 void
 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
                                        const UnicodeString& skeleton,
                                        UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
     UnicodeString pattern = fDtpng->getBestPattern(skeleton, status);
     if ( U_FAILURE(status) ) {
         return;
     }
     setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder());
 }
 void
 DateIntervalFormat::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;
 }
 void
 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                                        const UnicodeString& intervalPattern) {
     UBool order = fInfo->getDefaultOrder();
     setIntervalPattern(field, intervalPattern, order);
 }
 void
 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                                        const UnicodeString& intervalPattern,
                                        UBool laterDateFirst) {
     const UnicodeString* pattern = &intervalPattern;
     UBool order = laterDateFirst;
     // check for "latestFirst:" or "earliestFirst:" prefix
     int8_t prefixLength = sizeof(gLaterFirstPrefix)/sizeof(gLaterFirstPrefix[0]);
     int8_t earliestFirstLength = 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);
 }
 /**
  * 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
  */
 UBool
 DateIntervalFormat::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() ) {
                 setIntervalPattern(field, pattern);
             }
             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() ) {
         if ( differenceInfo != 0 ) {
             UnicodeString adjustIntervalPattern;
             adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
                               adjustIntervalPattern);
             setIntervalPattern(field, adjustIntervalPattern);
         } else {
             setIntervalPattern(field, pattern);
         }
         if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) {
             return TRUE;
         }
     }
     return FALSE;
 }
 int32_t  U_EXPORT2
 DateIntervalFormat::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,
     //   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,
     //       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
     };
     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 == FALSE ) {
                 patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE;
             } else {
                 foundRepetition = true;
                 break;
             }
             count = 0;
         }
         if (ch == '\'') {
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
             if ((i+1) < intervalPattern.length() &&
                 intervalPattern.charAt(i+1) == '\'') {
                 ++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 == FALSE ) {
         if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) {
             count = 0;
         }
     }
     return (i - count);
 }
 UnicodeString&
 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                    Calendar& toCalendar,
                                    UnicodeString& appendTo,
                                    FieldPosition& pos,
                                    UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     // the fall back
     // no need delete earlierDate and laterDate since they are adopted
     UnicodeString* earlierDate = new UnicodeString();
     *earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos);
     UnicodeString* laterDate = new UnicodeString();
     *laterDate = fDateFormat->format(toCalendar, *laterDate, pos);
     UnicodeString fallbackPattern;
     fInfo->getFallbackIntervalPattern(fallbackPattern);
     Formattable fmtArray[2];
     fmtArray[0].adoptString(earlierDate);
     fmtArray[1].adoptString(laterDate);
     UnicodeString fallback;
     MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status);
     if ( U_SUCCESS(status) ) {
         appendTo.append(fallback);
     }
     return appendTo;
 }
 UBool  U_EXPORT2
 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
                                           const UnicodeString& skeleton)
 {
     const UChar fieldChar = fgCalendarFieldToPatternLetter[field];
     return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ;
 }
 void  U_EXPORT2
 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
                  const UnicodeString& bestMatchSkeleton,
                  const UnicodeString& bestIntervalPattern,
                  int8_t differenceInfo,
                  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,
     //   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,
     //       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
     };
     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,
     //   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,
     //       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
     };
     DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
     DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
     if ( differenceInfo == 2 ) {
         adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */),
                                    UnicodeString((UChar)0x7a /* z */));
     }
     UBool inQuote = false;
     UChar prevCh = 0;
     int32_t count = 0;
     const int8_t PATTERN_CHAR_BASE = 0x41;
     // 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 ) {
                 // 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;
             }
             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 == '\'') {
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
             if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') {
                 ++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 ) {
             // 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;
         }
         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);
             }
         }
     }
 }
 void
 DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
                                               int32_t formatLen,
                                               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 allocated here is adopted, so no need to delete
         UnicodeString* timeIntervalPattern = new UnicodeString(timeItvPtnInfo.firstPart);
         timeIntervalPattern->append(timeItvPtnInfo.secondPart);
         UnicodeString* dateStr = new UnicodeString(datePattern);
         Formattable fmtArray[2];
         fmtArray[0].adoptString(timeIntervalPattern);
         fmtArray[1].adoptString(dateStr);
         UnicodeString combinedPattern;
         MessageFormat::format(UnicodeString(TRUE, format, formatLen),
                               fmtArray, 2, 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
 }
 const UChar
 DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
 {
     /*GyM*/ CAP_G, LOW_Y, CAP_M,
     /*wWd*/ LOW_W, CAP_W, LOW_D,
     /*DEF*/ CAP_D, CAP_E, CAP_F,
     /*ahH*/ LOW_A, LOW_H, CAP_H,
     /*m..*/ LOW_M,
 };
 U_NAMESPACE_END
 #endif

The Tor Browser / annotate

intl/icu/source/i18n/dtitvfmt.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/dtitvfmt.cpp