]> git.saurik.com Git - apple/icu.git/blobdiff - icuSources/i18n/dtitvfmt.cpp
projects / apple / icu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ICU-64232.0.1.tar.gz
[apple/icu.git] / icuSources / i18n / dtitvfmt.cpp
diff --git a/icuSources/i18n/dtitvfmt.cpp b/icuSources/i18n/dtitvfmt.cpp
index 985176e03c2446d9417f38889c4c981a77b96606..ba6001f5fe30413bdb4c92f2b7538a92864709bf 100644 (file)
--- a/icuSources/i18n/dtitvfmt.cpp
+++ b/icuSources/i18n/dtitvfmt.cpp
@@ -1,39 +1,46 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
 /*******************************************************************************
 /*******************************************************************************
-* Copyright (C) 2008, International Business Machines Corporation and
+* Copyright (C) 2008-2016, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * others. All Rights Reserved.
 *******************************************************************************
 *
-* File DTITVFMT.CPP 
+* File DTITVFMT.CPP
 *
 *******************************************************************************
 */
 
 *
 *******************************************************************************
 */
 
+#include "utypeinfo.h"  // for 'typeid' to work
+
 #include "unicode/dtitvfmt.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/dtitvfmt.h"
 
 #if !UCONFIG_NO_FORMATTING
 
-//FIXME: put in compilation
+//TODO: put in compilation
 //#define DTITVFMT_DEBUG 1
 
 //#define DTITVFMT_DEBUG 1
 
-#include "cstring.h"
-#include "unicode/msgfmt.h"
+#include "unicode/calendar.h"
 #include "unicode/dtptngen.h"
 #include "unicode/dtitvinf.h"
 #include "unicode/dtptngen.h"
 #include "unicode/dtitvinf.h"
-#include "unicode/calendar.h"
+#include "unicode/simpleformatter.h"
+#include "cmemory.h"
+#include "cstring.h"
 #include "dtitv_impl.h"
 #include "dtitv_impl.h"
+#include "mutex.h"
+#include "uresimp.h"
+#include "formattedval_impl.h"
+// Apple addition
+#include "unicode/udateintervalformat.h"
 
 
-#ifdef DTITVFMT_DEBUG 
+#ifdef DTITVFMT_DEBUG
 #include <iostream>
 #include <iostream>
-#include "cstring.h"
 #endif
 
 #endif
 
-#include "gregoimp.h"
-
 U_NAMESPACE_BEGIN
 
 
 
 U_NAMESPACE_BEGIN
 
 
 
-#ifdef DTITVFMT_DEBUG 
+#ifdef DTITVFMT_DEBUG
 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
 #endif
 
 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
 #endif
 
@@ -49,33 +56,50 @@ static const UChar gDateFormatSkeleton[][11] = {
 {LOW_Y, CAP_M, LOW_D, 0} };
 
 
 {LOW_Y, CAP_M, LOW_D, 0} };
 
 
-static const char gDateTimePatternsTag[]="DateTimePatterns";
+static const char gCalendarTag[] = "calendar";
+static const char gGregorianTag[] = "gregorian";
+static const char gDateTimePatternsTag[] = "DateTimePatterns";
 
 
 // latestFirst:
 
 
 // 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, 0};
+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:
 
 // 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, 0};
+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};
+
+
+class FormattedDateIntervalData : public FormattedValueFieldPositionIteratorImpl {
+public:
+    FormattedDateIntervalData(UErrorCode& status) : FormattedValueFieldPositionIteratorImpl(5, status) {}
+    virtual ~FormattedDateIntervalData();
+};
+
+FormattedDateIntervalData::~FormattedDateIntervalData() = default;
+
+UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedDateInterval)
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
 
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
 
+// Mutex, protects access to fDateFormat, fFromCalendar and fToCalendar.
+//        Needed because these data members are modified by const methods of DateIntervalFormat.
 
 
+static UMutex *gFormatterMutex() {
+    static UMutex *m = STATIC_NEW(UMutex);
+    return m;
+}
 
 DateIntervalFormat* U_EXPORT2
 
 DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    UErrorCode& status) {
     return createInstance(skeleton, Locale::getDefault(), status);
 }
 
 
 DateIntervalFormat* U_EXPORT2
                                    UErrorCode& status) {
     return createInstance(skeleton, Locale::getDefault(), status);
 }
 
 
 DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
-                                   const Locale& locale, 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton,
+                                   const Locale& locale,
                                    UErrorCode& status) {
                                    UErrorCode& status) {
-    DateFormat* dtfmt = DateFormat::createPatternInstance(skeleton, locale, status);
-
 #ifdef DTITVFMT_DEBUG
     char result[1000];
     char result_1[1000];
 #ifdef DTITVFMT_DEBUG
     char result[1000];
     char result_1[1000];
@@ -89,7 +113,7 @@ DateIntervalFormat::createInstance(const UnicodeString& skeleton,
 #endif
 
     DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
 #endif
 
     DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
-    return create(dtfmt, dtitvinf, &skeleton, status);
+    return create(locale, dtitvinf, &skeleton, status);
 }
 
 
 }
 
 
@@ -107,9 +131,8 @@ DateIntervalFormat::createInstance(const UnicodeString& skeleton,
                                    const Locale& locale,
                                    const DateIntervalInfo& dtitvinf,
                                    UErrorCode& status) {
                                    const Locale& locale,
                                    const DateIntervalInfo& dtitvinf,
                                    UErrorCode& status) {
-    DateFormat* dtfmt = DateFormat::createPatternInstance(skeleton, locale, status);
     DateIntervalInfo* ptn = dtitvinf.clone();
     DateIntervalInfo* ptn = dtitvinf.clone();
-    return create(dtfmt, ptn, &skeleton, status);
+    return create(locale, ptn, &skeleton, status);
 }
 
 
 }
 
 
@@ -117,7 +140,13 @@ DateIntervalFormat::DateIntervalFormat()
 :   fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
 :   fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
-    fToCalendar(NULL)
+    fToCalendar(NULL),
+    fLocale(Locale::getRoot()),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL),
+    fMinimizeType(UDTITVFMT_MINIMIZE_NONE),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 {}
 
 
 {}
 
 
@@ -126,7 +155,13 @@ DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
     fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
     fInfo(NULL),
     fDateFormat(NULL),
     fFromCalendar(NULL),
-    fToCalendar(NULL) {
+    fToCalendar(NULL),
+    fLocale(itvfmt.fLocale),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL),
+    fMinimizeType(UDTITVFMT_MINIMIZE_NONE),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE) {
     *this = itvfmt;
 }
 
     *this = itvfmt;
 }
 
@@ -138,31 +173,43 @@ DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
         delete fInfo;
         delete fFromCalendar;
         delete fToCalendar;
         delete fInfo;
         delete fFromCalendar;
         delete fToCalendar;
-        if ( itvfmt.fDateFormat ) {
-            fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone();
-        } else {
-            fDateFormat = NULL;
+        delete fDatePattern;
+        delete fTimePattern;
+        delete fDateTimeFormat;
+        {
+            Mutex lock(gFormatterMutex());
+            if ( itvfmt.fDateFormat ) {
+                fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone();
+            } else {
+                fDateFormat = NULL;
+            }
+            if ( itvfmt.fFromCalendar ) {
+                fFromCalendar = itvfmt.fFromCalendar->clone();
+            } else {
+                fFromCalendar = NULL;
+            }
+            if ( itvfmt.fToCalendar ) {
+                fToCalendar = itvfmt.fToCalendar->clone();
+            } else {
+                fToCalendar = NULL;
+            }
         }
         if ( itvfmt.fInfo ) {
             fInfo = itvfmt.fInfo->clone();
         } else {
             fInfo = 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];
         }
         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)?    (UnicodeString*)itvfmt.fDatePattern->clone(): NULL;
+        fTimePattern    = (itvfmt.fTimePattern)?    (UnicodeString*)itvfmt.fTimePattern->clone(): NULL;
+        fDateTimeFormat = (itvfmt.fDateTimeFormat)? (UnicodeString*)itvfmt.fDateTimeFormat->clone(): NULL;
+        fMinimizeType   = itvfmt.fMinimizeType;
+        fCapitalizationContext = itvfmt.fCapitalizationContext;
     }
     return *this;
 }
     }
     return *this;
 }
@@ -173,6 +220,9 @@ DateIntervalFormat::~DateIntervalFormat() {
     delete fDateFormat;
     delete fFromCalendar;
     delete fToCalendar;
     delete fDateFormat;
     delete fFromCalendar;
     delete fToCalendar;
+    delete fDatePattern;
+    delete fTimePattern;
+    delete fDateTimeFormat;
 }
 
 
 }
 
 
@@ -184,46 +234,39 @@ DateIntervalFormat::clone(void) const {
 
 UBool
 DateIntervalFormat::operator==(const Format& other) const {
 
 UBool
 DateIntervalFormat::operator==(const Format& other) const {
-    if ( other.getDynamicClassID() == DateIntervalFormat::getStaticClassID() ) {
-        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 );
-        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;
+    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 == NULL || fmt->fInfo == NULL)) {return FALSE;}
+    if (fInfo && fmt->fInfo && (*fInfo != *fmt->fInfo )) {return FALSE;}
+    {
+        Mutex lock(gFormatterMutex());
+        if (fDateFormat != fmt->fDateFormat && (fDateFormat == NULL || fmt->fDateFormat == NULL)) {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 master calendar for the DateIntervalFormat.
+    if (fSkeleton != fmt->fSkeleton) {return FALSE;}
+    if (fDatePattern != fmt->fDatePattern && (fDatePattern == NULL || fmt->fDatePattern == NULL)) {return FALSE;}
+    if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return FALSE;}
+    if (fTimePattern != fmt->fTimePattern && (fTimePattern == NULL || fmt->fTimePattern == NULL)) {return FALSE;}
+    if (fTimePattern && fmt->fTimePattern && (*fTimePattern != *fmt->fTimePattern)) {return FALSE;}
+    if (fDateTimeFormat != fmt->fDateTimeFormat && (fDateTimeFormat == NULL || fmt->fDateTimeFormat == NULL)) {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 (fMinimizeType != fmt->fMinimizeType) {return FALSE;}
+    if (fCapitalizationContext != fmt->fCapitalizationContext) {return FALSE;}
+    return TRUE;
 }
 
 
 }
 
 
-
 UnicodeString&
 DateIntervalFormat::format(const Formattable& obj,
                            UnicodeString& appendTo,
 UnicodeString&
 DateIntervalFormat::format(const Formattable& obj,
                            UnicodeString& appendTo,
@@ -235,8 +278,9 @@ DateIntervalFormat::format(const Formattable& obj,
 
     if ( obj.getType() == Formattable::kObject ) {
         const UObject* formatObj = obj.getObject();
 
     if ( obj.getType() == Formattable::kObject ) {
         const UObject* formatObj = obj.getObject();
-        if (formatObj->getDynamicClassID() == DateInterval::getStaticClassID()){
-            return format((DateInterval*)formatObj, appendTo, fieldPosition, status);
+        const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj);
+        if (interval != NULL) {
+            return format(interval, appendTo, fieldPosition, status);
         }
     }
     status = U_ILLEGAL_ARGUMENT_ERROR;
         }
     }
     status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -252,16 +296,51 @@ DateIntervalFormat::format(const DateInterval* dtInterval,
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
+    if (fDateFormat == NULL || fInfo == NULL) {
+        status = U_INVALID_STATE_ERROR;
+        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);
+    FieldPositionOnlyHandler handler(fieldPosition);
+    handler.setAcceptFirstOnly(TRUE);
+    int8_t ignore;
+
+    Mutex lock(gFormatterMutex());
+    return formatIntervalImpl(*dtInterval, appendTo, ignore, handler, status);
+}
+
+
+FormattedDateInterval DateIntervalFormat::formatToValue(
+        const DateInterval& dtInterval,
+        UErrorCode& status) const {
+    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 appendTo;
+
+    return FormattedDateInterval(result.orphan());
 }
 
 
 }
 
 
@@ -271,32 +350,138 @@ DateIntervalFormat::format(Calendar& fromCalendar,
                            UnicodeString& appendTo,
                            FieldPosition& pos,
                            UErrorCode& status) const {
                            UnicodeString& appendTo,
                            FieldPosition& pos,
                            UErrorCode& status) const {
+    FieldPositionOnlyHandler handler(pos);
+    handler.setAcceptFirstOnly(TRUE);
+    int8_t ignore;
+
+    Mutex lock(gFormatterMutex());
+    return formatImpl(fromCalendar, toCalendar, appendTo, ignore, handler, status);
+}
+
+
+FormattedDateInterval DateIntervalFormat::formatToValue(
+        Calendar& fromCalendar,
+        Calendar& toCalendar,
+        UErrorCode& status) const {
+    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());
+        formatImpl(fromCalendar, toCalendar, 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);
+        result->sort();
+    }
+
+    return FormattedDateInterval(result.orphan());
+}
+
+
+UnicodeString& 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);
+}
+
+
+UnicodeString&
+DateIntervalFormat::formatImpl(Calendar& fromCalendar,
+                           Calendar& toCalendar,
+                           UnicodeString& appendTo,
+                           int8_t& firstIndex,
+                           FieldPositionHandler& fphandler,
+                           UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
 
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
 
+    // Initialize firstIndex to -1 (single date, no range)
+    firstIndex = -1;
+
     // not support different calendar types and time zones
     //if ( fromCalendar.getType() != toCalendar.getType() ) {
     // not support different calendar types and time zones
     //if ( fromCalendar.getType() != toCalendar.getType() ) {
-    if ( !fromCalendar.isEquivalentTo(toCalendar) ||
-         uprv_strcmp(fromCalendar.getType(), "gregorian") ) {
+    if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return appendTo;
     }
 
     // First, find the largest different calendar field.
     UCalendarDateFields field = UCAL_FIELD_COUNT;
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return appendTo;
     }
 
     // First, find the largest different calendar field.
     UCalendarDateFields field = UCAL_FIELD_COUNT;
+    UChar patternDay  = 0x0064; // d
+    UChar patternYear = 0x0079; // y
 
     if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
         field = UCAL_ERA;
 
     if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
         field = UCAL_ERA;
-    } else if ( fromCalendar.get(UCAL_YEAR, status) != 
+    } else if ( fromCalendar.get(UCAL_YEAR, status) !=
                 toCalendar.get(UCAL_YEAR, status) ) {
         field = UCAL_YEAR;
                 toCalendar.get(UCAL_YEAR, status) ) {
         field = UCAL_YEAR;
+        if (fMinimizeType == UDTITVFMT_MINIMIZE_ADJACENT_MONTHS && fSkeleton.indexOf(patternDay) >= 0 && fSkeleton.indexOf(patternYear) < 0) {
+            UDate fromDate = fromCalendar.getTime(status);
+            UDate toDate = toCalendar.getTime(status);
+            int32_t fromDay = fromCalendar.get(UCAL_DATE, status);
+            int32_t toDay = toCalendar.get(UCAL_DATE, status);
+            fromCalendar.add(UCAL_MONTH, 1, status);
+            if ( fromDate < toDate && fromCalendar.getTime(status) > toDate && fromDay > toDay ) {
+                field = UCAL_DATE;
+            }
+            fromCalendar.setTime(fromDate, status);
+        }
     } else if ( fromCalendar.get(UCAL_MONTH, status) !=
                 toCalendar.get(UCAL_MONTH, status) ) {
         field = UCAL_MONTH;
     } else if ( fromCalendar.get(UCAL_MONTH, status) !=
                 toCalendar.get(UCAL_MONTH, status) ) {
         field = UCAL_MONTH;
+        if (fMinimizeType == UDTITVFMT_MINIMIZE_ADJACENT_MONTHS && fSkeleton.indexOf(patternDay) >= 0) {
+            UDate fromDate = fromCalendar.getTime(status);
+            UDate toDate = toCalendar.getTime(status);
+            int32_t fromDay = fromCalendar.get(UCAL_DATE, status);
+            int32_t toDay = toCalendar.get(UCAL_DATE, status);
+            fromCalendar.add(UCAL_MONTH, 1, status);
+            if ( fromDate < toDate && fromCalendar.getTime(status) > toDate && fromDay > toDay ) {
+                field = UCAL_DATE;
+            }
+            fromCalendar.setTime(fromDate, status);
+        }
     } else if ( fromCalendar.get(UCAL_DATE, status) !=
                 toCalendar.get(UCAL_DATE, status) ) {
         field = UCAL_DATE;
     } else if ( fromCalendar.get(UCAL_DATE, status) !=
                 toCalendar.get(UCAL_DATE, status) ) {
         field = UCAL_DATE;
+        if (fMinimizeType == UDTITVFMT_MINIMIZE_ADJACENT_DAYS &&
+                // check normalized skeleton for 'H', 'h', 'j'
+                (fSkeleton.indexOf(0x0048) >= 0 || fSkeleton.indexOf(0x0068) >= 0 || fSkeleton.indexOf(0x006A) >= 0)) {
+            UDate fromDate = fromCalendar.getTime(status);
+            UDate toDate = toCalendar.getTime(status);
+            int32_t fromHour = fromCalendar.get(UCAL_HOUR, status);
+            int32_t toHour = toCalendar.get(UCAL_HOUR, status);
+            fromCalendar.add(UCAL_HOUR_OF_DAY, 12, status);
+            if ( fromDate < toDate && fromCalendar.getTime(status) > toDate && fromHour > toHour ) {
+                field = UCAL_AM_PM;
+            }
+            fromCalendar.setTime(fromDate, status);
+        }
     } else if ( fromCalendar.get(UCAL_AM_PM, status) !=
                 toCalendar.get(UCAL_AM_PM, status) ) {
         field = UCAL_AM_PM;
     } else if ( fromCalendar.get(UCAL_AM_PM, status) !=
                 toCalendar.get(UCAL_AM_PM, status) ) {
         field = UCAL_AM_PM;
@@ -306,18 +491,23 @@ DateIntervalFormat::format(Calendar& fromCalendar,
     } else if ( fromCalendar.get(UCAL_MINUTE, status) !=
                 toCalendar.get(UCAL_MINUTE, status) ) {
         field = UCAL_MINUTE;
     } 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 ) {
     }
 
     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.
          */
          * use single date when all the above are the same.
          */
-        return fDateFormat->format(fromCalendar, appendTo, pos);
+        fDateFormat->setContext(fCapitalizationContext, status);
+        return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
     }
     }
-    
+    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,
     // following call should not set wrong status,
     // all the pass-in fields are valid till here
     int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
@@ -331,11 +521,12 @@ DateIntervalFormat::format(Calendar& fromCalendar,
              * the smallest calendar field in pattern,
              * return single date format.
              */
              * the smallest calendar field in pattern,
              * return single date format.
              */
-            return fDateFormat->format(fromCalendar, appendTo, pos);
+            fDateFormat->setContext(fCapitalizationContext, status);
+            return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
         }
         }
-        return fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
+        return fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
     }
     }
-    // If the first part in interval pattern is empty, 
+    // 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() ) {
     // 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() ) {
@@ -343,7 +534,7 @@ DateIntervalFormat::format(Calendar& fromCalendar,
         UnicodeString originalPattern;
         fDateFormat->toPattern(originalPattern);
         fDateFormat->applyPattern(intervalPattern.secondPart);
         UnicodeString originalPattern;
         fDateFormat->toPattern(originalPattern);
         fDateFormat->applyPattern(intervalPattern.secondPart);
-        appendTo = fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
+        appendTo = fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
         fDateFormat->applyPattern(originalPattern);
         return appendTo;
     }
         fDateFormat->applyPattern(originalPattern);
         return appendTo;
     }
@@ -352,19 +543,24 @@ DateIntervalFormat::format(Calendar& fromCalendar,
     if ( intervalPattern.laterDateFirst ) {
         firstCal = &toCalendar;
         secondCal = &fromCalendar;
     if ( intervalPattern.laterDateFirst ) {
         firstCal = &toCalendar;
         secondCal = &fromCalendar;
+        firstIndex = 1;
     } else {
         firstCal = &fromCalendar;
         secondCal = &toCalendar;
     } else {
         firstCal = &fromCalendar;
         secondCal = &toCalendar;
+        firstIndex = 0;
     }
     // break the interval pattern into 2 parts,
     }
     // break the interval pattern into 2 parts,
-    // first part should not be empty, 
+    // first part should not be empty,
     UnicodeString originalPattern;
     fDateFormat->toPattern(originalPattern);
     fDateFormat->applyPattern(intervalPattern.firstPart);
     UnicodeString originalPattern;
     fDateFormat->toPattern(originalPattern);
     fDateFormat->applyPattern(intervalPattern.firstPart);
-    fDateFormat->format(*firstCal, appendTo, pos);
+    fDateFormat->setContext(fCapitalizationContext, status);
+    fDateFormat->_format(*firstCal, appendTo, fphandler, status);
+
     if ( !intervalPattern.secondPart.isEmpty() ) {
         fDateFormat->applyPattern(intervalPattern.secondPart);
     if ( !intervalPattern.secondPart.isEmpty() ) {
         fDateFormat->applyPattern(intervalPattern.secondPart);
-        fDateFormat->format(*secondCal, appendTo, pos);
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, status);
+        fDateFormat->_format(*secondCal, appendTo, fphandler, status);
     }
     fDateFormat->applyPattern(originalPattern);
     return appendTo;
     }
     fDateFormat->applyPattern(originalPattern);
     return appendTo;
@@ -373,11 +569,11 @@ DateIntervalFormat::format(Calendar& fromCalendar,
 
 
 void
 
 
 void
-DateIntervalFormat::parseObject(const UnicodeString& /* source */, 
+DateIntervalFormat::parseObject(const UnicodeString& /* source */,
                                 Formattable& /* result */,
                                 ParsePosition& /* parse_pos */) const {
     // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
                                 Formattable& /* result */,
                                 ParsePosition& /* parse_pos */) const {
     // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
-    // will set status as U_INVALID_FORMAT_ERROR if 
+    // will set status as U_INVALID_FORMAT_ERROR if
     // parse_pos is still 0
 }
 
     // parse_pos is still 0
 }
 
@@ -395,67 +591,155 @@ DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
                                         UErrorCode& status) {
     delete fInfo;
     fInfo = new DateIntervalInfo(newItvPattern);
                                         UErrorCode& status) {
     delete fInfo;
     fInfo = new DateIntervalInfo(newItvPattern);
-    if ( fDateFormat ) {
+
+    // Delete patterns that get reset by initializePattern
+    delete fDatePattern;
+    fDatePattern = NULL;
+    delete fTimePattern;
+    fTimePattern = NULL;
+    delete fDateTimeFormat;
+    fDateTimeFormat = NULL;
+
+    if (fDateFormat) {
         initializePattern(status);
     }
 }
 
 
         initializePattern(status);
     }
 }
 
 
- 
+
 const DateFormat*
 DateIntervalFormat::getDateFormat() const {
     return fDateFormat;
 }
 
 
 const DateFormat*
 DateIntervalFormat::getDateFormat() const {
     return fDateFormat;
 }
 
 
-DateIntervalFormat::DateIntervalFormat(DateFormat* dtfmt,
-                                       DateIntervalInfo* dtItvInfo,
-                                       const UnicodeString* skeleton,
-                                       UErrorCode& status) 
-:   fInfo(0),
-    fDateFormat(0),
-    fFromCalendar(0),
-    fToCalendar(0)
+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) {
+        Mutex lock(gFormatterMutex());
+        return fDateFormat->getTimeZone();
+    }
+    // If fDateFormat is NULL (unexpected), create default timezone.
+    return *(TimeZone::createDefault());
+}
+
+void
+DateIntervalFormat::setAttribute(UDateIntervalFormatAttribute attr,
+                                 UDateIntervalFormatAttributeValue value,
+                                 UErrorCode &status)
 {
     if ( U_FAILURE(status) ) {
 {
     if ( U_FAILURE(status) ) {
-        delete dtfmt;
-        delete dtItvInfo;
         return;
     }
         return;
     }
-    if ( dtfmt == NULL || dtItvInfo == NULL ) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        // safe to delete NULL
-        delete dtfmt;
-        delete dtItvInfo;
+    if (attr == UDTITVFMT_MINIMIZE_TYPE) {
+        fMinimizeType = value;
+    } else {
+        status = U_ILLEGAL_ARGUMENT_ERROR; 
+    }
+}
+
+void
+DateIntervalFormat::setContext(UDisplayContext value, UErrorCode& status)
+{
+    if (U_FAILURE(status))
         return;
         return;
+    if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
+        fCapitalizationContext = value;
+    } else {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+   }
+}
+
+UDisplayContext
+DateIntervalFormat::getContext(UDisplayContextType type, UErrorCode& status) const
+{
+    if (U_FAILURE(status))
+        return (UDisplayContext)0;
+    if (type != UDISPCTX_TYPE_CAPITALIZATION) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return (UDisplayContext)0;
     }
     }
+    return fCapitalizationContext;
+}
+
+DateIntervalFormat::DateIntervalFormat(const Locale& locale,
+                                       DateIntervalInfo* dtItvInfo,
+                                       const UnicodeString* skeleton,
+                                       UErrorCode& status)
+:   fInfo(NULL),
+    fDateFormat(NULL),
+    fFromCalendar(NULL),
+    fToCalendar(NULL),
+    fLocale(locale),
+    fDatePattern(NULL),
+    fTimePattern(NULL),
+    fDateTimeFormat(NULL),
+    fMinimizeType(UDTITVFMT_MINIMIZE_NONE),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
+{
+    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;
     }
     if ( skeleton ) {
         fSkeleton = *skeleton;
     }
-    fInfo = dtItvInfo;
-    fDateFormat = (SimpleDateFormat*)dtfmt;
-    if ( dtfmt->getCalendar() ) {
-        fFromCalendar = dtfmt->getCalendar()->clone();
-        fToCalendar = dtfmt->getCalendar()->clone();
-    } else {
-        fFromCalendar = NULL;
-        fToCalendar = NULL;
+    fInfo = info.orphan();
+    fDateFormat = dtfmt.orphan();
+    if ( fDateFormat->getCalendar() ) {
+        fFromCalendar = fDateFormat->getCalendar()->clone();
+        fToCalendar = fDateFormat->getCalendar()->clone();
     }
     initializePattern(status);
 }
 
     }
     initializePattern(status);
 }
 
-
-
 DateIntervalFormat* U_EXPORT2
 DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::create(DateFormat* dtfmt,
+DateIntervalFormat::create(const Locale& locale,
                            DateIntervalInfo* dtitvinf,
                            const UnicodeString* skeleton,
                            UErrorCode& status) {
                            DateIntervalInfo* dtitvinf,
                            const UnicodeString* skeleton,
                            UErrorCode& status) {
-    DateIntervalFormat* f = new DateIntervalFormat(dtfmt, dtitvinf, 
+    DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
                                                    skeleton, status);
     if ( f == NULL ) {
         status = U_MEMORY_ALLOCATION_ERROR;
                                                    skeleton, status);
     if ( f == NULL ) {
         status = U_MEMORY_ALLOCATION_ERROR;
-        delete dtfmt;
         delete dtitvinf;
     } else if ( U_FAILURE(status) ) {
         // safe to delete f, although nothing acutally is saved
         delete dtitvinf;
     } else if ( U_FAILURE(status) ) {
         // safe to delete f, although nothing acutally is saved
@@ -467,10 +751,10 @@ DateIntervalFormat::create(DateFormat* dtfmt,
 
 
 
 
 
 
-/** 
+/**
  * Initialize interval patterns locale to this formatter
  * Initialize interval patterns locale to this formatter
- * 
- * This code is a bit complicated since 
+ *
+ * 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.
  * 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.
@@ -478,40 +762,35 @@ DateIntervalFormat::create(DateFormat* dtfmt,
  *
  *    For example, it has interval patterns on skeleton "dMy" and "hm",
  *    but it does not have interval patterns on skeleton "dMyhm".
  *
  *    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
  *    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" 
+ *    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 
+ *    2) otherwise, present the date followed by the range expression
  *    for the time.
  *    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" 
+ *    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.
  *
  * 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 
+ *    For example, a pattern/skeleton is "hm", but the interval pattern
  *    includes year, month, and date when year, month, and date differs.
  *    includes year, month, and date when year, month, and date differs.
- * 
+ *
  * @param status          output param set to success/failure code on exit
  * @param status          output param set to success/failure code on exit
- * @draft ICU 4.0 
+ * @stable ICU 4.0
  */
  */
-void 
+void
 DateIntervalFormat::initializePattern(UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
     const Locale& locale = fDateFormat->getSmpFmtLocale();
 DateIntervalFormat::initializePattern(UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
     const Locale& locale = fDateFormat->getSmpFmtLocale();
-    DateTimePatternGenerator* dtpng = DateTimePatternGenerator::createInstance(locale, status);
-    if ( U_FAILURE(status) ) {
-        delete dtpng;
-        return;    
-    }
     if ( fSkeleton.isEmpty() ) {
         UnicodeString fullPattern;
         fDateFormat->toPattern(fullPattern);
     if ( fSkeleton.isEmpty() ) {
         UnicodeString fullPattern;
         fDateFormat->toPattern(fullPattern);
@@ -525,10 +804,10 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
 #endif
         // fSkeleton is already set by createDateIntervalInstance()
         // or by createInstance(UnicodeString skeleton, .... )
 #endif
         // fSkeleton is already set by createDateIntervalInstance()
         // or by createInstance(UnicodeString skeleton, .... )
-        fSkeleton = dtpng->getSkeleton(fullPattern, status);
+        fSkeleton = DateTimePatternGenerator::staticGetSkeleton(
+                fullPattern, status);
         if ( U_FAILURE(status) ) {
         if ( U_FAILURE(status) ) {
-            delete dtpng;
-            return;    
+            return;
         }
     }
 
         }
     }
 
@@ -548,9 +827,9 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
 
 
     /* the difference between time skeleton and normalizedTimeSkeleton are:
 
 
     /* the difference between time skeleton and normalizedTimeSkeleton are:
-     * 1. both 'H' and 'h' are normalized as 'h' in normalized time skeleton,
+     * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
      * 2. 'a' is omitted in normalized time skeleton.
      * 2. 'a' is omitted in normalized time skeleton.
-     * 3. there is only one appearance for 'h', 'm','v', 'z' in normalized 
+     * 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:
      *    time skeleton
      *
      * The difference between date skeleton and normalizedDateSkeleton are:
@@ -570,138 +849,133 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
     PRINTMESG(mesg)
 #endif
 
     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.
+        LocalUResourceBundlePointer dateTimePatternsRes(ures_open(NULL, locale.getBaseName(), &status));
+        ures_getByKey(dateTimePatternsRes.getAlias(), gCalendarTag,
+                      dateTimePatternsRes.getAlias(), &status);
+        ures_getByKeyWithFallback(dateTimePatternsRes.getAlias(), gGregorianTag,
+                                  dateTimePatternsRes.getAlias(), &status);
+        ures_getByKeyWithFallback(dateTimePatternsRes.getAlias(), gDateTimePatternsTag,
+                                  dateTimePatternsRes.getAlias(), &status);
 
 
-    UBool found = setSeparateDateTimePtn(normalizedDateSkeleton, 
+        int32_t dateTimeFormatLength;
+        const UChar* dateTimeFormat = ures_getStringByIndex(
+                                            dateTimePatternsRes.getAlias(),
+                                            (int32_t)DateFormat::kDateTime,
+                                            &dateTimeFormatLength, &status);
+        if ( U_SUCCESS(status) && dateTimeFormatLength >= 3 ) {
+            fDateTimeFormat = new UnicodeString(dateTimeFormat, dateTimeFormatLength);
+        }
+    }
+
+    UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
                                          normalizedTimeSkeleton);
 
                                          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
     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]);
-                UnicodeString pattern =dtpng->getBestPattern(timeSkeleton, status);
+                timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
+                UnicodeString pattern = DateFormat::getBestPattern(
+                        locale, timeSkeleton, status);
                 if ( U_FAILURE(status) ) {
                 if ( U_FAILURE(status) ) {
-                    delete dtpng;
-                    return;    
+                    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.
                 }
                 // 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()); 
+                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
         }
             } else {
                 // TODO: fall back
             }
         } else {
             // TODO: fall back
         }
-        delete dtpng;
         return;
     } // end of skeleton not found
         return;
     } // end of skeleton not found
-    // interval patterns for skeleton are found in resource 
+    // interval patterns for skeleton are found in resource
     if ( timeSkeleton.length() == 0 ) {
         // done
     } else if ( dateSkeleton.length() == 0 ) {
         // prefix with yMd
     if ( timeSkeleton.length() == 0 ) {
         // done
     } else if ( dateSkeleton.length() == 0 ) {
         // prefix with yMd
-        timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort]);
-        UnicodeString pattern =dtpng->getBestPattern(timeSkeleton, status);
+        timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
+        UnicodeString pattern = DateFormat::getBestPattern(
+                locale, timeSkeleton, status);
         if ( U_FAILURE(status) ) {
         if ( U_FAILURE(status) ) {
-            delete dtpng;
-            return;    
+            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.
         }
         // 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()); 
+        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,
     } 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,
+         * 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, 
+         * 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);
          */
         // 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, dtpng, status);
+            setFallbackPattern(UCAL_DATE, skeleton, status);
         }
         if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
             // then prefix skeleton with 'M'
             skeleton.insert(0, CAP_M);
         }
         if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
             // then prefix skeleton with 'M'
             skeleton.insert(0, CAP_M);
-            setFallbackPattern(UCAL_MONTH, skeleton, dtpng, status);
+            setFallbackPattern(UCAL_MONTH, skeleton, status);
         }
         if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
             // then prefix skeleton with 'y'
             skeleton.insert(0, LOW_Y);
         }
         if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
             // then prefix skeleton with 'y'
             skeleton.insert(0, LOW_Y);
-            setFallbackPattern(UCAL_YEAR, skeleton, dtpng, status);
+            setFallbackPattern(UCAL_YEAR, skeleton, status);
         }
         }
-        
+
         /*
         /*
-         * 2) otherwise, present the date followed by the 
-         * range expression for the time. 
+         * 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;
-            delete dtpng;
+        if ( fDateTimeFormat == NULL ) {
+            // earlier failure getting dateTimeFormat
             return;
         }
 
             return;
         }
 
-        if ( calData == NULL ) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            delete dtpng;
-            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) ) {
-            delete dtpng;
-            return;
-        }
-
-        UnicodeString datePattern = dtpng->getBestPattern(dateSkeleton, status);
+        UnicodeString datePattern = DateFormat::getBestPattern(
+                locale, 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);
     }
     }
-    delete dtpng;
 }
 
 
 
 }
 
 
 
-void  U_EXPORT2 
-DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton, 
-                                        UnicodeString& dateSkeleton, 
-                                        UnicodeString& normalizedDateSkeleton, 
+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*
                                         UnicodeString& timeSkeleton,
                                         UnicodeString& normalizedTimeSkeleton) {
     // dateSkeleton follows the sequence of y*M*E*d*
@@ -711,6 +985,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
     int32_t MCount = 0;
     int32_t yCount = 0;
     int32_t hCount = 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 mCount = 0;
     int32_t vCount = 0;
     int32_t zCount = 0;
@@ -749,18 +1024,23 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
           case LOW_G:
           case LOW_E:
           case LOW_C:
           case LOW_G:
           case LOW_E:
           case LOW_C:
+          case CAP_U:
+          case LOW_R:
             normalizedDateSkeleton.append(ch);
             dateSkeleton.append(ch);
             break;
           case LOW_A:
             normalizedDateSkeleton.append(ch);
             dateSkeleton.append(ch);
             break;
           case LOW_A:
-            // 'a' is implicitly handled 
+            // 'a' is implicitly handled
             timeSkeleton.append(ch);
             break;
           case LOW_H:
             timeSkeleton.append(ch);
             break;
           case LOW_H:
-          case CAP_H:
             timeSkeleton.append(ch);
             ++hCount;
             break;
             timeSkeleton.append(ch);
             ++hCount;
             break;
+          case CAP_H:
+            timeSkeleton.append(ch);
+            ++HCount;
+            break;
           case LOW_M:
             timeSkeleton.append(ch);
             ++mCount;
           case LOW_M:
             timeSkeleton.append(ch);
             ++mCount;
@@ -773,7 +1053,6 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
             ++vCount;
             timeSkeleton.append(ch);
             break;
             ++vCount;
             timeSkeleton.append(ch);
             break;
-          // FIXME: what is the difference between CAP_V/Z and LOW_V/Z
           case CAP_V:
           case CAP_Z:
           case LOW_K:
           case CAP_V:
           case CAP_Z:
           case LOW_K:
@@ -784,20 +1063,21 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
           case CAP_A:
             timeSkeleton.append(ch);
             normalizedTimeSkeleton.append(ch);
           case CAP_A:
             timeSkeleton.append(ch);
             normalizedTimeSkeleton.append(ch);
-            break;     
+            break;
         }
     }
 
     /* generate normalized form for date*/
     if ( yCount != 0 ) {
         }
     }
 
     /* generate normalized form for date*/
     if ( yCount != 0 ) {
-        normalizedDateSkeleton.append(LOW_Y);
+        for (i = 0; i < yCount; ++i) {
+            normalizedDateSkeleton.append(LOW_Y);
+        }
     }
     if ( MCount != 0 ) {
         if ( MCount < 3 ) {
             normalizedDateSkeleton.append(CAP_M);
         } else {
     }
     if ( MCount != 0 ) {
         if ( MCount < 3 ) {
             normalizedDateSkeleton.append(CAP_M);
         } else {
-            int32_t i;
-            for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) {
+            for ( int32_t j = 0; j < MCount && j < MAX_M_COUNT; ++j) {
                  normalizedDateSkeleton.append(CAP_M);
             }
         }
                  normalizedDateSkeleton.append(CAP_M);
             }
         }
@@ -806,8 +1086,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
         if ( ECount <= 3 ) {
             normalizedDateSkeleton.append(CAP_E);
         } else {
         if ( ECount <= 3 ) {
             normalizedDateSkeleton.append(CAP_E);
         } else {
-            int32_t i;
-            for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) {
+            for ( int32_t j = 0; j < ECount && j < MAX_E_COUNT; ++j ) {
                  normalizedDateSkeleton.append(CAP_E);
             }
         }
                  normalizedDateSkeleton.append(CAP_E);
             }
         }
@@ -817,7 +1096,10 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
     }
 
     /* generate normalized form for time */
     }
 
     /* generate normalized form for time */
-    if ( hCount != 0 ) {
+    if ( HCount != 0 ) {
+        normalizedTimeSkeleton.append(CAP_H);
+    }
+    else if ( hCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_H);
     }
     if ( mCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_H);
     }
     if ( mCount != 0 ) {
@@ -836,7 +1118,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
  * Generate date or time interval pattern from resource,
  * and set them into the interval pattern locale to this formatter.
  *
  * 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: 
+ * 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".
  * 1. need to adjust field width.
  *    For example, the interval patterns saved in DateIntervalInfo
  *    includes "dMMMy", but not "dMMMMy".
@@ -854,9 +1136,9 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
  * @return               whether the resource is found for the skeleton.
  *                       TRUE if interval pattern found for the skeleton,
  *                       FALSE otherwise.
  * @return               whether the resource is found for the skeleton.
  *                       TRUE if interval pattern found for the skeleton,
  *                       FALSE otherwise.
- * @draft ICU 4.0
+ * @stable ICU 4.0
  */
  */
-UBool 
+UBool
 DateIntervalFormat::setSeparateDateTimePtn(
                                  const UnicodeString& dateSkeleton,
                                  const UnicodeString& timeSkeleton) {
 DateIntervalFormat::setSeparateDateTimePtn(
                                  const UnicodeString& dateSkeleton,
                                  const UnicodeString& timeSkeleton) {
@@ -872,17 +1154,17 @@ DateIntervalFormat::setSeparateDateTimePtn(
         skeleton = &dateSkeleton;
     }
 
         skeleton = &dateSkeleton;
     }
 
-    /* interval patterns for skeleton "dMMMy" (but not "dMMMMy") 
+    /* 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",
      * 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" 
+     * 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;
      * getBestSkeleton() is step 1.
      */
     // best skeleton, and the difference information
     int8_t differenceInfo = 0;
-    const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton, 
+    const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
                                                                differenceInfo);
     /* best skeleton could be NULL.
        For example: in "ca" resource file,
                                                                differenceInfo);
     /* best skeleton could be NULL.
        For example: in "ca" resource file,
@@ -894,15 +1176,31 @@ DateIntervalFormat::setSeparateDateTimePtn(
        and the best skeleton match could be NULL
      */
     if ( bestSkeleton == NULL ) {
        and the best skeleton match could be NULL
      */
     if ( bestSkeleton == NULL ) {
-        return false; 
-    } 
-   
+        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,
     // 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 ) { 
+    // -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;
     }
         // skeleton has different fields, not only  v/z difference
         return false;
     }
@@ -914,16 +1212,18 @@ DateIntervalFormat::setSeparateDateTimePtn(
         setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
                            &extendedSkeleton, &extendedBestSkeleton);
 
         setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
                            &extendedSkeleton, &extendedBestSkeleton);
 
-        UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton, 
+        UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
                                      differenceInfo,
                                      &extendedSkeleton, &extendedBestSkeleton);
                                      differenceInfo,
                                      &extendedSkeleton, &extendedBestSkeleton);
-                                              
+
         if ( extended ) {
             bestSkeleton = &extendedBestSkeleton;
             skeleton = &extendedSkeleton;
         }
         setIntervalPattern(UCAL_YEAR, 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);
     } else {
         setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
         setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
@@ -937,12 +1237,12 @@ DateIntervalFormat::setSeparateDateTimePtn(
 void
 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
                                        const UnicodeString& skeleton,
 void
 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
                                        const UnicodeString& skeleton,
-                                       DateTimePatternGenerator* dtpng,
                                        UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
                                        UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
-    UnicodeString pattern =dtpng->getBestPattern(skeleton, status);
+    UnicodeString pattern = DateFormat::getBestPattern(
+            fLocale, skeleton, status);
     if ( U_FAILURE(status) ) {
         return;
     }
     if ( U_FAILURE(status) ) {
         return;
     }
@@ -953,9 +1253,9 @@ DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
 
 
 void
 
 
 void
-DateIntervalFormat::setPatternInfo(UCalendarDateFields field, 
+DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
                                    const UnicodeString* firstPart,
                                    const UnicodeString* firstPart,
-                                   const UnicodeString* secondPart, 
+                                   const UnicodeString* secondPart,
                                    UBool laterDateFirst) {
     // for fall back interval patterns,
     // the first part of the pattern is empty,
                                    UBool laterDateFirst) {
     // for fall back interval patterns,
     // the first part of the pattern is empty,
@@ -993,12 +1293,12 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
     const UnicodeString* pattern = &intervalPattern;
     UBool order = laterDateFirst;
     // check for "latestFirst:" or "earliestFirst:" prefix
     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]);
+    int8_t prefixLength = UPRV_LENGTHOF(gLaterFirstPrefix);
+    int8_t earliestFirstLength = UPRV_LENGTHOF(gEarlierFirstPrefix);
     UnicodeString realPattern;
     if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
         order = true;
     UnicodeString realPattern;
     if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
         order = true;
-        intervalPattern.extract(prefixLength, 
+        intervalPattern.extract(prefixLength,
                                 intervalPattern.length() - prefixLength,
                                 realPattern);
         pattern = &realPattern;
                                 intervalPattern.length() - prefixLength,
                                 realPattern);
         pattern = &realPattern;
@@ -1012,7 +1312,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
     }
 
     int32_t splitPoint = splitPatternInto2Part(*pattern);
     }
 
     int32_t splitPoint = splitPatternInto2Part(*pattern);
-    
+
     UnicodeString firstPart;
     UnicodeString secondPart;
     pattern->extract(0, splitPoint, firstPart);
     UnicodeString firstPart;
     UnicodeString secondPart;
     pattern->extract(0, splitPoint, firstPart);
@@ -1039,15 +1339,15 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
  *         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,
  *         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 
+ *        -1 means there are other fields difference
  *
  * @param extendedSkeleton      extended skeleton
  * @param extendedBestSkeleton  extended best match skeleton
  *
  * @param extendedSkeleton      extended skeleton
  * @param extendedBestSkeleton  extended best match skeleton
- * @return                      whether the interval pattern is found 
+ * @return                      whether the interval pattern is found
  *                              through extending skeleton or not.
  *                              TRUE if interval pattern is found by
  *                              extending skeleton, FALSE otherwise.
  *                              through extending skeleton or not.
  *                              TRUE if interval pattern is found by
  *                              extending skeleton, FALSE otherwise.
- * @draft ICU 4.0
+ * @stable ICU 4.0
  */
 UBool
 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
  */
 UBool
 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
@@ -1068,7 +1368,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
         }
 
         // for 24 hour system, interval patterns in resource file
         }
 
         // for 24 hour system, interval patterns in resource file
-        // might not include pattern when am_pm differ, 
+        // 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 ) {
         // which should be the same as hour differ.
         // add it here for simplicity
         if ( field == UCAL_AM_PM ) {
@@ -1077,7 +1377,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                 setIntervalPattern(field, pattern);
             }
             return false;
                 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',
         // 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',
@@ -1091,11 +1391,11 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
             extendedSkeleton->insert(0, fieldLetter);
             extendedBestSkeleton->insert(0, fieldLetter);
             // for example, looking for patterns when 'y' differ for
             extendedSkeleton->insert(0, fieldLetter);
             extendedBestSkeleton->insert(0, fieldLetter);
             // for example, looking for patterns when 'y' differ for
-            // skeleton "MMMM". 
+            // skeleton "MMMM".
             fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status);
             if ( pattern.isEmpty() && differenceInfo == 0 ) {
                 // if there is no skeleton "yMMMM" defined,
             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" 
+                // look for the best match skeleton, for example: "yMMM"
                 const UnicodeString* tmpBest = fInfo->getBestSkeleton(
                                         *extendedBestSkeleton, differenceInfo);
                 if ( tmpBest != 0 && differenceInfo != -1 ) {
                 const UnicodeString* tmpBest = fInfo->getBestSkeleton(
                                         *extendedBestSkeleton, differenceInfo);
                 if ( tmpBest != 0 && differenceInfo != -1 ) {
@@ -1104,7 +1404,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
                 }
             }
         }
                 }
             }
         }
-    } 
+    }
     if ( !pattern.isEmpty() ) {
         if ( differenceInfo != 0 ) {
             UnicodeString adjustIntervalPattern;
     if ( !pattern.isEmpty() ) {
         if ( differenceInfo != 0 ) {
             UnicodeString adjustIntervalPattern;
@@ -1123,7 +1423,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
 
 
 
 
 
 
-int32_t  U_EXPORT2 
+int32_t  U_EXPORT2
 DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
     UBool inQuote = false;
     UChar prevCh = 0;
 DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
     UBool inQuote = false;
     UChar prevCh = 0;
@@ -1133,7 +1433,7 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
        It is a pattern applies to first calendar if it is first time seen,
        otherwise, it is a pattern applies to the second calendar
      */
        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[] = 
+    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,
     {
     //       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,
@@ -1146,16 +1446,16 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
     };
 
     int8_t PATTERN_CHAR_BASE = 0x41;
     };
 
     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
     /* loop through the pattern string character by character looking for
      * the first repeated pattern letter, which breaks the interval pattern
-     * into 2 parts. 
+     * into 2 parts.
      */
     int32_t i;
     UBool foundRepetition = false;
     for (i = 0; i < intervalPattern.length(); ++i) {
         UChar ch = intervalPattern.charAt(i);
      */
     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 (ch != prevCh && count > 0) {
             // check the repeativeness of pattern letter
             UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)];
@@ -1167,26 +1467,26 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
             }
             count = 0;
         }
             }
             count = 0;
         }
-        if (ch == '\'') {
+        if (ch == 0x0027 /*'*/) {
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
-            if ((i+1) < intervalPattern.length() && 
-                intervalPattern.charAt(i+1) == '\'') {
+            if ((i+1) < intervalPattern.length() &&
+                intervalPattern.charAt(i+1) == 0x0027 /*'*/) {
                 ++i;
             } else {
                 inQuote = ! inQuote;
             }
                 ++i;
             } else {
                 inQuote = ! inQuote;
             }
-        } 
+        }
         else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
         else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
-            // ch is a date-time pattern character 
+            // ch is a date-time pattern character
             prevCh = ch;
             ++count;
         }
     }
     // check last pattern char, distinguish
             prevCh = ch;
             ++count;
         }
     }
     // check last pattern char, distinguish
-    // "dd MM" ( no repetition ), 
-    // "d-d"(last char repeated ), and 
+    // "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 ) {
     // "d-d MM" ( repetition found )
     if ( count > 0 && foundRepetition == FALSE ) {
         if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) {
@@ -1196,33 +1496,97 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
     return (i - count);
 }
 
     return (i - count);
 }
 
+void 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);
+
+    // TODO(ICU-20406): Use SimpleFormatter Iterator interface when available.
+    // The context for the first of the _format calls in each pair is set by caller.
+    // This function always leaves _format context as UDISPCTX_CAPITALIZATION_NONE.
+    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]));
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, status);
+        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]));
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, status);
+        fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
+        appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
+    }
+}
 
 
-
-UnicodeString& 
+UnicodeString&
 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                    Calendar& toCalendar,
 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                    Calendar& toCalendar,
+                                   UBool fromToOnSameDay, // new
                                    UnicodeString& appendTo,
                                    UnicodeString& appendTo,
-                                   FieldPosition& pos,
+                                   int8_t& firstIndex,
+                                   FieldPositionHandler& fphandler,
                                    UErrorCode& status) const {
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
                                    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);
+
+    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
+
+        // {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);
+            fDateFormat->setContext(fCapitalizationContext, status);
+            fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
+            appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
+            fDateFormat->applyPattern(*fDatePattern);
+            fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
+            appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
+        } else {
+            appendTo.append(patternBody.tempSubStringBetween(0, offsets[1]));
+            fDateFormat->applyPattern(*fDatePattern);
+            fDateFormat->setContext(fCapitalizationContext, status);
+            fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
+            appendTo.append(patternBody.tempSubStringBetween(offsets[1], offsets[0]));
+            fDateFormat->applyPattern(*fTimePattern);
+            fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, status);
+            fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
+            appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
+        }
+
+        // restore full pattern
+        fDateFormat->applyPattern(fullPattern);
+    } else {
+        fDateFormat->setContext(fCapitalizationContext, status);
+        fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
     }
     return appendTo;
 }
     }
     return appendTo;
 }
@@ -1230,7 +1594,7 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
 
 
 
 
 
 
-UBool  U_EXPORT2 
+UBool  U_EXPORT2
 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
                                           const UnicodeString& skeleton)
 {
 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
                                           const UnicodeString& skeleton)
 {
@@ -1240,14 +1604,14 @@ DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
 
 
 
 
 
 
-void  U_EXPORT2 
+void  U_EXPORT2
 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
                  const UnicodeString& bestMatchSkeleton,
                  const UnicodeString& bestIntervalPattern,
                  int8_t differenceInfo,
                  UnicodeString& adjustedPtn) {
     adjustedPtn = bestIntervalPattern;
 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
                  const UnicodeString& bestMatchSkeleton,
                  const UnicodeString& bestIntervalPattern,
                  int8_t differenceInfo,
                  UnicodeString& adjustedPtn) {
     adjustedPtn = bestIntervalPattern;
-    int32_t inputSkeletonFieldWidth[] = 
+    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,
     {
     //       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,
@@ -1259,7 +1623,7 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
     };
 
          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
     };
 
-    int32_t bestMatchSkeletonFieldWidth[] = 
+    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,
     {
     //       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,
@@ -1274,7 +1638,8 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
     DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
     DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
     if ( differenceInfo == 2 ) {
     DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
     DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
     if ( differenceInfo == 2 ) {
-        adjustedPtn.findAndReplace("v", "z");
+        adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */),
+                                   UnicodeString((UChar)0x7a /* z */));
     }
 
     UBool inQuote = false;
     }
 
     UBool inQuote = false;
@@ -1282,8 +1647,8 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
     int32_t count = 0;
 
     const int8_t PATTERN_CHAR_BASE = 0x41;
     int32_t count = 0;
 
     const int8_t PATTERN_CHAR_BASE = 0x41;
-    
-    // loop through the pattern string character by character 
+
+    // loop through the pattern string character by character
     int32_t adjustedPtnLength = adjustedPtn.length();
     int32_t i;
     for (i = 0; i < adjustedPtnLength; ++i) {
     int32_t adjustedPtnLength = adjustedPtn.length();
     int32_t i;
     for (i = 0; i < adjustedPtnLength; ++i) {
@@ -1292,9 +1657,9 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
             // check the repeativeness of pattern letter
             UChar skeletonChar = prevCh;
             if ( skeletonChar ==  CAP_L ) {
             // check the repeativeness of pattern letter
             UChar skeletonChar = prevCh;
             if ( skeletonChar ==  CAP_L ) {
-                // there is no "L" (always be "M") in skeleton, 
+                // there is no "L" (always be "M") in skeleton,
                 // but there is "L" in pattern.
                 // but there is "L" in pattern.
-                // for skeleton "M+", the pattern might be "...L..." 
+                // for skeleton "M+", the pattern might be "...L..."
                 skeletonChar = CAP_M;
             }
             int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
                 skeletonChar = CAP_M;
             }
             int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
@@ -1303,25 +1668,25 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
                 count = inputFieldCount - fieldCount;
                 int32_t j;
                 for ( j = 0; j < count; ++j ) {
                 count = inputFieldCount - fieldCount;
                 int32_t j;
                 for ( j = 0; j < count; ++j ) {
-                    adjustedPtn.insert(i, prevCh);    
-                }                    
+                    adjustedPtn.insert(i, prevCh);
+                }
                 i += count;
                 adjustedPtnLength += count;
             }
             count = 0;
         }
                 i += count;
                 adjustedPtnLength += count;
             }
             count = 0;
         }
-        if (ch == '\'') {
+        if (ch == 0x0027 /*'*/) {
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
             // Consecutive single quotes are a single quote literal,
             // either outside of quotes or between quotes
-            if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') {
+            if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == 0x0027 /* ' */) {
                 ++i;
             } else {
                 inQuote = ! inQuote;
             }
                 ++i;
             } else {
                 inQuote = ! inQuote;
             }
-        } 
-        else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 
+        }
+        else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
-            // ch is a date-time pattern character 
+            // ch is a date-time pattern character
             prevCh = ch;
             ++count;
         }
             prevCh = ch;
             ++count;
         }
@@ -1331,9 +1696,9 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
         // check the repeativeness of pattern letter
         UChar skeletonChar = prevCh;
         if ( skeletonChar == CAP_L ) {
         // check the repeativeness of pattern letter
         UChar skeletonChar = prevCh;
         if ( skeletonChar == CAP_L ) {
-            // there is no "L" (always be "M") in skeleton, 
+            // there is no "L" (always be "M") in skeleton,
             // but there is "L" in pattern.
             // but there is "L" in pattern.
-            // for skeleton "M+", the pattern might be "...L..." 
+            // for skeleton "M+", the pattern might be "...L..."
             skeletonChar = CAP_M;
         }
         int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
             skeletonChar = CAP_M;
         }
         int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
@@ -1342,17 +1707,16 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
             count = inputFieldCount - fieldCount;
             int32_t j;
             for ( j = 0; j < count; ++j ) {
             count = inputFieldCount - fieldCount;
             int32_t j;
             for ( j = 0; j < count; ++j ) {
-                adjustedPtn.append(prevCh);    
-            }                    
+                adjustedPtn.append(prevCh);
+            }
         }
     }
 }
 
 
 
         }
     }
 }
 
 
 
-void 
-DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
-                                              int32_t formatLen,
+void
+DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format,
                                               const UnicodeString& datePattern,
                                               UCalendarDateFields field,
                                               UErrorCode& status) {
                                               const UnicodeString& datePattern,
                                               UCalendarDateFields field,
                                               UErrorCode& status) {
@@ -1364,21 +1728,16 @@ DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
     }
     PatternInfo&  timeItvPtnInfo = fIntervalPatterns[itvPtnIndex];
     if ( !timeItvPtnInfo.firstPart.isEmpty() ) {
     }
     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 timeIntervalPattern(timeItvPtnInfo.firstPart);
+        timeIntervalPattern.append(timeItvPtnInfo.secondPart);
         UnicodeString combinedPattern;
         UnicodeString combinedPattern;
-        MessageFormat::format(UnicodeString(TRUE, format, formatLen),
-                              fmtArray, 2, combinedPattern, status);
+        SimpleFormatter(format, 2, 2, status).
+                format(timeIntervalPattern, datePattern, combinedPattern, status);
         if ( U_FAILURE(status) ) {
             return;
         }
         setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
         if ( U_FAILURE(status) ) {
             return;
         }
         setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
-    } 
+    }
     // else: fall back
     // it should not happen if the interval format defined is valid
 }
     // else: fall back
     // it should not happen if the interval format defined is valid
 }
@@ -1392,10 +1751,14 @@ DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
     /*wWd*/ LOW_W, CAP_W, LOW_D,
     /*DEF*/ CAP_D, CAP_E, CAP_F,
     /*ahH*/ LOW_A, LOW_H, CAP_H,
     /*wWd*/ LOW_W, CAP_W, LOW_D,
     /*DEF*/ CAP_D, CAP_E, CAP_F,
     /*ahH*/ LOW_A, LOW_H, CAP_H,
-    /*m..*/ LOW_M,
+    /*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
 U_NAMESPACE_END
 
 #endif
mirror of ICU