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

1 files changed, 156 insertions, 156 deletions

diff --git a/contrib/libs/icu/i18n/calendar.cpp b/contrib/libs/icu/i18n/calendar.cpp
index 981f09c574..bc299aa4c8 100644
--- a/contrib/libs/icu/i18n/calendar.cpp
+++ b/contrib/libs/icu/i18n/calendar.cpp
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 *******************************************************************************
@@ -8,12 +8,12 @@
 *
 * File CALENDAR.CPP
 *
-* Modification History:
+* Modification History: 
 *
 *   Date        Name        Description
 *   02/03/97    clhuang     Creation.
-*   04/22/97    aliu        Cleaned up, fixed memory leak, made
-*                           setWeekCountData() more robust.
+*   04/22/97    aliu        Cleaned up, fixed memory leak, made 
+*                           setWeekCountData() more robust. 
 *                           Moved platform code to TPlatformUtilities.
 *   05/01/97    aliu        Made equals(), before(), after() arguments const.
 *   05/20/97    aliu        Changed logic of when to compute fields and time
@@ -26,7 +26,7 @@
 *******************************************************************************
 */
 
-#include "utypeinfo.h"  // for 'typeid' to work
+#include "utypeinfo.h"  // for 'typeid' to work 
 
 #include "unicode/utypes.h"
 
@@ -80,7 +80,7 @@ static UBool calendar_cleanup(void) {
     return TRUE;
 }
 U_CDECL_END
-#endif
+#endif 
 
 // ------------------------------------------
 //
@@ -92,9 +92,9 @@ U_CDECL_END
 
 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
 
-/**
- * fldName was removed as a duplicate implementation.
- * use  udbg_ services instead,
+/** 
+ * fldName was removed as a duplicate implementation. 
+ * use  udbg_ services instead, 
  * which depend on include files and library from ../tools/toolutil, the following circular link:
  *   CPPFLAGS+=-I$(top_srcdir)/tools/toolutil
  *   LIBS+=$(LIBICUTOOLUTIL)
@@ -122,7 +122,7 @@ void ucal_dump(const Calendar &cal) {
 void Calendar::dump() const {
     int i;
     fprintf(stderr, "@calendar=%s, timeset=%c, fieldset=%c, allfields=%c, virtualset=%c, t=%.2f",
-        getType(), fIsTimeSet?'y':'n',  fAreFieldsSet?'y':'n',  fAreAllFieldsSet?'y':'n',
+        getType(), fIsTimeSet?'y':'n',  fAreFieldsSet?'y':'n',  fAreAllFieldsSet?'y':'n', 
         fAreFieldsVirtuallySet?'y':'n',
         fTime);
 
@@ -134,9 +134,9 @@ void Calendar::dump() const {
         fprintf(stderr, "  %25s: %-11ld", f, fFields[i]);
         if(fStamp[i] == kUnset) {
             fprintf(stderr, " (unset) ");
-        } else if(fStamp[i] == kInternallySet) {
+        } else if(fStamp[i] == kInternallySet) { 
             fprintf(stderr, " (internally set) ");
-            //} else if(fStamp[i] == kInternalDefault) {
+            //} else if(fStamp[i] == kInternalDefault) { 
             //    fprintf(stderr, " (internal default) ");
         } else {
             fprintf(stderr, " %%%d ", fStamp[i]);
@@ -212,7 +212,7 @@ const SharedCalendar *LocaleCacheKey<SharedCalendar>::createObject(
         const void * /*unusedCreationContext*/, UErrorCode &status) const {
     Calendar *calendar = Calendar::makeInstance(fLoc, status);
     if (U_FAILURE(status)) {
-        return NULL;
+        return NULL; 
     }
     SharedCalendar *shared = new SharedCalendar(calendar);
     if (shared == NULL) {
@@ -233,9 +233,9 @@ static ECalType getCalendarType(const char *s) {
     return CALTYPE_UNKNOWN;
 }
 
-#if !UCONFIG_NO_SERVICE
-// Only used with service registration.
-static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) {
+#if !UCONFIG_NO_SERVICE 
+// Only used with service registration. 
+static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) { 
     if(U_FAILURE(status)) {
         return FALSE;
     }
@@ -243,7 +243,7 @@ static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status)
     return (calType != CALTYPE_UNKNOWN);
 }
 
-// only used with service registration.
+// only used with service registration. 
 static void getCalendarKeyword(const UnicodeString &id, char *targetBuffer, int32_t targetBufferSize) {
     UnicodeString calendarKeyword = UNICODE_STRING_SIMPLE("calendar=");
     int32_t calKeyLen = calendarKeyword.length();
@@ -257,7 +257,7 @@ static void getCalendarKeyword(const UnicodeString &id, char *targetBuffer, int3
     }
     targetBuffer[keyLen] = 0;
 }
-#endif
+#endif 
 
 static ECalType getCalendarTypeForLocale(const char *locid) {
     UErrorCode status = U_ZERO_ERROR;
@@ -268,8 +268,8 @@ static ECalType getCalendarTypeForLocale(const char *locid) {
 
     // canonicalize, so grandfathered variant will be transformed to keywords
     // e.g ja_JP_TRADITIONAL -> ja_JP@calendar=japanese
-    // NOTE: Since ICU-20187, ja_JP_TRADITIONAL no longer canonicalizes, and
-    // the Gregorian calendar is returned instead.
+    // NOTE: Since ICU-20187, ja_JP_TRADITIONAL no longer canonicalizes, and 
+    // the Gregorian calendar is returned instead. 
     int32_t canonicalLen = uloc_canonicalize(locid, canonicalName, sizeof(canonicalName) - 1, &status);
     if (U_FAILURE(status)) {
         return CALTYPE_GREGORIAN;
@@ -296,7 +296,7 @@ static ECalType getCalendarTypeForLocale(const char *locid) {
     if (U_FAILURE(status)) {
         return CALTYPE_GREGORIAN;
     }
-
+ 
     // Read preferred calendar values from supplementalData calendarPreference
     UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", &status);
     ures_getByKey(rb, "calendarPreferenceData", rb, &status);
@@ -329,73 +329,73 @@ static ECalType getCalendarTypeForLocale(const char *locid) {
 }
 
 static Calendar *createStandardCalendar(ECalType calType, const Locale &loc, UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return nullptr;
-    }
-    LocalPointer<Calendar> cal;
+    if (U_FAILURE(status)) { 
+        return nullptr; 
+    } 
+    LocalPointer<Calendar> cal; 
 
     switch (calType) {
         case CALTYPE_GREGORIAN:
-            cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status); 
             break;
         case CALTYPE_JAPANESE:
-            cal.adoptInsteadAndCheckErrorCode(new JapaneseCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new JapaneseCalendar(loc, status), status); 
             break;
         case CALTYPE_BUDDHIST:
-            cal.adoptInsteadAndCheckErrorCode(new BuddhistCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new BuddhistCalendar(loc, status), status); 
             break;
         case CALTYPE_ROC:
-            cal.adoptInsteadAndCheckErrorCode(new TaiwanCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new TaiwanCalendar(loc, status), status); 
             break;
         case CALTYPE_PERSIAN:
-            cal.adoptInsteadAndCheckErrorCode(new PersianCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new PersianCalendar(loc, status), status); 
             break;
         case CALTYPE_ISLAMIC_TBLA:
-            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::TBLA), status);
+            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::TBLA), status); 
             break;
         case CALTYPE_ISLAMIC_CIVIL:
-            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::CIVIL), status);
+            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::CIVIL), status); 
             break;
         case CALTYPE_ISLAMIC_RGSA:
             // default any region specific not handled individually to islamic
         case CALTYPE_ISLAMIC:
-            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::ASTRONOMICAL), status);
+            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::ASTRONOMICAL), status); 
             break;
         case CALTYPE_ISLAMIC_UMALQURA:
-            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::UMALQURA), status);
+            cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::UMALQURA), status); 
             break;
         case CALTYPE_HEBREW:
-            cal.adoptInsteadAndCheckErrorCode(new HebrewCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new HebrewCalendar(loc, status), status); 
             break;
         case CALTYPE_CHINESE:
-            cal.adoptInsteadAndCheckErrorCode(new ChineseCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new ChineseCalendar(loc, status), status); 
             break;
         case CALTYPE_INDIAN:
-            cal.adoptInsteadAndCheckErrorCode(new IndianCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new IndianCalendar(loc, status), status); 
             break;
         case CALTYPE_COPTIC:
-            cal.adoptInsteadAndCheckErrorCode(new CopticCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new CopticCalendar(loc, status), status); 
             break;
         case CALTYPE_ETHIOPIC:
-            cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_MIHRET_ERA), status);
+            cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_MIHRET_ERA), status); 
             break;
         case CALTYPE_ETHIOPIC_AMETE_ALEM:
-            cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_ALEM_ERA), status);
+            cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_ALEM_ERA), status); 
             break;
         case CALTYPE_ISO8601:
-            cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status);
-            if (cal.isValid()) {
-                cal->setFirstDayOfWeek(UCAL_MONDAY);
-                cal->setMinimalDaysInFirstWeek(4);
-            }
+            cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status); 
+            if (cal.isValid()) { 
+                cal->setFirstDayOfWeek(UCAL_MONDAY); 
+                cal->setMinimalDaysInFirstWeek(4); 
+            } 
             break;
         case CALTYPE_DANGI:
-            cal.adoptInsteadAndCheckErrorCode(new DangiCalendar(loc, status), status);
+            cal.adoptInsteadAndCheckErrorCode(new DangiCalendar(loc, status), status); 
             break;
         default:
             status = U_UNSUPPORTED_ERROR;
     }
-    return cal.orphan();
+    return cal.orphan(); 
 }
 
 
@@ -404,7 +404,7 @@ static Calendar *createStandardCalendar(ECalType calType, const Locale &loc, UEr
 // -------------------------------------
 
 /**
-* a Calendar Factory which creates the "basic" calendar types, that is, those
+* a Calendar Factory which creates the "basic" calendar types, that is, those 
 * shipped with ICU.
 */
 class BasicCalendarFactory : public LocaleKeyFactory {
@@ -418,7 +418,7 @@ public:
     virtual ~BasicCalendarFactory();
 
 protected:
-    //virtual UBool isSupportedID( const UnicodeString& id, UErrorCode& status) const {
+    //virtual UBool isSupportedID( const UnicodeString& id, UErrorCode& status) const { 
     //  if(U_FAILURE(status)) {
     //    return FALSE;
     //  }
@@ -476,7 +476,7 @@ protected:
 
 BasicCalendarFactory::~BasicCalendarFactory() {}
 
-/**
+/** 
 * A factory which looks up the DefaultCalendar resource to determine which class of calendar to use
 */
 
@@ -520,7 +520,7 @@ public:
     virtual UObject* cloneInstance(UObject* instance) const {
         UnicodeString *s = dynamic_cast<UnicodeString *>(instance);
         if(s != NULL) {
-            return s->clone();
+            return s->clone(); 
         } else {
 #ifdef U_DEBUG_CALSVC_F
             UErrorCode status2 = U_ZERO_ERROR;
@@ -543,10 +543,10 @@ public:
         fprintf(stderr, "CalSvc:handleDefault for currentLoc %s, canloc %s\n", (const char*)loc.getName(),  (const char*)loc2.getName());
 #endif
         Calendar *nc =  new GregorianCalendar(loc, status);
-        if (nc == nullptr) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            return nc;
-        }
+        if (nc == nullptr) { 
+            status = U_MEMORY_ALLOCATION_ERROR; 
+            return nc; 
+        } 
 
 #ifdef U_DEBUG_CALSVC
         UErrorCode status2 = U_ZERO_ERROR;
@@ -587,7 +587,7 @@ initCalendarService(UErrorCode &status)
         fprintf(stderr, "Registering classes..\n");
 #endif
 
-        // Register all basic instances.
+        // Register all basic instances. 
     gService->registerFactory(new BasicCalendarFactory(),status);
 
 #ifdef U_DEBUG_CALSVC
@@ -603,7 +603,7 @@ initCalendarService(UErrorCode &status)
     }
         }
 
-static ICULocaleService*
+static ICULocaleService* 
 getCalendarService(UErrorCode &status)
 {
     umtx_initOnce(gServiceInitOnce, &initCalendarService, status);
@@ -719,8 +719,8 @@ fZone(NULL),
 fRepeatedWallTime(UCAL_WALLTIME_LAST),
 fSkippedWallTime(UCAL_WALLTIME_LAST)
 {
-    validLocale[0] = 0;
-    actualLocale[0] = 0;
+    validLocale[0] = 0; 
+    actualLocale[0] = 0; 
     clear();
     if (U_FAILURE(success)) {
         return;
@@ -747,10 +747,10 @@ fZone(NULL),
 fRepeatedWallTime(UCAL_WALLTIME_LAST),
 fSkippedWallTime(UCAL_WALLTIME_LAST)
 {
-    validLocale[0] = 0;
-    actualLocale[0] = 0;
+    validLocale[0] = 0; 
+    actualLocale[0] = 0; 
     if (U_FAILURE(success)) {
-        delete zone;
+        delete zone; 
         return;
     }
     if(zone == 0) {
@@ -762,7 +762,7 @@ fSkippedWallTime(UCAL_WALLTIME_LAST)
         return;
     }
 
-    clear();
+    clear(); 
     fZone = zone;
     setWeekData(aLocale, NULL, success);
 }
@@ -782,8 +782,8 @@ fZone(NULL),
 fRepeatedWallTime(UCAL_WALLTIME_LAST),
 fSkippedWallTime(UCAL_WALLTIME_LAST)
 {
-    validLocale[0] = 0;
-    actualLocale[0] = 0;
+    validLocale[0] = 0; 
+    actualLocale[0] = 0; 
     if (U_FAILURE(success)) {
         return;
     }
@@ -840,10 +840,10 @@ Calendar::operator=(const Calendar &right)
         fWeekendCease            = right.fWeekendCease;
         fWeekendCeaseMillis      = right.fWeekendCeaseMillis;
         fNextStamp               = right.fNextStamp;
-        uprv_strncpy(validLocale, right.validLocale, sizeof(validLocale));
-        uprv_strncpy(actualLocale, right.actualLocale, sizeof(actualLocale));
-        validLocale[sizeof(validLocale)-1] = 0;
-        actualLocale[sizeof(validLocale)-1] = 0;
+        uprv_strncpy(validLocale, right.validLocale, sizeof(validLocale)); 
+        uprv_strncpy(actualLocale, right.actualLocale, sizeof(actualLocale)); 
+        validLocale[sizeof(validLocale)-1] = 0; 
+        actualLocale[sizeof(validLocale)-1] = 0; 
     }
 
     return *this;
@@ -873,7 +873,7 @@ Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
     return createInstance(TimeZone::createDefault(), aLocale, success);
 }
 
-// ------------------------------------- Adopting
+// ------------------------------------- Adopting 
 
 // Note: this is the bottleneck that actually calls the service routines.
 
@@ -926,7 +926,7 @@ Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
         c = (Calendar*)getCalendarService(success)->get(l, LocaleKey::KIND_ANY, &actualLoc2, success);
 
         if(U_FAILURE(success) || !c) {
-            if(U_SUCCESS(success)) {
+            if(U_SUCCESS(success)) { 
                 success = U_INTERNAL_PROGRAM_ERROR; // Propagate some err
             }
             return NULL;
@@ -934,7 +934,7 @@ Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
 
         str = dynamic_cast<const UnicodeString*>(c);
         if(str != NULL) {
-            // recursed! Second lookup returned a UnicodeString.
+            // recursed! Second lookup returned a UnicodeString. 
             // Perhaps DefaultCalendar{} was set to another locale.
 #ifdef U_DEBUG_CALSVC
             char tmp[200];
@@ -958,7 +958,7 @@ Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
 #endif
         c->setWeekData(aLocale, c->getType(), success);  // set the correct locale (this was an indirected calendar)
 
-        char keyword[ULOC_FULLNAME_CAPACITY] = "";
+        char keyword[ULOC_FULLNAME_CAPACITY] = ""; 
         UErrorCode tmpStatus = U_ZERO_ERROR;
         l.getKeywordValue("calendar", keyword, ULOC_FULLNAME_CAPACITY, tmpStatus);
         if (U_SUCCESS(tmpStatus) && uprv_strcmp(keyword, "iso8601") == 0) {
@@ -1008,7 +1008,7 @@ Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode
     if(U_SUCCESS(success) && c) {
         c->setTimeZone(zone);
     }
-    return c;
+    return c; 
 }
 
 // -------------------------------------
@@ -1040,7 +1040,7 @@ Calendar::operator==(const Calendar& that) const
         U_SUCCESS(status);
 }
 
-UBool
+UBool 
 Calendar::isEquivalentTo(const Calendar& other) const
 {
     return typeid(*this) == typeid(other) &&
@@ -1105,11 +1105,11 @@ Calendar::getKeywordValuesForLocale(const char* key,
         uenum_close(uenum);
         return NULL;
     }
-    UStringEnumeration* ustringenum = new UStringEnumeration(uenum);
-    if (ustringenum == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return ustringenum;
+    UStringEnumeration* ustringenum = new UStringEnumeration(uenum); 
+    if (ustringenum == nullptr) { 
+        status = U_MEMORY_ALLOCATION_ERROR; 
+    } 
+    return ustringenum; 
 }
 
 // -------------------------------------
@@ -1126,13 +1126,13 @@ Calendar::getNow()
 * Gets this Calendar's current time as a long.
 * @return the current time as UTC milliseconds from the epoch.
 */
-double
+double 
 Calendar::getTimeInMillis(UErrorCode& status) const
 {
-    if(U_FAILURE(status))
+    if(U_FAILURE(status)) 
         return 0.0;
 
-    if ( ! fIsTimeSet)
+    if ( ! fIsTimeSet) 
         ((Calendar*)this)->updateTime(status);
 
     /* Test for buffer overflows */
@@ -1151,9 +1151,9 @@ Calendar::getTimeInMillis(UErrorCode& status) const
 * when in lenient mode the out of range values are pinned to their respective min/max.
 * @param date the new time in UTC milliseconds from the epoch.
 */
-void
+void 
 Calendar::setTimeInMillis( double millis, UErrorCode& status ) {
-    if(U_FAILURE(status))
+    if(U_FAILURE(status)) 
         return;
 
     if (millis > MAX_MILLIS) {
@@ -1182,7 +1182,7 @@ Calendar::setTimeInMillis( double millis, UErrorCode& status ) {
         fIsSet[i]     = FALSE;
     }
 
-
+ 
 }
 
 // -------------------------------------
@@ -1506,7 +1506,7 @@ void Calendar::computeFields(UErrorCode &ec)
     double localMillis = internalGetTime();
     int32_t rawOffset, dstOffset;
     getTimeZone().getOffset(localMillis, FALSE, rawOffset, dstOffset, ec);
-    localMillis += (rawOffset + dstOffset);
+    localMillis += (rawOffset + dstOffset); 
 
     // Mark fields as set.  Do this before calling handleComputeFields().
     uint32_t mask =   //fInternalSetMask;
@@ -1515,7 +1515,7 @@ void Calendar::computeFields(UErrorCode &ec)
         (1 << UCAL_MONTH) |
         (1 << UCAL_DAY_OF_MONTH) | // = UCAL_DATE
         (1 << UCAL_DAY_OF_YEAR) |
-        (1 << UCAL_EXTENDED_YEAR);
+        (1 << UCAL_EXTENDED_YEAR); 
 
     for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
         if ((mask & 1) == 0) {
@@ -1544,7 +1544,7 @@ void Calendar::computeFields(UErrorCode &ec)
 #if defined (U_DEBUG_CAL)
     //fprintf(stderr, "%s:%d- Hmm! Jules @ %d, as per %.0lf millis\n",
     //__FILE__, __LINE__, fFields[UCAL_JULIAN_DAY], localMillis);
-#endif
+#endif 
 
     computeGregorianAndDOWFields(fFields[UCAL_JULIAN_DAY], ec);
 
@@ -1642,7 +1642,7 @@ void Calendar::computeGregorianFields(int32_t julianDay, UErrorCode & /* ec */)
 * proleptic Gregorian calendar, which has no field larger than a year.
 */
 void Calendar::computeWeekFields(UErrorCode &ec) {
-    if(U_FAILURE(ec)) {
+    if(U_FAILURE(ec)) { 
         return;
     }
     int32_t eyear = fFields[UCAL_EXTENDED_YEAR];
@@ -1705,7 +1705,7 @@ void Calendar::computeWeekFields(UErrorCode &ec) {
     fFields[UCAL_WEEK_OF_MONTH] = weekNumber(dayOfMonth, dayOfWeek);
     fFields[UCAL_DAY_OF_WEEK_IN_MONTH] = (dayOfMonth-1) / 7 + 1;
 #if defined (U_DEBUG_CAL)
-    if(fFields[UCAL_DAY_OF_WEEK_IN_MONTH]==0) fprintf(stderr, "%s:%d: DOWIM %d on %g\n",
+    if(fFields[UCAL_DAY_OF_WEEK_IN_MONTH]==0) fprintf(stderr, "%s:%d: DOWIM %d on %g\n", 
         __FILE__, __LINE__,fFields[UCAL_DAY_OF_WEEK_IN_MONTH], fTime);
 #endif
 }
@@ -1750,7 +1750,7 @@ void Calendar::handleComputeFields(int32_t /* julianDay */, UErrorCode &/* statu
 // -------------------------------------
 
 
-void Calendar::roll(EDateFields field, int32_t amount, UErrorCode& status)
+void Calendar::roll(EDateFields field, int32_t amount, UErrorCode& status) 
 {
     roll((UCalendarDateFields)field, amount, status);
 }
@@ -2088,7 +2088,7 @@ void Calendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& statu
     default:
         // Other fields cannot be rolled by this method
 #if defined (U_DEBUG_CAL)
-        fprintf(stderr, "%s:%d: ILLEGAL ARG because of roll on non-rollable field %s\n",
+        fprintf(stderr, "%s:%d: ILLEGAL ARG because of roll on non-rollable field %s\n", 
             __FILE__, __LINE__,fldName(field));
 #endif
         status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -2279,7 +2279,7 @@ void Calendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status
                 }
             }
         }
-    }
+    } 
 }
 
 // -------------------------------------
@@ -2595,7 +2595,7 @@ Calendar::isWeekend(UDate date, UErrorCode &status) const
         return FALSE;
     }
     // clone the calendar so we don't mess with the real one.
-    Calendar *work = this->clone();
+    Calendar *work = this->clone(); 
     if (work == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return FALSE;
@@ -2644,7 +2644,7 @@ Calendar::isWeekend(void) const
 
 // ------------------------------------- limits
 
-int32_t
+int32_t 
 Calendar::getMinimum(EDateFields field) const {
     return getLimit((UCalendarDateFields) field,UCAL_LIMIT_MINIMUM);
 }
@@ -2695,7 +2695,7 @@ Calendar::getLeastMaximum(UCalendarDateFields field) const
 }
 
 // -------------------------------------
-int32_t
+int32_t 
 Calendar::getActualMinimum(EDateFields field, UErrorCode& status) const
 {
     return getActualMinimum((UCalendarDateFields) field, status);
@@ -2755,7 +2755,7 @@ Calendar::getActualMinimum(UCalendarDateFields field, UErrorCode& status) const
 
     // clone the calendar so we don't mess with the real one, and set it to
     // accept anything for the field values
-    Calendar *work = this->clone();
+    Calendar *work = this->clone(); 
     if (work == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return 0;
@@ -2771,7 +2771,7 @@ Calendar::getActualMinimum(UCalendarDateFields field, UErrorCode& status) const
         work->set(field, fieldValue);
         if (work->get(field, status) != fieldValue) {
             break;
-        }
+        } 
         else {
             result = fieldValue;
             fieldValue--;
@@ -2827,7 +2827,7 @@ void Calendar::validateField(UCalendarDateFields field, UErrorCode &status) {
     case UCAL_DAY_OF_WEEK_IN_MONTH:
         if (internalGet(field) == 0) {
 #if defined (U_DEBUG_CAL)
-            fprintf(stderr, "%s:%d: ILLEGAL ARG because DOW in month cannot be 0\n",
+            fprintf(stderr, "%s:%d: ILLEGAL ARG because DOW in month cannot be 0\n", 
                 __FILE__, __LINE__);
 #endif
             status = U_ILLEGAL_ARGUMENT_ERROR; // "DAY_OF_WEEK_IN_MONTH cannot be zero"
@@ -2853,7 +2853,7 @@ void Calendar::validateField(UCalendarDateFields field, int32_t min, int32_t max
     int32_t value = fFields[field];
     if (value < min || value > max) {
 #if defined (U_DEBUG_CAL)
-        fprintf(stderr, "%s:%d: ILLEGAL ARG because of field %s out of range %d..%d  at %d\n",
+        fprintf(stderr, "%s:%d: ILLEGAL ARG because of field %s out of range %d..%d  at %d\n", 
             __FILE__, __LINE__,fldName(field),min,max,value);
 #endif
         status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -2919,7 +2919,7 @@ linesInGroup:
 }
 
 const UFieldResolutionTable Calendar::kDatePrecedence[] =
-{
+{ 
     {
         { UCAL_DAY_OF_MONTH, kResolveSTOP },
         { UCAL_WEEK_OF_YEAR, UCAL_DAY_OF_WEEK, kResolveSTOP },
@@ -2940,12 +2940,12 @@ const UFieldResolutionTable Calendar::kDatePrecedence[] =
         { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
         { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
         { kResolveSTOP }
-    },
+    }, 
     {{kResolveSTOP}}
 };
 
 
-const UFieldResolutionTable Calendar::kDOWPrecedence[] =
+const UFieldResolutionTable Calendar::kDOWPrecedence[] = 
 {
     {
         { UCAL_DAY_OF_WEEK,kResolveSTOP, kResolveSTOP },
@@ -2956,7 +2956,7 @@ const UFieldResolutionTable Calendar::kDOWPrecedence[] =
 };
 
 // precedence for calculating a year
-const UFieldResolutionTable Calendar::kYearPrecedence[] =
+const UFieldResolutionTable Calendar::kYearPrecedence[] = 
 {
     {
         { UCAL_YEAR, kResolveSTOP },
@@ -2993,7 +2993,7 @@ void Calendar::computeTime(UErrorCode& status) {
     //  }
 #endif
 
-    double millisInDay;
+    double millisInDay; 
 
     // We only use MILLISECONDS_IN_DAY if it has been set by the user.
     // This makes it possible for the caller to set the calendar to a
@@ -3113,10 +3113,10 @@ UBool Calendar::getImmediatePreviousZoneTransition(UDate base, UDate *transition
 * reflects local zone wall time.
 * @stable ICU 2.0
 */
-double Calendar::computeMillisInDay() {
+double Calendar::computeMillisInDay() { 
   // Do the time portion of the conversion.
 
-    double millisInDay = 0;
+    double millisInDay = 0; 
 
     // Find the best set of fields specifying the time of day.  There
     // are only two possibilities here; the HOUR_OF_DAY or the
@@ -3158,7 +3158,7 @@ double Calendar::computeMillisInDay() {
 * or range.
 * @stable ICU 2.0
 */
-int32_t Calendar::computeZoneOffset(double millis, double millisInDay, UErrorCode &ec) {
+int32_t Calendar::computeZoneOffset(double millis, double millisInDay, UErrorCode &ec) { 
     int32_t rawOffset, dstOffset;
     UDate wall = millis + millisInDay;
     BasicTimeZone* btz = getBasicTimeZone();
@@ -3205,7 +3205,7 @@ int32_t Calendar::computeZoneOffset(double millis, double millisInDay, UErrorCod
     return rawOffset + dstOffset;
 }
 
-int32_t Calendar::computeJulianDay()
+int32_t Calendar::computeJulianDay() 
 {
     // We want to see if any of the date fields is newer than the
     // JULIAN_DAY.  If not, then we use JULIAN_DAY.  If so, then we do
@@ -3239,17 +3239,17 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
         bestField == UCAL_DAY_OF_WEEK_IN_MONTH);
     int32_t year;
 
-    if (bestField == UCAL_WEEK_OF_YEAR && newerField(UCAL_YEAR_WOY, UCAL_YEAR) == UCAL_YEAR_WOY) {
-        year = internalGet(UCAL_YEAR_WOY);
+    if (bestField == UCAL_WEEK_OF_YEAR && newerField(UCAL_YEAR_WOY, UCAL_YEAR) == UCAL_YEAR_WOY) { 
+        year = internalGet(UCAL_YEAR_WOY); 
     } else {
         year = handleGetExtendedYear();
     }
 
-    internalSet(UCAL_EXTENDED_YEAR, year);
-
-#if defined (U_DEBUG_CAL)
+    internalSet(UCAL_EXTENDED_YEAR, year); 
+ 
+#if defined (U_DEBUG_CAL) 
     fprintf(stderr, "%s:%d: bestField= %s - y=%d\n", __FILE__, __LINE__, fldName(bestField), year);
-#endif
+#endif 
 
     // Get the Julian day of the day BEFORE the start of this year.
     // If useMonth is true, get the day before the start of the month.
@@ -3331,9 +3331,9 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
             date += ((monthLength - date) / 7 + dim + 1) * 7;
         }
     } else {
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
         fprintf(stderr, "%s:%d - bf= %s\n", __FILE__, __LINE__, fldName(bestField));
-#endif
+#endif 
 
         if(bestField == UCAL_WEEK_OF_YEAR) {  // ------------------------------------- WOY -------------
             if(!isSet(UCAL_YEAR_WOY) ||  // YWOY not set at all or
@@ -3344,30 +3344,30 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
                 int32_t woy = internalGet(bestField);
 
                 int32_t nextJulianDay = handleComputeMonthStart(year+1, 0, FALSE); // jd of day before jan 1
-                int32_t nextFirst = julianDayToDayOfWeek(nextJulianDay + 1) - firstDayOfWeek;
+                int32_t nextFirst = julianDayToDayOfWeek(nextJulianDay + 1) - firstDayOfWeek; 
 
                 if (nextFirst < 0) { // 0..6 ldow of Jan 1
                     nextFirst += 7;
                 }
 
                 if(woy==1) {  // FIRST WEEK ---------------------------------
-#if defined (U_DEBUG_CAL)
-                    fprintf(stderr, "%s:%d - woy=%d, yp=%d, nj(%d)=%d, nf=%d", __FILE__, __LINE__,
-                        internalGet(bestField), resolveFields(kYearPrecedence), year+1,
+#if defined (U_DEBUG_CAL) 
+                    fprintf(stderr, "%s:%d - woy=%d, yp=%d, nj(%d)=%d, nf=%d", __FILE__, __LINE__, 
+                        internalGet(bestField), resolveFields(kYearPrecedence), year+1, 
                         nextJulianDay, nextFirst);
 
                     fprintf(stderr, " next: %d DFW,  min=%d   \n", (7-nextFirst), getMinimalDaysInFirstWeek() );
-#endif
+#endif 
 
                     // nextFirst is now the localized DOW of Jan 1  of y-woy+1
                     if((nextFirst > 0) &&   // Jan 1 starts on FDOW
                         (7-nextFirst) >= getMinimalDaysInFirstWeek()) // or enough days in the week
                     {
                         // Jan 1 of (yearWoy+1) is in yearWoy+1 - recalculate JD to next year
-#if defined (U_DEBUG_CAL)
-                        fprintf(stderr, "%s:%d - was going to move JD from %d to %d [d%d]\n", __FILE__, __LINE__,
+#if defined (U_DEBUG_CAL) 
+                        fprintf(stderr, "%s:%d - was going to move JD from %d to %d [d%d]\n", __FILE__, __LINE__, 
                             julianDay, nextJulianDay, (nextJulianDay-julianDay));
-#endif
+#endif 
                         julianDay = nextJulianDay;
 
                         // recalculate 'first' [0-based local dow of jan 1]
@@ -3378,7 +3378,7 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
                         // recalculate date.
                         date = 1 - first + dowLocal;
                     }
-                } else if(woy>=getLeastMaximum(bestField)) {
+                } else if(woy>=getLeastMaximum(bestField)) { 
                     // could be in the last week- find out if this JD would overstep
                     int32_t testDate = date;
                     if ((7 - first) < getMinimalDaysInFirstWeek()) {
@@ -3388,7 +3388,7 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
                     // Now adjust for the week number.
                     testDate += 7 * (woy - 1);
 
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
                     fprintf(stderr, "%s:%d - y=%d, y-1=%d doy%d, njd%d (C.F. %d)\n",
                         __FILE__, __LINE__, year, year-1, testDate, julianDay+testDate, nextJulianDay);
 #endif
@@ -3402,7 +3402,7 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
                         }
                         date = 1 - first + dowLocal;
 
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
                         fprintf(stderr, "%s:%d - date now %d, jd%d, ywoy%d\n",
                             __FILE__, __LINE__, date, julianDay, year-1);
 #endif
@@ -3427,13 +3427,13 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
 }
 
 int32_t
-Calendar::getDefaultMonthInYear(int32_t /*eyear*/)
+Calendar::getDefaultMonthInYear(int32_t /*eyear*/) 
 {
     return 0;
 }
 
 int32_t
-Calendar::getDefaultDayInMonth(int32_t /*eyear*/, int32_t /*month*/)
+Calendar::getDefaultDayInMonth(int32_t /*eyear*/, int32_t /*month*/) 
 {
     return 1;
 }
@@ -3463,13 +3463,13 @@ int32_t Calendar::getLocalDOW()
 
 int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy)
 {
-    // We have UCAL_YEAR_WOY and UCAL_WEEK_OF_YEAR - from those, determine
+    // We have UCAL_YEAR_WOY and UCAL_WEEK_OF_YEAR - from those, determine 
     // what year we fall in, so that other code can set it properly.
     // (code borrowed from computeWeekFields and handleComputeJulianDay)
     //return yearWoy;
 
     // First, we need a reliable DOW.
-    UCalendarDateFields bestField = resolveFields(kDatePrecedence); // !! Note: if subclasses have a different table, they should override handleGetExtendedYearFromWeekFields
+    UCalendarDateFields bestField = resolveFields(kDatePrecedence); // !! Note: if subclasses have a different table, they should override handleGetExtendedYearFromWeekFields 
 
     // Now, a local DOW
     int32_t dowLocal = getLocalDOW(); // 0..6
@@ -3502,9 +3502,9 @@ int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t w
 
     int32_t minDays = getMinimalDaysInFirstWeek();
     UBool jan1InPrevYear = FALSE;  // January 1st in the year of WOY is the 1st week?  (i.e. first week is < minimal )
-    //UBool nextJan1InPrevYear = FALSE; // January 1st of Year of WOY + 1 is in the first week?
+    //UBool nextJan1InPrevYear = FALSE; // January 1st of Year of WOY + 1 is in the first week? 
 
-    if((7 - first) < minDays) {
+    if((7 - first) < minDays) { 
         jan1InPrevYear = TRUE;
     }
 
@@ -3527,8 +3527,8 @@ int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t w
                     return yearWoy; // in this year
                 }
             }
-        } else if(woy >= getLeastMaximum(bestField)) {
-            // we _might_ be in the last week..
+        } else if(woy >= getLeastMaximum(bestField)) { 
+            // we _might_ be in the last week.. 
             int32_t jd =  // Calculate JD of our target day:
                 jan1Start +  // JD of Jan 1
                 (7-first) + //  days in the first week (Jan 1.. )
@@ -3565,7 +3565,7 @@ int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t w
             }
 
             //(internalGet(UCAL_DATE) <= (7-first)) /* && in minDow  */ ) {
-            //within 1st week and in this month..
+            //within 1st week and in this month.. 
             //return yearWoy+1;
             return yearWoy;
 
@@ -3698,7 +3698,7 @@ void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErr
                     dow += 7;
                 }
             }
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
             fprintf(stderr, "prepareGetActualHelper(WOM/WOY) - dow=%d\n", dow);
 #endif
             set(UCAL_DAY_OF_WEEK, dow);
@@ -3714,7 +3714,7 @@ void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErr
 
 int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue, int32_t endValue, UErrorCode &status) const
 {
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
     fprintf(stderr, "getActualHelper(%d,%d .. %d, %s)\n", field, startValue, endValue, u_errorName(status));
 #endif
     if (startValue == endValue) {
@@ -3750,7 +3750,7 @@ int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue,
     int32_t result = startValue;
     if ((work->get(field, status) != startValue
          && field != UCAL_WEEK_OF_MONTH && delta > 0 ) || U_FAILURE(status)) {
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
         fprintf(stderr, "getActualHelper(fld %d) - got  %d (not %d) - %s\n", field, work->get(field,status), startValue, u_errorName(status));
 #endif
     } else {
@@ -3767,7 +3767,7 @@ int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue,
         } while (startValue != endValue);
     }
     delete work;
-#if defined (U_DEBUG_CAL)
+#if defined (U_DEBUG_CAL) 
     fprintf(stderr, "getActualHelper(%d) = %d\n", field, result);
 #endif
     return result;
@@ -3794,27 +3794,27 @@ Calendar::setWeekData(const Locale& desiredLocale, const char *type, UErrorCode&
     // Since week and weekend data is territory based instead of language based,
     // we may need to tweak the locale that we are using to try to get the appropriate
     // values, using the following logic:
-    // 1). If the locale has a language but no territory, use the territory as defined by
+    // 1). If the locale has a language but no territory, use the territory as defined by 
     //     the likely subtags.
     // 2). If the locale has a script designation then we ignore it,
     //     then remove it ( i.e. "en_Latn_US" becomes "en_US" )
-
+ 
     UErrorCode myStatus = U_ZERO_ERROR;
 
-    Locale min(desiredLocale);
-    min.minimizeSubtags(myStatus);
+    Locale min(desiredLocale); 
+    min.minimizeSubtags(myStatus); 
     Locale useLocale;
-    if ( uprv_strlen(desiredLocale.getCountry()) == 0 ||
+    if ( uprv_strlen(desiredLocale.getCountry()) == 0 || 
          (uprv_strlen(desiredLocale.getScript()) > 0 && uprv_strlen(min.getScript()) == 0) ) {
         myStatus = U_ZERO_ERROR;
-        Locale max(desiredLocale);
-        max.addLikelySubtags(myStatus);
+        Locale max(desiredLocale); 
+        max.addLikelySubtags(myStatus); 
         useLocale = Locale(max.getLanguage(),max.getCountry());
     } else {
-        useLocale = desiredLocale;
+        useLocale = desiredLocale; 
     }
-
-    /* The code here is somewhat of a hack, since week data and weekend data aren't really tied to
+ 
+    /* The code here is somewhat of a hack, since week data and weekend data aren't really tied to 
        a specific calendar, they aren't truly locale data.  But this is the only place where valid and
        actual locale can be set, so we take a shot at it here by loading a representative resource
        from the calendar data.  The code used to use the dateTimeElements resource to get first day
@@ -3890,8 +3890,8 @@ Calendar::setWeekData(const Locale& desiredLocale, const char *type, UErrorCode&
 * and areFieldsSet.  Callers should check isTimeSet and only
 * call this method if isTimeSet is false.
 */
-void
-Calendar::updateTime(UErrorCode& status)
+void 
+Calendar::updateTime(UErrorCode& status) 
 {
     computeTime(status);
     if(U_FAILURE(status))
@@ -3900,14 +3900,14 @@ Calendar::updateTime(UErrorCode& status)
     // If we are lenient, we need to recompute the fields to normalize
     // the values.  Also, if we haven't set all the fields yet (i.e.,
     // in a newly-created object), we need to fill in the fields. [LIU]
-    if (isLenient() || ! fAreAllFieldsSet)
+    if (isLenient() || ! fAreAllFieldsSet) 
         fAreFieldsSet = FALSE;
 
     fIsTimeSet = TRUE;
     fAreFieldsVirtuallySet = FALSE;
 }
 
-Locale
+Locale 
 Calendar::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
     U_LOCALE_BASED(locBased, *this);
     return locBased.getLocale(type, status);