Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1411 insertions, 1411 deletions

diff --git a/contrib/libs/icu/i18n/dtitvfmt.cpp b/contrib/libs/icu/i18n/dtitvfmt.cpp
index b71a571d1c..3c3b048aa1 100644
--- a/contrib/libs/icu/i18n/dtitvfmt.cpp
+++ b/contrib/libs/icu/i18n/dtitvfmt.cpp
@@ -1,71 +1,71 @@
 // © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*******************************************************************************
-* Copyright (C) 2008-2016, International Business Machines Corporation and
-* others. All Rights Reserved.
-*******************************************************************************
-*
-* File DTITVFMT.CPP
-*
-*******************************************************************************
-*/
-
-#include "utypeinfo.h"  // for 'typeid' to work
-
-#include "unicode/dtitvfmt.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-//TODO: put in compilation
-//#define DTITVFMT_DEBUG 1
-
-#include "unicode/calendar.h"
-#include "unicode/dtptngen.h"
-#include "unicode/dtitvinf.h"
-#include "unicode/simpleformatter.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "dtitv_impl.h"
-#include "mutex.h"
-#include "uresimp.h"
+// License & terms of use: http://www.unicode.org/copyright.html 
+/******************************************************************************* 
+* Copyright (C) 2008-2016, International Business Machines Corporation and 
+* others. All Rights Reserved. 
+******************************************************************************* 
+* 
+* File DTITVFMT.CPP 
+* 
+******************************************************************************* 
+*/ 
+ 
+#include "utypeinfo.h"  // for 'typeid' to work 
+ 
+#include "unicode/dtitvfmt.h" 
+ 
+#if !UCONFIG_NO_FORMATTING 
+ 
+//TODO: put in compilation 
+//#define DTITVFMT_DEBUG 1 
+ 
+#include "unicode/calendar.h" 
+#include "unicode/dtptngen.h" 
+#include "unicode/dtitvinf.h" 
+#include "unicode/simpleformatter.h" 
+#include "cmemory.h" 
+#include "cstring.h" 
+#include "dtitv_impl.h" 
+#include "mutex.h" 
+#include "uresimp.h" 
 #include "formattedval_impl.h"
-
-#ifdef DTITVFMT_DEBUG
-#include <iostream>
-#endif
-
-U_NAMESPACE_BEGIN
-
-
-
-#ifdef DTITVFMT_DEBUG
-#define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
-#endif
-
-
-static const UChar gDateFormatSkeleton[][11] = {
-//yMMMMEEEEd
-{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0},
-//yMMMMd
-{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0},
-//yMMMd
-{LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0},
-//yMd
-{LOW_Y, CAP_M, LOW_D, 0} };
-
-
-static const char gCalendarTag[] = "calendar";
-static const char gGregorianTag[] = "gregorian";
-static const char gDateTimePatternsTag[] = "DateTimePatterns";
-
-
-// latestFirst:
-static const UChar gLaterFirstPrefix[] = {LOW_L, LOW_A, LOW_T, LOW_E, LOW_S,LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
-
-// earliestFirst:
-static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, LOW_E, LOW_S, LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
-
-
+ 
+#ifdef DTITVFMT_DEBUG 
+#include <iostream> 
+#endif 
+ 
+U_NAMESPACE_BEGIN 
+ 
+ 
+ 
+#ifdef DTITVFMT_DEBUG 
+#define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; } 
+#endif 
+ 
+ 
+static const UChar gDateFormatSkeleton[][11] = { 
+//yMMMMEEEEd 
+{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0}, 
+//yMMMMd 
+{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0}, 
+//yMMMd 
+{LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0}, 
+//yMd 
+{LOW_Y, CAP_M, LOW_D, 0} }; 
+ 
+ 
+static const char gCalendarTag[] = "calendar"; 
+static const char gGregorianTag[] = "gregorian"; 
+static const char gDateTimePatternsTag[] = "DateTimePatterns"; 
+ 
+ 
+// latestFirst: 
+static const UChar gLaterFirstPrefix[] = {LOW_L, LOW_A, LOW_T, LOW_E, LOW_S,LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON}; 
+ 
+// earliestFirst: 
+static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, LOW_E, LOW_S, LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON}; 
+ 
+ 
 class FormattedDateIntervalData : public FormattedValueFieldPositionIteratorImpl {
 public:
     FormattedDateIntervalData(UErrorCode& status) : FormattedValueFieldPositionIteratorImpl(5, status) {}
@@ -77,230 +77,230 @@ FormattedDateIntervalData::~FormattedDateIntervalData() = default;
 UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedDateInterval)
 
 
-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.
-
+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;
-
-DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton,
-                                   UErrorCode& status) {
-    return createInstance(skeleton, Locale::getDefault(), status);
-}
-
-
-DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton,
-                                   const Locale& locale,
-                                   UErrorCode& status) {
-#ifdef DTITVFMT_DEBUG
-    char result[1000];
-    char result_1[1000];
-    char mesg[2000];
-    skeleton.extract(0,  skeleton.length(), result, "UTF-8");
-    UnicodeString pat;
-    ((SimpleDateFormat*)dtfmt)->toPattern(pat);
-    pat.extract(0,  pat.length(), result_1, "UTF-8");
-    sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1);
-    PRINTMESG(mesg)
-#endif
-
-    DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
+ 
+DateIntervalFormat* U_EXPORT2 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
+                                   UErrorCode& status) { 
+    return createInstance(skeleton, Locale::getDefault(), status); 
+} 
+ 
+ 
+DateIntervalFormat* U_EXPORT2 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
+                                   const Locale& locale, 
+                                   UErrorCode& status) { 
+#ifdef DTITVFMT_DEBUG 
+    char result[1000]; 
+    char result_1[1000]; 
+    char mesg[2000]; 
+    skeleton.extract(0,  skeleton.length(), result, "UTF-8"); 
+    UnicodeString pat; 
+    ((SimpleDateFormat*)dtfmt)->toPattern(pat); 
+    pat.extract(0,  pat.length(), result_1, "UTF-8"); 
+    sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1); 
+    PRINTMESG(mesg) 
+#endif 
+ 
+    DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status); 
     if (dtitvinf == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return nullptr;
     }
-    return create(locale, dtitvinf, &skeleton, status);
-}
-
-
-
-DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton,
-                                   const DateIntervalInfo& dtitvinf,
-                                   UErrorCode& status) {
-    return createInstance(skeleton, Locale::getDefault(), dtitvinf, status);
-}
-
-
-DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::createInstance(const UnicodeString& skeleton,
-                                   const Locale& locale,
-                                   const DateIntervalInfo& dtitvinf,
-                                   UErrorCode& status) {
-    DateIntervalInfo* ptn = dtitvinf.clone();
-    return create(locale, ptn, &skeleton, status);
-}
-
-
-DateIntervalFormat::DateIntervalFormat()
+    return create(locale, dtitvinf, &skeleton, status); 
+} 
+ 
+ 
+ 
+DateIntervalFormat* U_EXPORT2 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
+                                   const DateIntervalInfo& dtitvinf, 
+                                   UErrorCode& status) { 
+    return createInstance(skeleton, Locale::getDefault(), dtitvinf, status); 
+} 
+ 
+ 
+DateIntervalFormat* U_EXPORT2 
+DateIntervalFormat::createInstance(const UnicodeString& skeleton, 
+                                   const Locale& locale, 
+                                   const DateIntervalInfo& dtitvinf, 
+                                   UErrorCode& status) { 
+    DateIntervalInfo* ptn = dtitvinf.clone(); 
+    return create(locale, ptn, &skeleton, status); 
+} 
+ 
+ 
+DateIntervalFormat::DateIntervalFormat() 
 :   fInfo(nullptr),
     fDateFormat(nullptr),
     fFromCalendar(nullptr),
     fToCalendar(nullptr),
-    fLocale(Locale::getRoot()),
+    fLocale(Locale::getRoot()), 
     fDatePattern(nullptr),
     fTimePattern(nullptr),
     fDateTimeFormat(nullptr)
-{}
-
-
-DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
-:   Format(itvfmt),
+{} 
+ 
+ 
+DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt) 
+:   Format(itvfmt), 
     fInfo(nullptr),
     fDateFormat(nullptr),
     fFromCalendar(nullptr),
     fToCalendar(nullptr),
-    fLocale(itvfmt.fLocale),
+    fLocale(itvfmt.fLocale), 
     fDatePattern(nullptr),
     fTimePattern(nullptr),
     fDateTimeFormat(nullptr) {
-    *this = itvfmt;
-}
-
-
-DateIntervalFormat&
-DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
-    if ( this != &itvfmt ) {
-        delete fDateFormat;
-        delete fInfo;
-        delete fFromCalendar;
-        delete fToCalendar;
-        delete fDatePattern;
-        delete fTimePattern;
-        delete fDateTimeFormat;
-        {
-            Mutex lock(&gFormatterMutex);
-            if ( itvfmt.fDateFormat ) {
+    *this = itvfmt; 
+} 
+ 
+ 
+DateIntervalFormat& 
+DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) { 
+    if ( this != &itvfmt ) { 
+        delete fDateFormat; 
+        delete fInfo; 
+        delete fFromCalendar; 
+        delete fToCalendar; 
+        delete fDatePattern; 
+        delete fTimePattern; 
+        delete fDateTimeFormat; 
+        { 
+            Mutex lock(&gFormatterMutex); 
+            if ( itvfmt.fDateFormat ) { 
                 fDateFormat = itvfmt.fDateFormat->clone();
-            } else {
+            } else { 
                 fDateFormat = nullptr;
-            }
-            if ( itvfmt.fFromCalendar ) {
-                fFromCalendar = itvfmt.fFromCalendar->clone();
-            } else {
+            } 
+            if ( itvfmt.fFromCalendar ) { 
+                fFromCalendar = itvfmt.fFromCalendar->clone(); 
+            } else { 
                 fFromCalendar = nullptr;
-            }
-            if ( itvfmt.fToCalendar ) {
-                fToCalendar = itvfmt.fToCalendar->clone();
-            } else {
+            } 
+            if ( itvfmt.fToCalendar ) { 
+                fToCalendar = itvfmt.fToCalendar->clone(); 
+            } else { 
                 fToCalendar = nullptr;
-            }
-        }
-        if ( itvfmt.fInfo ) {
-            fInfo = itvfmt.fInfo->clone();
-        } else {
+            } 
+        } 
+        if ( itvfmt.fInfo ) { 
+            fInfo = itvfmt.fInfo->clone(); 
+        } else { 
             fInfo = nullptr;
-        }
-        fSkeleton = itvfmt.fSkeleton;
-        int8_t i;
-        for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
-            fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i];
-        }
-        fLocale = itvfmt.fLocale;
+        } 
+        fSkeleton = itvfmt.fSkeleton; 
+        int8_t i; 
+        for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) { 
+            fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i]; 
+        } 
+        fLocale = itvfmt.fLocale; 
         fDatePattern    = (itvfmt.fDatePattern)?    itvfmt.fDatePattern->clone(): nullptr;
         fTimePattern    = (itvfmt.fTimePattern)?    itvfmt.fTimePattern->clone(): nullptr;
         fDateTimeFormat = (itvfmt.fDateTimeFormat)? itvfmt.fDateTimeFormat->clone(): nullptr;
-    }
-    return *this;
-}
-
-
-DateIntervalFormat::~DateIntervalFormat() {
-    delete fInfo;
-    delete fDateFormat;
-    delete fFromCalendar;
-    delete fToCalendar;
-    delete fDatePattern;
-    delete fTimePattern;
-    delete fDateTimeFormat;
-}
-
-
+    } 
+    return *this; 
+} 
+ 
+ 
+DateIntervalFormat::~DateIntervalFormat() { 
+    delete fInfo; 
+    delete fDateFormat; 
+    delete fFromCalendar; 
+    delete fToCalendar; 
+    delete fDatePattern; 
+    delete fTimePattern; 
+    delete fDateTimeFormat; 
+} 
+ 
+ 
 DateIntervalFormat*
 DateIntervalFormat::clone() const {
-    return new DateIntervalFormat(*this);
-}
-
-
-UBool
-DateIntervalFormat::operator==(const Format& other) const {
-    if (typeid(*this) != typeid(other)) {return FALSE;}
-    const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
-    if (this == fmt) {return TRUE;}
-    if (!Format::operator==(other)) {return FALSE;}
+    return new DateIntervalFormat(*this); 
+} 
+ 
+ 
+UBool 
+DateIntervalFormat::operator==(const Format& other) const { 
+    if (typeid(*this) != typeid(other)) {return FALSE;} 
+    const DateIntervalFormat* fmt = (DateIntervalFormat*)&other; 
+    if (this == fmt) {return TRUE;} 
+    if (!Format::operator==(other)) {return FALSE;} 
     if ((fInfo != fmt->fInfo) && (fInfo == nullptr || fmt->fInfo == nullptr)) {return FALSE;}
-    if (fInfo && fmt->fInfo && (*fInfo != *fmt->fInfo )) {return FALSE;}
-    {
-        Mutex lock(&gFormatterMutex);
+    if (fInfo && fmt->fInfo && (*fInfo != *fmt->fInfo )) {return FALSE;} 
+    { 
+        Mutex lock(&gFormatterMutex); 
         if (fDateFormat != fmt->fDateFormat && (fDateFormat == nullptr || fmt->fDateFormat == nullptr)) {return FALSE;}
-        if (fDateFormat && fmt->fDateFormat && (*fDateFormat != *fmt->fDateFormat)) {return FALSE;}
-    }
-    // note: fFromCalendar and fToCalendar hold no persistent state, and therefore do not participate in operator ==.
-    //       fDateFormat has the master calendar for the DateIntervalFormat.
-    if (fSkeleton != fmt->fSkeleton) {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 == nullptr || fmt->fDatePattern == nullptr)) {return FALSE;}
-    if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return FALSE;}
+    if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return FALSE;} 
     if (fTimePattern != fmt->fTimePattern && (fTimePattern == nullptr || fmt->fTimePattern == nullptr)) {return FALSE;}
-    if (fTimePattern && fmt->fTimePattern && (*fTimePattern != *fmt->fTimePattern)) {return FALSE;}
+    if (fTimePattern && fmt->fTimePattern && (*fTimePattern != *fmt->fTimePattern)) {return FALSE;} 
     if (fDateTimeFormat != fmt->fDateTimeFormat && (fDateTimeFormat == nullptr || fmt->fDateTimeFormat == nullptr)) {return FALSE;}
-    if (fDateTimeFormat && fmt->fDateTimeFormat && (*fDateTimeFormat != *fmt->fDateTimeFormat)) {return FALSE;}
-    if (fLocale != fmt->fLocale) {return FALSE;}
-
-    for (int32_t i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
-        if (fIntervalPatterns[i].firstPart != fmt->fIntervalPatterns[i].firstPart) {return FALSE;}
-        if (fIntervalPatterns[i].secondPart != fmt->fIntervalPatterns[i].secondPart ) {return FALSE;}
-        if (fIntervalPatterns[i].laterDateFirst != fmt->fIntervalPatterns[i].laterDateFirst) {return FALSE;}
-    }
-    return TRUE;
-}
-
-
-UnicodeString&
-DateIntervalFormat::format(const Formattable& obj,
-                           UnicodeString& appendTo,
-                           FieldPosition& fieldPosition,
-                           UErrorCode& status) const {
-    if ( U_FAILURE(status) ) {
-        return appendTo;
-    }
-
-    if ( obj.getType() == Formattable::kObject ) {
-        const UObject* formatObj = obj.getObject();
-        const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj);
+    if (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;} 
+    } 
+    return TRUE; 
+} 
+ 
+ 
+UnicodeString& 
+DateIntervalFormat::format(const Formattable& obj, 
+                           UnicodeString& appendTo, 
+                           FieldPosition& fieldPosition, 
+                           UErrorCode& status) const { 
+    if ( U_FAILURE(status) ) { 
+        return appendTo; 
+    } 
+ 
+    if ( obj.getType() == Formattable::kObject ) { 
+        const UObject* formatObj = obj.getObject(); 
+        const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj); 
         if (interval != nullptr) {
-            return format(interval, appendTo, fieldPosition, status);
-        }
-    }
-    status = U_ILLEGAL_ARGUMENT_ERROR;
-    return appendTo;
-}
-
-
-UnicodeString&
-DateIntervalFormat::format(const DateInterval* dtInterval,
-                           UnicodeString& appendTo,
-                           FieldPosition& fieldPosition,
-                           UErrorCode& status) const {
-    if ( U_FAILURE(status) ) {
-        return appendTo;
-    }
+            return format(interval, appendTo, fieldPosition, status); 
+        } 
+    } 
+    status = U_ILLEGAL_ARGUMENT_ERROR; 
+    return appendTo; 
+} 
+ 
+ 
+UnicodeString& 
+DateIntervalFormat::format(const DateInterval* dtInterval, 
+                           UnicodeString& appendTo, 
+                           FieldPosition& fieldPosition, 
+                           UErrorCode& status) const { 
+    if ( U_FAILURE(status) ) { 
+        return appendTo; 
+    } 
     if (fDateFormat == nullptr || fInfo == nullptr) {
-        status = U_INVALID_STATE_ERROR;
-        return appendTo;
-    }
-
+        status = U_INVALID_STATE_ERROR; 
+        return appendTo; 
+    } 
+ 
     FieldPositionOnlyHandler handler(fieldPosition);
     handler.setAcceptFirstOnly(TRUE);
     int8_t ignore;
 
-    Mutex lock(&gFormatterMutex);
+    Mutex lock(&gFormatterMutex); 
     return formatIntervalImpl(*dtInterval, appendTo, ignore, handler, status);
-}
-
-
+} 
+ 
+ 
 FormattedDateInterval DateIntervalFormat::formatToValue(
         const DateInterval& dtInterval,
         UErrorCode& status) const {
@@ -339,21 +339,21 @@ FormattedDateInterval DateIntervalFormat::formatToValue(
 }
 
 
-UnicodeString&
-DateIntervalFormat::format(Calendar& fromCalendar,
-                           Calendar& toCalendar,
-                           UnicodeString& appendTo,
-                           FieldPosition& pos,
-                           UErrorCode& status) const {
+UnicodeString& 
+DateIntervalFormat::format(Calendar& fromCalendar, 
+                           Calendar& toCalendar, 
+                           UnicodeString& appendTo, 
+                           FieldPosition& pos, 
+                           UErrorCode& status) const { 
     FieldPositionOnlyHandler handler(pos);
     handler.setAcceptFirstOnly(TRUE);
     int8_t ignore;
 
-    Mutex lock(&gFormatterMutex);
+    Mutex lock(&gFormatterMutex); 
     return formatImpl(fromCalendar, toCalendar, appendTo, ignore, handler, status);
-}
-
-
+} 
+ 
+ 
 FormattedDateInterval DateIntervalFormat::formatToValue(
         Calendar& fromCalendar,
         Calendar& toCalendar,
@@ -409,1022 +409,1022 @@ UnicodeString& DateIntervalFormat::formatIntervalImpl(
 }
 
 
-UnicodeString&
-DateIntervalFormat::formatImpl(Calendar& fromCalendar,
-                           Calendar& toCalendar,
-                           UnicodeString& appendTo,
+UnicodeString& 
+DateIntervalFormat::formatImpl(Calendar& fromCalendar, 
+                           Calendar& toCalendar, 
+                           UnicodeString& appendTo, 
                            int8_t& firstIndex,
                            FieldPositionHandler& fphandler,
-                           UErrorCode& status) const {
-    if ( U_FAILURE(status) ) {
-        return appendTo;
-    }
-
+                           UErrorCode& status) const { 
+    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() ) {
-    if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return appendTo;
-    }
-
-    // First, find the largest different calendar field.
-    UCalendarDateFields field = UCAL_FIELD_COUNT;
-
-    if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
-        field = UCAL_ERA;
-    } else if ( fromCalendar.get(UCAL_YEAR, status) !=
-                toCalendar.get(UCAL_YEAR, status) ) {
-        field = UCAL_YEAR;
-    } else if ( fromCalendar.get(UCAL_MONTH, status) !=
-                toCalendar.get(UCAL_MONTH, status) ) {
-        field = UCAL_MONTH;
-    } else if ( fromCalendar.get(UCAL_DATE, status) !=
-                toCalendar.get(UCAL_DATE, status) ) {
-        field = UCAL_DATE;
-    } else if ( fromCalendar.get(UCAL_AM_PM, status) !=
-                toCalendar.get(UCAL_AM_PM, status) ) {
-        field = UCAL_AM_PM;
-    } else if ( fromCalendar.get(UCAL_HOUR, status) !=
-                toCalendar.get(UCAL_HOUR, status) ) {
-        field = UCAL_HOUR;
-    } else if ( fromCalendar.get(UCAL_MINUTE, status) !=
-                toCalendar.get(UCAL_MINUTE, status) ) {
-        field = UCAL_MINUTE;
-    } else if ( fromCalendar.get(UCAL_SECOND, status) !=
-                toCalendar.get(UCAL_SECOND, status) ) {
-        field = UCAL_SECOND;
+    // not support different calendar types and time zones 
+    //if ( fromCalendar.getType() != toCalendar.getType() ) { 
+    if ( !fromCalendar.isEquivalentTo(toCalendar) ) { 
+        status = U_ILLEGAL_ARGUMENT_ERROR; 
+        return appendTo; 
+    } 
+ 
+    // First, find the largest different calendar field. 
+    UCalendarDateFields field = UCAL_FIELD_COUNT; 
+ 
+    if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) { 
+        field = UCAL_ERA; 
+    } else if ( fromCalendar.get(UCAL_YEAR, status) != 
+                toCalendar.get(UCAL_YEAR, status) ) { 
+        field = UCAL_YEAR; 
+    } else if ( fromCalendar.get(UCAL_MONTH, status) != 
+                toCalendar.get(UCAL_MONTH, status) ) { 
+        field = UCAL_MONTH; 
+    } else if ( fromCalendar.get(UCAL_DATE, status) != 
+                toCalendar.get(UCAL_DATE, status) ) { 
+        field = UCAL_DATE; 
+    } else if ( fromCalendar.get(UCAL_AM_PM, status) != 
+                toCalendar.get(UCAL_AM_PM, status) ) { 
+        field = UCAL_AM_PM; 
+    } else if ( fromCalendar.get(UCAL_HOUR, status) != 
+                toCalendar.get(UCAL_HOUR, status) ) { 
+        field = UCAL_HOUR; 
+    } else if ( fromCalendar.get(UCAL_MINUTE, status) != 
+                toCalendar.get(UCAL_MINUTE, status) ) { 
+        field = UCAL_MINUTE; 
+    } else if ( fromCalendar.get(UCAL_SECOND, status) != 
+                toCalendar.get(UCAL_SECOND, status) ) { 
+        field = UCAL_SECOND; 
     } else if ( fromCalendar.get(UCAL_MILLISECOND, status) !=
                 toCalendar.get(UCAL_MILLISECOND, status) ) {
         field = UCAL_MILLISECOND;
-    }
-
-    if ( U_FAILURE(status) ) {
-        return appendTo;
-    }
-    if ( field == UCAL_FIELD_COUNT ) {
-        /* ignore the millisecond etc. small fields' difference.
-         * use single date when all the above are the same.
-         */
+    } 
+ 
+    if ( U_FAILURE(status) ) { 
+        return appendTo; 
+    } 
+    if ( field == UCAL_FIELD_COUNT ) { 
+        /* ignore the millisecond etc. small fields' difference. 
+         * use single date when all the above are the same. 
+         */ 
         return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
-    }
+    } 
     UBool fromToOnSameDay = (field==UCAL_AM_PM || field==UCAL_HOUR || field==UCAL_MINUTE || field==UCAL_SECOND || field==UCAL_MILLISECOND);
-
-    // following call should not set wrong status,
-    // all the pass-in fields are valid till here
-    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
-                                                                        status);
-    const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex];
-
-    if ( intervalPattern.firstPart.isEmpty() &&
-         intervalPattern.secondPart.isEmpty() ) {
-        if ( fDateFormat->isFieldUnitIgnored(field) ) {
-            /* the largest different calendar field is small than
-             * the smallest calendar field in pattern,
-             * return single date format.
-             */
+ 
+    // following call should not set wrong status, 
+    // all the pass-in fields are valid till here 
+    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 
+                                                                        status); 
+    const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex]; 
+ 
+    if ( intervalPattern.firstPart.isEmpty() && 
+         intervalPattern.secondPart.isEmpty() ) { 
+        if ( fDateFormat->isFieldUnitIgnored(field) ) { 
+            /* the largest different calendar field is small than 
+             * the smallest calendar field in pattern, 
+             * return single date format. 
+             */ 
             return fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
-        }
+        } 
         return fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
-    }
-    // If the first part in interval pattern is empty,
-    // the 2nd part of it saves the full-pattern used in fall-back.
-    // For a 'real' interval pattern, the first part will never be empty.
-    if ( intervalPattern.firstPart.isEmpty() ) {
-        // fall back
-        UnicodeString originalPattern;
-        fDateFormat->toPattern(originalPattern);
-        fDateFormat->applyPattern(intervalPattern.secondPart);
+    } 
+    // If the first part in interval pattern is empty, 
+    // the 2nd part of it saves the full-pattern used in fall-back. 
+    // For a 'real' interval pattern, the first part will never be empty. 
+    if ( intervalPattern.firstPart.isEmpty() ) { 
+        // fall back 
+        UnicodeString originalPattern; 
+        fDateFormat->toPattern(originalPattern); 
+        fDateFormat->applyPattern(intervalPattern.secondPart); 
         appendTo = fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, firstIndex, fphandler, status);
-        fDateFormat->applyPattern(originalPattern);
-        return appendTo;
-    }
-    Calendar* firstCal;
-    Calendar* secondCal;
-    if ( intervalPattern.laterDateFirst ) {
-        firstCal = &toCalendar;
-        secondCal = &fromCalendar;
+        fDateFormat->applyPattern(originalPattern); 
+        return appendTo; 
+    } 
+    Calendar* firstCal; 
+    Calendar* secondCal; 
+    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,
-    // first part should not be empty,
-    UnicodeString originalPattern;
-    fDateFormat->toPattern(originalPattern);
-    fDateFormat->applyPattern(intervalPattern.firstPart);
+    } 
+    // break the interval pattern into 2 parts, 
+    // first part should not be empty, 
+    UnicodeString originalPattern; 
+    fDateFormat->toPattern(originalPattern); 
+    fDateFormat->applyPattern(intervalPattern.firstPart); 
     fDateFormat->_format(*firstCal, appendTo, fphandler, status);
 
-    if ( !intervalPattern.secondPart.isEmpty() ) {
-        fDateFormat->applyPattern(intervalPattern.secondPart);
+    if ( !intervalPattern.secondPart.isEmpty() ) { 
+        fDateFormat->applyPattern(intervalPattern.secondPart); 
         fDateFormat->_format(*secondCal, appendTo, fphandler, status);
-    }
-    fDateFormat->applyPattern(originalPattern);
-    return appendTo;
-}
-
-
-
-void
-DateIntervalFormat::parseObject(const UnicodeString& /* source */,
-                                Formattable& /* result */,
-                                ParsePosition& /* parse_pos */) const {
-    // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
-    // will set status as U_INVALID_FORMAT_ERROR if
-    // parse_pos is still 0
-}
-
-
-
-
-const DateIntervalInfo*
-DateIntervalFormat::getDateIntervalInfo() const {
-    return fInfo;
-}
-
-
-void
-DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
-                                        UErrorCode& status) {
-    delete fInfo;
-    fInfo = new DateIntervalInfo(newItvPattern);
+    } 
+    fDateFormat->applyPattern(originalPattern); 
+    return appendTo; 
+} 
+ 
+ 
+ 
+void 
+DateIntervalFormat::parseObject(const UnicodeString& /* source */, 
+                                Formattable& /* result */, 
+                                ParsePosition& /* parse_pos */) const { 
+    // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const 
+    // will set status as U_INVALID_FORMAT_ERROR if 
+    // parse_pos is still 0 
+} 
+ 
+ 
+ 
+ 
+const DateIntervalInfo* 
+DateIntervalFormat::getDateIntervalInfo() const { 
+    return fInfo; 
+} 
+ 
+ 
+void 
+DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern, 
+                                        UErrorCode& status) { 
+    delete fInfo; 
+    fInfo = new DateIntervalInfo(newItvPattern); 
     if (fInfo == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
     }
-
-    // Delete patterns that get reset by initializePattern
-    delete fDatePattern;
+ 
+    // Delete patterns that get reset by initializePattern 
+    delete fDatePattern; 
     fDatePattern = nullptr;
-    delete fTimePattern;
+    delete fTimePattern; 
     fTimePattern = nullptr;
-    delete fDateTimeFormat;
+    delete fDateTimeFormat; 
     fDateTimeFormat = nullptr;
-
-    if (fDateFormat) {
-        initializePattern(status);
-    }
-}
-
-
-
-const DateFormat*
-DateIntervalFormat::getDateFormat() const {
-    return fDateFormat;
-}
-
-
-void
-DateIntervalFormat::adoptTimeZone(TimeZone* zone)
-{
+ 
+    if (fDateFormat) { 
+        initializePattern(status); 
+    } 
+} 
+ 
+ 
+ 
+const DateFormat* 
+DateIntervalFormat::getDateFormat() const { 
+    return fDateFormat; 
+} 
+ 
+ 
+void 
+DateIntervalFormat::adoptTimeZone(TimeZone* zone) 
+{ 
     if (fDateFormat != nullptr) {
-        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)
-{
+        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 != nullptr) {
-        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
-{
+        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 != nullptr) {
-        Mutex lock(&gFormatterMutex);
-        return fDateFormat->getTimeZone();
-    }
+        Mutex lock(&gFormatterMutex); 
+        return fDateFormat->getTimeZone(); 
+    } 
     // If fDateFormat is nullptr (unexpected), create default timezone.
-    return *(TimeZone::createDefault());
-}
-
-DateIntervalFormat::DateIntervalFormat(const Locale& locale,
-                                       DateIntervalInfo* dtItvInfo,
-                                       const UnicodeString* skeleton,
-                                       UErrorCode& status)
+    return *(TimeZone::createDefault()); 
+} 
+ 
+DateIntervalFormat::DateIntervalFormat(const Locale& locale, 
+                                       DateIntervalInfo* dtItvInfo, 
+                                       const UnicodeString* skeleton, 
+                                       UErrorCode& status) 
 :   fInfo(nullptr),
     fDateFormat(nullptr),
     fFromCalendar(nullptr),
     fToCalendar(nullptr),
-    fLocale(locale),
+    fLocale(locale), 
     fDatePattern(nullptr),
     fTimePattern(nullptr),
     fDateTimeFormat(nullptr)
-{
-    LocalPointer<DateIntervalInfo> info(dtItvInfo, status);
-    LocalPointer<SimpleDateFormat> dtfmt(static_cast<SimpleDateFormat *>(
-            DateFormat::createInstanceForSkeleton(*skeleton, locale, status)), status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    if ( skeleton ) {
-        fSkeleton = *skeleton;
-    }
-    fInfo = info.orphan();
-    fDateFormat = dtfmt.orphan();
-    if ( fDateFormat->getCalendar() ) {
-        fFromCalendar = fDateFormat->getCalendar()->clone();
-        fToCalendar = fDateFormat->getCalendar()->clone();
-    }
-    initializePattern(status);
-}
-
-DateIntervalFormat* U_EXPORT2
-DateIntervalFormat::create(const Locale& locale,
-                           DateIntervalInfo* dtitvinf,
-                           const UnicodeString* skeleton,
-                           UErrorCode& status) {
-    DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
-                                                   skeleton, status);
+{ 
+    LocalPointer<DateIntervalInfo> info(dtItvInfo, status); 
+    LocalPointer<SimpleDateFormat> dtfmt(static_cast<SimpleDateFormat *>( 
+            DateFormat::createInstanceForSkeleton(*skeleton, locale, status)), status); 
+    if (U_FAILURE(status)) { 
+        return; 
+    } 
+ 
+    if ( skeleton ) { 
+        fSkeleton = *skeleton; 
+    } 
+    fInfo = info.orphan(); 
+    fDateFormat = dtfmt.orphan(); 
+    if ( fDateFormat->getCalendar() ) { 
+        fFromCalendar = fDateFormat->getCalendar()->clone(); 
+        fToCalendar = fDateFormat->getCalendar()->clone(); 
+    } 
+    initializePattern(status); 
+} 
+ 
+DateIntervalFormat* U_EXPORT2 
+DateIntervalFormat::create(const Locale& locale, 
+                           DateIntervalInfo* dtitvinf, 
+                           const UnicodeString* skeleton, 
+                           UErrorCode& status) { 
+    DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf, 
+                                                   skeleton, status); 
     if ( f == nullptr ) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        delete dtitvinf;
-    } else if ( U_FAILURE(status) ) {
-        // safe to delete f, although nothing acutally is saved
-        delete f;
-        f = 0;
-    }
-    return f;
-}
-
-
-
-/**
- * Initialize interval patterns locale to this formatter
- *
- * This code is a bit complicated since
- * 1. the interval patterns saved in resource bundle files are interval
- *    patterns based on date or time only.
- *    It does not have interval patterns based on both date and time.
- *    Interval patterns on both date and time are algorithm generated.
- *
- *    For example, it has interval patterns on skeleton "dMy" and "hm",
- *    but it does not have interval patterns on skeleton "dMyhm".
- *
- *    The rule to genearte interval patterns for both date and time skeleton are
- *    1) when the year, month, or day differs, concatenate the two original
- *    expressions with a separator between,
- *    For example, interval pattern from "Jan 10, 2007 10:10 am"
- *    to "Jan 11, 2007 10:10am" is
- *    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
- *
- *    2) otherwise, present the date followed by the range expression
- *    for the time.
- *    For example, interval pattern from "Jan 10, 2007 10:10 am"
- *    to "Jan 10, 2007 11:10am" is
- *    "Jan 10, 2007 10:10 am - 11:10am"
- *
- * 2. even a pattern does not request a certion calendar field,
- *    the interval pattern needs to include such field if such fields are
- *    different between 2 dates.
- *    For example, a pattern/skeleton is "hm", but the interval pattern
- *    includes year, month, and date when year, month, and date differs.
- *
- * @param status          output param set to success/failure code on exit
- * @stable ICU 4.0
- */
-void
-DateIntervalFormat::initializePattern(UErrorCode& status) {
-    if ( U_FAILURE(status) ) {
-        return;
-    }
-    const Locale& locale = fDateFormat->getSmpFmtLocale();
-    if ( fSkeleton.isEmpty() ) {
-        UnicodeString fullPattern;
-        fDateFormat->toPattern(fullPattern);
-#ifdef DTITVFMT_DEBUG
-    char result[1000];
-    char result_1[1000];
-    char mesg[2000];
-    fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
-    sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
-    PRINTMESG(mesg)
-#endif
-        // fSkeleton is already set by createDateIntervalInstance()
-        // or by createInstance(UnicodeString skeleton, .... )
-        fSkeleton = DateTimePatternGenerator::staticGetSkeleton(
-                fullPattern, status);
-        if ( U_FAILURE(status) ) {
-            return;
-        }
-    }
-
-    // initialize the fIntervalPattern ordering
-    int8_t i;
-    for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
-        fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder();
-    }
-
-    /* Check whether the skeleton is a combination of date and time.
-     * For the complication reason 1 explained above.
-     */
-    UnicodeString dateSkeleton;
-    UnicodeString timeSkeleton;
-    UnicodeString normalizedTimeSkeleton;
-    UnicodeString normalizedDateSkeleton;
-
-
-    /* the difference between time skeleton and normalizedTimeSkeleton are:
-     * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
-     * 2. 'a' is omitted in normalized time skeleton.
-     * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized
-     *    time skeleton
-     *
-     * The difference between date skeleton and normalizedDateSkeleton are:
-     * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton
-     * 2. 'E' and 'EE' are normalized into 'EEE'
-     * 3. 'MM' is normalized into 'M'
-     */
-    getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton,
-                        timeSkeleton, normalizedTimeSkeleton);
-
-#ifdef DTITVFMT_DEBUG
-    char result[1000];
-    char result_1[1000];
-    char mesg[2000];
-    fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
-    sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
-    PRINTMESG(mesg)
-#endif
-
-    // 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.
+        status = U_MEMORY_ALLOCATION_ERROR; 
+        delete dtitvinf; 
+    } else if ( U_FAILURE(status) ) { 
+        // safe to delete f, although nothing acutally is saved 
+        delete f; 
+        f = 0; 
+    } 
+    return f; 
+} 
+ 
+ 
+ 
+/** 
+ * Initialize interval patterns locale to this formatter 
+ * 
+ * This code is a bit complicated since 
+ * 1. the interval patterns saved in resource bundle files are interval 
+ *    patterns based on date or time only. 
+ *    It does not have interval patterns based on both date and time. 
+ *    Interval patterns on both date and time are algorithm generated. 
+ * 
+ *    For example, it has interval patterns on skeleton "dMy" and "hm", 
+ *    but it does not have interval patterns on skeleton "dMyhm". 
+ * 
+ *    The rule to genearte interval patterns for both date and time skeleton are 
+ *    1) when the year, month, or day differs, concatenate the two original 
+ *    expressions with a separator between, 
+ *    For example, interval pattern from "Jan 10, 2007 10:10 am" 
+ *    to "Jan 11, 2007 10:10am" is 
+ *    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am" 
+ * 
+ *    2) otherwise, present the date followed by the range expression 
+ *    for the time. 
+ *    For example, interval pattern from "Jan 10, 2007 10:10 am" 
+ *    to "Jan 10, 2007 11:10am" is 
+ *    "Jan 10, 2007 10:10 am - 11:10am" 
+ * 
+ * 2. even a pattern does not request a certion calendar field, 
+ *    the interval pattern needs to include such field if such fields are 
+ *    different between 2 dates. 
+ *    For example, a pattern/skeleton is "hm", but the interval pattern 
+ *    includes year, month, and date when year, month, and date differs. 
+ * 
+ * @param status          output param set to success/failure code on exit 
+ * @stable ICU 4.0 
+ */ 
+void 
+DateIntervalFormat::initializePattern(UErrorCode& status) { 
+    if ( U_FAILURE(status) ) { 
+        return; 
+    } 
+    const Locale& locale = fDateFormat->getSmpFmtLocale(); 
+    if ( fSkeleton.isEmpty() ) { 
+        UnicodeString fullPattern; 
+        fDateFormat->toPattern(fullPattern); 
+#ifdef DTITVFMT_DEBUG 
+    char result[1000]; 
+    char result_1[1000]; 
+    char mesg[2000]; 
+    fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8"); 
+    sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 
+    PRINTMESG(mesg) 
+#endif 
+        // fSkeleton is already set by createDateIntervalInstance() 
+        // or by createInstance(UnicodeString skeleton, .... ) 
+        fSkeleton = DateTimePatternGenerator::staticGetSkeleton( 
+                fullPattern, status); 
+        if ( U_FAILURE(status) ) { 
+            return; 
+        } 
+    } 
+ 
+    // initialize the fIntervalPattern ordering 
+    int8_t i; 
+    for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) { 
+        fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder(); 
+    } 
+ 
+    /* Check whether the skeleton is a combination of date and time. 
+     * For the complication reason 1 explained above. 
+     */ 
+    UnicodeString dateSkeleton; 
+    UnicodeString timeSkeleton; 
+    UnicodeString normalizedTimeSkeleton; 
+    UnicodeString normalizedDateSkeleton; 
+ 
+ 
+    /* the difference between time skeleton and normalizedTimeSkeleton are: 
+     * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true) 
+     * 2. 'a' is omitted in normalized time skeleton. 
+     * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized 
+     *    time skeleton 
+     * 
+     * The difference between date skeleton and normalizedDateSkeleton are: 
+     * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton 
+     * 2. 'E' and 'EE' are normalized into 'EEE' 
+     * 3. 'MM' is normalized into 'M' 
+     */ 
+    getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton, 
+                        timeSkeleton, normalizedTimeSkeleton); 
+ 
+#ifdef DTITVFMT_DEBUG 
+    char result[1000]; 
+    char result_1[1000]; 
+    char mesg[2000]; 
+    fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8"); 
+    sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 
+    PRINTMESG(mesg) 
+#endif 
+ 
+    // 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(nullptr, 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);
-
-        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);
+        ures_getByKey(dateTimePatternsRes.getAlias(), gCalendarTag, 
+                      dateTimePatternsRes.getAlias(), &status); 
+        ures_getByKeyWithFallback(dateTimePatternsRes.getAlias(), gGregorianTag, 
+                                  dateTimePatternsRes.getAlias(), &status); 
+        ures_getByKeyWithFallback(dateTimePatternsRes.getAlias(), gDateTimePatternsTag, 
+                                  dateTimePatternsRes.getAlias(), &status); 
+ 
+        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); 
             if (fDateTimeFormat == nullptr) {
                 status = U_MEMORY_ALLOCATION_ERROR;
                 return;
             }
-        }
-    }
-
-    UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
-                                         normalizedTimeSkeleton);
-
-    // for skeletons with seconds, found is false and we enter this block
-    if ( found == false ) {
-        // use fallback
-        // TODO: if user asks "m"(minute), but "d"(day) differ
-        if ( timeSkeleton.length() != 0 ) {
-            if ( dateSkeleton.length() == 0 ) {
-                // prefix with yMd
-                timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
-                UnicodeString pattern = DateFormat::getBestPattern(
-                        locale, timeSkeleton, status);
-                if ( U_FAILURE(status) ) {
-                    return;
-                }
-                // for fall back interval patterns,
-                // the first part of the pattern is empty,
-                // the second part of the pattern is the full-pattern
-                // should be used in fall-back.
+        } 
+    } 
+ 
+    UBool found = setSeparateDateTimePtn(normalizedDateSkeleton, 
+                                         normalizedTimeSkeleton); 
+ 
+    // for skeletons with seconds, found is false and we enter this block 
+    if ( found == false ) { 
+        // use fallback 
+        // TODO: if user asks "m"(minute), but "d"(day) differ 
+        if ( timeSkeleton.length() != 0 ) { 
+            if ( dateSkeleton.length() == 0 ) { 
+                // prefix with yMd 
+                timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1); 
+                UnicodeString pattern = DateFormat::getBestPattern( 
+                        locale, timeSkeleton, status); 
+                if ( U_FAILURE(status) ) { 
+                    return; 
+                } 
+                // for fall back interval patterns, 
+                // the first part of the pattern is empty, 
+                // the second part of the pattern is the full-pattern 
+                // should be used in fall-back. 
                 setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());
-            } else {
-                // TODO: fall back
-            }
-        } else {
-            // TODO: fall back
-        }
-        return;
-    } // end of skeleton not found
-    // interval patterns for skeleton are found in resource
-    if ( timeSkeleton.length() == 0 ) {
-        // done
-    } else if ( dateSkeleton.length() == 0 ) {
-        // prefix with yMd
-        timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
-        UnicodeString pattern = DateFormat::getBestPattern(
-                locale, timeSkeleton, status);
-        if ( U_FAILURE(status) ) {
-            return;
-        }
-        // for fall back interval patterns,
-        // the first part of the pattern is empty,
-        // the second part of the pattern is the full-pattern
-        // should be used in fall-back.
+            } else { 
+                // TODO: fall back 
+            } 
+        } else { 
+            // TODO: fall back 
+        } 
+        return; 
+    } // end of skeleton not found 
+    // interval patterns for skeleton are found in resource 
+    if ( timeSkeleton.length() == 0 ) { 
+        // done 
+    } else if ( dateSkeleton.length() == 0 ) { 
+        // prefix with yMd 
+        timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1); 
+        UnicodeString pattern = DateFormat::getBestPattern( 
+                locale, timeSkeleton, status); 
+        if ( U_FAILURE(status) ) { 
+            return; 
+        } 
+        // for fall back interval patterns, 
+        // the first part of the pattern is empty, 
+        // the second part of the pattern is the full-pattern 
+        // should be used in fall-back. 
         setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());
-    } else {
-        /* if both present,
-         * 1) when the year, month, or day differs,
-         * concatenate the two original expressions with a separator between,
-         * 2) otherwise, present the date followed by the
-         * range expression for the time.
-         */
-        /*
-         * 1) when the year, month, or day differs,
-         * concatenate the two original expressions with a separator between,
-         */
-        // if field exists, use fall back
-        UnicodeString skeleton = fSkeleton;
-        if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) {
-            // prefix skeleton with 'd'
-            skeleton.insert(0, LOW_D);
-            setFallbackPattern(UCAL_DATE, skeleton, status);
-        }
-        if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
-            // then prefix skeleton with 'M'
-            skeleton.insert(0, CAP_M);
-            setFallbackPattern(UCAL_MONTH, skeleton, status);
-        }
-        if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
-            // then prefix skeleton with 'y'
-            skeleton.insert(0, LOW_Y);
-            setFallbackPattern(UCAL_YEAR, skeleton, status);
-        }
-
-        /*
-         * 2) otherwise, present the date followed by the
-         * range expression for the time.
-         */
-
+    } else { 
+        /* if both present, 
+         * 1) when the year, month, or day differs, 
+         * concatenate the two original expressions with a separator between, 
+         * 2) otherwise, present the date followed by the 
+         * range expression for the time. 
+         */ 
+        /* 
+         * 1) when the year, month, or day differs, 
+         * concatenate the two original expressions with a separator between, 
+         */ 
+        // if field exists, use fall back 
+        UnicodeString skeleton = fSkeleton; 
+        if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) { 
+            // prefix skeleton with 'd' 
+            skeleton.insert(0, LOW_D); 
+            setFallbackPattern(UCAL_DATE, skeleton, status); 
+        } 
+        if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) { 
+            // then prefix skeleton with 'M' 
+            skeleton.insert(0, CAP_M); 
+            setFallbackPattern(UCAL_MONTH, skeleton, status); 
+        } 
+        if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) { 
+            // then prefix skeleton with 'y' 
+            skeleton.insert(0, LOW_Y); 
+            setFallbackPattern(UCAL_YEAR, skeleton, status); 
+        } 
+ 
+        /* 
+         * 2) otherwise, present the date followed by the 
+         * range expression for the time. 
+         */ 
+ 
         if ( fDateTimeFormat == nullptr ) {
-            // earlier failure getting dateTimeFormat
-            return;
-        }
-
-        UnicodeString datePattern = DateFormat::getBestPattern(
-                locale, dateSkeleton, status);
-
-        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_AM_PM, status);
-        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_HOUR, status);
-        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_MINUTE, status);
-    }
-}
-
-
-
-void  U_EXPORT2
-DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
-                                        UnicodeString& dateSkeleton,
-                                        UnicodeString& normalizedDateSkeleton,
-                                        UnicodeString& timeSkeleton,
-                                        UnicodeString& normalizedTimeSkeleton) {
-    // dateSkeleton follows the sequence of y*M*E*d*
-    // timeSkeleton follows the sequence of hm*[v|z]?
-    int32_t ECount = 0;
-    int32_t dCount = 0;
-    int32_t MCount = 0;
-    int32_t yCount = 0;
-    int32_t hCount = 0;
-    int32_t HCount = 0;
-    int32_t mCount = 0;
-    int32_t vCount = 0;
-    int32_t zCount = 0;
-    int32_t i;
-
-    for (i = 0; i < skeleton.length(); ++i) {
-        UChar ch = skeleton[i];
-        switch ( ch ) {
-          case CAP_E:
-            dateSkeleton.append(ch);
-            ++ECount;
-            break;
-          case LOW_D:
-            dateSkeleton.append(ch);
-            ++dCount;
-            break;
-          case CAP_M:
-            dateSkeleton.append(ch);
-            ++MCount;
-            break;
-          case LOW_Y:
-            dateSkeleton.append(ch);
-            ++yCount;
-            break;
-          case CAP_G:
-          case CAP_Y:
-          case LOW_U:
-          case CAP_Q:
-          case LOW_Q:
-          case CAP_L:
-          case LOW_L:
-          case CAP_W:
-          case LOW_W:
-          case CAP_D:
-          case CAP_F:
-          case LOW_G:
-          case LOW_E:
-          case LOW_C:
-          case CAP_U:
-          case LOW_R:
-            normalizedDateSkeleton.append(ch);
-            dateSkeleton.append(ch);
-            break;
-          case LOW_A:
-            // 'a' is implicitly handled
-            timeSkeleton.append(ch);
-            break;
-          case LOW_H:
-            timeSkeleton.append(ch);
-            ++hCount;
-            break;
-          case CAP_H:
-            timeSkeleton.append(ch);
-            ++HCount;
-            break;
-          case LOW_M:
-            timeSkeleton.append(ch);
-            ++mCount;
-            break;
-          case LOW_Z:
-            ++zCount;
-            timeSkeleton.append(ch);
-            break;
-          case LOW_V:
-            ++vCount;
-            timeSkeleton.append(ch);
-            break;
-          case CAP_V:
-          case CAP_Z:
-          case LOW_K:
-          case CAP_K:
-          case LOW_J:
-          case LOW_S:
-          case CAP_S:
-          case CAP_A:
-            timeSkeleton.append(ch);
-            normalizedTimeSkeleton.append(ch);
-            break;
-        }
-    }
-
-    /* generate normalized form for date*/
-    if ( yCount != 0 ) {
-        for (i = 0; i < yCount; ++i) {
-            normalizedDateSkeleton.append(LOW_Y);
-        }
-    }
-    if ( MCount != 0 ) {
-        if ( MCount < 3 ) {
-            normalizedDateSkeleton.append(CAP_M);
-        } else {
+            // earlier failure getting dateTimeFormat 
+            return; 
+        } 
+ 
+        UnicodeString datePattern = DateFormat::getBestPattern( 
+                locale, dateSkeleton, status); 
+ 
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_AM_PM, status); 
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_HOUR, status); 
+        concatSingleDate2TimeInterval(*fDateTimeFormat, datePattern, UCAL_MINUTE, status); 
+    } 
+} 
+ 
+ 
+ 
+void  U_EXPORT2 
+DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton, 
+                                        UnicodeString& dateSkeleton, 
+                                        UnicodeString& normalizedDateSkeleton, 
+                                        UnicodeString& timeSkeleton, 
+                                        UnicodeString& normalizedTimeSkeleton) { 
+    // dateSkeleton follows the sequence of y*M*E*d* 
+    // timeSkeleton follows the sequence of hm*[v|z]? 
+    int32_t ECount = 0; 
+    int32_t dCount = 0; 
+    int32_t MCount = 0; 
+    int32_t yCount = 0; 
+    int32_t hCount = 0; 
+    int32_t HCount = 0; 
+    int32_t mCount = 0; 
+    int32_t vCount = 0; 
+    int32_t zCount = 0; 
+    int32_t i; 
+ 
+    for (i = 0; i < skeleton.length(); ++i) { 
+        UChar ch = skeleton[i]; 
+        switch ( ch ) { 
+          case CAP_E: 
+            dateSkeleton.append(ch); 
+            ++ECount; 
+            break; 
+          case LOW_D: 
+            dateSkeleton.append(ch); 
+            ++dCount; 
+            break; 
+          case CAP_M: 
+            dateSkeleton.append(ch); 
+            ++MCount; 
+            break; 
+          case LOW_Y: 
+            dateSkeleton.append(ch); 
+            ++yCount; 
+            break; 
+          case CAP_G: 
+          case CAP_Y: 
+          case LOW_U: 
+          case CAP_Q: 
+          case LOW_Q: 
+          case CAP_L: 
+          case LOW_L: 
+          case CAP_W: 
+          case LOW_W: 
+          case CAP_D: 
+          case CAP_F: 
+          case LOW_G: 
+          case LOW_E: 
+          case LOW_C: 
+          case CAP_U: 
+          case LOW_R: 
+            normalizedDateSkeleton.append(ch); 
+            dateSkeleton.append(ch); 
+            break; 
+          case LOW_A: 
+            // 'a' is implicitly handled 
+            timeSkeleton.append(ch); 
+            break; 
+          case LOW_H: 
+            timeSkeleton.append(ch); 
+            ++hCount; 
+            break; 
+          case CAP_H: 
+            timeSkeleton.append(ch); 
+            ++HCount; 
+            break; 
+          case LOW_M: 
+            timeSkeleton.append(ch); 
+            ++mCount; 
+            break; 
+          case LOW_Z: 
+            ++zCount; 
+            timeSkeleton.append(ch); 
+            break; 
+          case LOW_V: 
+            ++vCount; 
+            timeSkeleton.append(ch); 
+            break; 
+          case CAP_V: 
+          case CAP_Z: 
+          case LOW_K: 
+          case CAP_K: 
+          case LOW_J: 
+          case LOW_S: 
+          case CAP_S: 
+          case CAP_A: 
+            timeSkeleton.append(ch); 
+            normalizedTimeSkeleton.append(ch); 
+            break; 
+        } 
+    } 
+ 
+    /* generate normalized form for date*/ 
+    if ( yCount != 0 ) { 
+        for (i = 0; i < yCount; ++i) { 
+            normalizedDateSkeleton.append(LOW_Y); 
+        } 
+    } 
+    if ( MCount != 0 ) { 
+        if ( MCount < 3 ) { 
+            normalizedDateSkeleton.append(CAP_M); 
+        } else { 
             for ( int32_t j = 0; j < MCount && j < MAX_M_COUNT; ++j) {
-                 normalizedDateSkeleton.append(CAP_M);
-            }
-        }
-    }
-    if ( ECount != 0 ) {
-        if ( ECount <= 3 ) {
-            normalizedDateSkeleton.append(CAP_E);
-        } else {
+                 normalizedDateSkeleton.append(CAP_M); 
+            } 
+        } 
+    } 
+    if ( ECount != 0 ) { 
+        if ( ECount <= 3 ) { 
+            normalizedDateSkeleton.append(CAP_E); 
+        } else { 
             for ( int32_t j = 0; j < ECount && j < MAX_E_COUNT; ++j ) {
-                 normalizedDateSkeleton.append(CAP_E);
-            }
-        }
-    }
-    if ( dCount != 0 ) {
-        normalizedDateSkeleton.append(LOW_D);
-    }
-
-    /* generate normalized form for time */
-    if ( HCount != 0 ) {
-        normalizedTimeSkeleton.append(CAP_H);
-    }
-    else if ( hCount != 0 ) {
-        normalizedTimeSkeleton.append(LOW_H);
-    }
-    if ( mCount != 0 ) {
-        normalizedTimeSkeleton.append(LOW_M);
-    }
-    if ( zCount != 0 ) {
-        normalizedTimeSkeleton.append(LOW_Z);
-    }
-    if ( vCount != 0 ) {
-        normalizedTimeSkeleton.append(LOW_V);
-    }
-}
-
-
-/**
- * Generate date or time interval pattern from resource,
- * and set them into the interval pattern locale to this formatter.
- *
- * It needs to handle the following:
- * 1. need to adjust field width.
- *    For example, the interval patterns saved in DateIntervalInfo
- *    includes "dMMMy", but not "dMMMMy".
- *    Need to get interval patterns for dMMMMy from dMMMy.
- *    Another example, the interval patterns saved in DateIntervalInfo
- *    includes "hmv", but not "hmz".
- *    Need to get interval patterns for "hmz' from 'hmv'
- *
- * 2. there might be no pattern for 'y' differ for skeleton "Md",
- *    in order to get interval patterns for 'y' differ,
- *    need to look for it from skeleton 'yMd'
- *
- * @param dateSkeleton   normalized date skeleton
- * @param timeSkeleton   normalized time skeleton
- * @return               whether the resource is found for the skeleton.
- *                       TRUE if interval pattern found for the skeleton,
- *                       FALSE otherwise.
- * @stable ICU 4.0
- */
-UBool
-DateIntervalFormat::setSeparateDateTimePtn(
-                                 const UnicodeString& dateSkeleton,
-                                 const UnicodeString& timeSkeleton) {
-    const UnicodeString* skeleton;
-    // if both date and time skeleton present,
-    // the final interval pattern might include time interval patterns
-    // ( when, am_pm, hour, minute differ ),
-    // but not date interval patterns ( when year, month, day differ ).
-    // For year/month/day differ, it falls back to fall-back pattern.
-    if ( timeSkeleton.length() != 0  ) {
-        skeleton = &timeSkeleton;
-    } else {
-        skeleton = &dateSkeleton;
-    }
-
-    /* interval patterns for skeleton "dMMMy" (but not "dMMMMy")
-     * are defined in resource,
-     * interval patterns for skeleton "dMMMMy" are calculated by
-     * 1. get the best match skeleton for "dMMMMy", which is "dMMMy"
-     * 2. get the interval patterns for "dMMMy",
-     * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy"
-     * getBestSkeleton() is step 1.
-     */
-    // best skeleton, and the difference information
-    int8_t differenceInfo = 0;
-    const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
-                                                               differenceInfo);
+                 normalizedDateSkeleton.append(CAP_E); 
+            } 
+        } 
+    } 
+    if ( dCount != 0 ) { 
+        normalizedDateSkeleton.append(LOW_D); 
+    } 
+ 
+    /* generate normalized form for time */ 
+    if ( HCount != 0 ) { 
+        normalizedTimeSkeleton.append(CAP_H); 
+    } 
+    else if ( hCount != 0 ) { 
+        normalizedTimeSkeleton.append(LOW_H); 
+    } 
+    if ( mCount != 0 ) { 
+        normalizedTimeSkeleton.append(LOW_M); 
+    } 
+    if ( zCount != 0 ) { 
+        normalizedTimeSkeleton.append(LOW_Z); 
+    } 
+    if ( vCount != 0 ) { 
+        normalizedTimeSkeleton.append(LOW_V); 
+    } 
+} 
+ 
+ 
+/** 
+ * Generate date or time interval pattern from resource, 
+ * and set them into the interval pattern locale to this formatter. 
+ * 
+ * It needs to handle the following: 
+ * 1. need to adjust field width. 
+ *    For example, the interval patterns saved in DateIntervalInfo 
+ *    includes "dMMMy", but not "dMMMMy". 
+ *    Need to get interval patterns for dMMMMy from dMMMy. 
+ *    Another example, the interval patterns saved in DateIntervalInfo 
+ *    includes "hmv", but not "hmz". 
+ *    Need to get interval patterns for "hmz' from 'hmv' 
+ * 
+ * 2. there might be no pattern for 'y' differ for skeleton "Md", 
+ *    in order to get interval patterns for 'y' differ, 
+ *    need to look for it from skeleton 'yMd' 
+ * 
+ * @param dateSkeleton   normalized date skeleton 
+ * @param timeSkeleton   normalized time skeleton 
+ * @return               whether the resource is found for the skeleton. 
+ *                       TRUE if interval pattern found for the skeleton, 
+ *                       FALSE otherwise. 
+ * @stable ICU 4.0 
+ */ 
+UBool 
+DateIntervalFormat::setSeparateDateTimePtn( 
+                                 const UnicodeString& dateSkeleton, 
+                                 const UnicodeString& timeSkeleton) { 
+    const UnicodeString* skeleton; 
+    // if both date and time skeleton present, 
+    // the final interval pattern might include time interval patterns 
+    // ( when, am_pm, hour, minute differ ), 
+    // but not date interval patterns ( when year, month, day differ ). 
+    // For year/month/day differ, it falls back to fall-back pattern. 
+    if ( timeSkeleton.length() != 0  ) { 
+        skeleton = &timeSkeleton; 
+    } else { 
+        skeleton = &dateSkeleton; 
+    } 
+ 
+    /* interval patterns for skeleton "dMMMy" (but not "dMMMMy") 
+     * are defined in resource, 
+     * interval patterns for skeleton "dMMMMy" are calculated by 
+     * 1. get the best match skeleton for "dMMMMy", which is "dMMMy" 
+     * 2. get the interval patterns for "dMMMy", 
+     * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy" 
+     * getBestSkeleton() is step 1. 
+     */ 
+    // best skeleton, and the difference information 
+    int8_t differenceInfo = 0; 
+    const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton, 
+                                                               differenceInfo); 
     /* best skeleton could be nullptr.
-       For example: in "ca" resource file,
-       interval format is defined as following
-           intervalFormats{
-                fallback{"{0} - {1}"}
-            }
-       there is no skeletons/interval patterns defined,
+       For example: in "ca" resource file, 
+       interval format is defined as following 
+           intervalFormats{ 
+                fallback{"{0} - {1}"} 
+            } 
+       there is no skeletons/interval patterns defined, 
        and the best skeleton match could be nullptr
-     */
+     */ 
     if ( bestSkeleton == nullptr ) {
-        return false;
-    }
-
-    // Set patterns for fallback use, need to do this
-    // before returning if differenceInfo == -1
-    UErrorCode status;
-    if ( dateSkeleton.length() != 0) {
-        status = U_ZERO_ERROR;
-        fDatePattern = new UnicodeString(DateFormat::getBestPattern(
-                fLocale, dateSkeleton, status));
+        return false; 
+    } 
+ 
+    // Set patterns for fallback use, need to do this 
+    // before returning if differenceInfo == -1 
+    UErrorCode status; 
+    if ( dateSkeleton.length() != 0) { 
+        status = U_ZERO_ERROR; 
+        fDatePattern = new UnicodeString(DateFormat::getBestPattern( 
+                fLocale, dateSkeleton, status)); 
         // no way to report OOM. :(
-    }
-    if ( timeSkeleton.length() != 0) {
-        status = U_ZERO_ERROR;
-        fTimePattern = new UnicodeString(DateFormat::getBestPattern(
-                fLocale, timeSkeleton, status));
+    } 
+    if ( timeSkeleton.length() != 0) { 
+        status = U_ZERO_ERROR; 
+        fTimePattern = new UnicodeString(DateFormat::getBestPattern( 
+                fLocale, timeSkeleton, status)); 
         // no way to report OOM. :(
-    }
-
-    // difference:
-    // 0 means the best matched skeleton is the same as input skeleton
-    // 1 means the fields are the same, but field width are different
-    // 2 means the only difference between fields are v/z,
-    // -1 means there are other fields difference
-    // (this will happen, for instance, if the supplied skeleton has seconds,
-    //  but no skeletons in the intervalFormats data do)
-    if ( differenceInfo == -1 ) {
-        // skeleton has different fields, not only  v/z difference
-        return false;
-    }
-
-    if ( timeSkeleton.length() == 0 ) {
-        UnicodeString extendedSkeleton;
-        UnicodeString extendedBestSkeleton;
-        // only has date skeleton
-        setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
-                           &extendedSkeleton, &extendedBestSkeleton);
-
-        UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
-                                     differenceInfo,
-                                     &extendedSkeleton, &extendedBestSkeleton);
-
-        if ( extended ) {
-            bestSkeleton = &extendedBestSkeleton;
-            skeleton = &extendedSkeleton;
-        }
-        setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo,
-                           &extendedSkeleton, &extendedBestSkeleton);
+    } 
+ 
+    // difference: 
+    // 0 means the best matched skeleton is the same as input skeleton 
+    // 1 means the fields are the same, but field width are different 
+    // 2 means the only difference between fields are v/z, 
+    // -1 means there are other fields difference 
+    // (this will happen, for instance, if the supplied skeleton has seconds, 
+    //  but no skeletons in the intervalFormats data do) 
+    if ( differenceInfo == -1 ) { 
+        // skeleton has different fields, not only  v/z difference 
+        return false; 
+    } 
+ 
+    if ( timeSkeleton.length() == 0 ) { 
+        UnicodeString extendedSkeleton; 
+        UnicodeString extendedBestSkeleton; 
+        // only has date skeleton 
+        setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo, 
+                           &extendedSkeleton, &extendedBestSkeleton); 
+ 
+        UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton, 
+                                     differenceInfo, 
+                                     &extendedSkeleton, &extendedBestSkeleton); 
+ 
+        if ( extended ) { 
+            bestSkeleton = &extendedBestSkeleton; 
+            skeleton = &extendedSkeleton; 
+        } 
+        setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo, 
+                           &extendedSkeleton, &extendedBestSkeleton); 
         setIntervalPattern(UCAL_ERA, skeleton, bestSkeleton, differenceInfo,
                            &extendedSkeleton, &extendedBestSkeleton);
      } else {
-        setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
-        setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
-        setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo);
-    }
-    return true;
-}
-
-
-
-void
-DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
-                                       const UnicodeString& skeleton,
-                                       UErrorCode& status) {
-    if ( U_FAILURE(status) ) {
-        return;
-    }
-    UnicodeString pattern = DateFormat::getBestPattern(
-            fLocale, skeleton, status);
-    if ( U_FAILURE(status) ) {
-        return;
-    }
+        setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo); 
+        setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo); 
+        setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo); 
+    } 
+    return true; 
+} 
+ 
+ 
+ 
+void 
+DateIntervalFormat::setFallbackPattern(UCalendarDateFields field, 
+                                       const UnicodeString& skeleton, 
+                                       UErrorCode& status) { 
+    if ( U_FAILURE(status) ) { 
+        return; 
+    } 
+    UnicodeString pattern = DateFormat::getBestPattern( 
+            fLocale, skeleton, status); 
+    if ( U_FAILURE(status) ) { 
+        return; 
+    } 
     setPatternInfo(field, nullptr, &pattern, fInfo->getDefaultOrder());
-}
-
-
-
-
-void
-DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
-                                   const UnicodeString* firstPart,
-                                   const UnicodeString* secondPart,
-                                   UBool laterDateFirst) {
-    // for fall back interval patterns,
-    // the first part of the pattern is empty,
-    // the second part of the pattern is the full-pattern
-    // should be used in fall-back.
-    UErrorCode status = U_ZERO_ERROR;
-    // following should not set any wrong status.
-    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
-                                                                        status);
-    if ( U_FAILURE(status) ) {
-        return;
-    }
-    PatternInfo& ptn = fIntervalPatterns[itvPtnIndex];
-    if ( firstPart ) {
-        ptn.firstPart = *firstPart;
-    }
-    if ( secondPart ) {
-        ptn.secondPart = *secondPart;
-    }
-    ptn.laterDateFirst = laterDateFirst;
-}
-
-void
-DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
-                                       const UnicodeString& intervalPattern) {
-    UBool order = fInfo->getDefaultOrder();
-    setIntervalPattern(field, intervalPattern, order);
-}
-
-
-void
-DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
-                                       const UnicodeString& intervalPattern,
-                                       UBool laterDateFirst) {
-    const UnicodeString* pattern = &intervalPattern;
-    UBool order = laterDateFirst;
-    // check for "latestFirst:" or "earliestFirst:" prefix
-    int8_t prefixLength = UPRV_LENGTHOF(gLaterFirstPrefix);
-    int8_t earliestFirstLength = UPRV_LENGTHOF(gEarlierFirstPrefix);
-    UnicodeString realPattern;
-    if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
-        order = true;
-        intervalPattern.extract(prefixLength,
-                                intervalPattern.length() - prefixLength,
-                                realPattern);
-        pattern = &realPattern;
-    } else if ( intervalPattern.startsWith(gEarlierFirstPrefix,
-                                           earliestFirstLength) ) {
-        order = false;
-        intervalPattern.extract(earliestFirstLength,
-                                intervalPattern.length() - earliestFirstLength,
-                                realPattern);
-        pattern = &realPattern;
-    }
-
-    int32_t splitPoint = splitPatternInto2Part(*pattern);
-
-    UnicodeString firstPart;
-    UnicodeString secondPart;
-    pattern->extract(0, splitPoint, firstPart);
-    if ( splitPoint < pattern->length() ) {
-        pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart);
-    }
-    setPatternInfo(field, &firstPart, &secondPart, order);
-}
-
-
-
-
-/**
- * Generate interval pattern from existing resource
- *
- * It not only save the interval patterns,
- * but also return the extended skeleton and its best match skeleton.
- *
- * @param field           largest different calendar field
- * @param skeleton        skeleton
- * @param bestSkeleton    the best match skeleton which has interval pattern
- *                        defined in resource
- * @param differenceInfo  the difference between skeleton and best skeleton
- *         0 means the best matched skeleton is the same as input skeleton
- *         1 means the fields are the same, but field width are different
- *         2 means the only difference between fields are v/z,
- *        -1 means there are other fields difference
- *
- * @param extendedSkeleton      extended skeleton
- * @param extendedBestSkeleton  extended best match skeleton
- * @return                      whether the interval pattern is found
- *                              through extending skeleton or not.
- *                              TRUE if interval pattern is found by
- *                              extending skeleton, FALSE otherwise.
- * @stable ICU 4.0
- */
-UBool
-DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
-                                       const UnicodeString* skeleton,
-                                       const UnicodeString* bestSkeleton,
-                                       int8_t differenceInfo,
-                                       UnicodeString* extendedSkeleton,
-                                       UnicodeString* extendedBestSkeleton) {
-    UErrorCode status = U_ZERO_ERROR;
-    // following getIntervalPattern() should not generate error status
-    UnicodeString pattern;
-    fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status);
-    if ( pattern.isEmpty() ) {
-        // single date
-        if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) {
-            // do nothing, format will handle it
-            return false;
-        }
-
-        // for 24 hour system, interval patterns in resource file
-        // might not include pattern when am_pm differ,
-        // which should be the same as hour differ.
-        // add it here for simplicity
-        if ( field == UCAL_AM_PM ) {
-            fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status);
-            if ( !pattern.isEmpty() ) {
-                setIntervalPattern(field, pattern);
-            }
-            return false;
-        }
-        // else, looking for pattern when 'y' differ for 'dMMMM' skeleton,
-        // first, get best match pattern "MMMd",
-        // since there is no pattern for 'y' differs for skeleton 'MMMd',
-        // need to look for it from skeleton 'yMMMd',
-        // if found, adjust field width in interval pattern from
-        // "MMM" to "MMMM".
-        UChar fieldLetter = fgCalendarFieldToPatternLetter[field];
-        if ( extendedSkeleton ) {
-            *extendedSkeleton = *skeleton;
-            *extendedBestSkeleton = *bestSkeleton;
-            extendedSkeleton->insert(0, fieldLetter);
-            extendedBestSkeleton->insert(0, fieldLetter);
-            // for example, looking for patterns when 'y' differ for
-            // skeleton "MMMM".
-            fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status);
-            if ( pattern.isEmpty() && differenceInfo == 0 ) {
-                // if there is no skeleton "yMMMM" defined,
-                // look for the best match skeleton, for example: "yMMM"
-                const UnicodeString* tmpBest = fInfo->getBestSkeleton(
-                                        *extendedBestSkeleton, differenceInfo);
-                if ( tmpBest != 0 && differenceInfo != -1 ) {
-                    fInfo->getIntervalPattern(*tmpBest, field, pattern, status);
-                    bestSkeleton = tmpBest;
-                }
-            }
-        }
-    }
-    if ( !pattern.isEmpty() ) {
-        if ( differenceInfo != 0 ) {
-            UnicodeString adjustIntervalPattern;
-            adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
-                              adjustIntervalPattern);
-            setIntervalPattern(field, adjustIntervalPattern);
-        } else {
-            setIntervalPattern(field, pattern);
-        }
-        if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-
-
-int32_t  U_EXPORT2
-DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
-    UBool inQuote = false;
-    UChar prevCh = 0;
-    int32_t count = 0;
-
-    /* repeatedPattern used to record whether a pattern has already seen.
-       It is a pattern applies to first calendar if it is first time seen,
-       otherwise, it is a pattern applies to the second calendar
-     */
-    UBool patternRepeated[] =
-    {
-    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   P   Q   R   S   T   U   V   W   X   Y   Z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
-    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   p   q   r   s   t   u   v   w   x   y   z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
-    };
-
-    int8_t PATTERN_CHAR_BASE = 0x41;
-
-    /* loop through the pattern string character by character looking for
-     * the first repeated pattern letter, which breaks the interval pattern
-     * into 2 parts.
-     */
-    int32_t i;
-    UBool foundRepetition = false;
-    for (i = 0; i < intervalPattern.length(); ++i) {
-        UChar ch = intervalPattern.charAt(i);
-
-        if (ch != prevCh && count > 0) {
-            // check the repeativeness of pattern letter
-            UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)];
-            if ( repeated == FALSE ) {
-                patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE;
-            } else {
-                foundRepetition = true;
-                break;
-            }
-            count = 0;
-        }
-        if (ch == 0x0027 /*'*/) {
-            // Consecutive single quotes are a single quote literal,
-            // either outside of quotes or between quotes
-            if ((i+1) < intervalPattern.length() &&
-                intervalPattern.charAt(i+1) == 0x0027 /*'*/) {
-                ++i;
-            } else {
-                inQuote = ! inQuote;
-            }
-        }
-        else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
-                    || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
-            // ch is a date-time pattern character
-            prevCh = ch;
-            ++count;
-        }
-    }
-    // check last pattern char, distinguish
-    // "dd MM" ( no repetition ),
-    // "d-d"(last char repeated ), and
-    // "d-d MM" ( repetition found )
-    if ( count > 0 && foundRepetition == FALSE ) {
-        if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) {
-            count = 0;
-        }
-    }
-    return (i - count);
-}
-
+} 
+ 
+ 
+ 
+ 
+void 
+DateIntervalFormat::setPatternInfo(UCalendarDateFields field, 
+                                   const UnicodeString* firstPart, 
+                                   const UnicodeString* secondPart, 
+                                   UBool laterDateFirst) { 
+    // for fall back interval patterns, 
+    // the first part of the pattern is empty, 
+    // the second part of the pattern is the full-pattern 
+    // should be used in fall-back. 
+    UErrorCode status = U_ZERO_ERROR; 
+    // following should not set any wrong status. 
+    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 
+                                                                        status); 
+    if ( U_FAILURE(status) ) { 
+        return; 
+    } 
+    PatternInfo& ptn = fIntervalPatterns[itvPtnIndex]; 
+    if ( firstPart ) { 
+        ptn.firstPart = *firstPart; 
+    } 
+    if ( secondPart ) { 
+        ptn.secondPart = *secondPart; 
+    } 
+    ptn.laterDateFirst = laterDateFirst; 
+} 
+ 
+void 
+DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 
+                                       const UnicodeString& intervalPattern) { 
+    UBool order = fInfo->getDefaultOrder(); 
+    setIntervalPattern(field, intervalPattern, order); 
+} 
+ 
+ 
+void 
+DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 
+                                       const UnicodeString& intervalPattern, 
+                                       UBool laterDateFirst) { 
+    const UnicodeString* pattern = &intervalPattern; 
+    UBool order = laterDateFirst; 
+    // check for "latestFirst:" or "earliestFirst:" prefix 
+    int8_t prefixLength = UPRV_LENGTHOF(gLaterFirstPrefix); 
+    int8_t earliestFirstLength = UPRV_LENGTHOF(gEarlierFirstPrefix); 
+    UnicodeString realPattern; 
+    if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) { 
+        order = true; 
+        intervalPattern.extract(prefixLength, 
+                                intervalPattern.length() - prefixLength, 
+                                realPattern); 
+        pattern = &realPattern; 
+    } else if ( intervalPattern.startsWith(gEarlierFirstPrefix, 
+                                           earliestFirstLength) ) { 
+        order = false; 
+        intervalPattern.extract(earliestFirstLength, 
+                                intervalPattern.length() - earliestFirstLength, 
+                                realPattern); 
+        pattern = &realPattern; 
+    } 
+ 
+    int32_t splitPoint = splitPatternInto2Part(*pattern); 
+ 
+    UnicodeString firstPart; 
+    UnicodeString secondPart; 
+    pattern->extract(0, splitPoint, firstPart); 
+    if ( splitPoint < pattern->length() ) { 
+        pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart); 
+    } 
+    setPatternInfo(field, &firstPart, &secondPart, order); 
+} 
+ 
+ 
+ 
+ 
+/** 
+ * Generate interval pattern from existing resource 
+ * 
+ * It not only save the interval patterns, 
+ * but also return the extended skeleton and its best match skeleton. 
+ * 
+ * @param field           largest different calendar field 
+ * @param skeleton        skeleton 
+ * @param bestSkeleton    the best match skeleton which has interval pattern 
+ *                        defined in resource 
+ * @param differenceInfo  the difference between skeleton and best skeleton 
+ *         0 means the best matched skeleton is the same as input skeleton 
+ *         1 means the fields are the same, but field width are different 
+ *         2 means the only difference between fields are v/z, 
+ *        -1 means there are other fields difference 
+ * 
+ * @param extendedSkeleton      extended skeleton 
+ * @param extendedBestSkeleton  extended best match skeleton 
+ * @return                      whether the interval pattern is found 
+ *                              through extending skeleton or not. 
+ *                              TRUE if interval pattern is found by 
+ *                              extending skeleton, FALSE otherwise. 
+ * @stable ICU 4.0 
+ */ 
+UBool 
+DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 
+                                       const UnicodeString* skeleton, 
+                                       const UnicodeString* bestSkeleton, 
+                                       int8_t differenceInfo, 
+                                       UnicodeString* extendedSkeleton, 
+                                       UnicodeString* extendedBestSkeleton) { 
+    UErrorCode status = U_ZERO_ERROR; 
+    // following getIntervalPattern() should not generate error status 
+    UnicodeString pattern; 
+    fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status); 
+    if ( pattern.isEmpty() ) { 
+        // single date 
+        if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) { 
+            // do nothing, format will handle it 
+            return false; 
+        } 
+ 
+        // for 24 hour system, interval patterns in resource file 
+        // might not include pattern when am_pm differ, 
+        // which should be the same as hour differ. 
+        // add it here for simplicity 
+        if ( field == UCAL_AM_PM ) { 
+            fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status); 
+            if ( !pattern.isEmpty() ) { 
+                setIntervalPattern(field, pattern); 
+            } 
+            return false; 
+        } 
+        // else, looking for pattern when 'y' differ for 'dMMMM' skeleton, 
+        // first, get best match pattern "MMMd", 
+        // since there is no pattern for 'y' differs for skeleton 'MMMd', 
+        // need to look for it from skeleton 'yMMMd', 
+        // if found, adjust field width in interval pattern from 
+        // "MMM" to "MMMM". 
+        UChar fieldLetter = fgCalendarFieldToPatternLetter[field]; 
+        if ( extendedSkeleton ) { 
+            *extendedSkeleton = *skeleton; 
+            *extendedBestSkeleton = *bestSkeleton; 
+            extendedSkeleton->insert(0, fieldLetter); 
+            extendedBestSkeleton->insert(0, fieldLetter); 
+            // for example, looking for patterns when 'y' differ for 
+            // skeleton "MMMM". 
+            fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status); 
+            if ( pattern.isEmpty() && differenceInfo == 0 ) { 
+                // if there is no skeleton "yMMMM" defined, 
+                // look for the best match skeleton, for example: "yMMM" 
+                const UnicodeString* tmpBest = fInfo->getBestSkeleton( 
+                                        *extendedBestSkeleton, differenceInfo); 
+                if ( tmpBest != 0 && differenceInfo != -1 ) { 
+                    fInfo->getIntervalPattern(*tmpBest, field, pattern, status); 
+                    bestSkeleton = tmpBest; 
+                } 
+            } 
+        } 
+    } 
+    if ( !pattern.isEmpty() ) { 
+        if ( differenceInfo != 0 ) { 
+            UnicodeString adjustIntervalPattern; 
+            adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo, 
+                              adjustIntervalPattern); 
+            setIntervalPattern(field, adjustIntervalPattern); 
+        } else { 
+            setIntervalPattern(field, pattern); 
+        } 
+        if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) { 
+            return TRUE; 
+        } 
+    } 
+    return FALSE; 
+} 
+ 
+ 
+ 
+int32_t  U_EXPORT2 
+DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) { 
+    UBool inQuote = false; 
+    UChar prevCh = 0; 
+    int32_t count = 0; 
+ 
+    /* repeatedPattern used to record whether a pattern has already seen. 
+       It is a pattern applies to first calendar if it is first time seen, 
+       otherwise, it is a pattern applies to the second calendar 
+     */ 
+    UBool patternRepeated[] = 
+    { 
+    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O 
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   P   Q   R   S   T   U   V   W   X   Y   Z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0, 
+    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   p   q   r   s   t   u   v   w   x   y   z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 
+    }; 
+ 
+    int8_t PATTERN_CHAR_BASE = 0x41; 
+ 
+    /* loop through the pattern string character by character looking for 
+     * the first repeated pattern letter, which breaks the interval pattern 
+     * into 2 parts. 
+     */ 
+    int32_t i; 
+    UBool foundRepetition = false; 
+    for (i = 0; i < intervalPattern.length(); ++i) { 
+        UChar ch = intervalPattern.charAt(i); 
+ 
+        if (ch != prevCh && count > 0) { 
+            // check the repeativeness of pattern letter 
+            UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)]; 
+            if ( repeated == FALSE ) { 
+                patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE; 
+            } else { 
+                foundRepetition = true; 
+                break; 
+            } 
+            count = 0; 
+        } 
+        if (ch == 0x0027 /*'*/) { 
+            // Consecutive single quotes are a single quote literal, 
+            // either outside of quotes or between quotes 
+            if ((i+1) < intervalPattern.length() && 
+                intervalPattern.charAt(i+1) == 0x0027 /*'*/) { 
+                ++i; 
+            } else { 
+                inQuote = ! inQuote; 
+            } 
+        } 
+        else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 
+                    || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 
+            // ch is a date-time pattern character 
+            prevCh = ch; 
+            ++count; 
+        } 
+    } 
+    // check last pattern char, distinguish 
+    // "dd MM" ( no repetition ), 
+    // "d-d"(last char repeated ), and 
+    // "d-d MM" ( repetition found ) 
+    if ( count > 0 && foundRepetition == FALSE ) { 
+        if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) { 
+            count = 0; 
+        } 
+    } 
+    return (i - count); 
+} 
+ 
 void DateIntervalFormat::fallbackFormatRange(
         Calendar& fromCalendar,
         Calendar& toCalendar,
@@ -1436,8 +1436,8 @@ void DateIntervalFormat::fallbackFormatRange(
     fInfo->getFallbackIntervalPattern(fallbackPattern);
     SimpleFormatter sf(fallbackPattern, 2, 2, status);
     if (U_FAILURE(status)) {
-        return;
-    }
+        return; 
+    } 
     int32_t offsets[2];
     UnicodeString patternBody = sf.getTextWithNoArguments(offsets, 2);
 
@@ -1449,30 +1449,30 @@ void DateIntervalFormat::fallbackFormatRange(
         appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
         fDateFormat->_format(toCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
-    } else {
+    } 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->_format(fromCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
-    }
-}
-
-UnicodeString&
-DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
-                                   Calendar& toCalendar,
-                                   UBool fromToOnSameDay, // new
-                                   UnicodeString& appendTo,
+    } 
+} 
+ 
+UnicodeString& 
+DateIntervalFormat::fallbackFormat(Calendar& fromCalendar, 
+                                   Calendar& toCalendar, 
+                                   UBool fromToOnSameDay, // new 
+                                   UnicodeString& appendTo, 
                                    int8_t& firstIndex,
                                    FieldPositionHandler& fphandler,
-                                   UErrorCode& status) const {
-    if ( U_FAILURE(status) ) {
-        return appendTo;
-    }
+                                   UErrorCode& status) const { 
+    if ( U_FAILURE(status) ) { 
+        return appendTo; 
+    } 
 
-    UBool formatDatePlusTimeRange = (fromToOnSameDay && fDatePattern && fTimePattern);
-    if (formatDatePlusTimeRange) {
+    UBool formatDatePlusTimeRange = (fromToOnSameDay && fDatePattern && fTimePattern); 
+    if (formatDatePlusTimeRange) { 
         SimpleFormatter sf(*fDateTimeFormat, 2, 2, status);
         if (U_FAILURE(status)) {
             return appendTo;
@@ -1481,7 +1481,7 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
         UnicodeString patternBody = sf.getTextWithNoArguments(offsets, 2);
 
         UnicodeString fullPattern; // for saving the pattern in fDateFormat
-        fDateFormat->toPattern(fullPattern); // save current pattern, restore later
+        fDateFormat->toPattern(fullPattern); // save current pattern, restore later 
 
         // {0} is time range
         // {1} is single date portion
@@ -1504,182 +1504,182 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
             appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
         }
 
-        // restore full pattern
-        fDateFormat->applyPattern(fullPattern);
+        // restore full pattern 
+        fDateFormat->applyPattern(fullPattern); 
     } else {
         fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
-    }
-    return appendTo;
-}
-
-
-
-
-UBool  U_EXPORT2
-DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
-                                          const UnicodeString& skeleton)
-{
-    const UChar fieldChar = fgCalendarFieldToPatternLetter[field];
-    return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ;
-}
-
-
-
-void  U_EXPORT2
-DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
-                 const UnicodeString& bestMatchSkeleton,
-                 const UnicodeString& bestIntervalPattern,
-                 int8_t differenceInfo,
-                 UnicodeString& adjustedPtn) {
-    adjustedPtn = bestIntervalPattern;
-    int32_t inputSkeletonFieldWidth[] =
-    {
-    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   P   Q   R   S   T   U   V   W   X   Y   Z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
-    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   p   q   r   s   t   u   v   w   x   y   z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
-    };
-
-    int32_t bestMatchSkeletonFieldWidth[] =
-    {
-    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   P   Q   R   S   T   U   V   W   X   Y   Z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
-    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    //   p   q   r   s   t   u   v   w   x   y   z
-         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
-    };
-
-    DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
-    DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
-    if ( differenceInfo == 2 ) {
-        adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */),
-                                   UnicodeString((UChar)0x7a /* z */));
-    }
-
-    UBool inQuote = false;
-    UChar prevCh = 0;
-    int32_t count = 0;
-
-    const int8_t PATTERN_CHAR_BASE = 0x41;
-
-    // loop through the pattern string character by character
-    int32_t adjustedPtnLength = adjustedPtn.length();
-    int32_t i;
-    for (i = 0; i < adjustedPtnLength; ++i) {
-        UChar ch = adjustedPtn.charAt(i);
-        if (ch != prevCh && count > 0) {
-            // check the repeativeness of pattern letter
-            UChar skeletonChar = prevCh;
-            if ( skeletonChar ==  CAP_L ) {
-                // there is no "L" (always be "M") in skeleton,
-                // but there is "L" in pattern.
-                // for skeleton "M+", the pattern might be "...L..."
-                skeletonChar = CAP_M;
-            }
-            int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
-            int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
-            if ( fieldCount == count && inputFieldCount > fieldCount ) {
-                count = inputFieldCount - fieldCount;
-                int32_t j;
-                for ( j = 0; j < count; ++j ) {
-                    adjustedPtn.insert(i, prevCh);
-                }
-                i += count;
-                adjustedPtnLength += count;
-            }
-            count = 0;
-        }
-        if (ch == 0x0027 /*'*/) {
-            // Consecutive single quotes are a single quote literal,
-            // either outside of quotes or between quotes
-            if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == 0x0027 /* ' */) {
-                ++i;
-            } else {
-                inQuote = ! inQuote;
-            }
-        }
-        else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
-                    || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
-            // ch is a date-time pattern character
-            prevCh = ch;
-            ++count;
-        }
-    }
-    if ( count > 0 ) {
-        // last item
-        // check the repeativeness of pattern letter
-        UChar skeletonChar = prevCh;
-        if ( skeletonChar == CAP_L ) {
-            // there is no "L" (always be "M") in skeleton,
-            // but there is "L" in pattern.
-            // for skeleton "M+", the pattern might be "...L..."
-            skeletonChar = CAP_M;
-        }
-        int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
-        int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
-        if ( fieldCount == count && inputFieldCount > fieldCount ) {
-            count = inputFieldCount - fieldCount;
-            int32_t j;
-            for ( j = 0; j < count; ++j ) {
-                adjustedPtn.append(prevCh);
-            }
-        }
-    }
-}
-
-
-
-void
-DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format,
-                                              const UnicodeString& datePattern,
-                                              UCalendarDateFields field,
-                                              UErrorCode& status) {
-    // following should not set wrong status
-    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
-                                                                        status);
-    if ( U_FAILURE(status) ) {
-        return;
-    }
-    PatternInfo&  timeItvPtnInfo = fIntervalPatterns[itvPtnIndex];
-    if ( !timeItvPtnInfo.firstPart.isEmpty() ) {
-        UnicodeString timeIntervalPattern(timeItvPtnInfo.firstPart);
-        timeIntervalPattern.append(timeItvPtnInfo.secondPart);
-        UnicodeString combinedPattern;
-        SimpleFormatter(format, 2, 2, status).
-                format(timeIntervalPattern, datePattern, combinedPattern, status);
-        if ( U_FAILURE(status) ) {
-            return;
-        }
-        setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
-    }
-    // else: fall back
-    // it should not happen if the interval format defined is valid
-}
-
-
-
-const UChar
-DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
-{
-    /*GyM*/ CAP_G, LOW_Y, CAP_M,
-    /*wWd*/ LOW_W, CAP_W, LOW_D,
-    /*DEF*/ CAP_D, CAP_E, CAP_F,
-    /*ahH*/ LOW_A, LOW_H, CAP_H,
-    /*msS*/ LOW_M, LOW_S, CAP_S, // MINUTE, SECOND, MILLISECOND
-    /*z.Y*/ LOW_Z, SPACE, CAP_Y, // ZONE_OFFSET, DST_OFFSET, YEAR_WOY,
-    /*eug*/ LOW_E, LOW_U, LOW_G, // DOW_LOCAL, EXTENDED_YEAR, JULIAN_DAY,
-    /*A..*/ CAP_A, SPACE, SPACE, // MILLISECONDS_IN_DAY, IS_LEAP_MONTH, FIELD_COUNT
-};
-
-
-
-U_NAMESPACE_END
-
-#endif
+    } 
+    return appendTo; 
+} 
+ 
+ 
+ 
+ 
+UBool  U_EXPORT2 
+DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field, 
+                                          const UnicodeString& skeleton) 
+{ 
+    const UChar fieldChar = fgCalendarFieldToPatternLetter[field]; 
+    return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ; 
+} 
+ 
+ 
+ 
+void  U_EXPORT2 
+DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton, 
+                 const UnicodeString& bestMatchSkeleton, 
+                 const UnicodeString& bestIntervalPattern, 
+                 int8_t differenceInfo, 
+                 UnicodeString& adjustedPtn) { 
+    adjustedPtn = bestIntervalPattern; 
+    int32_t inputSkeletonFieldWidth[] = 
+    { 
+    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O 
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   P   Q   R   S   T   U   V   W   X   Y   Z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0, 
+    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   p   q   r   s   t   u   v   w   x   y   z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 
+    }; 
+ 
+    int32_t bestMatchSkeletonFieldWidth[] = 
+    { 
+    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O 
+             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   P   Q   R   S   T   U   V   W   X   Y   Z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0, 
+    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    //   p   q   r   s   t   u   v   w   x   y   z 
+         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 
+    }; 
+ 
+    DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth); 
+    DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth); 
+    if ( differenceInfo == 2 ) { 
+        adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */), 
+                                   UnicodeString((UChar)0x7a /* z */)); 
+    } 
+ 
+    UBool inQuote = false; 
+    UChar prevCh = 0; 
+    int32_t count = 0; 
+ 
+    const int8_t PATTERN_CHAR_BASE = 0x41; 
+ 
+    // loop through the pattern string character by character 
+    int32_t adjustedPtnLength = adjustedPtn.length(); 
+    int32_t i; 
+    for (i = 0; i < adjustedPtnLength; ++i) { 
+        UChar ch = adjustedPtn.charAt(i); 
+        if (ch != prevCh && count > 0) { 
+            // check the repeativeness of pattern letter 
+            UChar skeletonChar = prevCh; 
+            if ( skeletonChar ==  CAP_L ) { 
+                // there is no "L" (always be "M") in skeleton, 
+                // but there is "L" in pattern. 
+                // for skeleton "M+", the pattern might be "...L..." 
+                skeletonChar = CAP_M; 
+            } 
+            int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 
+            int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 
+            if ( fieldCount == count && inputFieldCount > fieldCount ) { 
+                count = inputFieldCount - fieldCount; 
+                int32_t j; 
+                for ( j = 0; j < count; ++j ) { 
+                    adjustedPtn.insert(i, prevCh); 
+                } 
+                i += count; 
+                adjustedPtnLength += count; 
+            } 
+            count = 0; 
+        } 
+        if (ch == 0x0027 /*'*/) { 
+            // Consecutive single quotes are a single quote literal, 
+            // either outside of quotes or between quotes 
+            if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == 0x0027 /* ' */) { 
+                ++i; 
+            } else { 
+                inQuote = ! inQuote; 
+            } 
+        } 
+        else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 
+                    || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 
+            // ch is a date-time pattern character 
+            prevCh = ch; 
+            ++count; 
+        } 
+    } 
+    if ( count > 0 ) { 
+        // last item 
+        // check the repeativeness of pattern letter 
+        UChar skeletonChar = prevCh; 
+        if ( skeletonChar == CAP_L ) { 
+            // there is no "L" (always be "M") in skeleton, 
+            // but there is "L" in pattern. 
+            // for skeleton "M+", the pattern might be "...L..." 
+            skeletonChar = CAP_M; 
+        } 
+        int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 
+        int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 
+        if ( fieldCount == count && inputFieldCount > fieldCount ) { 
+            count = inputFieldCount - fieldCount; 
+            int32_t j; 
+            for ( j = 0; j < count; ++j ) { 
+                adjustedPtn.append(prevCh); 
+            } 
+        } 
+    } 
+} 
+ 
+ 
+ 
+void 
+DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format, 
+                                              const UnicodeString& datePattern, 
+                                              UCalendarDateFields field, 
+                                              UErrorCode& status) { 
+    // following should not set wrong status 
+    int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 
+                                                                        status); 
+    if ( U_FAILURE(status) ) { 
+        return; 
+    } 
+    PatternInfo&  timeItvPtnInfo = fIntervalPatterns[itvPtnIndex]; 
+    if ( !timeItvPtnInfo.firstPart.isEmpty() ) { 
+        UnicodeString timeIntervalPattern(timeItvPtnInfo.firstPart); 
+        timeIntervalPattern.append(timeItvPtnInfo.secondPart); 
+        UnicodeString combinedPattern; 
+        SimpleFormatter(format, 2, 2, status). 
+                format(timeIntervalPattern, datePattern, combinedPattern, status); 
+        if ( U_FAILURE(status) ) { 
+            return; 
+        } 
+        setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst); 
+    } 
+    // else: fall back 
+    // it should not happen if the interval format defined is valid 
+} 
+ 
+ 
+ 
+const UChar 
+DateIntervalFormat::fgCalendarFieldToPatternLetter[] = 
+{ 
+    /*GyM*/ CAP_G, LOW_Y, CAP_M, 
+    /*wWd*/ LOW_W, CAP_W, LOW_D, 
+    /*DEF*/ CAP_D, CAP_E, CAP_F, 
+    /*ahH*/ LOW_A, LOW_H, CAP_H, 
+    /*msS*/ LOW_M, LOW_S, CAP_S, // MINUTE, SECOND, MILLISECOND 
+    /*z.Y*/ LOW_Z, SPACE, CAP_Y, // ZONE_OFFSET, DST_OFFSET, YEAR_WOY, 
+    /*eug*/ LOW_E, LOW_U, LOW_G, // DOW_LOCAL, EXTENDED_YEAR, JULIAN_DAY, 
+    /*A..*/ CAP_A, SPACE, SPACE, // MILLISECONDS_IN_DAY, IS_LEAP_MONTH, FIELD_COUNT 
+}; 
+ 
+ 
+
+U_NAMESPACE_END 
+ 
+#endif