ICU 56 update step 1

source/i18n/dtitvfmt.cpp

 /*******************************************************************************
-* Copyright (C) 2008-2014, International Business Machines Corporation and
+* Copyright (C) 2008-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File DTITVFMT.CPP 
 *
 *******************************************************************************
 */
 
 #include "utypeinfo.h"  // for 'typeid' to work
 
@@ skipping 97 matching lines @@
     DateIntervalInfo* ptn = dtitvinf.clone();
     return create(locale, ptn, &skeleton, status);
 }
 
 
 DateIntervalFormat::DateIntervalFormat()
 :   fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fToCalendar(NULL),
-    fDtpng(NULL)
+    fLocale(Locale::getRoot()),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL)
 {}
 
 
 DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
 :   Format(itvfmt),
     fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fToCalendar(NULL),
-    fDtpng(NULL) {
+    fLocale(itvfmt.fLocale),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL) {
     *this = itvfmt;
 }
 
 
 DateIntervalFormat&
 DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
     if ( this != &itvfmt ) {
         delete fDateFormat;
         delete fInfo;
         delete fFromCalendar;
         delete fToCalendar;
-        delete fDtpng;
+        delete fDatePattern;
+        delete fTimePattern;
+        delete fDateTimeFormat;
         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();
-        }
+        fLocale = itvfmt.fLocale;
+        fDatePattern    = (itvfmt.fDatePattern)?    (UnicodeString*)itvfmt.fDatePattern->clone(): NULL;
+        fTimePattern    = (itvfmt.fTimePattern)?    (UnicodeString*)itvfmt.fTimePattern->clone(): NULL;
+        fDateTimeFormat = (itvfmt.fDateTimeFormat)? (UnicodeString*)itvfmt.fDateTimeFormat->clone(): NULL;
     }
     return *this;
 }
 
 
 DateIntervalFormat::~DateIntervalFormat() {
     delete fInfo;
     delete fDateFormat;
     delete fFromCalendar;
     delete fToCalendar;
-    delete fDtpng;
+    delete fDatePattern;
+    delete fTimePattern;
+    delete fDateTimeFormat;
 }
 
 
 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);
+    equal = ((fDatePattern == NULL && fmt->fDatePattern == NULL) || (fDatePattern && fmt->fDatePattern && *fDatePattern == *fmt->fDatePattern));
+    equal = ((fTimePattern == NULL && fmt->fTimePattern == NULL) || (fTimePattern && fmt->fTimePattern && *fTimePattern == *fmt->fTimePattern));
+    equal = ((fDateTimeFormat == NULL && fmt->fDateTimeFormat == NULL) || (fDateTimeFormat && fmt->fDateTimeFormat && *fDateTimeFormat == *fmt->fDateTimeFormat));
 #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) );
+                 ((fDatePattern == NULL && fmt->fDatePattern == NULL)       || (fDatePattern && fmt->fDatePattern && *fDatePattern == *fmt->fDatePattern)) &&
+                 ((fTimePattern == NULL && fmt->fTimePattern == NULL)       || (fTimePattern && fmt->fTimePattern && *fTimePattern == *fmt->fTimePattern)) &&
+                 ((fDateTimeFormat == NULL && fmt->fDateTimeFormat == NULL) || (fDateTimeFormat && fmt->fDateTimeFormat && *fDateTimeFormat == *fmt->fDateTimeFormat)) && fLocale == fmt->fLocale);
         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;
@@ skipping 78 matching lines @@
         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;
     }
 
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     if ( field == UCAL_FIELD_COUNT ) {
-        /* ignore the second/millisecond etc. small fields' difference.
+        /* ignore the millisecond etc. small fields' difference.
          * use single date when all the above are the same.
          */
         return fDateFormat->format(fromCalendar, appendTo, pos);
     }
+    UBool fromToOnSameDay = (field==UCAL_AM_PM || field==UCAL_HOUR || field==UCAL_MINUTE || field==UCAL_SECOND);
     
     // 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);
+        return fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, 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);
+        appendTo = fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, 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);
+        FieldPosition otherPos;
+        otherPos.setField(pos.getField());
+        fDateFormat->format(*secondCal, appendTo, otherPos);
+        if (pos.getEndIndex() == 0 && otherPos.getEndIndex() > 0) {
+            pos = otherPos;
+        }
     }
     fDateFormat->applyPattern(originalPattern);
     return appendTo;
 }
 
 
 
 void
 DateIntervalFormat::parseObject(const UnicodeString& /* source */, 
                                 Formattable& /* result */,
@@ skipping 10 matching lines @@
 DateIntervalFormat::getDateIntervalInfo() const {
     return fInfo;
 }
 
 
 void
 DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
                                         UErrorCode& status) {
     delete fInfo;
     fInfo = new DateIntervalInfo(newItvPattern);
+
+    // Delete patterns that get reset by initializePattern
+    delete fDatePattern;
+    fDatePattern = NULL;
+    delete fTimePattern;
+    fTimePattern = NULL;
+    delete fDateTimeFormat;
+    fDateTimeFormat = NULL;
+
     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);
+        fFromCalendar->setTimeZone(*zone);
     }
     if (fToCalendar) {
-        fToCalendar->setTimeZone(*zone);
+        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);
+        fFromCalendar->setTimeZone(zone);
     }
     if (fToCalendar) {
-        fToCalendar->setTimeZone(zone);
+        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)
+    fLocale(locale),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL)
 {
     if ( U_FAILURE(status) ) {
         delete dtItvInfo;
         return;
     }
-    fDtpng = DateTimePatternGenerator::createInstance(locale, status);
-    SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale, 
-                                                    fDtpng, status);
+    SimpleDateFormat* dtfmt =
+        static_cast<SimpleDateFormat *>(
+            DateFormat::createInstanceForSkeleton(
+                *skeleton, locale, status));
     if ( U_FAILURE(status) ) {
         delete dtItvInfo;
-        delete fDtpng;
         delete dtfmt;
         return;
     }
-    if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) {
+    if ( dtfmt == NULL || dtItvInfo == 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;
@@ skipping 53 matching lines @@
 #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);
+        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();
     }
@@ skipping 23 matching lines @@
 
 #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
 
+    // 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.
+        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_SUCCESS(status) && dateTimeFormatLength >= 3 ) {
+            fDateTimeFormat = new UnicodeString(dateTimeFormat, dateTimeFormatLength);
+        }
+        delete calData;
+    }
 
     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 = fDtpng->getBestPattern(timeSkeleton, status);
+                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, 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);
+        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, NULL, &pattern, fInfo->getDefaultOrder()); 
         setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder()); 
         setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder()); 
@@ skipping 23 matching lines @@
         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;
+        if ( fDateTimeFormat == 0 ) {
+            // earlier failure getting dateTimeFormat
             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 = DateFormat::getBestPattern(
+                locale, dateSkeleton, status);
 
-        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;
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_AM_PM, status);
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_HOUR, status);
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_MINUTE, status);
     }
 }
 
 
 
 void  U_EXPORT2 
 DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton, 
                                         UnicodeString& dateSkeleton, 
                                         UnicodeString& normalizedDateSkeleton, 
                                         UnicodeString& timeSkeleton,
@@ skipping 194 matching lines @@
            intervalFormats{
                 fallback{"{0} - {1}"}
             }
        there is no skeletons/interval patterns defined,
        and the best skeleton match could be NULL
      */
     if ( bestSkeleton == NULL ) {
         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));
+    }
+    if ( timeSkeleton.length() != 0) {
+        status = U_ZERO_ERROR;
+        fTimePattern = new UnicodeString(DateFormat::getBestPattern(
+                fLocale, timeSkeleton, status));
+    }
+
     // 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,
@@ skipping 19 matching lines @@
 
 
 
 void
 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
                                        const UnicodeString& skeleton,
                                        UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
-    UnicodeString pattern = fDtpng->getBestPattern(skeleton, status);
+    UnicodeString pattern = DateFormat::getBestPattern(
+            fLocale, skeleton, status);
     if ( U_FAILURE(status) ) {
         return;
     }
     setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder());
 }
 
 
 
 
 void
@@ skipping 233 matching lines @@
     // "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);
 }
 
+static const UChar bracketedZero[] = {0x7B,0x30,0x7D};
+static const UChar bracketedOne[]  = {0x7B,0x31,0x7D};
 
+void
+DateIntervalFormat::adjustPosition(UnicodeString& combiningPattern, // has {0} and {1} in it
+                                   UnicodeString& pat0, FieldPosition& pos0, // pattern and pos corresponding to {0}
+                                   UnicodeString& pat1, FieldPosition& pos1, // pattern and pos corresponding to {1}
+                                   FieldPosition& posResult)  {
+    int32_t index0 = combiningPattern.indexOf(bracketedZero, 3, 0);
+    int32_t index1 = combiningPattern.indexOf(bracketedOne,  3, 0);
+    if (index0 < 0 || index1 < 0) {
+        return;
+    }
+    int32_t placeholderLen = 3; // length of "{0}" or "{1}"
+    if (index0 < index1) {
+        if (pos0.getEndIndex() > 0) {
+            posResult.setBeginIndex(pos0.getBeginIndex() + index0);
+            posResult.setEndIndex(pos0.getEndIndex() + index0);
+        } else if (pos1.getEndIndex() > 0) {
+            // here index1 >= 3
+            index1 += pat0.length() - placeholderLen; // adjust for pat0 replacing {0}
+            posResult.setBeginIndex(pos1.getBeginIndex() + index1);
+            posResult.setEndIndex(pos1.getEndIndex() + index1);
+        }
+    } else {
+        if (pos1.getEndIndex() > 0) {
+            posResult.setBeginIndex(pos1.getBeginIndex() + index1);
+            posResult.setEndIndex(pos1.getEndIndex() + index1);
+        } else if (pos0.getEndIndex() > 0) {
+            // here index0 >= 3
+            index0 += pat1.length() - placeholderLen; // adjust for pat1 replacing {1}
+            posResult.setBeginIndex(pos0.getBeginIndex() + index0);
+            posResult.setEndIndex(pos0.getEndIndex() + index0);
+        }
+    }
+}
 
 UnicodeString& 
 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                    Calendar& toCalendar,
+                                   UBool fromToOnSameDay, // new
                                    UnicodeString& appendTo,
                                    FieldPosition& pos,
                                    UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
+    UnicodeString fullPattern; // for saving the pattern in fDateFormat
+    UBool formatDatePlusTimeRange = (fromToOnSameDay && fDatePattern && fTimePattern);
     // the fall back
     // no need delete earlierDate and laterDate since they are adopted
+    if (formatDatePlusTimeRange) {
+        fDateFormat->toPattern(fullPattern); // save current pattern, restore later
+        fDateFormat->applyPattern(*fTimePattern);
+    }
+    FieldPosition otherPos;
+    otherPos.setField(pos.getField());
     UnicodeString* earlierDate = new UnicodeString();
-    *earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos);
+    fDateFormat->format(fromCalendar, *earlierDate, pos);
     UnicodeString* laterDate = new UnicodeString();
-    *laterDate = fDateFormat->format(toCalendar, *laterDate, pos);
+    fDateFormat->format(toCalendar, *laterDate, otherPos);
     UnicodeString fallbackPattern;
     fInfo->getFallbackIntervalPattern(fallbackPattern);
+    adjustPosition(fallbackPattern, *earlierDate, pos, *laterDate, otherPos, pos);
     Formattable fmtArray[2];
     fmtArray[0].adoptString(earlierDate);
     fmtArray[1].adoptString(laterDate);
     
-    UnicodeString fallback;
-    MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status);
+    UnicodeString fallbackRange;
+    MessageFormat::format(fallbackPattern, fmtArray, 2, fallbackRange, status);
+    if ( U_SUCCESS(status) && formatDatePlusTimeRange ) {
+        // fallbackRange has just the time range, need to format the date part and combine that
+        fDateFormat->applyPattern(*fDatePattern);
+        UnicodeString* datePortion = new UnicodeString();
+        otherPos.setBeginIndex(0);
+        otherPos.setEndIndex(0);
+        fDateFormat->format(fromCalendar, *datePortion, otherPos);
+        adjustPosition(*fDateTimeFormat, fallbackRange, pos, *datePortion, otherPos, pos);
+        fmtArray[0].setString(fallbackRange); // {0} is time range
+        fmtArray[1].adoptString(datePortion); // {1} is single date portion
+        fallbackRange.remove();
+        MessageFormat::format(*fDateTimeFormat, fmtArray, 2, fallbackRange, status);
+    }
     if ( U_SUCCESS(status) ) {
-        appendTo.append(fallback);
+        appendTo.append(fallbackRange);
+    }
+    if (formatDatePlusTimeRange) {
+        // restore full pattern
+        fDateFormat->applyPattern(fullPattern);
     }
     return appendTo;
 }
 
 
 
 
 UBool  U_EXPORT2 
 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
                                           const UnicodeString& skeleton)
@@ skipping 109 matching lines @@
             for ( j = 0; j < count; ++j ) {
                 adjustedPtn.append(prevCh);    
             }                    
         }
     }
 }
 
 
 
 void 
-DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
-                                              int32_t formatLen,
+DateIntervalFormat::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 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);
+        MessageFormat::format(format, 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,
     /*msS*/ LOW_M, LOW_S, CAP_S, // MINUTE, SECOND, MILLISECOND
     /*z.Y*/ LOW_Z, SPACE, CAP_Y, // ZONE_OFFSET, DST_OFFSET, YEAR_WOY,
     /*eug*/ LOW_E, LOW_U, LOW_G, // DOW_LOCAL, EXTENDED_YEAR, JULIAN_DAY,
     /*A..*/ CAP_A, SPACE, SPACE, // MILLISECONDS_IN_DAY, IS_LEAP_MONTH, FIELD_COUNT
 };
 
 
 U_NAMESPACE_END
 
 #endif