/* ******************************************************************************* * Copyright (C) 1997-2001, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* * * File SMPDTFMT.CPP * * Modification History: * * Date Name Description * 02/19/97 aliu Converted from java. * 03/31/97 aliu Modified extensively to work with 50 locales. * 04/01/97 aliu Added support for centuries. * 07/09/97 helena Made ParsePosition into a class. * 07/21/98 stephen Added initializeDefaultCentury. * Removed getZoneIndex (added in DateFormatSymbols) * Removed subParseLong * Removed chk * 02/22/99 stephen Removed character literals for EBCDIC safety * 10/14/99 aliu Updated 2-digit year parsing so that only "00" thru * "99" are recognized. {j28 4182066} * 11/15/99 weiv Added support for week of year/day of week format ******************************************************************************** */ #include "unicode/smpdtfmt.h" #include "unicode/dtfmtsym.h" #include "unicode/resbund.h" #include "unicode/msgfmt.h" #include "unicode/calendar.h" #include "unicode/gregocal.h" #include "unicode/timezone.h" #include "unicode/decimfmt.h" #include "unicode/dcfmtsym.h" #include "unicode/uchar.h" #include "unicode/ustring.h" #include // ***************************************************************************** // class SimpleDateFormat // ***************************************************************************** U_NAMESPACE_BEGIN // For time zones that have no names, use strings GMT+minutes and // GMT-minutes. For instance, in France the time zone is GMT+60. // Also accepted are GMT+H:MM or GMT-H:MM. const UChar SimpleDateFormat::fgGmt[] = {0x0047, 0x004D, 0x0054, 0x0000}; // "GMT" const UChar SimpleDateFormat::fgGmtPlus[] = {0x0047, 0x004D, 0x0054, 0x002B, 0x0000}; // "GMT+" const UChar SimpleDateFormat::fgGmtMinus[] = {0x0047, 0x004D, 0x0054, 0x002D, 0x0000}; // "GMT-" // This is a pattern-of-last-resort used when we can't load a usable pattern out // of a resource. const UChar SimpleDateFormat::fgDefaultPattern[] = { 0x79, 0x79, 0x79, 0x79, 0x4D, 0x4D, 0x64, 0x64, 0x20, 0x68, 0x68, 0x3A, 0x6D, 0x6D, 0x20, 0x61, 0 }; /* "yyyyMMdd hh:mm a" */ /** * These are the tags we expect to see in normal resource bundle files associated * with a locale. */ const char SimpleDateFormat::fgDateTimePatternsTag[]="DateTimePatterns"; const char SimpleDateFormat::fgClassID = 0; // Value is irrelevant /** * This value of defaultCenturyStart indicates that the system default is to be * used. */ const UDate SimpleDateFormat::fgSystemDefaultCentury = DBL_MIN; const int32_t SimpleDateFormat::fgSystemDefaultCenturyYear = -1; UDate SimpleDateFormat::fgSystemDefaultCenturyStart = DBL_MIN; int32_t SimpleDateFormat::fgSystemDefaultCenturyStartYear = -1; //---------------------------------------------------------------------- SimpleDateFormat::~SimpleDateFormat() { delete fSymbols; } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(UErrorCode& status) : fSymbols(NULL), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { construct(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault(), status); } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern, UErrorCode &status) : fPattern(pattern), fSymbols(new DateFormatSymbols(status)), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { initialize(Locale::getDefault(), status); } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern, const Locale& locale, UErrorCode& status) : fPattern(pattern), fSymbols(new DateFormatSymbols(locale, status)), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { initialize(locale, status); } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern, DateFormatSymbols* symbolsToAdopt, UErrorCode& status) : fPattern(pattern), fSymbols(symbolsToAdopt), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { initialize(Locale::getDefault(), status); } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern, const DateFormatSymbols& symbols, UErrorCode& status) : fPattern(pattern), fSymbols(new DateFormatSymbols(symbols)), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { initialize(Locale::getDefault(), status); } //---------------------------------------------------------------------- // Not for public consumption; used by DateFormat SimpleDateFormat::SimpleDateFormat(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status) : fSymbols(NULL), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { construct(timeStyle, dateStyle, locale, status); } //---------------------------------------------------------------------- /** * Not for public consumption; used by DateFormat. This constructor * never fails. If the resource data is not available, it uses the * the last resort symbols. */ SimpleDateFormat::SimpleDateFormat(const Locale& locale, UErrorCode& status) : fPattern(fgDefaultPattern), fSymbols(NULL), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { if (U_FAILURE(status)) return; fSymbols = new DateFormatSymbols(locale, status); if (U_FAILURE(status)) { status = U_ZERO_ERROR; delete fSymbols; // This constructor doesn't fail; it uses last resort data fSymbols = new DateFormatSymbols(status); /* test for NULL */ if (fSymbols == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } } initialize(locale, status); } //---------------------------------------------------------------------- SimpleDateFormat::SimpleDateFormat(const SimpleDateFormat& other) : DateFormat(other), fSymbols(NULL), fDefaultCenturyStart(fgSystemDefaultCentury), fDefaultCenturyStartYear(fgSystemDefaultCenturyYear) { *this = other; } //---------------------------------------------------------------------- SimpleDateFormat& SimpleDateFormat::operator=(const SimpleDateFormat& other) { DateFormat::operator=(other); delete fSymbols; fSymbols = NULL; if (other.fSymbols) fSymbols = new DateFormatSymbols(*other.fSymbols); fDefaultCenturyStart = other.fDefaultCenturyStart; fDefaultCenturyStartYear = other.fDefaultCenturyStartYear; fPattern = other.fPattern; return *this; } //---------------------------------------------------------------------- Format* SimpleDateFormat::clone() const { return new SimpleDateFormat(*this); } //---------------------------------------------------------------------- UBool SimpleDateFormat::operator==(const Format& other) const { if (DateFormat::operator==(other) && other.getDynamicClassID() == getStaticClassID()) { SimpleDateFormat* that = (SimpleDateFormat*)&other; return (fPattern == that->fPattern && fSymbols != NULL && // Check for pathological object that->fSymbols != NULL && // Check for pathological object *fSymbols == *that->fSymbols && fDefaultCenturyStart == that->fDefaultCenturyStart); } return FALSE; } //---------------------------------------------------------------------- void SimpleDateFormat::construct(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status) { // called by several constructors to load pattern data from the resources if (U_FAILURE(status)) return; // load up the DateTimePatters resource from the appropriate locale (throw // an error if for some weird reason the resource is malformed) ResourceBundle resources((char *)0, locale, status); ResourceBundle dateTimePatterns = resources.get(fgDateTimePatternsTag, status); if (U_FAILURE(status)) return; if (dateTimePatterns.getSize() <= kDateTime) { status = U_INVALID_FORMAT_ERROR; return; } // create a symbols object from the locale fSymbols = new DateFormatSymbols(locale, status); /* test for NULL */ if (fSymbols == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } UnicodeString str; // Move dateStyle from the range [0, 3] to [4, 7] if necessary //if (dateStyle >= 0 && dateStyle < DATE_OFFSET) dateStyle = (EStyle)(dateStyle + DATE_OFFSET); // if the pattern should include both date and time information, use the date/time // pattern string as a guide to tell use how to glue together the appropriate date // and time pattern strings. The actual gluing-together is handled by a convenience // method on MessageFormat. if ((timeStyle != kNone) && (dateStyle != kNone)) { // Object[] dateTimeArgs = { // dateTimePatterns[timeStyle], dateTimePatterns[dateStyle] // }; // pattern = MessageFormat.format(dateTimePatterns[8], dateTimeArgs); Formattable *timeDateArray = new Formattable[2]; /* test for NULL */ if (timeDateArray == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } //timeDateArray[0].setString(UnicodeString(dateTimePatterns[timeStyle])); //timeDateArray[1].setString(UnicodeString(dateTimePatterns[dateStyle])); timeDateArray[0].setString(dateTimePatterns.getStringEx(timeStyle, status)); timeDateArray[1].setString(dateTimePatterns.getStringEx(dateStyle, status)); //MessageFormat::format(UnicodeString(dateTimePatterns[kDateTime]), timeDateArray, 2, fPattern, status); MessageFormat::format(dateTimePatterns.getStringEx(kDateTime, status), timeDateArray, 2, fPattern, status); delete [] timeDateArray; } // if the pattern includes just time data or just date date, load the appropriate // pattern string from the resources //else if (timeStyle != kNone) fPattern = UnicodeString(dateTimePatterns[timeStyle]); //else if (dateStyle != kNone) fPattern = UnicodeString(dateTimePatterns[dateStyle]); else if (timeStyle != kNone) fPattern = dateTimePatterns.getStringEx(timeStyle, status); else if (dateStyle != kNone) fPattern = dateTimePatterns.getStringEx(dateStyle, status); // and if it includes _neither_, that's an error else status = U_INVALID_FORMAT_ERROR; // finally, finish initializing by creating a Calendar and a NumberFormat initialize(locale, status); } //---------------------------------------------------------------------- void SimpleDateFormat::initialize(const Locale& locale, UErrorCode& status) { if (U_FAILURE(status)) return; // {sfb} should this be here? if (fSymbols->fZoneStringsColCount < 1) { status = U_INVALID_FORMAT_ERROR; // Check for bogus locale data return; } // We don't need to check that the row count is >= 1, since all 2d arrays have at // least one row fCalendar = Calendar::createInstance(TimeZone::createDefault(), locale, status); fNumberFormat = NumberFormat::createInstance(locale, status); if (fNumberFormat != NULL && U_SUCCESS(status)) { // no matter what the locale's default number format looked like, we want // to modify it so that it doesn't use thousands separators, doesn't always // show the decimal point, and recognizes integers only when parsing fNumberFormat->setGroupingUsed(FALSE); if (fNumberFormat->getDynamicClassID() == DecimalFormat::getStaticClassID()) ((DecimalFormat*)fNumberFormat)->setDecimalSeparatorAlwaysShown(FALSE); fNumberFormat->setParseIntegerOnly(TRUE); fNumberFormat->setMinimumFractionDigits(0); // To prevent "Jan 1.00, 1997.00" initializeDefaultCentury(); } else if (U_SUCCESS(status)) { status = U_MISSING_RESOURCE_ERROR; } } /* Initialize the fields we use to disambiguate ambiguous years. Separate * so we can call it from readObject(). */ void SimpleDateFormat::initializeDefaultCentury() { fDefaultCenturyStart = internalGetDefaultCenturyStart(); fDefaultCenturyStartYear = internalGetDefaultCenturyStartYear(); UErrorCode status = U_ZERO_ERROR; fCalendar->setTime(fDefaultCenturyStart, status); // {sfb} throw away error } /* Define one-century window into which to disambiguate dates using * two-digit years. Make public in JDK 1.2. */ void SimpleDateFormat::parseAmbiguousDatesAsAfter(UDate startDate, UErrorCode& status) { if(U_FAILURE(status)) return; fCalendar->setTime(startDate, status); if(U_SUCCESS(status)) { fDefaultCenturyStart = startDate; fDefaultCenturyStartYear = fCalendar->get(Calendar::YEAR, status); } } //---------------------------------------------------------------------- UnicodeString& SimpleDateFormat::format(Calendar& cal, UnicodeString& toAppendTo, FieldPosition& pos) const { UErrorCode status = U_ZERO_ERROR; pos.setBeginIndex(0); pos.setEndIndex(0); UBool inQuote = FALSE; UChar prevCh = 0; int32_t count = 0; UnicodeString str; // loop through the pattern string character by character for (int32_t i = 0; i < fPattern.length() && U_SUCCESS(status); ++i) { UChar ch = fPattern[i]; // Use subFormat() to format a repeated pattern character // when a different pattern or non-pattern character is seen if (ch != prevCh && count > 0) { toAppendTo += subFormat(str, prevCh, count, toAppendTo.length(), pos, cal, status); count = 0; } if (ch == 0x0027 /*'\''*/) { // Consecutive single quotes are a single quote literal, // either outside of quotes or between quotes if ((i+1) < fPattern.length() && fPattern[i+1] == 0x0027 /*'\''*/) { toAppendTo += (UChar)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 to be interpreted // by subFormat(); count the number of times it is repeated prevCh = ch; ++count; } else { // Append quoted characters and unquoted non-pattern characters toAppendTo += ch; } } // Format the last item in the pattern, if any if (count > 0) { toAppendTo += subFormat(str, prevCh, count, toAppendTo.length(), pos, cal, status); } // and if something failed (e.g., an invalid format character), reset our FieldPosition // to (0, 0) to show that // {sfb} look at this later- are these being set correctly? if (U_FAILURE(status)) { pos.setBeginIndex(0); pos.setEndIndex(0); } return toAppendTo; } UnicodeString& SimpleDateFormat::format(const Formattable& obj, UnicodeString& toAppendTo, FieldPosition& pos, UErrorCode& status) const { // this is just here to get around the hiding problem // (the previous format() override would hide the version of // format() on DateFormat that this function correspond to, so we // have to redefine it here) return DateFormat::format(obj, toAppendTo, pos, status); } //---------------------------------------------------------------------- // Map index into pattern character string to Calendar field number. const Calendar::EDateFields SimpleDateFormat::fgPatternIndexToCalendarField[] = { Calendar::ERA, Calendar::YEAR, Calendar::MONTH, Calendar::DATE, Calendar::HOUR_OF_DAY, Calendar::HOUR_OF_DAY, Calendar::MINUTE, Calendar::SECOND, Calendar::MILLISECOND, Calendar::DAY_OF_WEEK, Calendar::DAY_OF_YEAR, Calendar::DAY_OF_WEEK_IN_MONTH, Calendar::WEEK_OF_YEAR, Calendar::WEEK_OF_MONTH, Calendar::AM_PM, Calendar::HOUR, Calendar::HOUR, Calendar::ZONE_OFFSET, Calendar::YEAR_WOY, Calendar::DOW_LOCAL }; // Map index into pattern character string to DateFormat field number const DateFormat::EField SimpleDateFormat::fgPatternIndexToDateFormatField[] = { DateFormat::kEraField, DateFormat::kYearField, DateFormat::kMonthField, DateFormat::kDateField, DateFormat::kHourOfDay1Field, DateFormat::kHourOfDay0Field, DateFormat::kMinuteField, DateFormat::kSecondField, DateFormat::kMillisecondField, DateFormat::kDayOfWeekField, DateFormat::kDayOfYearField, DateFormat::kDayOfWeekInMonthField, DateFormat::kWeekOfYearField, DateFormat::kWeekOfMonthField, DateFormat::kAmPmField, DateFormat::kHour1Field, DateFormat::kHour0Field, DateFormat::kTimezoneField, DateFormat::kYearWOYField, DateFormat::kDOWLocalField }; //---------------------------------------------------------------------- UnicodeString& SimpleDateFormat::subFormat(UnicodeString& result, UChar ch, int32_t count, int32_t beginOffset, FieldPosition& pos, Calendar& cal, UErrorCode& status) const { // this function gets called by format() to produce the appropriate substitution // text for an individual pattern symbol (e.g., "HH" or "yyyy") UChar *patternCharPtr = u_strchr(DateFormatSymbols::getPatternUChars(), ch); EField patternCharIndex; int32_t maxIntCount = 10; UnicodeString str; // Scratch result.remove(); // if the pattern character is unrecognized, signal an error and dump out if (patternCharPtr == NULL) { status = U_INVALID_FORMAT_ERROR; return result; } patternCharIndex = (EField)(patternCharPtr - DateFormatSymbols::getPatternUChars()); Calendar::EDateFields field = fgPatternIndexToCalendarField[patternCharIndex]; int32_t value = cal.get(field, status); if (U_FAILURE(status)) return result; switch (patternCharIndex) { // for any "G" symbol, write out the appropriate era string case kEraField: result = fSymbols->fEras[value]; break; // for "yyyy", write out the whole year; for "yy", write out the last 2 digits case kYearField: case kYearWOYField: if (count >= 4) zeroPaddingNumber(result, value, 4, maxIntCount); else zeroPaddingNumber(result, value, 2, 2); break; // for "MMMM", write out the whole month name, for "MMM", write out the month // abbreviation, for "M" or "MM", write out the month as a number with the // appropriate number of digits case kMonthField: if (count >= 4) result = fSymbols->fMonths[value]; else if (count == 3) result = fSymbols->fShortMonths[value]; else zeroPaddingNumber(result, value + 1, count, maxIntCount); break; // for "k" and "kk", write out the hour, adjusting midnight to appear as "24" case kHourOfDay1Field: if (value == 0) zeroPaddingNumber(result, cal.getMaximum(Calendar::HOUR_OF_DAY) + 1, count, maxIntCount); else zeroPaddingNumber(result, value, count, maxIntCount); break; // for "SS" and "S", we want to truncate digits so that you still see the MOST // significant digits rather than the LEAST (as is the case with the year) case kMillisecondField: if (count > 3) count = 3; else if (count == 2) value = value / 10; else if (count == 1) value = value / 100; zeroPaddingNumber(result, value, count, maxIntCount); break; // for "EEEE", write out the day-of-the-week name; otherwise, use the abbreviation case kDayOfWeekField: if (count >= 4) result = fSymbols->fWeekdays[value]; else result = fSymbols->fShortWeekdays[value]; break; // for and "a" symbol, write out the whole AM/PM string case kAmPmField: result = fSymbols->fAmPms[value]; break; // for "h" and "hh", write out the hour, adjusting noon and midnight to show up // as "12" case kHour1Field: if (value == 0) zeroPaddingNumber(result, cal.getLeastMaximum(Calendar::HOUR) + 1, count, maxIntCount); else zeroPaddingNumber(result, value, count, maxIntCount); break; // for the "z" symbols, we have to check our time zone data first. If we have a // localized name for the time zone, then "zzzz" is the whole name and anything // shorter is the abbreviation (we also have to check for daylight savings time // since the name will be different). If we don't have a localized time zone name, // then the time zone shows up as "GMT+hh:mm" or "GMT-hh:mm" (where "hh:mm" is the // offset from GMT) regardless of how many z's were in the pattern symbol case kTimezoneField: { int32_t zoneIndex = fSymbols->getZoneIndex(cal.getTimeZone().getID(str)); if (zoneIndex == -1) { UnicodeString zoneString; value = cal.get(Calendar::ZONE_OFFSET, status) + cal.get(Calendar::DST_OFFSET, status); if (value < 0) { zoneString += fgGmtMinus; value = -value; // suppress the '-' sign for text display. } else zoneString += fgGmtPlus; zoneString += zeroPaddingNumber(str, (int32_t)(value/U_MILLIS_PER_HOUR), 2, 2); zoneString += (UChar)0x003A /*':'*/; zoneString += zeroPaddingNumber(str, (int32_t)((value%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE), 2, 2); result = zoneString; } else if (cal.get(Calendar::DST_OFFSET, status) != 0) { if (count >= 4) result = fSymbols->fZoneStrings[zoneIndex][3]; else result = fSymbols->fZoneStrings[zoneIndex][4]; } else { if (count >= 4) result = fSymbols->fZoneStrings[zoneIndex][1]; else result = fSymbols->fZoneStrings[zoneIndex][2]; } } break; // all of the other pattern symbols can be formatted as simple numbers with // appropriate zero padding default: // case kDateField: // case kHourOfDay0Field: // case kMinuteField: // case kSecondField: // case kDayOfYearField: // case kDayOfWeekInMonthField: // case kWeekOfYearField: // case kWeekOfMonthField: // case kHour0Field: // case kDOWLocalField: zeroPaddingNumber(result, value, count, maxIntCount); break; } // if the field we're formatting is the one the FieldPosition says it's interested // in, fill in the FieldPosition with this field's positions if (pos.getField() == fgPatternIndexToDateFormatField[patternCharIndex]) { if (pos.getBeginIndex() == 0 && pos.getEndIndex() == 0) { pos.setBeginIndex(beginOffset); pos.setEndIndex(beginOffset + result.length()); } } return result; } //---------------------------------------------------------------------- UnicodeString& SimpleDateFormat::zeroPaddingNumber(UnicodeString& result, int32_t value, int32_t minDigits, int32_t maxDigits) const { FieldPosition pos(0); result.remove(); fNumberFormat->setMinimumIntegerDigits(minDigits); fNumberFormat->setMaximumIntegerDigits(maxDigits); return fNumberFormat->format(value, result, pos); // 3rd arg is there to speed up processing } //---------------------------------------------------------------------- // {sfb} removed /* // this function will dump output to the console on a debug build when there's a parse error #ifdef _DEBUG void chk(ParsePosition& val, UChar ch, ParsePosition& start, int32_t count) { if (val.getIndex() < 0) { cout << "[Parse failure on '" << (char)ch << "' x " << dec << count << " @ " << start.getIndex() << ']'; } } #else inline void chk(ParsePosition& val, UChar ch, ParsePosition& start, int32_t count) { } #endif inline Date parseFailureResult(ParsePosition& pos, ParsePosition& oldStart, ParsePosition& failurePos) { // Note: The C++ version currently supports the notion of returning zero // with a non-zero parse position, but only if this format is lenient. // The returned position in this case is the first un-parseable character. // This is useful, but is not present in the Java version, and causes a // DateFormat test to fail. // For now, I am removing this function. It can be restored later. // if (!isLenient()) pos = oldStart; // else { pos = failurePos.getIndex(); if (pos.getIndex() < 0) pos = -pos.getIndex(); }; pos = oldStart; return 0; } */ void SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition& pos) const { int32_t start = pos.getIndex(); int32_t oldStart = start; UBool ambiguousYear[] = { FALSE }; UBool inQuote = FALSE; UChar prevCh = 0; int32_t count = 0; int32_t interQuoteCount = 1; // Number of chars between quotes // loop through the pattern string character by character, using it to control how // we match characters in the input for (int32_t i = 0; i < fPattern.length();++i) { UChar ch = fPattern[i]; // if we're inside a quoted string, match characters exactly until we hit // another single quote (two single quotes in a row match one single quote // in the input) if (inQuote) { if (ch == 0x0027 /*'\''*/) { // ends with 2nd single quote inQuote = FALSE; // two consecutive quotes outside a quote means we have // a quote literal we need to match. if (count == 0) { if(start > text.length() || ch != text[start]) { pos.setIndex(oldStart); pos.setErrorIndex(start); return; } ++start; } count = 0; interQuoteCount = 0; } else { // pattern uses text following from 1st single quote. if (start >= text.length() || ch != text[start]) { // Check for cases like: 'at' in pattern vs "xt" // in time text, where 'a' doesn't match with 'x'. // If fail to match, return null. pos.setIndex(oldStart); // left unchanged pos.setErrorIndex(start); return; } ++count; ++start; } } // if we're not inside a quoted string... else { // ...a quote mark puts us into a quoted string (and we parse any pending // pattern symbols) if (ch == 0x0027 /*'\''*/) { inQuote = TRUE; if (count > 0) { int32_t startOffset = start; start = subParse(text, start, prevCh, count, FALSE, ambiguousYear, cal); if ( start < 0 ) { pos.setErrorIndex(startOffset); pos.setIndex(oldStart); // {sfb} correct Date return; } count = 0; } if (interQuoteCount == 0) { // This indicates two consecutive quotes inside a quote, // for example, 'o''clock'. We need to parse this as // representing a single quote within the quote. int32_t startOffset = start; if (start >= text.length() || ch != text[start]) { pos.setErrorIndex(startOffset); pos.setIndex(oldStart); // {sfb} correct Date return; } ++start; count = 1; // Make it look like we never left } } // if we're on a letter, collect copies of the same letter to determine // the whole parse symbol. when we hit a different character, parse the // input based on the resulting symbol else if ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/)) { // ch is a date-time pattern if (ch != prevCh && count > 0) // e.g., yyyyMMdd { int32_t startOffset = start; // This is the only case where we pass in 'true' for // obeyCount. That's because the next field directly // abuts this one, so we have to use the count to know when // to stop parsing. [LIU] start = subParse(text, start, prevCh, count, TRUE, ambiguousYear, cal); if (start < 0) { pos.setErrorIndex(startOffset); pos.setIndex(oldStart); // {sfb} correct Date return; } prevCh = ch; count = 1; } else { if (ch != prevCh) prevCh = ch; count++; } } // if we're on a non-letter, parse based on any pending pattern symbols else if (count > 0) { // handle cases like: MM-dd-yy, HH:mm:ss, or yyyy MM dd, // where ch = '-', ':', or ' ', repectively. int32_t startOffset = start; start = subParse( text, start, prevCh, count, FALSE, ambiguousYear, cal); if ( start < 0 ) { pos.setErrorIndex(startOffset); pos.setIndex(oldStart); return; } if (start >= text.length() || ch != text[start]) { // handle cases like: 'MMMM dd' in pattern vs. "janx20" // in time text, where ' ' doesn't match with 'x'. pos.setErrorIndex(start); pos.setIndex(oldStart); return; } start++; count = 0; prevCh = 0; } // otherwise, match characters exactly else { if (start >= text.length() || ch != text[start]) { // handle cases like: 'MMMM dd' in pattern vs. // "jan,,,20" in time text, where " " doesn't // match with ",,,". pos.setErrorIndex(start); pos.setIndex(oldStart); return; } start++; } ++interQuoteCount; } } // if we still have a pending pattern symbol after we're done looping through // characters in the pattern string, parse the input based on the final pending // pattern symbol if (count > 0) { int32_t startOffset = start; start = subParse(text, start, prevCh, count, FALSE, ambiguousYear, cal); if ( start < 0 ) { pos.setIndex(oldStart); pos.setErrorIndex(startOffset); return; } } // At this point the fields of Calendar have been set. Calendar // will fill in default values for missing fields when the time // is computed. pos.setIndex(start); // This part is a problem: When we call parsedDate.after, we compute the time. // Take the date April 3 2004 at 2:30 am. When this is first set up, the year // will be wrong if we're parsing a 2-digit year pattern. It will be 1904. // April 3 1904 is a Sunday (unlike 2004) so it is the DST onset day. 2:30 am // is therefore an "impossible" time, since the time goes from 1:59 to 3:00 am // on that day. It is therefore parsed out to fields as 3:30 am. Then we // add 100 years, and get April 3 2004 at 3:30 am. Note that April 3 2004 is // a Saturday, so it can have a 2:30 am -- and it should. [LIU] /* UDate parsedDate = calendar.getTime(); if( ambiguousYear[0] && !parsedDate.after(fDefaultCenturyStart) ) { calendar.add(Calendar.YEAR, 100); parsedDate = calendar.getTime(); } */ // Because of the above condition, save off the fields in case we need to readjust. // The procedure we use here is not particularly efficient, but there is no other // way to do this given the API restrictions present in Calendar. We minimize // inefficiency by only performing this computation when it might apply, that is, // when the two-digit year is equal to the start year, and thus might fall at the // front or the back of the default century. This only works because we adjust // the year correctly to start with in other cases -- see subParse(). UErrorCode status = U_ZERO_ERROR; if (ambiguousYear[0]) // If this is true then the two-digit year == the default start year { // We need a copy of the fields, and we need to avoid triggering a call to // complete(), which will recalculate the fields. Since we can't access // the fields[] array in Calendar, we clone the entire object. This will // stop working if Calendar.clone() is ever rewritten to call complete(). Calendar *copy = cal.clone(); UDate parsedDate = copy->getTime(status); // {sfb} check internalGetDefaultCenturyStart if (parsedDate < internalGetDefaultCenturyStart()) { // We can't use add here because that does a complete() first. cal.set(Calendar::YEAR, internalGetDefaultCenturyStartYear() + 100); } delete copy; } // If any Calendar calls failed, we pretend that we // couldn't parse the string, when in reality this isn't quite accurate-- // we did parse it; the Calendar calls just failed. if (U_FAILURE(status)) { pos.setErrorIndex(start); pos.setIndex(oldStart); } } UDate SimpleDateFormat::parse( const UnicodeString& text, ParsePosition& pos) const { // redefined here because the other parse() function hides this function's // cunterpart on DateFormat return DateFormat::parse(text, pos); } UDate SimpleDateFormat::parse(const UnicodeString& text, UErrorCode& status) const { // redefined here because the other parse() function hides this function's // counterpart on DateFormat return DateFormat::parse(text, status); } //---------------------------------------------------------------------- int32_t SimpleDateFormat::matchString(const UnicodeString& text, int32_t start, Calendar::EDateFields field, const UnicodeString* data, int32_t dataCount, Calendar& cal) const { int32_t i = 0; int32_t count = dataCount; if (field == Calendar::DAY_OF_WEEK) i = 1; // There may be multiple strings in the data[] array which begin with // the same prefix (e.g., Cerven and Cervenec (June and July) in Czech). // We keep track of the longest match, and return that. Note that this // unfortunately requires us to test all array elements. int32_t bestMatchLength = 0, bestMatch = -1; // {sfb} kludge to support case-insensitive comparison UnicodeString lcaseText(text); lcaseText.toLower(); for (; i < count; ++i) { int32_t length = data[i].length(); // Always compare if we have no match yet; otherwise only compare // against potentially better matches (longer strings). UnicodeString lcase(data[i]); lcase.toLower(); if (length > bestMatchLength && (lcaseText.compareBetween(start, start + length, lcase, 0, length)) == 0) { bestMatch = i; bestMatchLength = length; } } if (bestMatch >= 0) { cal.set(field, bestMatch); return start + bestMatchLength; } return -start; } //---------------------------------------------------------------------- void SimpleDateFormat::set2DigitYearStart(UDate d, UErrorCode& status) { parseAmbiguousDatesAsAfter(d, status); } /** * Parse the given text, at the given position, as a numeric value, using * this objects fNumberFormat. Return the corresponding long value in the * fill-in parameter 'value'. If the parse fails, this method leaves pos * unchanged and returns FALSE; otherwise it advances pos and * returns TRUE. */ // {sfb} removed /* UBool SimpleDateFormat::subParseLong(const UnicodeString& text, ParsePosition& pos, int32_t& value) const { Formattable parseResult; ParsePosition posSave = pos; fNumberFormat->parse(text, parseResult, pos); if (pos != posSave && parseResult.getType() == Formattable::kLong) { value = parseResult.getLong(); return TRUE; } pos = posSave; return FALSE; } */ /** * Private member function that converts the parsed date strings into * timeFields. Returns -start (for ParsePosition) if failed. * @param text the time text to be parsed. * @param start where to start parsing. * @param ch the pattern character for the date field text to be parsed. * @param count the count of a pattern character. * @return the new start position if matching succeeded; a negative number * indicating matching failure, otherwise. */ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UChar ch, int32_t count, UBool obeyCount, UBool ambiguousYear[], Calendar& cal) const { Formattable number; int32_t value = 0; int32_t i; ParsePosition pos(0); int32_t patternCharIndex; UChar *patternCharPtr = u_strchr(DateFormatSymbols::getPatternUChars(), ch); if (patternCharPtr == NULL) { return -start; } patternCharIndex = (EField)(patternCharPtr - DateFormatSymbols::getPatternUChars()); pos.setIndex(start); Calendar::EDateFields field = fgPatternIndexToCalendarField[patternCharIndex]; // If there are any spaces here, skip over them. If we hit the end // of the string, then fail. for (;;) { if (pos.getIndex() >= text.length()) return -start; UChar c = text[pos.getIndex()]; if (c != 0x0020 /*' '*/ && c != 0x0009 /*'\t'*/) break; pos.setIndex(pos.getIndex() + 1); } // We handle a few special cases here where we need to parse // a number value. We handle further, more generic cases below. We need // to handle some of them here because some fields require extra processing on // the parsed value. if (patternCharIndex == kHourOfDay1Field /*HOUR_OF_DAY1_FIELD*/ || patternCharIndex == kHour1Field /*HOUR1_FIELD*/ || (patternCharIndex == kMonthField /*MONTH_FIELD*/ && count <= 2) || patternCharIndex == kYearField /*YEAR*/ || patternCharIndex == kYearWOYField) { int32_t parseStart = pos.getIndex(); // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 // It would be good to unify this with the obeyCount logic below, // but that's going to be difficult. if (obeyCount) { if ((start+count) > text.length()) return -start; UnicodeString temp; text.extractBetween(0, start + count, temp); fNumberFormat->parse(temp, number, pos); } else fNumberFormat->parse(text, number, pos); if (pos.getIndex() == parseStart) // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 return -start; value = number.getLong(); } switch (patternCharIndex) { case kEraField: return matchString(text, start, Calendar::ERA, fSymbols->fEras, fSymbols->fErasCount, cal); case kYearField: // If there are 3 or more YEAR pattern characters, this indicates // that the year value is to be treated literally, without any // two-digit year adjustments (e.g., from "01" to 2001). Otherwise // we made adjustments to place the 2-digit year in the proper // century, for parsed strings from "00" to "99". Any other string // is treated literally: "2250", "-1", "1", "002". if (count <= 2 && (pos.getIndex() - start) == 2 && u_isdigit(text.charAt(start)) && u_isdigit(text.charAt(start+1))) { // Assume for example that the defaultCenturyStart is 6/18/1903. // This means that two-digit years will be forced into the range // 6/18/1903 to 6/17/2003. As a result, years 00, 01, and 02 // correspond to 2000, 2001, and 2002. Years 04, 05, etc. correspond // to 1904, 1905, etc. If the year is 03, then it is 2003 if the // other fields specify a date before 6/18, or 1903 if they specify a // date afterwards. As a result, 03 is an ambiguous year. All other // two-digit years are unambiguous. int32_t ambiguousTwoDigitYear = fDefaultCenturyStartYear % 100; ambiguousYear[0] = (value == ambiguousTwoDigitYear); value += (fDefaultCenturyStartYear/100)*100 + (value < ambiguousTwoDigitYear ? 100 : 0); } cal.set(Calendar::YEAR, value); return pos.getIndex(); case kYearWOYField: // Comment is the same as for kYearFiels - look above if (count <= 2 && (pos.getIndex() - start) == 2 && u_isdigit(text.charAt(start)) && u_isdigit(text.charAt(start+1))) { int32_t ambiguousTwoDigitYear = fDefaultCenturyStartYear % 100; ambiguousYear[0] = (value == ambiguousTwoDigitYear); value += (fDefaultCenturyStartYear/100)*100 + (value < ambiguousTwoDigitYear ? 100 : 0); } cal.set(Calendar::YEAR_WOY, value); return pos.getIndex(); case kMonthField: if (count <= 2) // i.e., M or MM. { // Don't want to parse the month if it is a string // while pattern uses numeric style: M or MM. // [We computed 'value' above.] cal.set(Calendar::MONTH, value - 1); return pos.getIndex(); } else { // count >= 3 // i.e., MMM or MMMM // Want to be able to parse both short and long forms. // Try count == 4 first: int32_t newStart = 0; if ((newStart = matchString(text, start, Calendar::MONTH, fSymbols->fMonths, fSymbols->fMonthsCount, cal)) > 0) return newStart; else // count == 4 failed, now try count == 3 return matchString(text, start, Calendar::MONTH, fSymbols->fShortMonths, fSymbols->fShortMonthsCount, cal); } case kHourOfDay1Field: // [We computed 'value' above.] if (value == cal.getMaximum(Calendar::HOUR_OF_DAY) + 1) value = 0; cal.set(Calendar::HOUR_OF_DAY, value); return pos.getIndex(); case kDayOfWeekField: { // Want to be able to parse both short and long forms. // Try count == 4 (DDDD) first: int32_t newStart = 0; if ((newStart = matchString(text, start, Calendar::DAY_OF_WEEK, fSymbols->fWeekdays, fSymbols->fWeekdaysCount, cal)) > 0) return newStart; else // DDDD failed, now try DDD return matchString(text, start, Calendar::DAY_OF_WEEK, fSymbols->fShortWeekdays, fSymbols->fShortWeekdaysCount, cal); } case kAmPmField: return matchString(text, start, Calendar::AM_PM, fSymbols->fAmPms, fSymbols->fAmPmsCount, cal); case kHour1Field: // [We computed 'value' above.] if (value == cal.getLeastMaximum(Calendar::HOUR)+1) value = 0; cal.set(Calendar::HOUR, value); return pos.getIndex(); case kTimezoneField: { // First try to parse generic forms such as GMT-07:00. Do this first // in case localized DateFormatZoneData contains the string "GMT" // for a zone; in that case, we don't want to match the first three // characters of GMT+/-HH:MM etc. UnicodeString lcaseText(text); UnicodeString lcaseGMT(fgGmt); int32_t sign = 0; int32_t offset; int32_t gmtLen = lcaseGMT.length(); // For time zones that have no known names, look for strings // of the form: // GMT[+-]hours:minutes or // GMT[+-]hhmm or // GMT. // {sfb} kludge for case-insensitive compare lcaseText.toLower(); lcaseGMT.toLower(); if ((text.length() - start) > gmtLen && (lcaseText.compare(start, gmtLen, lcaseGMT, 0, gmtLen)) == 0) { cal.set(Calendar::DST_OFFSET, 0); pos.setIndex(start + gmtLen); if( text[pos.getIndex()] == 0x002B /*'+'*/ ) sign = 1; else if( text[pos.getIndex()] == 0x002D /*'-'*/ ) sign = -1; else { cal.set(Calendar::ZONE_OFFSET, 0 ); return pos.getIndex(); } // Look for hours:minutes or hhmm. pos.setIndex(pos.getIndex() + 1); // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 int32_t parseStart = pos.getIndex(); Formattable tzNumber; fNumberFormat->parse(text, tzNumber, pos); if( pos.getIndex() == parseStart) { // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 return -start; } if( text[pos.getIndex()] == 0x003A /*':'*/ ) { // This is the hours:minutes case offset = tzNumber.getLong() * 60; pos.setIndex(pos.getIndex() + 1); // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 parseStart = pos.getIndex(); fNumberFormat->parse(text, tzNumber, pos); if( pos.getIndex() == parseStart) { // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 return -start; } offset += tzNumber.getLong(); } else { // This is the hhmm case. offset = tzNumber.getLong(); if( offset < 24 ) offset *= 60; else offset = offset % 100 + offset / 100 * 60; } // Fall through for final processing below of 'offset' and 'sign'. } else { // At this point, check for named time zones by looking through // the locale data from the DateFormatZoneData strings. // Want to be able to parse both short and long forms. for (i = 0; i < fSymbols->fZoneStringsRowCount; i++) { // Checking long and short zones [1 & 2], // and long and short daylight [3 & 4]. int32_t j = 1; // {sfb} kludge for case-insensitive compare UnicodeString s1(text); s1.toLower(); UnicodeString s2; for (; j <= 4; ++j) { s2 = fSymbols->fZoneStrings[i][j]; s2.toLower(); if ((s1.compare(start, s2.length(), s2, 0, s2.length())) == 0) break; } if (j <= 4) { TimeZone *tz = TimeZone::createTimeZone(fSymbols->fZoneStrings[i][0]); cal.set(Calendar::ZONE_OFFSET, tz->getRawOffset()); // Must call set() with something -- TODO -- Fix this to // use the correct DST SAVINGS for the zone. delete tz; cal.set(Calendar::DST_OFFSET, j >= 3 ? U_MILLIS_PER_HOUR : 0); return (start + fSymbols->fZoneStrings[i][j].length()); } } // As a last resort, look for numeric timezones of the form // [+-]hhmm as specified by RFC 822. This code is actually // a little more permissive than RFC 822. It will try to do // its best with numbers that aren't strictly 4 digits long. UErrorCode status = U_ZERO_ERROR; DecimalFormat *fmt = new DecimalFormat("+####;-####", status); if(U_FAILURE(status)) return -start; fmt->setParseIntegerOnly(TRUE); // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 int32_t parseStart = pos.getIndex(); Formattable tzNumber; fmt->parse( text, tzNumber, pos ); if( pos.getIndex() == parseStart) { // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 return -start; // Wasn't actually a number. } offset = tzNumber.getLong(); sign = 1; if( offset < 0 ) { sign = -1; offset = -offset; } if( offset < 24 ) offset = offset * 60; else offset = offset % 100 + offset / 100 * 60; // Fall through for final processing below of 'offset' and 'sign'. } // Do the final processing for both of the above cases. We only // arrive here if the form GMT+/-... or an RFC 822 form was seen. if (sign != 0) { offset *= U_MILLIS_PER_MINUTE * sign; if (cal.getTimeZone().useDaylightTime()) { cal.set(Calendar::DST_OFFSET, U_MILLIS_PER_HOUR); offset -= U_MILLIS_PER_HOUR; } cal.set(Calendar::ZONE_OFFSET, offset); return pos.getIndex(); } // All efforts to parse a zone failed. return -start; } default: // case 3: // 'd' - DATE // case 5: // 'H' - HOUR_OF_DAY:0-based. eg, 23:59 + 1 hour =>> 00:59 // case 6: // 'm' - MINUTE // case 7: // 's' - SECOND // case 8: // 'S' - MILLISECOND // case 10: // 'D' - DAY_OF_YEAR // case 11: // 'F' - DAY_OF_WEEK_IN_MONTH // case 12: // 'w' - WEEK_OF_YEAR // case 13: // 'W' - WEEK_OF_MONTH // case 16: // 'K' - HOUR: 0-based. eg, 11PM + 1 hour =>> 0 AM // 'e' - DOW_LOCAL // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 int32_t parseStart = pos.getIndex(); // Handle "generic" fields if (obeyCount) { if ((start+count) > text.length()) return -start; UnicodeString s; // {sfb} old code had extract, make sure it works text.extractBetween(0, start + count, s); fNumberFormat->parse(s, number, pos); } else fNumberFormat->parse(text, number, pos); if (pos.getIndex() != parseStart) { // WORK AROUND BUG IN NUMBER FORMAT IN 1.2B3 cal.set(field, number.getLong()); return pos.getIndex(); } return -start; } } //---------------------------------------------------------------------- void SimpleDateFormat::translatePattern(const UnicodeString& originalPattern, UnicodeString& translatedPattern, const UnicodeString& from, const UnicodeString& to, UErrorCode& status) { // run through the pattern and convert any pattern symbols from the version // in "from" to the corresponding character ion "to". This code takes // quoted strings into account (it doesn't try to translate them), and it signals // an error if a particular "pattern character" doesn't appear in "from". // Depending on the values of "from" and "to" this can convert from generic // to localized patterns or localized to generic. if (U_FAILURE(status)) return; translatedPattern.remove(); UBool inQuote = FALSE; for (int32_t i = 0; i < originalPattern.length(); ++i) { UChar c = originalPattern[i]; if (inQuote) { if (c == 0x0027 /*'\''*/) inQuote = FALSE; } else { if (c == 0x0027 /*'\''*/) inQuote = TRUE; else if ((c >= 0x0061 /*'a'*/ && c <= 0x007A) /*'z'*/ || (c >= 0x0041 /*'A'*/ && c <= 0x005A /*'Z'*/)) { int32_t ci = from.indexOf(c); if (ci == -1) { status = U_INVALID_FORMAT_ERROR; return; } c = to[ci]; } } translatedPattern += c; } if (inQuote) { status = U_INVALID_FORMAT_ERROR; return; } } //---------------------------------------------------------------------- UnicodeString& SimpleDateFormat::toPattern(UnicodeString& result) const { result = fPattern; return result; } //---------------------------------------------------------------------- UnicodeString& SimpleDateFormat::toLocalizedPattern(UnicodeString& result, UErrorCode& status) const { translatePattern(fPattern, result, DateFormatSymbols::getPatternUChars(), fSymbols->fLocalPatternChars, status); return result; } //---------------------------------------------------------------------- void SimpleDateFormat::applyPattern(const UnicodeString& pattern) { fPattern = pattern; } //---------------------------------------------------------------------- void SimpleDateFormat::applyLocalizedPattern(const UnicodeString& pattern, UErrorCode &status) { translatePattern(pattern, fPattern, fSymbols->fLocalPatternChars, DateFormatSymbols::getPatternUChars(), status); } //---------------------------------------------------------------------- const DateFormatSymbols* SimpleDateFormat::getDateFormatSymbols() const { return fSymbols; } //---------------------------------------------------------------------- void SimpleDateFormat::adoptDateFormatSymbols(DateFormatSymbols* newFormatSymbols) { delete fSymbols; fSymbols = newFormatSymbols; } //---------------------------------------------------------------------- void SimpleDateFormat::setDateFormatSymbols(const DateFormatSymbols& newFormatSymbols) { delete fSymbols; fSymbols = new DateFormatSymbols(newFormatSymbols); } //---------------------------------------------------------------------- // {sfb} removed /*int32_t SimpleDateFormat::getZoneIndex(const UnicodeString& ID) const { // this function searches a time zone list for a time zone with the specified // ID. It'll either return an apprpriate row number or -1 if the ID wasn't // found. int32_t index, col; for (col=0; col<=4 && colfZoneStringsColCount; col+=2) { for (index = 0; index < fSymbols->fZoneStringsRowCount; index++) { if (fSymbols->fZoneStrings[index][col] == ID) return index; } } return - 1; }*/ //---------------------------------------------------------------------- UDate SimpleDateFormat::internalGetDefaultCenturyStart() const { // lazy-evaluate systemDefaultCenturyStart if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury) initializeSystemDefaultCentury(); // use defaultCenturyStart unless it's the flag value; // then use systemDefaultCenturyStart return (fDefaultCenturyStart == fgSystemDefaultCentury) ? fgSystemDefaultCenturyStart : fDefaultCenturyStart; } int32_t SimpleDateFormat::internalGetDefaultCenturyStartYear() const { // lazy-evaluate systemDefaultCenturyStartYear if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury) initializeSystemDefaultCentury(); // use defaultCenturyStart unless it's the flag value; // then use systemDefaultCenturyStartYear //return (fDefaultCenturyStart == fgSystemDefaultCentury) ? return (fDefaultCenturyStartYear == fgSystemDefaultCenturyYear) ? fgSystemDefaultCenturyStartYear : fDefaultCenturyStartYear; } void SimpleDateFormat::initializeSystemDefaultCentury() { // initialize systemDefaultCentury and systemDefaultCenturyYear based // on the current time. They'll be set to 80 years before // the current time. // No point in locking as it should be idempotent. if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury) { UErrorCode status = U_ZERO_ERROR; Calendar *calendar = Calendar::createInstance(status); if (calendar != NULL && U_SUCCESS(status)) { calendar->setTime(Calendar::getNow(), status); calendar->add(Calendar::YEAR, -80, status); fgSystemDefaultCenturyStart = calendar->getTime(status); fgSystemDefaultCenturyStartYear = calendar->get(Calendar::YEAR, status); delete calendar; } // We have no recourse upon failure unless we want to propagate the failure // out. } } U_NAMESPACE_END //eof