Home | History | Annotate | Download | only in i18n 
      1 /*******************************************************************************
      2 * Copyright (C) 2008-2010, International Business Machines Corporation and
      3 * others. All Rights Reserved.
      4 *******************************************************************************
      5 *
      6 * File DTITVFMT.CPP
      7 *
      8 *******************************************************************************
      9 */
     10 
     11 #include <typeinfo>  // for 'typeid' to work
     12 
     13 #include "unicode/dtitvfmt.h"
     14 
     15 #if !UCONFIG_NO_FORMATTING
     16 
     17 //TODO: put in compilation
     18 //#define DTITVFMT_DEBUG 1
     19 
     20 #include "cstring.h"
     21 #include "unicode/msgfmt.h"
     22 #include "unicode/dtptngen.h"
     23 #include "unicode/dtitvinf.h"
     24 #include "unicode/calendar.h"
     25 #include "dtitv_impl.h"
     26 
     27 #ifdef DTITVFMT_DEBUG
     28 #include <iostream>
     29 #include "cstring.h"
     30 #endif
     31 
     32 #include "gregoimp.h"
     33 
     34 U_NAMESPACE_BEGIN
     35 
     36 
     37 
     38 #ifdef DTITVFMT_DEBUG
     39 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
     40 #endif
     41 
     42 
     43 static const UChar gDateFormatSkeleton[][11] = {
     44 //yMMMMEEEEd
     45 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0},
     46 //yMMMMd
     47 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0},
     48 //yMMMd
     49 {LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0},
     50 //yMd
     51 {LOW_Y, CAP_M, LOW_D, 0} };
     52 
     53 
     54 static const char gDateTimePatternsTag[]="DateTimePatterns";
     55 
     56 
     57 // latestFirst:
     58 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};
     59 
     60 // earliestFirst:
     61 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};
     62 
     63 
     64 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
     65 
     66 
     67 
     68 DateIntervalFormat* U_EXPORT2
     69 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
     70                                    UErrorCode& status) {
     71     return createInstance(skeleton, Locale::getDefault(), status);
     72 }
     73 
     74 
     75 DateIntervalFormat* U_EXPORT2
     76 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
     77                                    const Locale& locale,
     78                                    UErrorCode& status) {
     79 #ifdef DTITVFMT_DEBUG
     80     char result[1000];
     81     char result_1[1000];
     82     char mesg[2000];
     83     skeleton.extract(0,  skeleton.length(), result, "UTF-8");
     84     UnicodeString pat;
     85     ((SimpleDateFormat*)dtfmt)->toPattern(pat);
     86     pat.extract(0,  pat.length(), result_1, "UTF-8");
     87     sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1);
     88     PRINTMESG(mesg)
     89 #endif
     90 
     91     DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
     92     return create(locale, dtitvinf, &skeleton, status);
     93 }
     94 
     95 
     96 
     97 DateIntervalFormat* U_EXPORT2
     98 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
     99                                    const DateIntervalInfo& dtitvinf,
    100                                    UErrorCode& status) {
    101     return createInstance(skeleton, Locale::getDefault(), dtitvinf, status);
    102 }
    103 
    104 
    105 DateIntervalFormat* U_EXPORT2
    106 DateIntervalFormat::createInstance(const UnicodeString& skeleton,
    107                                    const Locale& locale,
    108                                    const DateIntervalInfo& dtitvinf,
    109                                    UErrorCode& status) {
    110     DateIntervalInfo* ptn = dtitvinf.clone();
    111     return create(locale, ptn, &skeleton, status);
    112 }
    113 
    114 
    115 DateIntervalFormat::DateIntervalFormat()
    116 :   fInfo(NULL),
    117     fDateFormat(NULL),
    118     fFromCalendar(NULL),
    119     fToCalendar(NULL),
    120     fDtpng(NULL)
    121 {}
    122 
    123 
    124 DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
    125 :   Format(itvfmt),
    126     fInfo(NULL),
    127     fDateFormat(NULL),
    128     fFromCalendar(NULL),
    129     fToCalendar(NULL),
    130     fDtpng(NULL) {
    131     *this = itvfmt;
    132 }
    133 
    134 
    135 DateIntervalFormat&
    136 DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
    137     if ( this != &itvfmt ) {
    138         delete fDateFormat;
    139         delete fInfo;
    140         delete fFromCalendar;
    141         delete fToCalendar;
    142         delete fDtpng;
    143         if ( itvfmt.fDateFormat ) {
    144             fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone();
    145         } else {
    146             fDateFormat = NULL;
    147         }
    148         if ( itvfmt.fInfo ) {
    149             fInfo = itvfmt.fInfo->clone();
    150         } else {
    151             fInfo = NULL;
    152         }
    153         if ( itvfmt.fFromCalendar ) {
    154             fFromCalendar = itvfmt.fFromCalendar->clone();
    155         } else {
    156             fFromCalendar = NULL;
    157         }
    158         if ( itvfmt.fToCalendar ) {
    159             fToCalendar = itvfmt.fToCalendar->clone();
    160         } else {
    161             fToCalendar = NULL;
    162         }
    163         fSkeleton = itvfmt.fSkeleton;
    164         int8_t i;
    165         for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
    166             fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i];
    167         }
    168         if (itvfmt.fDtpng) {
    169             fDtpng = itvfmt.fDtpng->clone();
    170         }
    171     }
    172     return *this;
    173 }
    174 
    175 
    176 DateIntervalFormat::~DateIntervalFormat() {
    177     delete fInfo;
    178     delete fDateFormat;
    179     delete fFromCalendar;
    180     delete fToCalendar;
    181     delete fDtpng;
    182 }
    183 
    184 
    185 Format*
    186 DateIntervalFormat::clone(void) const {
    187     return new DateIntervalFormat(*this);
    188 }
    189 
    190 
    191 UBool
    192 DateIntervalFormat::operator==(const Format& other) const {
    193     if (typeid(*this) == typeid(other)) {
    194         const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
    195 #ifdef DTITVFMT_DEBUG
    196     UBool equal;
    197     equal = (this == fmt);
    198 
    199     equal = (*fInfo == *fmt->fInfo);
    200     equal = (*fDateFormat == *fmt->fDateFormat);
    201     equal = fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) ;
    202     equal = fToCalendar->isEquivalentTo(*fmt->fToCalendar) ;
    203     equal = (fSkeleton == fmt->fSkeleton);
    204 #endif
    205         UBool res;
    206         res =  ( this == fmt ) ||
    207                ( Format::operator==(other) &&
    208                  fInfo &&
    209                  ( *fInfo == *fmt->fInfo ) &&
    210                  fDateFormat &&
    211                  ( *fDateFormat == *fmt->fDateFormat ) &&
    212                  fFromCalendar &&
    213                  fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) &&
    214                  fToCalendar &&
    215                  fToCalendar->isEquivalentTo(*fmt->fToCalendar) &&
    216                  fSkeleton == fmt->fSkeleton &&
    217                  fDtpng &&
    218                  (*fDtpng == *fmt->fDtpng) );
    219         int8_t i;
    220         for (i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX && res == TRUE; ++i ) {
    221             res =   ( fIntervalPatterns[i].firstPart ==
    222                       fmt->fIntervalPatterns[i].firstPart) &&
    223                     ( fIntervalPatterns[i].secondPart ==
    224                       fmt->fIntervalPatterns[i].secondPart ) &&
    225                     ( fIntervalPatterns[i].laterDateFirst ==
    226                       fmt->fIntervalPatterns[i].laterDateFirst) ;
    227         }
    228         return res;
    229     }
    230     return FALSE;
    231 }
    232 
    233 
    234 
    235 UnicodeString&
    236 DateIntervalFormat::format(const Formattable& obj,
    237                            UnicodeString& appendTo,
    238                            FieldPosition& fieldPosition,
    239                            UErrorCode& status) const {
    240     if ( U_FAILURE(status) ) {
    241         return appendTo;
    242     }
    243 
    244     if ( obj.getType() == Formattable::kObject ) {
    245         const UObject* formatObj = obj.getObject();
    246         const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj);
    247         if (interval != NULL){
    248             return format(interval, appendTo, fieldPosition, status);
    249         }
    250     }
    251     status = U_ILLEGAL_ARGUMENT_ERROR;
    252     return appendTo;
    253 }
    254 
    255 
    256 UnicodeString&
    257 DateIntervalFormat::format(const DateInterval* dtInterval,
    258                            UnicodeString& appendTo,
    259                            FieldPosition& fieldPosition,
    260                            UErrorCode& status) const {
    261     if ( U_FAILURE(status) ) {
    262         return appendTo;
    263     }
    264 
    265     if ( fFromCalendar != NULL && fToCalendar != NULL &&
    266          fDateFormat != NULL && fInfo != NULL ) {
    267         fFromCalendar->setTime(dtInterval->getFromDate(), status);
    268         fToCalendar->setTime(dtInterval->getToDate(), status);
    269         if ( U_SUCCESS(status) ) {
    270             return format(*fFromCalendar, *fToCalendar, appendTo,fieldPosition, status);
    271         }
    272     }
    273     return appendTo;
    274 }
    275 
    276 
    277 UnicodeString&
    278 DateIntervalFormat::format(Calendar& fromCalendar,
    279                            Calendar& toCalendar,
    280                            UnicodeString& appendTo,
    281                            FieldPosition& pos,
    282                            UErrorCode& status) const {
    283     if ( U_FAILURE(status) ) {
    284         return appendTo;
    285     }
    286 
    287     // not support different calendar types and time zones
    288     //if ( fromCalendar.getType() != toCalendar.getType() ) {
    289     if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
    290         status = U_ILLEGAL_ARGUMENT_ERROR;
    291         return appendTo;
    292     }
    293 
    294     // First, find the largest different calendar field.
    295     UCalendarDateFields field = UCAL_FIELD_COUNT;
    296 
    297     if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
    298         field = UCAL_ERA;
    299     } else if ( fromCalendar.get(UCAL_YEAR, status) !=
    300                 toCalendar.get(UCAL_YEAR, status) ) {
    301         field = UCAL_YEAR;
    302     } else if ( fromCalendar.get(UCAL_MONTH, status) !=
    303                 toCalendar.get(UCAL_MONTH, status) ) {
    304         field = UCAL_MONTH;
    305     } else if ( fromCalendar.get(UCAL_DATE, status) !=
    306                 toCalendar.get(UCAL_DATE, status) ) {
    307         field = UCAL_DATE;
    308     } else if ( fromCalendar.get(UCAL_AM_PM, status) !=
    309                 toCalendar.get(UCAL_AM_PM, status) ) {
    310         field = UCAL_AM_PM;
    311     } else if ( fromCalendar.get(UCAL_HOUR, status) !=
    312                 toCalendar.get(UCAL_HOUR, status) ) {
    313         field = UCAL_HOUR;
    314     } else if ( fromCalendar.get(UCAL_MINUTE, status) !=
    315                 toCalendar.get(UCAL_MINUTE, status) ) {
    316         field = UCAL_MINUTE;
    317     }
    318 
    319     if ( U_FAILURE(status) ) {
    320         return appendTo;
    321     }
    322     if ( field == UCAL_FIELD_COUNT ) {
    323         /* ignore the second/millisecond etc. small fields' difference.
    324          * use single date when all the above are the same.
    325          */
    326         return fDateFormat->format(fromCalendar, appendTo, pos);
    327     }
    328 
    329     // following call should not set wrong status,
    330     // all the pass-in fields are valid till here
    331     int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
    332                                                                         status);
    333     const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex];
    334 
    335     if ( intervalPattern.firstPart.isEmpty() &&
    336          intervalPattern.secondPart.isEmpty() ) {
    337         if ( fDateFormat->isFieldUnitIgnored(field) ) {
    338             /* the largest different calendar field is small than
    339              * the smallest calendar field in pattern,
    340              * return single date format.
    341              */
    342             return fDateFormat->format(fromCalendar, appendTo, pos);
    343         }
    344         return fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
    345     }
    346     // If the first part in interval pattern is empty,
    347     // the 2nd part of it saves the full-pattern used in fall-back.
    348     // For a 'real' interval pattern, the first part will never be empty.
    349     if ( intervalPattern.firstPart.isEmpty() ) {
    350         // fall back
    351         UnicodeString originalPattern;
    352         fDateFormat->toPattern(originalPattern);
    353         fDateFormat->applyPattern(intervalPattern.secondPart);
    354         appendTo = fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
    355         fDateFormat->applyPattern(originalPattern);
    356         return appendTo;
    357     }
    358     Calendar* firstCal;
    359     Calendar* secondCal;
    360     if ( intervalPattern.laterDateFirst ) {
    361         firstCal = &toCalendar;
    362         secondCal = &fromCalendar;
    363     } else {
    364         firstCal = &fromCalendar;
    365         secondCal = &toCalendar;
    366     }
    367     // break the interval pattern into 2 parts,
    368     // first part should not be empty,
    369     UnicodeString originalPattern;
    370     fDateFormat->toPattern(originalPattern);
    371     fDateFormat->applyPattern(intervalPattern.firstPart);
    372     fDateFormat->format(*firstCal, appendTo, pos);
    373     if ( !intervalPattern.secondPart.isEmpty() ) {
    374         fDateFormat->applyPattern(intervalPattern.secondPart);
    375         fDateFormat->format(*secondCal, appendTo, pos);
    376     }
    377     fDateFormat->applyPattern(originalPattern);
    378     return appendTo;
    379 }
    380 
    381 
    382 
    383 void
    384 DateIntervalFormat::parseObject(const UnicodeString& /* source */,
    385                                 Formattable& /* result */,
    386                                 ParsePosition& /* parse_pos */) const {
    387     // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
    388     // will set status as U_INVALID_FORMAT_ERROR if
    389     // parse_pos is still 0
    390 }
    391 
    392 
    393 
    394 
    395 const DateIntervalInfo*
    396 DateIntervalFormat::getDateIntervalInfo() const {
    397     return fInfo;
    398 }
    399 
    400 
    401 void
    402 DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
    403                                         UErrorCode& status) {
    404     delete fInfo;
    405     fInfo = new DateIntervalInfo(newItvPattern);
    406     if ( fDateFormat ) {
    407         initializePattern(status);
    408     }
    409 }
    410 
    411 
    412 
    413 const DateFormat*
    414 DateIntervalFormat::getDateFormat() const {
    415     return fDateFormat;
    416 }
    417 
    418 
    419 DateIntervalFormat::DateIntervalFormat(const Locale& locale,
    420                                        DateIntervalInfo* dtItvInfo,
    421                                        const UnicodeString* skeleton,
    422                                        UErrorCode& status)
    423 :   fInfo(NULL),
    424     fDateFormat(NULL),
    425     fFromCalendar(NULL),
    426     fToCalendar(NULL),
    427     fDtpng(NULL)
    428 {
    429     if ( U_FAILURE(status) ) {
    430         delete dtItvInfo;
    431         return;
    432     }
    433     fDtpng = DateTimePatternGenerator::createInstance(locale, status);
    434     SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale,
    435                                                     fDtpng, status);
    436     if ( U_FAILURE(status) ) {
    437         delete dtItvInfo;
    438         delete fDtpng;
    439         delete dtfmt;
    440         return;
    441     }
    442     if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) {
    443         status = U_MEMORY_ALLOCATION_ERROR;
    444         // safe to delete NULL
    445         delete dtfmt;
    446         delete dtItvInfo;
    447         delete fDtpng;
    448         return;
    449     }
    450     if ( skeleton ) {
    451         fSkeleton = *skeleton;
    452     }
    453     fInfo = dtItvInfo;
    454     fDateFormat = dtfmt;
    455     if ( dtfmt->getCalendar() ) {
    456         fFromCalendar = dtfmt->getCalendar()->clone();
    457         fToCalendar = dtfmt->getCalendar()->clone();
    458     } else {
    459         fFromCalendar = NULL;
    460         fToCalendar = NULL;
    461     }
    462     initializePattern(status);
    463 }
    464 
    465 
    466 SimpleDateFormat* U_EXPORT2
    467 DateIntervalFormat::createSDFPatternInstance(const UnicodeString& skeleton,
    468                                              const Locale& locale,
    469                                              DateTimePatternGenerator* dtpng,
    470                                              UErrorCode& status)
    471 {
    472     if ( U_FAILURE(status) ) {
    473         return NULL;
    474     }
    475 
    476     const UnicodeString pattern = dtpng->getBestPattern(skeleton, status);
    477     if ( U_FAILURE(status) ) {
    478         return NULL;
    479     }
    480     SimpleDateFormat* dtfmt = new SimpleDateFormat(pattern, locale, status);
    481     if ( U_FAILURE(status) ) {
    482         delete dtfmt;
    483         return NULL;
    484     }
    485     return dtfmt;
    486 }
    487 
    488 
    489 DateIntervalFormat* U_EXPORT2
    490 DateIntervalFormat::create(const Locale& locale,
    491                            DateIntervalInfo* dtitvinf,
    492                            const UnicodeString* skeleton,
    493                            UErrorCode& status) {
    494     DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
    495                                                    skeleton, status);
    496     if ( f == NULL ) {
    497         status = U_MEMORY_ALLOCATION_ERROR;
    498         delete dtitvinf;
    499     } else if ( U_FAILURE(status) ) {
    500         // safe to delete f, although nothing acutally is saved
    501         delete f;
    502         f = 0;
    503     }
    504     return f;
    505 }
    506 
    507 
    508 
    509 /**
    510  * Initialize interval patterns locale to this formatter
    511  *
    512  * This code is a bit complicated since
    513  * 1. the interval patterns saved in resource bundle files are interval
    514  *    patterns based on date or time only.
    515  *    It does not have interval patterns based on both date and time.
    516  *    Interval patterns on both date and time are algorithm generated.
    517  *
    518  *    For example, it has interval patterns on skeleton "dMy" and "hm",
    519  *    but it does not have interval patterns on skeleton "dMyhm".
    520  *
    521  *    The rule to genearte interval patterns for both date and time skeleton are
    522  *    1) when the year, month, or day differs, concatenate the two original
    523  *    expressions with a separator between,
    524  *    For example, interval pattern from "Jan 10, 2007 10:10 am"
    525  *    to "Jan 11, 2007 10:10am" is
    526  *    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
    527  *
    528  *    2) otherwise, present the date followed by the range expression
    529  *    for the time.
    530  *    For example, interval pattern from "Jan 10, 2007 10:10 am"
    531  *    to "Jan 10, 2007 11:10am" is
    532  *    "Jan 10, 2007 10:10 am - 11:10am"
    533  *
    534  * 2. even a pattern does not request a certion calendar field,
    535  *    the interval pattern needs to include such field if such fields are
    536  *    different between 2 dates.
    537  *    For example, a pattern/skeleton is "hm", but the interval pattern
    538  *    includes year, month, and date when year, month, and date differs.
    539  *
    540  * @param status          output param set to success/failure code on exit
    541  * @stable ICU 4.0
    542  */
    543 void
    544 DateIntervalFormat::initializePattern(UErrorCode& status) {
    545     if ( U_FAILURE(status) ) {
    546         return;
    547     }
    548     const Locale& locale = fDateFormat->getSmpFmtLocale();
    549     if ( fSkeleton.isEmpty() ) {
    550         UnicodeString fullPattern;
    551         fDateFormat->toPattern(fullPattern);
    552 #ifdef DTITVFMT_DEBUG
    553     char result[1000];
    554     char result_1[1000];
    555     char mesg[2000];
    556     fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
    557     sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
    558     PRINTMESG(mesg)
    559 #endif
    560         // fSkeleton is already set by createDateIntervalInstance()
    561         // or by createInstance(UnicodeString skeleton, .... )
    562         fSkeleton = fDtpng->getSkeleton(fullPattern, status);
    563         if ( U_FAILURE(status) ) {
    564             return;
    565         }
    566     }
    567 
    568     // initialize the fIntervalPattern ordering
    569     int8_t i;
    570     for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
    571         fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder();
    572     }
    573 
    574     /* Check whether the skeleton is a combination of date and time.
    575      * For the complication reason 1 explained above.
    576      */
    577     UnicodeString dateSkeleton;
    578     UnicodeString timeSkeleton;
    579     UnicodeString normalizedTimeSkeleton;
    580     UnicodeString normalizedDateSkeleton;
    581 
    582 
    583     /* the difference between time skeleton and normalizedTimeSkeleton are:
    584      * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
    585      * 2. 'a' is omitted in normalized time skeleton.
    586      * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized
    587      *    time skeleton
    588      *
    589      * The difference between date skeleton and normalizedDateSkeleton are:
    590      * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton
    591      * 2. 'E' and 'EE' are normalized into 'EEE'
    592      * 3. 'MM' is normalized into 'M'
    593      */
    594     getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton,
    595                         timeSkeleton, normalizedTimeSkeleton);
    596 
    597 #ifdef DTITVFMT_DEBUG
    598     char result[1000];
    599     char result_1[1000];
    600     char mesg[2000];
    601     fSkeleton.extract(0,  fSkeleton.length(), result, "UTF-8");
    602     sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
    603     PRINTMESG(mesg)
    604 #endif
    605 
    606 
    607     UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
    608                                          normalizedTimeSkeleton);
    609 
    610     if ( found == false ) {
    611         // use fallback
    612         // TODO: if user asks "m"(minute), but "d"(day) differ
    613         if ( timeSkeleton.length() != 0 ) {
    614             if ( dateSkeleton.length() == 0 ) {
    615                 // prefix with yMd
    616                 timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort]);
    617                 UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status);
    618                 if ( U_FAILURE(status) ) {
    619                     return;
    620                 }
    621                 // for fall back interval patterns,
    622                 // the first part of the pattern is empty,
    623                 // the second part of the pattern is the full-pattern
    624                 // should be used in fall-back.
    625                 setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder());
    626                 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
    627                 setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder());
    628             } else {
    629                 // TODO: fall back
    630             }
    631         } else {
    632             // TODO: fall back
    633         }
    634         return;
    635     } // end of skeleton not found
    636     // interval patterns for skeleton are found in resource
    637     if ( timeSkeleton.length() == 0 ) {
    638         // done
    639     } else if ( dateSkeleton.length() == 0 ) {
    640         // prefix with yMd
    641         timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort]);
    642         UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status);
    643         if ( U_FAILURE(status) ) {
    644             return;
    645         }
    646         // for fall back interval patterns,
    647         // the first part of the pattern is empty,
    648         // the second part of the pattern is the full-pattern
    649         // should be used in fall-back.
    650         setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder());
    651         setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
    652         setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder());
    653     } else {
    654         /* if both present,
    655          * 1) when the year, month, or day differs,
    656          * concatenate the two original expressions with a separator between,
    657          * 2) otherwise, present the date followed by the
    658          * range expression for the time.
    659          */
    660         /*
    661          * 1) when the year, month, or day differs,
    662          * concatenate the two original expressions with a separator between,
    663          */
    664         // if field exists, use fall back
    665         UnicodeString skeleton = fSkeleton;
    666         if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) {
    667             // prefix skeleton with 'd'
    668             skeleton.insert(0, LOW_D);
    669             setFallbackPattern(UCAL_DATE, skeleton, status);
    670         }
    671         if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
    672             // then prefix skeleton with 'M'
    673             skeleton.insert(0, CAP_M);
    674             setFallbackPattern(UCAL_MONTH, skeleton, status);
    675         }
    676         if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
    677             // then prefix skeleton with 'y'
    678             skeleton.insert(0, LOW_Y);
    679             setFallbackPattern(UCAL_YEAR, skeleton, status);
    680         }
    681 
    682         /*
    683          * 2) otherwise, present the date followed by the
    684          * range expression for the time.
    685          */
    686         // Need the Date/Time pattern for concatnation the date with
    687         // the time interval.
    688         // The date/time pattern ( such as {0} {1} ) is saved in
    689         // calendar, that is why need to get the CalendarData here.
    690         CalendarData* calData = new CalendarData(locale, NULL, status);
    691 
    692         if ( U_FAILURE(status) ) {
    693             delete calData;
    694             return;
    695         }
    696 
    697         if ( calData == NULL ) {
    698             status = U_MEMORY_ALLOCATION_ERROR;
    699             return;
    700         }
    701 
    702         const UResourceBundle* dateTimePatternsRes = calData->getByKey(
    703                                            gDateTimePatternsTag, status);
    704         int32_t dateTimeFormatLength;
    705         const UChar* dateTimeFormat = ures_getStringByIndex(
    706                                             dateTimePatternsRes,
    707                                             (int32_t)DateFormat::kDateTime,
    708                                             &dateTimeFormatLength, &status);
    709         if ( U_FAILURE(status) ) {
    710             return;
    711         }
    712 
    713         UnicodeString datePattern = fDtpng->getBestPattern(dateSkeleton, status);
    714 
    715         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
    716                                       datePattern, UCAL_AM_PM, status);
    717         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
    718                                       datePattern, UCAL_HOUR, status);
    719         concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
    720                                       datePattern, UCAL_MINUTE, status);
    721         delete calData;
    722     }
    723 }
    724 
    725 
    726 
    727 void  U_EXPORT2
    728 DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
    729                                         UnicodeString& dateSkeleton,
    730                                         UnicodeString& normalizedDateSkeleton,
    731                                         UnicodeString& timeSkeleton,
    732                                         UnicodeString& normalizedTimeSkeleton) {
    733     // dateSkeleton follows the sequence of y*M*E*d*
    734     // timeSkeleton follows the sequence of hm*[v|z]?
    735     int32_t ECount = 0;
    736     int32_t dCount = 0;
    737     int32_t MCount = 0;
    738     int32_t yCount = 0;
    739     int32_t hCount = 0;
    740     int32_t HCount = 0;
    741     int32_t mCount = 0;
    742     int32_t vCount = 0;
    743     int32_t zCount = 0;
    744     int32_t i;
    745 
    746     for (i = 0; i < skeleton.length(); ++i) {
    747         UChar ch = skeleton[i];
    748         switch ( ch ) {
    749           case CAP_E:
    750             dateSkeleton.append(ch);
    751             ++ECount;
    752             break;
    753           case LOW_D:
    754             dateSkeleton.append(ch);
    755             ++dCount;
    756             break;
    757           case CAP_M:
    758             dateSkeleton.append(ch);
    759             ++MCount;
    760             break;
    761           case LOW_Y:
    762             dateSkeleton.append(ch);
    763             ++yCount;
    764             break;
    765           case CAP_G:
    766           case CAP_Y:
    767           case LOW_U:
    768           case CAP_Q:
    769           case LOW_Q:
    770           case CAP_L:
    771           case LOW_L:
    772           case CAP_W:
    773           case LOW_W:
    774           case CAP_D:
    775           case CAP_F:
    776           case LOW_G:
    777           case LOW_E:
    778           case LOW_C:
    779             normalizedDateSkeleton.append(ch);
    780             dateSkeleton.append(ch);
    781             break;
    782           case LOW_A:
    783             // 'a' is implicitly handled
    784             timeSkeleton.append(ch);
    785             break;
    786           case LOW_H:
    787             timeSkeleton.append(ch);
    788             ++hCount;
    789             break;
    790           case CAP_H:
    791             timeSkeleton.append(ch);
    792             ++HCount;
    793             break;
    794           case LOW_M:
    795             timeSkeleton.append(ch);
    796             ++mCount;
    797             break;
    798           case LOW_Z:
    799             ++zCount;
    800             timeSkeleton.append(ch);
    801             break;
    802           case LOW_V:
    803             ++vCount;
    804             timeSkeleton.append(ch);
    805             break;
    806           case CAP_V:
    807           case CAP_Z:
    808           case LOW_K:
    809           case CAP_K:
    810           case LOW_J:
    811           case LOW_S:
    812           case CAP_S:
    813           case CAP_A:
    814             timeSkeleton.append(ch);
    815             normalizedTimeSkeleton.append(ch);
    816             break;
    817         }
    818     }
    819 
    820     /* generate normalized form for date*/
    821     if ( yCount != 0 ) {
    822         normalizedDateSkeleton.append(LOW_Y);
    823     }
    824     if ( MCount != 0 ) {
    825         if ( MCount < 3 ) {
    826             normalizedDateSkeleton.append(CAP_M);
    827         } else {
    828             int32_t i;
    829             for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) {
    830                  normalizedDateSkeleton.append(CAP_M);
    831             }
    832         }
    833     }
    834     if ( ECount != 0 ) {
    835         if ( ECount <= 3 ) {
    836             normalizedDateSkeleton.append(CAP_E);
    837         } else {
    838             int32_t i;
    839             for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) {
    840                  normalizedDateSkeleton.append(CAP_E);
    841             }
    842         }
    843     }
    844     if ( dCount != 0 ) {
    845         normalizedDateSkeleton.append(LOW_D);
    846     }
    847 
    848     /* generate normalized form for time */
    849     if ( HCount != 0 ) {
    850         normalizedTimeSkeleton.append(CAP_H);
    851     }
    852     else if ( hCount != 0 ) {
    853         normalizedTimeSkeleton.append(LOW_H);
    854     }
    855     if ( mCount != 0 ) {
    856         normalizedTimeSkeleton.append(LOW_M);
    857     }
    858     if ( zCount != 0 ) {
    859         normalizedTimeSkeleton.append(LOW_Z);
    860     }
    861     if ( vCount != 0 ) {
    862         normalizedTimeSkeleton.append(LOW_V);
    863     }
    864 }
    865 
    866 
    867 /**
    868  * Generate date or time interval pattern from resource,
    869  * and set them into the interval pattern locale to this formatter.
    870  *
    871  * It needs to handle the following:
    872  * 1. need to adjust field width.
    873  *    For example, the interval patterns saved in DateIntervalInfo
    874  *    includes "dMMMy", but not "dMMMMy".
    875  *    Need to get interval patterns for dMMMMy from dMMMy.
    876  *    Another example, the interval patterns saved in DateIntervalInfo
    877  *    includes "hmv", but not "hmz".
    878  *    Need to get interval patterns for "hmz' from 'hmv'
    879  *
    880  * 2. there might be no pattern for 'y' differ for skeleton "Md",
    881  *    in order to get interval patterns for 'y' differ,
    882  *    need to look for it from skeleton 'yMd'
    883  *
    884  * @param dateSkeleton   normalized date skeleton
    885  * @param timeSkeleton   normalized time skeleton
    886  * @return               whether the resource is found for the skeleton.
    887  *                       TRUE if interval pattern found for the skeleton,
    888  *                       FALSE otherwise.
    889  * @stable ICU 4.0
    890  */
    891 UBool
    892 DateIntervalFormat::setSeparateDateTimePtn(
    893                                  const UnicodeString& dateSkeleton,
    894                                  const UnicodeString& timeSkeleton) {
    895     const UnicodeString* skeleton;
    896     // if both date and time skeleton present,
    897     // the final interval pattern might include time interval patterns
    898     // ( when, am_pm, hour, minute differ ),
    899     // but not date interval patterns ( when year, month, day differ ).
    900     // For year/month/day differ, it falls back to fall-back pattern.
    901     if ( timeSkeleton.length() != 0  ) {
    902         skeleton = &timeSkeleton;
    903     } else {
    904         skeleton = &dateSkeleton;
    905     }
    906 
    907     /* interval patterns for skeleton "dMMMy" (but not "dMMMMy")
    908      * are defined in resource,
    909      * interval patterns for skeleton "dMMMMy" are calculated by
    910      * 1. get the best match skeleton for "dMMMMy", which is "dMMMy"
    911      * 2. get the interval patterns for "dMMMy",
    912      * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy"
    913      * getBestSkeleton() is step 1.
    914      */
    915     // best skeleton, and the difference information
    916     int8_t differenceInfo = 0;
    917     const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
    918                                                                differenceInfo);
    919     /* best skeleton could be NULL.
    920        For example: in "ca" resource file,
    921        interval format is defined as following
    922            intervalFormats{
    923                 fallback{"{0} - {1}"}
    924             }
    925        there is no skeletons/interval patterns defined,
    926        and the best skeleton match could be NULL
    927      */
    928     if ( bestSkeleton == NULL ) {
    929         return false;
    930     }
    931 
    932     // difference:
    933     // 0 means the best matched skeleton is the same as input skeleton
    934     // 1 means the fields are the same, but field width are different
    935     // 2 means the only difference between fields are v/z,
    936     // -1 means there are other fields difference
    937     if ( differenceInfo == -1 ) {
    938         // skeleton has different fields, not only  v/z difference
    939         return false;
    940     }
    941 
    942     if ( timeSkeleton.length() == 0 ) {
    943         UnicodeString extendedSkeleton;
    944         UnicodeString extendedBestSkeleton;
    945         // only has date skeleton
    946         setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
    947                            &extendedSkeleton, &extendedBestSkeleton);
    948 
    949         UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
    950                                      differenceInfo,
    951                                      &extendedSkeleton, &extendedBestSkeleton);
    952 
    953         if ( extended ) {
    954             bestSkeleton = &extendedBestSkeleton;
    955             skeleton = &extendedSkeleton;
    956         }
    957         setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo,
    958                            &extendedSkeleton, &extendedBestSkeleton);
    959     } else {
    960         setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
    961         setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
    962         setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo);
    963     }
    964     return true;
    965 }
    966 
    967 
    968 
    969 void
    970 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
    971                                        const UnicodeString& skeleton,
    972                                        UErrorCode& status) {
    973     if ( U_FAILURE(status) ) {
    974         return;
    975     }
    976     UnicodeString pattern = fDtpng->getBestPattern(skeleton, status);
    977     if ( U_FAILURE(status) ) {
    978         return;
    979     }
    980     setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder());
    981 }
    982 
    983 
    984 
    985 
    986 void
    987 DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
    988                                    const UnicodeString* firstPart,
    989                                    const UnicodeString* secondPart,
    990                                    UBool laterDateFirst) {
    991     // for fall back interval patterns,
    992     // the first part of the pattern is empty,
    993     // the second part of the pattern is the full-pattern
    994     // should be used in fall-back.
    995     UErrorCode status = U_ZERO_ERROR;
    996     // following should not set any wrong status.
    997     int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
    998                                                                         status);
    999     if ( U_FAILURE(status) ) {
   1000         return;
   1001     }
   1002     PatternInfo& ptn = fIntervalPatterns[itvPtnIndex];
   1003     if ( firstPart ) {
   1004         ptn.firstPart = *firstPart;
   1005     }
   1006     if ( secondPart ) {
   1007         ptn.secondPart = *secondPart;
   1008     }
   1009     ptn.laterDateFirst = laterDateFirst;
   1010 }
   1011 
   1012 void
   1013 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
   1014                                        const UnicodeString& intervalPattern) {
   1015     UBool order = fInfo->getDefaultOrder();
   1016     setIntervalPattern(field, intervalPattern, order);
   1017 }
   1018 
   1019 
   1020 void
   1021 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
   1022                                        const UnicodeString& intervalPattern,
   1023                                        UBool laterDateFirst) {
   1024     const UnicodeString* pattern = &intervalPattern;
   1025     UBool order = laterDateFirst;
   1026     // check for "latestFirst:" or "earliestFirst:" prefix
   1027     int8_t prefixLength = sizeof(gLaterFirstPrefix)/sizeof(gLaterFirstPrefix[0]);
   1028     int8_t earliestFirstLength = sizeof(gEarlierFirstPrefix)/sizeof(gEarlierFirstPrefix[0]);
   1029     UnicodeString realPattern;
   1030     if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
   1031         order = true;
   1032         intervalPattern.extract(prefixLength,
   1033                                 intervalPattern.length() - prefixLength,
   1034                                 realPattern);
   1035         pattern = &realPattern;
   1036     } else if ( intervalPattern.startsWith(gEarlierFirstPrefix,
   1037                                            earliestFirstLength) ) {
   1038         order = false;
   1039         intervalPattern.extract(earliestFirstLength,
   1040                                 intervalPattern.length() - earliestFirstLength,
   1041                                 realPattern);
   1042         pattern = &realPattern;
   1043     }
   1044 
   1045     int32_t splitPoint = splitPatternInto2Part(*pattern);
   1046 
   1047     UnicodeString firstPart;
   1048     UnicodeString secondPart;
   1049     pattern->extract(0, splitPoint, firstPart);
   1050     if ( splitPoint < pattern->length() ) {
   1051         pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart);
   1052     }
   1053     setPatternInfo(field, &firstPart, &secondPart, order);
   1054 }
   1055 
   1056 
   1057 
   1058 
   1059 /**
   1060  * Generate interval pattern from existing resource
   1061  *
   1062  * It not only save the interval patterns,
   1063  * but also return the extended skeleton and its best match skeleton.
   1064  *
   1065  * @param field           largest different calendar field
   1066  * @param skeleton        skeleton
   1067  * @param bestSkeleton    the best match skeleton which has interval pattern
   1068  *                        defined in resource
   1069  * @param differenceInfo  the difference between skeleton and best skeleton
   1070  *         0 means the best matched skeleton is the same as input skeleton
   1071  *         1 means the fields are the same, but field width are different
   1072  *         2 means the only difference between fields are v/z,
   1073  *        -1 means there are other fields difference
   1074  *
   1075  * @param extendedSkeleton      extended skeleton
   1076  * @param extendedBestSkeleton  extended best match skeleton
   1077  * @return                      whether the interval pattern is found
   1078  *                              through extending skeleton or not.
   1079  *                              TRUE if interval pattern is found by
   1080  *                              extending skeleton, FALSE otherwise.
   1081  * @stable ICU 4.0
   1082  */
   1083 UBool
   1084 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
   1085                                        const UnicodeString* skeleton,
   1086                                        const UnicodeString* bestSkeleton,
   1087                                        int8_t differenceInfo,
   1088                                        UnicodeString* extendedSkeleton,
   1089                                        UnicodeString* extendedBestSkeleton) {
   1090     UErrorCode status = U_ZERO_ERROR;
   1091     // following getIntervalPattern() should not generate error status
   1092     UnicodeString pattern;
   1093     fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status);
   1094     if ( pattern.isEmpty() ) {
   1095         // single date
   1096         if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) {
   1097             // do nothing, format will handle it
   1098             return false;
   1099         }
   1100 
   1101         // for 24 hour system, interval patterns in resource file
   1102         // might not include pattern when am_pm differ,
   1103         // which should be the same as hour differ.
   1104         // add it here for simplicity
   1105         if ( field == UCAL_AM_PM ) {
   1106             fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status);
   1107             if ( !pattern.isEmpty() ) {
   1108                 setIntervalPattern(field, pattern);
   1109             }
   1110             return false;
   1111         }
   1112         // else, looking for pattern when 'y' differ for 'dMMMM' skeleton,
   1113         // first, get best match pattern "MMMd",
   1114         // since there is no pattern for 'y' differs for skeleton 'MMMd',
   1115         // need to look for it from skeleton 'yMMMd',
   1116         // if found, adjust field width in interval pattern from
   1117         // "MMM" to "MMMM".
   1118         UChar fieldLetter = fgCalendarFieldToPatternLetter[field];
   1119         if ( extendedSkeleton ) {
   1120             *extendedSkeleton = *skeleton;
   1121             *extendedBestSkeleton = *bestSkeleton;
   1122             extendedSkeleton->insert(0, fieldLetter);
   1123             extendedBestSkeleton->insert(0, fieldLetter);
   1124             // for example, looking for patterns when 'y' differ for
   1125             // skeleton "MMMM".
   1126             fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status);
   1127             if ( pattern.isEmpty() && differenceInfo == 0 ) {
   1128                 // if there is no skeleton "yMMMM" defined,
   1129                 // look for the best match skeleton, for example: "yMMM"
   1130                 const UnicodeString* tmpBest = fInfo->getBestSkeleton(
   1131                                         *extendedBestSkeleton, differenceInfo);
   1132                 if ( tmpBest != 0 && differenceInfo != -1 ) {
   1133                     fInfo->getIntervalPattern(*tmpBest, field, pattern, status);
   1134                     bestSkeleton = tmpBest;
   1135                 }
   1136             }
   1137         }
   1138     }
   1139     if ( !pattern.isEmpty() ) {
   1140         if ( differenceInfo != 0 ) {
   1141             UnicodeString adjustIntervalPattern;
   1142             adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
   1143                               adjustIntervalPattern);
   1144             setIntervalPattern(field, adjustIntervalPattern);
   1145         } else {
   1146             setIntervalPattern(field, pattern);
   1147         }
   1148         if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) {
   1149             return TRUE;
   1150         }
   1151     }
   1152     return FALSE;
   1153 }
   1154 
   1155 
   1156 
   1157 int32_t  U_EXPORT2
   1158 DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
   1159     UBool inQuote = false;
   1160     UChar prevCh = 0;
   1161     int32_t count = 0;
   1162 
   1163     /* repeatedPattern used to record whether a pattern has already seen.
   1164        It is a pattern applies to first calendar if it is first time seen,
   1165        otherwise, it is a pattern applies to the second calendar
   1166      */
   1167     UBool patternRepeated[] =
   1168     {
   1169     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
   1170              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1171     //   P   Q   R   S   T   U   V   W   X   Y   Z
   1172          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
   1173     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
   1174          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1175     //   p   q   r   s   t   u   v   w   x   y   z
   1176          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
   1177     };
   1178 
   1179     int8_t PATTERN_CHAR_BASE = 0x41;
   1180 
   1181     /* loop through the pattern string character by character looking for
   1182      * the first repeated pattern letter, which breaks the interval pattern
   1183      * into 2 parts.
   1184      */
   1185     int32_t i;
   1186     UBool foundRepetition = false;
   1187     for (i = 0; i < intervalPattern.length(); ++i) {
   1188         UChar ch = intervalPattern.charAt(i);
   1189 
   1190         if (ch != prevCh && count > 0) {
   1191             // check the repeativeness of pattern letter
   1192             UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)];
   1193             if ( repeated == FALSE ) {
   1194                 patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE;
   1195             } else {
   1196                 foundRepetition = true;
   1197                 break;
   1198             }
   1199             count = 0;
   1200         }
   1201         if (ch == '\'') {
   1202             // Consecutive single quotes are a single quote literal,
   1203             // either outside of quotes or between quotes
   1204             if ((i+1) < intervalPattern.length() &&
   1205                 intervalPattern.charAt(i+1) == '\'') {
   1206                 ++i;
   1207             } else {
   1208                 inQuote = ! inQuote;
   1209             }
   1210         }
   1211         else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
   1212                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
   1213             // ch is a date-time pattern character
   1214             prevCh = ch;
   1215             ++count;
   1216         }
   1217     }
   1218     // check last pattern char, distinguish
   1219     // "dd MM" ( no repetition ),
   1220     // "d-d"(last char repeated ), and
   1221     // "d-d MM" ( repetition found )
   1222     if ( count > 0 && foundRepetition == FALSE ) {
   1223         if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) {
   1224             count = 0;
   1225         }
   1226     }
   1227     return (i - count);
   1228 }
   1229 
   1230 
   1231 
   1232 UnicodeString&
   1233 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
   1234                                    Calendar& toCalendar,
   1235                                    UnicodeString& appendTo,
   1236                                    FieldPosition& pos,
   1237                                    UErrorCode& status) const {
   1238     if ( U_FAILURE(status) ) {
   1239         return appendTo;
   1240     }
   1241     // the fall back
   1242     // no need delete earlierDate and laterDate since they are adopted
   1243     UnicodeString* earlierDate = new UnicodeString();
   1244     *earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos);
   1245     UnicodeString* laterDate = new UnicodeString();
   1246     *laterDate = fDateFormat->format(toCalendar, *laterDate, pos);
   1247     UnicodeString fallbackPattern;
   1248     fInfo->getFallbackIntervalPattern(fallbackPattern);
   1249     Formattable fmtArray[2];
   1250     fmtArray[0].adoptString(earlierDate);
   1251     fmtArray[1].adoptString(laterDate);
   1252 
   1253     UnicodeString fallback;
   1254     MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status);
   1255     if ( U_SUCCESS(status) ) {
   1256         appendTo.append(fallback);
   1257     }
   1258     return appendTo;
   1259 }
   1260 
   1261 
   1262 
   1263 
   1264 UBool  U_EXPORT2
   1265 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
   1266                                           const UnicodeString& skeleton)
   1267 {
   1268     const UChar fieldChar = fgCalendarFieldToPatternLetter[field];
   1269     return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ;
   1270 }
   1271 
   1272 
   1273 
   1274 void  U_EXPORT2
   1275 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
   1276                  const UnicodeString& bestMatchSkeleton,
   1277                  const UnicodeString& bestIntervalPattern,
   1278                  int8_t differenceInfo,
   1279                  UnicodeString& adjustedPtn) {
   1280     adjustedPtn = bestIntervalPattern;
   1281     int32_t inputSkeletonFieldWidth[] =
   1282     {
   1283     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
   1284              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1285     //   P   Q   R   S   T   U   V   W   X   Y   Z
   1286          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
   1287     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
   1288          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1289     //   p   q   r   s   t   u   v   w   x   y   z
   1290          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
   1291     };
   1292 
   1293     int32_t bestMatchSkeletonFieldWidth[] =
   1294     {
   1295     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
   1296              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1297     //   P   Q   R   S   T   U   V   W   X   Y   Z
   1298          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
   1299     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
   1300          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   1301     //   p   q   r   s   t   u   v   w   x   y   z
   1302          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
   1303     };
   1304 
   1305     DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
   1306     DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
   1307     if ( differenceInfo == 2 ) {
   1308         adjustedPtn.findAndReplace("v", "z");
   1309     }
   1310 
   1311     UBool inQuote = false;
   1312     UChar prevCh = 0;
   1313     int32_t count = 0;
   1314 
   1315     const int8_t PATTERN_CHAR_BASE = 0x41;
   1316 
   1317     // loop through the pattern string character by character
   1318     int32_t adjustedPtnLength = adjustedPtn.length();
   1319     int32_t i;
   1320     for (i = 0; i < adjustedPtnLength; ++i) {
   1321         UChar ch = adjustedPtn.charAt(i);
   1322         if (ch != prevCh && count > 0) {
   1323             // check the repeativeness of pattern letter
   1324             UChar skeletonChar = prevCh;
   1325             if ( skeletonChar ==  CAP_L ) {
   1326                 // there is no "L" (always be "M") in skeleton,
   1327                 // but there is "L" in pattern.
   1328                 // for skeleton "M+", the pattern might be "...L..."
   1329                 skeletonChar = CAP_M;
   1330             }
   1331             int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
   1332             int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
   1333             if ( fieldCount == count && inputFieldCount > fieldCount ) {
   1334                 count = inputFieldCount - fieldCount;
   1335                 int32_t j;
   1336                 for ( j = 0; j < count; ++j ) {
   1337                     adjustedPtn.insert(i, prevCh);
   1338                 }
   1339                 i += count;
   1340                 adjustedPtnLength += count;
   1341             }
   1342             count = 0;
   1343         }
   1344         if (ch == '\'') {
   1345             // Consecutive single quotes are a single quote literal,
   1346             // either outside of quotes or between quotes
   1347             if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') {
   1348                 ++i;
   1349             } else {
   1350                 inQuote = ! inQuote;
   1351             }
   1352         }
   1353         else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
   1354                     || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
   1355             // ch is a date-time pattern character
   1356             prevCh = ch;
   1357             ++count;
   1358         }
   1359     }
   1360     if ( count > 0 ) {
   1361         // last item
   1362         // check the repeativeness of pattern letter
   1363         UChar skeletonChar = prevCh;
   1364         if ( skeletonChar == CAP_L ) {
   1365             // there is no "L" (always be "M") in skeleton,
   1366             // but there is "L" in pattern.
   1367             // for skeleton "M+", the pattern might be "...L..."
   1368             skeletonChar = CAP_M;
   1369         }
   1370         int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
   1371         int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
   1372         if ( fieldCount == count && inputFieldCount > fieldCount ) {
   1373             count = inputFieldCount - fieldCount;
   1374             int32_t j;
   1375             for ( j = 0; j < count; ++j ) {
   1376                 adjustedPtn.append(prevCh);
   1377             }
   1378         }
   1379     }
   1380 }
   1381 
   1382 
   1383 
   1384 void
   1385 DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
   1386                                               int32_t formatLen,
   1387                                               const UnicodeString& datePattern,
   1388                                               UCalendarDateFields field,
   1389                                               UErrorCode& status) {
   1390     // following should not set wrong status
   1391     int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
   1392                                                                         status);
   1393     if ( U_FAILURE(status) ) {
   1394         return;
   1395     }
   1396     PatternInfo&  timeItvPtnInfo = fIntervalPatterns[itvPtnIndex];
   1397     if ( !timeItvPtnInfo.firstPart.isEmpty() ) {
   1398         // UnicodeString allocated here is adopted, so no need to delete
   1399         UnicodeString* timeIntervalPattern = new UnicodeString(timeItvPtnInfo.firstPart);
   1400         timeIntervalPattern->append(timeItvPtnInfo.secondPart);
   1401         UnicodeString* dateStr = new UnicodeString(datePattern);
   1402         Formattable fmtArray[2];
   1403         fmtArray[0].adoptString(timeIntervalPattern);
   1404         fmtArray[1].adoptString(dateStr);
   1405         UnicodeString combinedPattern;
   1406         MessageFormat::format(UnicodeString(TRUE, format, formatLen),
   1407                               fmtArray, 2, combinedPattern, status);
   1408         if ( U_FAILURE(status) ) {
   1409             return;
   1410         }
   1411         setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
   1412     }
   1413     // else: fall back
   1414     // it should not happen if the interval format defined is valid
   1415 }
   1416 
   1417 
   1418 
   1419 const UChar
   1420 DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
   1421 {
   1422     /*GyM*/ CAP_G, LOW_Y, CAP_M,
   1423     /*wWd*/ LOW_W, CAP_W, LOW_D,
   1424     /*DEF*/ CAP_D, CAP_E, CAP_F,
   1425     /*ahH*/ LOW_A, LOW_H, CAP_H,
   1426     /*m..*/ LOW_M,
   1427 };
   1428 
   1429 
   1430 U_NAMESPACE_END
   1431 
   1432 #endif
   1433