The Tor Browser: intl/icu/source/i18n/basictz.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/basictz.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/basictz.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
 *******************************************************************************
 * Copyright (C) 2007-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 */
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_FORMATTING
 #include "unicode/basictz.h"
 #include "gregoimp.h"
 #include "uvector.h"
 #include "cmemory.h"
 U_NAMESPACE_BEGIN
 #define MILLIS_PER_YEAR (365*24*60*60*1000.0)
 BasicTimeZone::BasicTimeZone()
 : TimeZone() {
 }
 BasicTimeZone::BasicTimeZone(const UnicodeString &id)
 : TimeZone(id) {
 }
 BasicTimeZone::BasicTimeZone(const BasicTimeZone& source)
 : TimeZone(source) {
 }
 BasicTimeZone::~BasicTimeZone() {
 }
 UBool
 BasicTimeZone::hasEquivalentTransitions(const BasicTimeZone& tz, UDate start, UDate end,
                                         UBool ignoreDstAmount, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return FALSE;
     }
     if (hasSameRules(tz)) {
         return TRUE;
     }
     // Check the offsets at the start time
     int32_t raw1, raw2, dst1, dst2;
     getOffset(start, FALSE, raw1, dst1, status);
     if (U_FAILURE(status)) {
         return FALSE;
     }
     tz.getOffset(start, FALSE, raw2, dst2, status);
     if (U_FAILURE(status)) {
         return FALSE;
     }
     if (ignoreDstAmount) {
         if ((raw1 + dst1 != raw2 + dst2)
             || (dst1 != 0 && dst2 == 0)
             || (dst1 == 0 && dst2 != 0)) {
             return FALSE;
         }
     } else {
         if (raw1 != raw2 || dst1 != dst2) {
             return FALSE;
         }
     }
     // Check transitions in the range
     UDate time = start;
     TimeZoneTransition tr1, tr2;
     while (TRUE) {
         UBool avail1 = getNextTransition(time, FALSE, tr1);
         UBool avail2 = tz.getNextTransition(time, FALSE, tr2);
         if (ignoreDstAmount) {
             // Skip a transition which only differ the amount of DST savings
             while (TRUE) {
                 if (avail1
                         && tr1.getTime() <= end
                         && (tr1.getFrom()->getRawOffset() + tr1.getFrom()->getDSTSavings()
                                 == tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings())
                         && (tr1.getFrom()->getDSTSavings() != 0 && tr1.getTo()->getDSTSavings() != 0)) {
                     getNextTransition(tr1.getTime(), FALSE, tr1);
                 } else {
                     break;
                 }
             }
             while (TRUE) {
                 if (avail2
                         && tr2.getTime() <= end
                         && (tr2.getFrom()->getRawOffset() + tr2.getFrom()->getDSTSavings()
                                 == tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings())
                         && (tr2.getFrom()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() != 0)) {
                     tz.getNextTransition(tr2.getTime(), FALSE, tr2);
                 } else {
                     break;
                 }
             }
         }
         UBool inRange1 = (avail1 && tr1.getTime() <= end);
         UBool inRange2 = (avail2 && tr2.getTime() <= end);
         if (!inRange1 && !inRange2) {
             // No more transition in the range
             break;
         }
         if (!inRange1 || !inRange2) {
             return FALSE;
         }
         if (tr1.getTime() != tr2.getTime()) {
             return FALSE;
         }
         if (ignoreDstAmount) {
             if (tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings()
                         != tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings()
                     || (tr1.getTo()->getDSTSavings() != 0 &&  tr2.getTo()->getDSTSavings() == 0)
                     || (tr1.getTo()->getDSTSavings() == 0 &&  tr2.getTo()->getDSTSavings() != 0)) {
                 return FALSE;
             }
         } else {
             if (tr1.getTo()->getRawOffset() != tr2.getTo()->getRawOffset() ||
                 tr1.getTo()->getDSTSavings() != tr2.getTo()->getDSTSavings()) {
                 return FALSE;
             }
         }
         time = tr1.getTime();
     }
     return TRUE;
 }
 void
 BasicTimeZone::getSimpleRulesNear(UDate date, InitialTimeZoneRule*& initial,
         AnnualTimeZoneRule*& std, AnnualTimeZoneRule*& dst, UErrorCode& status) const {
     initial = NULL;
     std = NULL;
     dst = NULL;
     if (U_FAILURE(status)) {
         return;
     }
     int32_t initialRaw, initialDst;
     UnicodeString initialName;
     AnnualTimeZoneRule *ar1 = NULL;
     AnnualTimeZoneRule *ar2 = NULL;
     UnicodeString name;
     UBool avail;
     TimeZoneTransition tr;
     // Get the next transition
     avail = getNextTransition(date, FALSE, tr);
     if (avail) {
         tr.getFrom()->getName(initialName);
         initialRaw = tr.getFrom()->getRawOffset();
         initialDst = tr.getFrom()->getDSTSavings();
         // Check if the next transition is either DST->STD or STD->DST and
         // within roughly 1 year from the specified date
         UDate nextTransitionTime = tr.getTime();
         if (((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
               || (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0))
             && (date + MILLIS_PER_YEAR > nextTransitionTime)) {
             int32_t year, month, dom, dow, doy, mid;
             UDate d;
             // Get local wall time for the next transition time
             Grego::timeToFields(nextTransitionTime + initialRaw + initialDst,
                 year, month, dom, dow, doy, mid);
             int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
             // Create DOW rule
             DateTimeRule *dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
             tr.getTo()->getName(name);
             // Note:  SimpleTimeZone does not support raw offset change.
             // So we always use raw offset of the given time for the rule,
             // even raw offset is changed.  This will result that the result
             // zone to return wrong offset after the transition.
             // When we encounter such case, we do not inspect next next
             // transition for another rule.
             ar1 = new AnnualTimeZoneRule(name, initialRaw, tr.getTo()->getDSTSavings(),
                 dtr, year, AnnualTimeZoneRule::MAX_YEAR);
             if (tr.getTo()->getRawOffset() == initialRaw) {
                 // Get the next next transition
                 avail = getNextTransition(nextTransitionTime, FALSE, tr);
                 if (avail) {
                     // Check if the next next transition is either DST->STD or STD->DST
                     // and within roughly 1 year from the next transition
                     if (((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
                           || (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0))
                          && nextTransitionTime + MILLIS_PER_YEAR > tr.getTime()) {
                         // Get local wall time for the next transition time
                         Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(),
                             year, month, dom, dow, doy, mid);
                         weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
                         // Generate another DOW rule
                         dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
                         tr.getTo()->getName(name);
                         ar2 = new AnnualTimeZoneRule(name, tr.getTo()->getRawOffset(), tr.getTo()->getDSTSavings(),
                             dtr, year - 1, AnnualTimeZoneRule::MAX_YEAR);
                         // Make sure this rule can be applied to the specified date
                         avail = ar2->getPreviousStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), TRUE, d);
                         if (!avail || d > date
                                 || initialRaw != tr.getTo()->getRawOffset()
                                 || initialDst != tr.getTo()->getDSTSavings()) {
                             // We cannot use this rule as the second transition rule
                             delete ar2;
                             ar2 = NULL;
                         }
                     }
                 }
             }
             if (ar2 == NULL) {
                 // Try previous transition
                 avail = getPreviousTransition(date, TRUE, tr);
                 if (avail) {
                     // Check if the previous transition is either DST->STD or STD->DST.
                     // The actual transition time does not matter here.
                     if ((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
                         || (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0)) {
                         // Generate another DOW rule
                         Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(),
                             year, month, dom, dow, doy, mid);
                         weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
                         dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
                         tr.getTo()->getName(name);
                         // second rule raw/dst offsets should match raw/dst offsets
                         // at the given time
                         ar2 = new AnnualTimeZoneRule(name, initialRaw, initialDst,
                             dtr, ar1->getStartYear() - 1, AnnualTimeZoneRule::MAX_YEAR);
                         // Check if this rule start after the first rule after the specified date
                         avail = ar2->getNextStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), FALSE, d);
                         if (!avail || d <= nextTransitionTime) {
                             // We cannot use this rule as the second transition rule
                             delete ar2;
                             ar2 = NULL;
                         }
                     }
                 }
             }
             if (ar2 == NULL) {
                 // Cannot find a good pair of AnnualTimeZoneRule
                 delete ar1;
                 ar1 = NULL;
             } else {
                 // The initial rule should represent the rule before the previous transition
                 ar1->getName(initialName);
                 initialRaw = ar1->getRawOffset();
                 initialDst = ar1->getDSTSavings();
             }
         }
     }
     else {
         // Try the previous one
         avail = getPreviousTransition(date, TRUE, tr);
         if (avail) {
             tr.getTo()->getName(initialName);
             initialRaw = tr.getTo()->getRawOffset();
             initialDst = tr.getTo()->getDSTSavings();
         } else {
             // No transitions in the past.  Just use the current offsets
             getOffset(date, FALSE, initialRaw, initialDst, status);
             if (U_FAILURE(status)) {
                 return;
             }
         }
     }
     // Set the initial rule
     initial = new InitialTimeZoneRule(initialName, initialRaw, initialDst);
     // Set the standard and daylight saving rules
     if (ar1 != NULL && ar2 != NULL) {
         if (ar1->getDSTSavings() != 0) {
             dst = ar1;
             std = ar2;
         } else {
             std = ar1;
             dst = ar2;
         }
     }
 }
 void
 BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial,
                                      UVector*& transitionRules, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     const InitialTimeZoneRule *orgini;
     const TimeZoneRule **orgtrs = NULL;
     TimeZoneTransition tzt;
     UBool avail;
     UVector *orgRules = NULL;
     int32_t ruleCount;
     TimeZoneRule *r = NULL;
     UBool *done = NULL;
     InitialTimeZoneRule *res_initial = NULL;
     UVector *filteredRules = NULL;
     UnicodeString name;
     int32_t i;
     UDate time, t;
     UDate *newTimes = NULL;
     UDate firstStart;
     UBool bFinalStd = FALSE, bFinalDst = FALSE;
     // Original transition rules
     ruleCount = countTransitionRules(status);
     if (U_FAILURE(status)) {
         return;
     }
     orgRules = new UVector(ruleCount, status);
     if (U_FAILURE(status)) {
         return;
     }
     orgtrs = (const TimeZoneRule**)uprv_malloc(sizeof(TimeZoneRule*)*ruleCount);
     if (orgtrs == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         goto error;
     }
     getTimeZoneRules(orgini, orgtrs, ruleCount, status);
     if (U_FAILURE(status)) {
         goto error;
     }
     for (i = 0; i < ruleCount; i++) {
         orgRules->addElement(orgtrs[i]->clone(), status);
         if (U_FAILURE(status)) {
             goto error;
         }
     }
     uprv_free(orgtrs);
     orgtrs = NULL;
     avail = getPreviousTransition(start, TRUE, tzt);
     if (!avail) {
         // No need to filter out rules only applicable to time before the start
         initial = orgini->clone();
         transitionRules = orgRules;
         return;
     }
     done = (UBool*)uprv_malloc(sizeof(UBool)*ruleCount);
     if (done == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         goto error;
     }
     filteredRules = new UVector(status);
     if (U_FAILURE(status)) {
         goto error;
     }
     // Create initial rule
     tzt.getTo()->getName(name);
     res_initial = new InitialTimeZoneRule(name, tzt.getTo()->getRawOffset(),
         tzt.getTo()->getDSTSavings());
     // Mark rules which does not need to be processed
     for (i = 0; i < ruleCount; i++) {
         r = (TimeZoneRule*)orgRules->elementAt(i);
         avail = r->getNextStart(start, res_initial->getRawOffset(), res_initial->getDSTSavings(), FALSE, time);
         done[i] = !avail;
     }
     time = start;
     while (!bFinalStd || !bFinalDst) {
         avail = getNextTransition(time, FALSE, tzt);
         if (!avail) {
             break;
         }
         UDate updatedTime = tzt.getTime();
         if (updatedTime == time) {
             // Can get here if rules for start & end of daylight time have exactly
             // the same time.
             // TODO:  fix getNextTransition() to prevent it?
             status = U_INVALID_STATE_ERROR;
             goto error;
         }
         time = updatedTime;
         const TimeZoneRule *toRule = tzt.getTo();
         for (i = 0; i < ruleCount; i++) {
             r = (TimeZoneRule*)orgRules->elementAt(i);
             if (*r == *toRule) {
                 break;
             }
         }
         if (i >= ruleCount) {
             // This case should never happen
             status = U_INVALID_STATE_ERROR;
             goto error;
         }
         if (done[i]) {
             continue;
         }
         const TimeArrayTimeZoneRule *tar = dynamic_cast<const TimeArrayTimeZoneRule *>(toRule);
         const AnnualTimeZoneRule *ar;
         if (tar != NULL) {
             // Get the previous raw offset and DST savings before the very first start time
             TimeZoneTransition tzt0;
             t = start;
             while (TRUE) {
                 avail = getNextTransition(t, FALSE, tzt0);
                 if (!avail) {
                     break;
                 }
                 if (*(tzt0.getTo()) == *tar) {
                     break;
                 }
                 t = tzt0.getTime();
             }
             if (avail) {
                 // Check if the entire start times to be added
                 tar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart);
                 if (firstStart > start) {
                     // Just add the rule as is
                     filteredRules->addElement(tar->clone(), status);
                     if (U_FAILURE(status)) {
                         goto error;
                     }
                 } else {
                     // Colllect transitions after the start time
                     int32_t startTimes;
                     DateTimeRule::TimeRuleType timeType;
                     int32_t idx;
                     startTimes = tar->countStartTimes();
                     timeType = tar->getTimeType();
                     for (idx = 0; idx < startTimes; idx++) {
                         tar->getStartTimeAt(idx, t);
                         if (timeType == DateTimeRule::STANDARD_TIME) {
                             t -= tzt.getFrom()->getRawOffset();
                         }
                         if (timeType == DateTimeRule::WALL_TIME) {
                             t -= tzt.getFrom()->getDSTSavings();
                         }
                         if (t > start) {
                             break;
                         }
                     }
                     int32_t asize = startTimes - idx;
                     if (asize > 0) {
                         newTimes = (UDate*)uprv_malloc(sizeof(UDate) * asize);
                         if (newTimes == NULL) {
                             status = U_MEMORY_ALLOCATION_ERROR;
                             goto error;
                         }
                         for (int32_t newidx = 0; newidx < asize; newidx++) {
                             tar->getStartTimeAt(idx + newidx, newTimes[newidx]);
                             if (U_FAILURE(status)) {
                                 uprv_free(newTimes);
                                 newTimes = NULL;
                                 goto error;
                             }
                         }
                         tar->getName(name);
                         TimeArrayTimeZoneRule *newTar = new TimeArrayTimeZoneRule(name,
                             tar->getRawOffset(), tar->getDSTSavings(), newTimes, asize, timeType);
                         uprv_free(newTimes);
                         filteredRules->addElement(newTar, status);
                         if (U_FAILURE(status)) {
                             goto error;
                         }
                     }
                 }
             }
         } else if ((ar = dynamic_cast<const AnnualTimeZoneRule *>(toRule)) != NULL) {
             ar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart);
             if (firstStart == tzt.getTime()) {
                 // Just add the rule as is
                 filteredRules->addElement(ar->clone(), status);
                 if (U_FAILURE(status)) {
                     goto error;
                 }
             } else {
                 // Calculate the transition year
                 int32_t year, month, dom, dow, doy, mid;
                 Grego::timeToFields(tzt.getTime(), year, month, dom, dow, doy, mid);
                 // Re-create the rule
                 ar->getName(name);
                 AnnualTimeZoneRule *newAr = new AnnualTimeZoneRule(name, ar->getRawOffset(), ar->getDSTSavings(),
                     *(ar->getRule()), year, ar->getEndYear());
                 filteredRules->addElement(newAr, status);
                 if (U_FAILURE(status)) {
                     goto error;
                 }
             }
             // check if this is a final rule
             if (ar->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
                 // After bot final standard and dst rules are processed,
                 // exit this while loop.
                 if (ar->getDSTSavings() == 0) {
                     bFinalStd = TRUE;
                 } else {
                     bFinalDst = TRUE;
                 }
             }
         }
         done[i] = TRUE;
     }
     // Set the results
     if (orgRules != NULL) {
         while (!orgRules->isEmpty()) {
             r = (TimeZoneRule*)orgRules->orphanElementAt(0);
             delete r;
         }
         delete orgRules;
     }
     if (done != NULL) {
         uprv_free(done);
     }
     initial = res_initial;
     transitionRules = filteredRules;
     return;
 error:
     if (orgtrs != NULL) {
         uprv_free(orgtrs);
     }
     if (orgRules != NULL) {
         while (!orgRules->isEmpty()) {
             r = (TimeZoneRule*)orgRules->orphanElementAt(0);
             delete r;
         }
         delete orgRules;
     }
     if (done != NULL) {
         if (filteredRules != NULL) {
             while (!filteredRules->isEmpty()) {
                 r = (TimeZoneRule*)filteredRules->orphanElementAt(0);
                 delete r;
             }
             delete filteredRules;
         }
         delete res_initial;
         uprv_free(done);
     }
     initial = NULL;
     transitionRules = NULL;
 }
 void
 BasicTimeZone::getOffsetFromLocal(UDate /*date*/, int32_t /*nonExistingTimeOpt*/, int32_t /*duplicatedTimeOpt*/,
                             int32_t& /*rawOffset*/, int32_t& /*dstOffset*/, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     status = U_UNSUPPORTED_ERROR;
 }
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_FORMATTING */
 //eof

The Tor Browser / annotate

intl/icu/source/i18n/basictz.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/basictz.cpp