/root/firefox-clang/intl/icu/source/i18n/calendar.cpp

Bug Summary

File:	root/firefox-clang/intl/icu/source/i18n/calendar.cpp
Warning:	line 510, column 20 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name calendar.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/i18n -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/i18n -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D U_I18N_IMPLEMENTATION -D _LIBCPP_DISABLE_DEPRECATION_WARNINGS -D U_USING_ICU_NAMESPACE=0 -D U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1 -D U_HIDE_OBSOLETE_UTF_OLD_H=1 -D UCONFIG_NO_LEGACY_CONVERSION -D UCONFIG_NO_TRANSLITERATION -D UCONFIG_NO_REGULAR_EXPRESSIONS -D UCONFIG_NO_BREAK_ITERATION -D UCONFIG_NO_IDNA -D UCONFIG_NO_MF2 -D U_CHARSET_IS_UTF8 -D UNISTR_FROM_CHAR_EXPLICIT=explicit -D UNISTR_FROM_STRING_EXPLICIT=explicit -D U_ENABLE_DYLOAD=0 -D U_DEBUG=1 -I /root/firefox-clang/config/external/icu/i18n -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/i18n -I /root/firefox-clang/intl/icu/source/common -I /root/firefox-clang/mfbt/double-conversion -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-comma -Wno-implicit-const-int-float-conversion -Wno-macro-redefined -Wno-microsoft-include -Wno-tautological-unsigned-enum-zero-compare -Wno-unreachable-code-loop-increment -Wno-unreachable-code-return -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ /root/firefox-clang/intl/icu/source/i18n/calendar.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4*******************************************************************************
5* Copyright (C) 1997-2016, International Business Machines Corporation and    *
6* others. All Rights Reserved.                                                *
7*******************************************************************************
8*
9* File CALENDAR.CPP
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   02/03/97    clhuang     Creation.
15*   04/22/97    aliu        Cleaned up, fixed memory leak, made
16*                           setWeekCountData() more robust.
17*                           Moved platform code to TPlatformUtilities.
18*   05/01/97    aliu        Made equals(), before(), after() arguments const.
19*   05/20/97    aliu        Changed logic of when to compute fields and time
20*                           to fix bugs.
21*   08/12/97    aliu        Added equivalentTo.  Misc other fixes.
22*   07/28/98    stephen     Sync up with JDK 1.2
23*   09/02/98    stephen     Sync with JDK 1.2 8/31 build (getActualMin/Max)
24*   03/17/99    stephen     Changed adoptTimeZone() - now fAreFieldsSet is
25*                           set to false to force update of time.
26*******************************************************************************
27*/

29#include "utypeinfo.h"  // for 'typeid' to work

31#include "unicode/utypes.h"

33#if !UCONFIG_NO_FORMATTING0

35#include "unicode/gregocal.h"
36#include "unicode/basictz.h"
37#include "unicode/simpletz.h"
38#include "unicode/rbtz.h"
39#include "unicode/vtzone.h"
40#include "gregoimp.h"
41#include "buddhcal.h"
42#include "taiwncal.h"
43#include "japancal.h"
44#include "islamcal.h"
45#include "hebrwcal.h"
46#include "persncal.h"
47#include "indiancal.h"
48#include "iso8601cal.h"
49#include "chnsecal.h"
50#include "coptccal.h"
51#include "dangical.h"
52#include "ethpccal.h"
53#include "unicode/calendar.h"
54#include "cpputils.h"
55#include "servloc.h"
56#include "ucln_in.h"
57#include "cstring.h"
58#include "locbased.h"
59#include "uresimp.h"
60#include "ustrenum.h"
61#include "uassert.h"
62#include "olsontz.h"
63#include "sharedcalendar.h"
64#include "unifiedcache.h"
65#include "ulocimp.h"
66#include "charstr.h"

68#if !UCONFIG_NO_SERVICE0
69static icu::ICULocaleService* gService = nullptr;
70static icu::UInitOnce gServiceInitOnce {};

72// INTERNAL - for cleanup
73U_CDECL_BEGINextern "C" {
74static UBool calendar_cleanup() {
75#if !UCONFIG_NO_SERVICE0
  if (gService) {
      delete gService;
      gService = nullptr;
  }
  gServiceInitOnce.reset();
81#endif
  return true;
83}
84U_CDECL_END}
85#endif

87// ------------------------------------------
88//
89// Registration
90//
91//-------------------------------------------
92//#define U_DEBUG_CALSVC 1
93//

95#if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)

97/**
* 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)
*/
104#include "udbgutil.h"
105#include <stdio.h>

107/**
108* convert a UCalendarDateFields into a string - for debugging
109* @param f field enum
110* @return static string to the field name
111* @internal
112*/

114const char* fldName(UCalendarDateFields f) {
  return udbg_enumName(UDBG_UCalendarDateFields, (int32_t)f);
116}

118#if UCAL_DEBUG_DUMP
119// from CalendarTest::calToStr - but doesn't modify contents.
120void ucal_dump(const Calendar &cal) {
  cal.dump();
122}

124void Calendar::dump() const {
  int i;
  fprintf(stderrstderr, "@calendar=%s, timeset=%c, fieldset=%c, allfields=%c, virtualset=%c, t=%.2f",
      getType(), fIsTimeSet?'y':'n',  fAreFieldsSet?'y':'n',  fAreAllFieldsSet?'y':'n',
      fAreFieldsVirtuallySet?'y':'n',
      fTime);

  // can add more things here: DST, zone, etc.
  fprintf(stderrstderr, "\n");
  for(i = 0;i<UCAL_FIELD_COUNT;i++) {
      int n;
      const char *f = fldName((UCalendarDateFields)i);
      fprintf(stderrstderr, "  %25s: %-11ld", f, fFields[i]);
      if(fStamp[i] == kUnset) {
          fprintf(stderrstderr, " (unset) ");
      } else if(fStamp[i] == kInternallySet) {
          fprintf(stderrstderr, " (internally set) ");
          //} else if(fStamp[i] == kInternalDefault) {
          //    fprintf(stderr, " (internal default) ");
      } else {
          fprintf(stderrstderr, " %%%d ", fStamp[i]);
      }
      fprintf(stderrstderr, "\n");

  }
149}

151U_CFUNCextern "C" void ucal_dump(UCalendar* cal) {
  ucal_dump( *((Calendar*)cal)  );
153}
154#endif

156#endif

158/* Max value for stamp allowable before recalculation */
159#define STAMP_MAX127 127

161static const char * const gCalTypes[] = {
  "gregorian",
  "japanese",
  "buddhist",
  "roc",
  "persian",
  "islamic-civil",
  "islamic",
  "hebrew",
  "chinese",
  "indian",
  "coptic",
  "ethiopic",
  "ethiopic-amete-alem",
  "iso8601",
  "dangi",
  "islamic-umalqura",
  "islamic-tbla",
  "islamic-rgsa",
  nullptr
181};

183// Must be in the order of gCalTypes above
184typedef enum ECalType {
  CALTYPE_UNKNOWN = -1,
  CALTYPE_GREGORIAN = 0,
  CALTYPE_JAPANESE,
  CALTYPE_BUDDHIST,
  CALTYPE_ROC,
  CALTYPE_PERSIAN,
  CALTYPE_ISLAMIC_CIVIL,
  CALTYPE_ISLAMIC,
  CALTYPE_HEBREW,
  CALTYPE_CHINESE,
  CALTYPE_INDIAN,
  CALTYPE_COPTIC,
  CALTYPE_ETHIOPIC,
  CALTYPE_ETHIOPIC_AMETE_ALEM,
  CALTYPE_ISO8601,
  CALTYPE_DANGI,
  CALTYPE_ISLAMIC_UMALQURA,
  CALTYPE_ISLAMIC_TBLA,
  CALTYPE_ISLAMIC_RGSA
204} ECalType;

206U_NAMESPACE_BEGINnamespace icu_77 {

208SharedCalendar::~SharedCalendar() {
  delete ptr;
210}

212template<> U_I18N_API
213const SharedCalendar *LocaleCacheKey<SharedCalendar>::createObject(
      const void * /*unusedCreationContext*/, UErrorCode &status) const {
  if (U_FAILURE(status)) {
     return nullptr;
  }
  Calendar *calendar = Calendar::makeInstance(fLoc, status);
  if (U_FAILURE(status)) {
      return nullptr;
  }
  SharedCalendar *shared = new SharedCalendar(calendar);
  if (shared == nullptr) {
      delete calendar;
      status = U_MEMORY_ALLOCATION_ERROR;
      return nullptr;
  }
  shared->addRef();
  return shared;
230}

232static ECalType getCalendarType(const char *s) {
  for (int i = 0; gCalTypes[i] != nullptr; i++) {
      if (uprv_stricmpuprv_stricmp_77(s, gCalTypes[i]) == 0) {
          return static_cast<ECalType>(i);
      }
  }
  return CALTYPE_UNKNOWN;
239}

241#if !UCONFIG_NO_SERVICE0
242// Only used with service registration.
243static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) {
  if(U_FAILURE(status)) {
      return false;
  }
  ECalType calType = getCalendarType(keyword);
  return (calType != CALTYPE_UNKNOWN);
249}

251#endif

253static ECalType getCalendarTypeForLocale(const char *locid) {
  UErrorCode status = U_ZERO_ERROR;
  ECalType calType = CALTYPE_UNKNOWN;

  // Canonicalize, so that an old-style 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.
  CharString canonicalName = ulocimp_canonicalizeulocimp_canonicalize_77(locid, status);
  if (U_FAILURE(status)) {
      return CALTYPE_GREGORIAN;
  }

  CharString calTypeBuf = ulocimp_getKeywordValueulocimp_getKeywordValue_77(canonicalName.data(), "calendar", status);
  if (U_SUCCESS(status)) {
      calType = getCalendarType(calTypeBuf.data());
      if (calType != CALTYPE_UNKNOWN) {
          return calType;
      }
  }
  status = U_ZERO_ERROR;

  // when calendar keyword is not available or not supported, read supplementalData
  // to get the default calendar type for the locale's region
  CharString region = ulocimp_getRegionForSupplementalDataulocimp_getRegionForSupplementalData_77(canonicalName.data(), true, status);
  if (U_FAILURE(status)) {
      return CALTYPE_GREGORIAN;
  }

  // Read preferred calendar values from supplementalData calendarPreference
  UResourceBundle *rb = ures_openDirectures_openDirect_77(nullptr, "supplementalData", &status);
  ures_getByKeyures_getByKey_77(rb, "calendarPreferenceData", rb, &status);
  UResourceBundle *order = ures_getByKeyures_getByKey_77(rb, region.data(), nullptr, &status);
  if (status == U_MISSING_RESOURCE_ERROR && rb != nullptr) {
      status = U_ZERO_ERROR;
      order = ures_getByKeyures_getByKey_77(rb, "001", nullptr, &status);
  }

  calTypeBuf.clear();
  if (U_SUCCESS(status) && order != nullptr) {
      // the first calendar type is the default for the region
      int32_t len = 0;
      const char16_t *uCalType = ures_getStringByIndexures_getStringByIndex_77(order, 0, &len, &status);
      calTypeBuf.appendInvariantChars(uCalType, len, status);
      calType = getCalendarType(calTypeBuf.data());
  }

  ures_closeures_close_77(order);
  ures_closeures_close_77(rb);

  if (calType == CALTYPE_UNKNOWN) {
      // final fallback
      calType = CALTYPE_GREGORIAN;
  }
  return calType;
308}

310static Calendar *createStandardCalendar(ECalType calType, const Locale &loc, UErrorCode& status) {
  if (U_FAILURE(status)) {
      return nullptr;
  }
  LocalPointer<Calendar> cal;

  switch (calType) {
      case CALTYPE_GREGORIAN:
          cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status);
          break;
      case CALTYPE_JAPANESE:
          cal.adoptInsteadAndCheckErrorCode(new JapaneseCalendar(loc, status), status);
          break;
      case CALTYPE_BUDDHIST:
          cal.adoptInsteadAndCheckErrorCode(new BuddhistCalendar(loc, status), status);
          break;
      case CALTYPE_ROC:
          cal.adoptInsteadAndCheckErrorCode(new TaiwanCalendar(loc, status), status);
          break;
      case CALTYPE_PERSIAN:
          cal.adoptInsteadAndCheckErrorCode(new PersianCalendar(loc, status), status);
          break;
      case CALTYPE_ISLAMIC_TBLA:
          cal.adoptInsteadAndCheckErrorCode(new IslamicTBLACalendar(loc, status), status);
          break;
      case CALTYPE_ISLAMIC_CIVIL:
          cal.adoptInsteadAndCheckErrorCode(new IslamicCivilCalendar(loc, status), status);
          break;
      case CALTYPE_ISLAMIC_RGSA:
          cal.adoptInsteadAndCheckErrorCode(new IslamicRGSACalendar(loc, status), status);
          break;
      case CALTYPE_ISLAMIC:
          cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status), status);
          break;
      case CALTYPE_ISLAMIC_UMALQURA:
          cal.adoptInsteadAndCheckErrorCode(new IslamicUmalquraCalendar(loc, status), status);
          break;
      case CALTYPE_HEBREW:
          cal.adoptInsteadAndCheckErrorCode(new HebrewCalendar(loc, status), status);
          break;
      case CALTYPE_CHINESE:
          cal.adoptInsteadAndCheckErrorCode(new ChineseCalendar(loc, status), status);
          break;
      case CALTYPE_INDIAN:
          cal.adoptInsteadAndCheckErrorCode(new IndianCalendar(loc, status), status);
          break;
      case CALTYPE_COPTIC:
          cal.adoptInsteadAndCheckErrorCode(new CopticCalendar(loc, status), status);
          break;
      case CALTYPE_ETHIOPIC:
          cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status), status);
          break;
      case CALTYPE_ETHIOPIC_AMETE_ALEM:
          cal.adoptInsteadAndCheckErrorCode(new EthiopicAmeteAlemCalendar(loc, status), status);
          break;
      case CALTYPE_ISO8601:
          cal.adoptInsteadAndCheckErrorCode(new ISO8601Calendar(loc, status), status);
          break;
      case CALTYPE_DANGI:
          cal.adoptInsteadAndCheckErrorCode(new DangiCalendar(loc, status), status);
          break;
      default:
          status = U_UNSUPPORTED_ERROR;
  }
  return cal.orphan();
375}


378#if !UCONFIG_NO_SERVICE0

380// -------------------------------------

382/**
383* a Calendar Factory which creates the "basic" calendar types, that is, those
384* shipped with ICU.
385*/
386class BasicCalendarFactory : public LocaleKeyFactory {
387public:
  /**
  * @param calendarType static const string (caller owns storage - will be aliased) to calendar type
  */
  BasicCalendarFactory()
      : LocaleKeyFactory(LocaleKeyFactory::INVISIBLE) { }

  virtual ~BasicCalendarFactory();

396protected:
  //virtual UBool isSupportedID( const UnicodeString& id, UErrorCode& status) const {
  //  if(U_FAILURE(status)) {
  //    return false;
  //  }
  //  char keyword[ULOC_FULLNAME_CAPACITY];
  //  getCalendarKeyword(id, keyword, (int32_t)sizeof(keyword));
  //  return isStandardSupportedKeyword(keyword, status);
  //}

  virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const override
  {
      if (U_SUCCESS(status)) {
          for(int32_t i=0;gCalTypes[i] != nullptr;i++) {
              UnicodeString id(static_cast<char16_t>(0x40)); /* '@' a variant character */
              id.append(UNICODE_STRING_SIMPLE("calendar=")icu::UnicodeString(true, u"calendar=", -1));
              id.append(UnicodeString(gCalTypes[i], -1, US_INVicu::UnicodeString::kInvariant));
              result.put(id, (void*)this, status);
          }
      }
  }

  virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const override {
      if (U_FAILURE(status)) {
         return nullptr;
      }
422#ifdef U_DEBUG_CALSVC
      if(dynamic_cast<const LocaleKey*>(&key) == nullptr) {
          fprintf(stderrstderr, "::create - not a LocaleKey!\n");
      }
426#endif
      const LocaleKey* lkey = dynamic_cast<const LocaleKey*>(&key);
      U_ASSERT(lkey != nullptr)(static_cast <bool> (lkey != nullptr) ? void (0) : __assert_fail
 ("lkey != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      Locale curLoc;  // current locale
      Locale canLoc;  // Canonical locale

      lkey->currentLocale(curLoc);
      lkey->canonicalLocale(canLoc);

      char keyword[ULOC_FULLNAME_CAPACITY157];
      curLoc.getKeywordValue("calendar", keyword, static_cast<int32_t>(sizeof(keyword)), status);

438#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "BasicCalendarFactory::create() - cur %s, can %s\n", (const char*)curLoc.getName(), (const char*)canLoc.getName());
440#endif

      if(!isStandardSupportedKeyword(keyword,status)) {  // Do we handle this type?
443#ifdef U_DEBUG_CALSVC

          fprintf(stderrstderr, "BasicCalendarFactory - not handling %s.[%s]\n", (const char*) curLoc.getName(), tmp );
446#endif
          return nullptr;
      }

      return createStandardCalendar(getCalendarType(keyword), canLoc, status);
  }
452};

454BasicCalendarFactory::~BasicCalendarFactory() {}

456/**
457* A factory which looks up the DefaultCalendar resource to determine which class of calendar to use
458*/

460class DefaultCalendarFactory : public ICUResourceBundleFactory {
461public:
  DefaultCalendarFactory() : ICUResourceBundleFactory() { }
  virtual ~DefaultCalendarFactory();
464protected:
  virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const override {
      if (U_FAILURE(status)) {
         return nullptr;
      }

      const LocaleKey *lkey = dynamic_cast<const LocaleKey*>(&key);
      U_ASSERT(lkey != nullptr)(static_cast <bool> (lkey != nullptr) ? void (0) : __assert_fail
 ("lkey != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      Locale loc;
      lkey->currentLocale(loc);

      UnicodeString *ret = new UnicodeString();
      if (ret == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
      } else {
          ret->append(static_cast<char16_t>(0x40)); // '@' is a variant character
          ret->append(UNICODE_STRING("calendar=", 9)icu::UnicodeString(true, u"calendar=", 9));
          ret->append(UnicodeString(gCalTypes[getCalendarTypeForLocale(loc.getName())], -1, US_INVicu::UnicodeString::kInvariant));
      }
      return ret;
  }
485};

487DefaultCalendarFactory::~DefaultCalendarFactory() {}

489// -------------------------------------
490class CalendarService : public ICULocaleService {
491public:
  CalendarService()
      : ICULocaleService(UNICODE_STRING_SIMPLE("Calendar")icu::UnicodeString(true, u"Calendar", -1))
  {
      UErrorCode status = U_ZERO_ERROR;
      registerFactory(new DefaultCalendarFactory(), status);
  }

  virtual ~CalendarService();

  virtual UObject* cloneInstance(UObject* instance) const override {
      UnicodeString *s = dynamic_cast<UnicodeString *>(instance);
      if(s != nullptr) {
1
Assuming pointer value is null→
2
←
Taking false branch→
          return s->clone();
      } else {
506#ifdef U_DEBUG_CALSVC_F
          UErrorCode status2 = U_ZERO_ERROR;
          fprintf(stderrstderr, "Cloning a %s calendar with tz=%ld\n", ((Calendar*)instance)->getType(), ((Calendar*)instance)->get(UCAL_ZONE_OFFSET, status2));
509#endif
          return ((Calendar*)instance)->clone();
3
←
Called C++ object pointer is null
      }
  }

  virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const override {
      if (U_FAILURE(status)) {
         return nullptr;
      }
      LocaleKey& lkey = static_cast<LocaleKey&>(const_cast<ICUServiceKey&>(key));
      //int32_t kind = lkey.kind();

      Locale loc;
      lkey.canonicalLocale(loc);

524#ifdef U_DEBUG_CALSVC
      Locale loc2;
      lkey.currentLocale(loc2);
      fprintf(stderrstderr, "CalSvc:handleDefault for currentLoc %s, canloc %s\n", (const char*)loc.getName(),  (const char*)loc2.getName());
528#endif
      Calendar *nc =  new GregorianCalendar(loc, status);
      if (nc == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return nc;
      }

535#ifdef U_DEBUG_CALSVC
      UErrorCode status2 = U_ZERO_ERROR;
      fprintf(stderrstderr, "New default calendar has tz=%d\n", ((Calendar*)nc)->get(UCAL_ZONE_OFFSET, status2));
538#endif
      return nc;
  }

  virtual UBool isDefault() const override {
      return countFactories() == 1;
  }
545};

547CalendarService::~CalendarService() {}

549// -------------------------------------

551static inline UBool
552isCalendarServiceUsed() {
  return !gServiceInitOnce.isReset();
554}

556// -------------------------------------

558static void U_CALLCONV
559initCalendarService(UErrorCode &status)
560{
561#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Spinning up Calendar Service\n");
563#endif
  if (U_FAILURE(status)) {
     return;
  }
  ucln_i18n_registerCleanupucln_i18n_registerCleanup_77(UCLN_I18N_CALENDAR, calendar_cleanup);
  gService = new CalendarService();
  if (gService == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
      return;
      }
573#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Registering classes..\n");
575#endif

      // Register all basic instances.
  gService->registerFactory(new BasicCalendarFactory(),status);

580#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Done..\n");
582#endif

      if(U_FAILURE(status)) {
585#ifdef U_DEBUG_CALSVC
          fprintf(stderrstderr, "err (%s) registering classes, deleting service.....\n", u_errorNameu_errorName_77(status));
587#endif
      delete gService;
      gService = nullptr;
  }
      }

593static ICULocaleService*
594getCalendarService(UErrorCode &status)
595{
  umtx_initOnce(gServiceInitOnce, &initCalendarService, status);
  return gService;
598}

600URegistryKey Calendar::registerFactory(ICUServiceFactory* toAdopt, UErrorCode& status)
601{
  return getCalendarService(status)->registerFactory(toAdopt, status);
603}

605UBool Calendar::unregister(URegistryKey key, UErrorCode& status) {
  return getCalendarService(status)->unregister(key, status);
607}
608#endif /* UCONFIG_NO_SERVICE */

610// -------------------------------------

612static const int32_t kCalendarLimits[UCAL_FIELD_COUNT][4] = {
  //    Minimum  Greatest min      Least max   Greatest max
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // ERA
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // YEAR
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // MONTH
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // WEEK_OF_YEAR
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // WEEK_OF_MONTH
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // DAY_OF_MONTH
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // DAY_OF_YEAR
  {           1,            1,             7,             7  }, // DAY_OF_WEEK
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // DAY_OF_WEEK_IN_MONTH
  {           0,            0,             1,             1  }, // AM_PM
  {           0,            0,            11,            11  }, // HOUR
  {           0,            0,            23,            23  }, // HOUR_OF_DAY
  {           0,            0,            59,            59  }, // MINUTE
  {           0,            0,            59,            59  }, // SECOND
  {           0,            0,           999,           999  }, // MILLISECOND
  {-24*kOneHour(60*60*1000), -16*kOneHour(60*60*1000),   12*kOneHour(60*60*1000),   30*kOneHour(60*60*1000)  }, // ZONE_OFFSET
  { -1*kOneHour(60*60*1000),  -1*kOneHour(60*60*1000),    2*kOneHour(60*60*1000),    2*kOneHour(60*60*1000)  }, // DST_OFFSET
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // YEAR_WOY
  {           1,            1,             7,             7  }, // DOW_LOCAL
  {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // EXTENDED_YEAR
  { -0x7F000000,  -0x7F000000,    0x7F000000,    0x7F000000  }, // JULIAN_DAY
  {           0,            0, 24*kOneHour(60*60*1000)-1, 24*kOneHour(60*60*1000)-1  }, // MILLISECONDS_IN_DAY
  {           0,            0,             1,             1  }, // IS_LEAP_MONTH
  {           0,            0,            11,            11  }  // ORDINAL_MONTH
638};

640// Resource bundle tags read by this class
641static const char gCalendar[] = "calendar";
642static const char gMonthNames[] = "monthNames";
643static const char gGregorian[] = "gregorian";

645// Data flow in Calendar
646// ---------------------

648// The current time is represented in two ways by Calendar: as UTC
649// milliseconds from the epoch start (1 January 1970 0:00 UTC), and as local
650// fields such as MONTH, HOUR, AM_PM, etc.  It is possible to compute the
651// millis from the fields, and vice versa.  The data needed to do this
652// conversion is encapsulated by a TimeZone object owned by the Calendar.
653// The data provided by the TimeZone object may also be overridden if the
654// user sets the ZONE_OFFSET and/or DST_OFFSET fields directly. The class
655// keeps track of what information was most recently set by the caller, and
656// uses that to compute any other information as needed.

658// If the user sets the fields using set(), the data flow is as follows.
659// This is implemented by the Calendar subclass's computeTime() method.
660// During this process, certain fields may be ignored.  The disambiguation
661// algorithm for resolving which fields to pay attention to is described
662// above.

664//   local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
665//           |
666//           | Using Calendar-specific algorithm
667//           V
668//   local standard millis
669//           |
670//           | Using TimeZone or user-set ZONE_OFFSET / DST_OFFSET
671//           V
672//   UTC millis (in time data member)

674// If the user sets the UTC millis using setTime(), the data flow is as
675// follows.  This is implemented by the Calendar subclass's computeFields()
676// method.

678//   UTC millis (in time data member)
679//           |
680//           | Using TimeZone getOffset()
681//           V
682//   local standard millis
683//           |
684//           | Using Calendar-specific algorithm
685//           V
686//   local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)

688// In general, a round trip from fields, through local and UTC millis, and
689// back out to fields is made when necessary.  This is implemented by the
690// complete() method.  Resolving a partial set of fields into a UTC millis
691// value allows all remaining fields to be generated from that value.  If
692// the Calendar is lenient, the fields are also renormalized to standard
693// ranges when they are regenerated.

695// -------------------------------------

697Calendar::Calendar(UErrorCode& success)
  UObject(),
699fIsTimeSet(false),
700fAreFieldsSet(false),
701fAreAllFieldsSet(false),
702fAreFieldsVirtuallySet(false),
703fLenient(true),
704fRepeatedWallTime(UCAL_WALLTIME_LAST),
705fSkippedWallTime(UCAL_WALLTIME_LAST)
706{
  clear();
  if (U_FAILURE(success)) {
      return;
  }
  fZone = TimeZone::createDefault();
  if (fZone == nullptr) {
      success = U_MEMORY_ALLOCATION_ERROR;
  }
  setWeekData(Locale::getDefault(), nullptr, success);
716}

718// -------------------------------------

720Calendar::Calendar(TimeZone* adoptZone, const Locale& aLocale, UErrorCode& success)
  UObject(),
722fIsTimeSet(false),
723fAreFieldsSet(false),
724fAreAllFieldsSet(false),
725fAreFieldsVirtuallySet(false),
726fLenient(true),
727fRepeatedWallTime(UCAL_WALLTIME_LAST),
728fSkippedWallTime(UCAL_WALLTIME_LAST)
729{
  LocalPointer<TimeZone> zone(adoptZone, success);
  if (U_FAILURE(success)) {
      return;
  }
  if (zone.isNull()) {
735#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because timezone cannot be 0\n",
          __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__737);
738#endif
      success = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  clear();
  fZone = zone.orphan();
  setWeekData(aLocale, nullptr, success);
746}

748// -------------------------------------

750Calendar::Calendar(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
  UObject(),
752fIsTimeSet(false),
753fAreFieldsSet(false),
754fAreAllFieldsSet(false),
755fAreFieldsVirtuallySet(false),
756fLenient(true),
757fRepeatedWallTime(UCAL_WALLTIME_LAST),
758fSkippedWallTime(UCAL_WALLTIME_LAST)
759{
  if (U_FAILURE(success)) {
      return;
  }
  clear();
  fZone = zone.clone();
  if (fZone == nullptr) {
      success = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  setWeekData(aLocale, nullptr, success);
770}

772// -------------------------------------

774Calendar::~Calendar()
775{
  delete fZone;
  delete actualLocale;
  delete validLocale;
779}

781// -------------------------------------

783Calendar::Calendar(const Calendar &source)
  UObject(source)
785{
  *this = source;
787}

789// -------------------------------------

791Calendar &
792Calendar::operator=(const Calendar &right)
793{
  if (this != &right) {
      uprv_arrayCopy(right.fFields, fFields, UCAL_FIELD_COUNT);
      uprv_arrayCopy(right.fStamp, fStamp, UCAL_FIELD_COUNT);
      fTime                    = right.fTime;
      fIsTimeSet               = right.fIsTimeSet;
      fAreAllFieldsSet         = right.fAreAllFieldsSet;
      fAreFieldsSet            = right.fAreFieldsSet;
      fAreFieldsVirtuallySet   = right.fAreFieldsVirtuallySet;
      fLenient                 = right.fLenient;
      fRepeatedWallTime        = right.fRepeatedWallTime;
      fSkippedWallTime         = right.fSkippedWallTime;
      delete fZone;
      fZone = nullptr;
      if (right.fZone != nullptr) {
          fZone                = right.fZone->clone();
      }
      fFirstDayOfWeek          = right.fFirstDayOfWeek;
      fMinimalDaysInFirstWeek  = right.fMinimalDaysInFirstWeek;
      fWeekendOnset            = right.fWeekendOnset;
      fWeekendOnsetMillis      = right.fWeekendOnsetMillis;
      fWeekendCease            = right.fWeekendCease;
      fWeekendCeaseMillis      = right.fWeekendCeaseMillis;
      fNextStamp               = right.fNextStamp;
      UErrorCode status = U_ZERO_ERROR;
      U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
      locBased.setLocaleIDs(right.validLocale, right.actualLocale, status);
      U_ASSERT(U_SUCCESS(status))(static_cast <bool> (U_SUCCESS(status)) ? void (0) : __assert_fail
 ("U_SUCCESS(status)", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  }

  return *this;
824}

826// -------------------------------------

828Calendar* U_EXPORT2
829Calendar::createInstance(UErrorCode& success)
830{
  return createInstance(TimeZone::createDefault(), Locale::getDefault(), success);
832}

834// -------------------------------------

836Calendar* U_EXPORT2
837Calendar::createInstance(const TimeZone& zone, UErrorCode& success)
838{
  return createInstance(zone, Locale::getDefault(), success);
840}

842// -------------------------------------

844Calendar* U_EXPORT2
845Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
846{
  return createInstance(TimeZone::forLocaleOrDefault(aLocale), aLocale, success);
848}

850// ------------------------------------- Adopting

852// Note: this is the bottleneck that actually calls the service routines.

854Calendar * U_EXPORT2
855Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
  if (U_FAILURE(success)) {
      return nullptr;
  }

  Locale actualLoc;
  UObject* u = nullptr;

863#if !UCONFIG_NO_SERVICE0
  if (isCalendarServiceUsed()) {
      u = getCalendarService(success)->get(aLocale, LocaleKey::KIND_ANY, &actualLoc, success);
  }
  else
868#endif
  {
      u = createStandardCalendar(getCalendarTypeForLocale(aLocale.getName()), aLocale, success);
  }
  Calendar* c = nullptr;

  if(U_FAILURE(success) || !u) {
      if(U_SUCCESS(success)) { // Propagate some kind of err
          success = U_INTERNAL_PROGRAM_ERROR;
      }
      return nullptr;
  }

881#if !UCONFIG_NO_SERVICE0
  const UnicodeString* str = dynamic_cast<const UnicodeString*>(u);
  if(str != nullptr) {
      // It's a unicode string telling us what type of calendar to load ("gregorian", etc)
      // Create a Locale over this string
      Locale l("");
      LocaleUtility::initLocaleFromName(*str, l);

889#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Calendar::createInstance(%s), looking up [%s]\n", aLocale.getName(), l.getName());
891#endif

      Locale actualLoc2;
      delete u;
      u = nullptr;

      // Don't overwrite actualLoc, since the actual loc from this call
      // may be something like "@calendar=gregorian" -- TODO investigate
      // further...
      c = (Calendar*)getCalendarService(success)->get(l, LocaleKey::KIND_ANY, &actualLoc2, success);

      if(U_FAILURE(success) || !c) {
          if(U_SUCCESS(success)) {
              success = U_INTERNAL_PROGRAM_ERROR; // Propagate some err
          }
          return nullptr;
      }

      str = dynamic_cast<const UnicodeString*>(c);
      if(str != nullptr) {
          // recursed! Second lookup returned a UnicodeString.
          // Perhaps DefaultCalendar{} was set to another locale.
913#ifdef U_DEBUG_CALSVC
          char tmp[200];
          // Extract a char* out of it..
          int32_t len = str->length();
          int32_t actLen = sizeof(tmp)-1;
          if(len > actLen) {
              len = actLen;
          }
          str->extract(0,len,tmp);
          tmp[len]=0;

          fprintf(stderrstderr, "err - recursed, 2nd lookup was unistring %s\n", tmp);
925#endif
          success = U_MISSING_RESOURCE_ERROR;  // requested a calendar type which could NOT be found.
          delete c;
          return nullptr;
      }
930#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "%p: setting week count data to locale %s, actual locale %s\n", c, (const char*)aLocale.getName(), (const char *)actualLoc.getName());
932#endif
      c->setWeekData(aLocale, c->getType(), success);  // set the correct locale (this was an indirect calendar)

      char keyword[ULOC_FULLNAME_CAPACITY157] = "";
      UErrorCode tmpStatus = U_ZERO_ERROR;
      l.getKeywordValue("calendar", keyword, ULOC_FULLNAME_CAPACITY157, tmpStatus);
      if (U_SUCCESS(tmpStatus) && uprv_strcmp(keyword, "iso8601"):: strcmp(keyword, "iso8601") == 0) {
          c->setFirstDayOfWeek(UCAL_MONDAY);
          c->setMinimalDaysInFirstWeek(4);
      }
  }
  else
944#endif /* UCONFIG_NO_SERVICE */
  {
      // a calendar was returned - we assume the factory did the right thing.
      c = (Calendar*)u;
  }

  return c;
951}

953Calendar* U_EXPORT2
954Calendar::createInstance(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
955{
  LocalPointer<TimeZone> zonePtr(zone);
  const SharedCalendar *shared = nullptr;
  UnifiedCache::getByLocale(aLocale, shared, success);
  if (U_FAILURE(success)) {
      return nullptr;
  }
  Calendar *c = (*shared)->clone();
  shared->removeRef();
  if (c == nullptr) {
      success = U_MEMORY_ALLOCATION_ERROR;
      return nullptr;
  }

  // Now, reset calendar to default state:
  c->adoptTimeZone(zonePtr.orphan()); //  Set the correct time zone
  c->setTimeInMillis(getNow(), success); // let the new calendar have the current time.

  return c;
974}

976// -------------------------------------

978Calendar* U_EXPORT2
979Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
980{
  Calendar* c = createInstance(aLocale, success);
  if(U_SUCCESS(success) && c) {
      c->setTimeZone(zone);
  }
  return c;
986}

988// -------------------------------------

990void U_EXPORT2
991Calendar::getCalendarTypeFromLocale(
      const Locale &aLocale,
      char *typeBuffer,
      int32_t typeBufferSize,
      UErrorCode &success) {
  const SharedCalendar *shared = nullptr;
  UnifiedCache::getByLocale(aLocale, shared, success);
  if (U_FAILURE(success)) {
      return;
  }
  uprv_strncpy(typeBuffer, (*shared)->getType(), typeBufferSize):: strncpy(typeBuffer, (*shared)->getType(), typeBufferSize
);
  shared->removeRef();
  if (typeBuffer[typeBufferSize - 1]) {
      success = U_BUFFER_OVERFLOW_ERROR;
  }
1006}

1008bool
1009Calendar::operator==(const Calendar& that) const
1010{
  UErrorCode status = U_ZERO_ERROR;
  return isEquivalentTo(that) &&
      getTimeInMillis(status) == that.getTimeInMillis(status) &&
      U_SUCCESS(status);
1015}

1017UBool
1018Calendar::isEquivalentTo(const Calendar& other) const
1019{
  return typeid(*this) == typeid(other) &&
      fLenient                == other.fLenient &&
      fRepeatedWallTime       == other.fRepeatedWallTime &&
      fSkippedWallTime        == other.fSkippedWallTime &&
      fFirstDayOfWeek         == other.fFirstDayOfWeek &&
      fMinimalDaysInFirstWeek == other.fMinimalDaysInFirstWeek &&
      fWeekendOnset           == other.fWeekendOnset &&
      fWeekendOnsetMillis     == other.fWeekendOnsetMillis &&
      fWeekendCease           == other.fWeekendCease &&
      fWeekendCeaseMillis     == other.fWeekendCeaseMillis &&
      *fZone                  == *other.fZone;
1031}

1033// -------------------------------------

1035UBool
1036Calendar::equals(const Calendar& when, UErrorCode& status) const
1037{
  return (this == &when ||
      getTime(status) == when.getTime(status));
1040}

1042// -------------------------------------

1044UBool
1045Calendar::before(const Calendar& when, UErrorCode& status) const
1046{
  return (this != &when &&
      getTimeInMillis(status) < when.getTimeInMillis(status));
1049}

1051// -------------------------------------

1053UBool
1054Calendar::after(const Calendar& when, UErrorCode& status) const
1055{
  return (this != &when &&
      getTimeInMillis(status) > when.getTimeInMillis(status));
1058}

1060// -------------------------------------


1063const Locale* U_EXPORT2
1064Calendar::getAvailableLocales(int32_t& count)
1065{
  return Locale::getAvailableLocales(count);
1067}

1069// -------------------------------------

1071StringEnumeration* U_EXPORT2
1072Calendar::getKeywordValuesForLocale(const char* key,
                  const Locale& locale, UBool commonlyUsed, UErrorCode& status)
1074{
  // This is a wrapper over ucal_getKeywordValuesForLocale
  UEnumeration *uenum = ucal_getKeywordValuesForLocaleucal_getKeywordValuesForLocale_77(key, locale.getName(),
                                                      commonlyUsed, &status);
  if (U_FAILURE(status)) {
      uenum_closeuenum_close_77(uenum);
      return nullptr;
  }
  UStringEnumeration* ustringenum = new UStringEnumeration(uenum);
  if (ustringenum == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }
  return ustringenum;
1087}

1089// -------------------------------------

1091UDate U_EXPORT2
1092Calendar::getNow()
1093{
  return uprv_getUTCtimeuprv_getUTCtime_77(); // return as milliseconds
1095}

1097// -------------------------------------

1099/**
1100* Gets this Calendar's current time as a long.
1101* @return the current time as UTC milliseconds from the epoch.
1102*/
1103double
1104Calendar::getTimeInMillis(UErrorCode& status) const
1105{
  if(U_FAILURE(status))
      return 0.0;

  if ( ! fIsTimeSet)
      const_cast<Calendar*>(this)->updateTime(status);

  /* Test for buffer overflows */
  if(U_FAILURE(status)) {
      return 0.0;
  }
  return fTime;
1117}

1119// -------------------------------------

1121/**
1122* Sets this Calendar's current time from the given long value.
1123* A status of U_ILLEGAL_ARGUMENT_ERROR is set when millis is
1124* outside the range permitted by a Calendar object when not in lenient mode.
1125* when in lenient mode the out of range values are pinned to their respective min/max.
1126* @param date the new time in UTC milliseconds from the epoch.
1127*/
1128void
1129Calendar::setTimeInMillis( double millis, UErrorCode& status ) {
  if(U_FAILURE(status))
      return;

  if (millis > MAX_MILLIS(((+0x7F000000) - 2440588) * (1.0 * (86400000)))) {
      if(isLenient()) {
          millis = MAX_MILLIS(((+0x7F000000) - 2440588) * (1.0 * (86400000)));
      } else {
    status = U_ILLEGAL_ARGUMENT_ERROR;
    return;
      }
  } else if (millis < MIN_MILLIS(((-0x7F000000) - 2440588) * (1.0 * (86400000)))) {
      if(isLenient()) {
          millis = MIN_MILLIS(((-0x7F000000) - 2440588) * (1.0 * (86400000)));
      } else {
  		status = U_ILLEGAL_ARGUMENT_ERROR;
   	return;
      }
  } else if (uprv_isNaNuprv_isNaN_77(millis)) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  fTime = millis;
  fAreFieldsSet = fAreAllFieldsSet = false;
  fIsTimeSet = fAreFieldsVirtuallySet = true;

  uprv_memset(fFields, 0, sizeof(fFields)):: memset(fFields, 0, sizeof(fFields));
  uprv_memset(fStamp, kUnset, sizeof(fStamp)):: memset(fStamp, kUnset, sizeof(fStamp));
  fNextStamp = kMinimumUserStamp;
1159}

1161// -------------------------------------

1163int32_t
1164Calendar::get(UCalendarDateFields field, UErrorCode& status) const
1165{
  if (U_FAILURE(status)) {
      return 0;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  // field values are only computed when actually requested; for more on when computation
  // of various things happens, see the "data flow in Calendar" description at the top
  // of this file
  if (U_SUCCESS(status)) const_cast<Calendar*>(this)->complete(status); // Cast away const
  return U_SUCCESS(status) ? fFields[field] : 0;
1178}

1180// -------------------------------------

1182void
1183Calendar::set(UCalendarDateFields field, int32_t value)
1184{
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      return;
  }
  if (fAreFieldsVirtuallySet) {
      UErrorCode ec = U_ZERO_ERROR;
      computeFields(ec);
  }
  fFields[field]     = value;
  /* Ensure that the fNextStamp value doesn't go pass max value for int8_t */
  if (fNextStamp == STAMP_MAX127) {
      recalculateStamp();
  }
  fStamp[field]     = fNextStamp++;
  fIsTimeSet = fAreFieldsSet = fAreFieldsVirtuallySet = false;
1199}

1201// -------------------------------------

1203void
1204Calendar::set(int32_t year, int32_t month, int32_t date)
1205{
  set(UCAL_YEAR, year);
  set(UCAL_MONTH, month);
  set(UCAL_DATE, date);
1209}

1211// -------------------------------------

1213void
1214Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute)
1215{
  set(UCAL_YEAR, year);
  set(UCAL_MONTH, month);
  set(UCAL_DATE, date);
  set(UCAL_HOUR_OF_DAY, hour);
  set(UCAL_MINUTE, minute);
1221}

1223// -------------------------------------

1225void
1226Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute, int32_t second)
1227{
  set(UCAL_YEAR, year);
  set(UCAL_MONTH, month);
  set(UCAL_DATE, date);
  set(UCAL_HOUR_OF_DAY, hour);
  set(UCAL_MINUTE, minute);
  set(UCAL_SECOND, second);
1234}

1236// -------------------------------------
1237int32_t Calendar::getRelatedYear(UErrorCode &status) const
1238{
  return get(UCAL_EXTENDED_YEAR, status);
1240}

1242// -------------------------------------
1243void Calendar::setRelatedYear(int32_t year)
1244{
  // set extended year
  set(UCAL_EXTENDED_YEAR, year);
1247}

1249// -------------------------------------

1251void
1252Calendar::clear()
1253{
  uprv_memset(fFields, 0, sizeof(fFields)):: memset(fFields, 0, sizeof(fFields));
  uprv_memset(fStamp, kUnset, sizeof(fStamp)):: memset(fStamp, kUnset, sizeof(fStamp));
  fNextStamp = kMinimumUserStamp;
  fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = false;
  // fTime is not 'cleared' - may be used if no fields are set.
1259}

1261// -------------------------------------

1263void
1264Calendar::clear(UCalendarDateFields field)
1265{
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      return;
  }
  if (fAreFieldsVirtuallySet) {
      UErrorCode ec = U_ZERO_ERROR;
      computeFields(ec);
  }
  fFields[field]         = 0;
  fStamp[field]         = kUnset;
  if (field == UCAL_MONTH) {
      fFields[UCAL_ORDINAL_MONTH]         = 0;
      fStamp[UCAL_ORDINAL_MONTH]         = kUnset;
  }
  if (field == UCAL_ORDINAL_MONTH) {
      fFields[UCAL_MONTH]         = 0;
      fStamp[UCAL_MONTH]         = kUnset;
  }
  fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = false;
1284}

1286// -------------------------------------

1288UBool
1289Calendar::isSet(UCalendarDateFields field) const
1290{
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      return false;
  }
  return fAreFieldsVirtuallySet || (fStamp[field] != kUnset);
1295}


1298int32_t Calendar::newestStamp(UCalendarDateFields first, UCalendarDateFields last, int32_t bestStampSoFar) const
1299{
  int32_t bestStamp = bestStampSoFar;
  for (int32_t i = static_cast<int32_t>(first); i <= static_cast<int32_t>(last); ++i) {
      if (fStamp[i] > bestStamp) {
          bestStamp = fStamp[i];
      }
  }
  return bestStamp;
1307}


1310// -------------------------------------

1312void
1313Calendar::complete(UErrorCode& status)
1314{
  if (U_FAILURE(status)) {
     return;
  }
  if (!fIsTimeSet) {
      updateTime(status);
      /* Test for buffer overflows */
      if(U_FAILURE(status)) {
          return;
      }
  }
  if (!fAreFieldsSet) {
      computeFields(status); // fills in unset fields
      /* Test for buffer overflows */
      if(U_FAILURE(status)) {
          return;
      }
      fAreFieldsSet         = true;
      fAreAllFieldsSet     = true;
  }
1334}

1336//-------------------------------------------------------------------------
1337// Protected utility methods for use by subclasses.  These are very handy
1338// for implementing add, roll, and computeFields.
1339//-------------------------------------------------------------------------

1341/**
1342* Adjust the specified field so that it is within
1343* the allowable range for the date to which this calendar is set.
1344* For example, in a Gregorian calendar pinning the {@link #DAY_OF_MONTH DAY_OF_MONTH}
1345* field for a calendar set to April 31 would cause it to be set
1346* to April 30.
1347* <p>
1348* <b>Subclassing:</b>
1349* <br>
1350* This utility method is intended for use by subclasses that need to implement
1351* their own overrides of {@link #roll roll} and {@link #add add}.
1352* <p>
1353* <b>Note:</b>
1354* <code>pinField</code> is implemented in terms of
1355* {@link #getActualMinimum getActualMinimum}
1356* and {@link #getActualMaximum getActualMaximum}.  If either of those methods uses
1357* a slow, iterative algorithm for a particular field, it would be
1358* unwise to attempt to call <code>pinField</code> for that field.  If you
1359* really do need to do so, you should override this method to do
1360* something more efficient for that field.
1361* <p>
1362* @param field The calendar field whose value should be pinned.
1363*
1364* @see #getActualMinimum
1365* @see #getActualMaximum
1366* @stable ICU 2.0
1367*/
1368void Calendar::pinField(UCalendarDateFields field, UErrorCode& status) {
  if (U_FAILURE(status)) {
     return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
     status = U_ILLEGAL_ARGUMENT_ERROR;
     return;
  }
  int32_t max = getActualMaximum(field, status);
  int32_t min = getActualMinimum(field, status);

  if (fFields[field] > max) {
      set(field, max);
  } else if (fFields[field] < min) {
      set(field, min);
  }
1384}


1387void Calendar::computeFields(UErrorCode &ec)
1388{
  if (U_FAILURE(ec)) {
      return;
  }
  // Compute local wall millis
  double localMillis = internalGetTime();
  int32_t rawOffset, dstOffset;
  getTimeZone().getOffset(localMillis, false, rawOffset, dstOffset, ec);
  if (U_FAILURE(ec)) {
      return;
  }
  localMillis += (rawOffset + dstOffset);

  // Mark fields as set.  Do this before calling handleComputeFields().
  uint32_t mask =   //fInternalSetMask;
      (1 << UCAL_ERA) |
      (1 << UCAL_YEAR) |
      (1 << UCAL_MONTH) |
      (1 << UCAL_DAY_OF_MONTH) | // = UCAL_DATE
      (1 << UCAL_DAY_OF_YEAR) |
      (1 << UCAL_EXTENDED_YEAR) |
      (1 << UCAL_ORDINAL_MONTH);

  for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
      if ((mask & 1) == 0) {
          fStamp[i] = kInternallySet;
      } else {
          fStamp[i] = kUnset;
      }
      mask >>= 1;
  }

  // We used to check for and correct extreme millis values (near
  // Long.MIN_VALUE or Long.MAX_VALUE) here.  Such values would cause
  // overflows from positive to negative (or vice versa) and had to
  // be manually tweaked.  We no longer need to do this because we
  // have limited the range of supported dates to those that have a
  // Julian day that fits into an int.  This allows us to implement a
  // JULIAN_DAY field and also removes some inelegant code. - Liu
  // 11/6/00

  int32_t millisInDay;
  double days = ClockMath::floorDivide(
      localMillis, U_MILLIS_PER_DAY(86400000), &millisInDay) +
      kEpochStartAsJulianDay2440588;
  if (days > INT32_MAX(2147483647) || days < INT32_MIN(-2147483647-1)) {
      ec = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  internalSet(UCAL_JULIAN_DAY, static_cast<int32_t>(days));

1440#if defined (U_DEBUG_CAL)
  //fprintf(stderr, "%s:%d- Hmm! Jules @ %d, as per %.0lf millis\n",
  //__FILE__, __LINE__, fFields[UCAL_JULIAN_DAY], localMillis);
1443#endif

  computeGregorianFields(fFields[UCAL_JULIAN_DAY], ec);

  // Call framework method to have subclass compute its fields.
  // These must include, at a minimum, MONTH, DAY_OF_MONTH,
  // EXTENDED_YEAR, YEAR, DAY_OF_YEAR.  This method will call internalSet(),
  // which will update stamp[].
  handleComputeFields(fFields[UCAL_JULIAN_DAY], ec);

  // Compute week-related fields, based on the subclass-computed
  // fields computed by handleComputeFields().
  computeWeekFields(ec);

  // Compute time-related fields.  These are independent of the date and
  // of the subclass algorithm.  They depend only on the local zone
  // wall milliseconds in day.
  if (U_FAILURE(ec)) {
      return;
  }

  fFields[UCAL_MILLISECONDS_IN_DAY] = millisInDay;
  U_ASSERT(getMinimum(UCAL_MILLISECONDS_IN_DAY) <=(static_cast <bool> (getMinimum(UCAL_MILLISECONDS_IN_DAY
) <= fFields[UCAL_MILLISECONDS_IN_DAY]) ? void (0) : __assert_fail
 ("getMinimum(UCAL_MILLISECONDS_IN_DAY) <= fFields[UCAL_MILLISECONDS_IN_DAY]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           fFields[UCAL_MILLISECONDS_IN_DAY])(static_cast <bool> (getMinimum(UCAL_MILLISECONDS_IN_DAY
) <= fFields[UCAL_MILLISECONDS_IN_DAY]) ? void (0) : __assert_fail
 ("getMinimum(UCAL_MILLISECONDS_IN_DAY) <= fFields[UCAL_MILLISECONDS_IN_DAY]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_MILLISECONDS_IN_DAY] <=(static_cast <bool> (fFields[UCAL_MILLISECONDS_IN_DAY] <=
 getMaximum(UCAL_MILLISECONDS_IN_DAY)) ? void (0) : __assert_fail
 ("fFields[UCAL_MILLISECONDS_IN_DAY] <= getMaximum(UCAL_MILLISECONDS_IN_DAY)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           getMaximum(UCAL_MILLISECONDS_IN_DAY))(static_cast <bool> (fFields[UCAL_MILLISECONDS_IN_DAY] <=
 getMaximum(UCAL_MILLISECONDS_IN_DAY)) ? void (0) : __assert_fail
 ("fFields[UCAL_MILLISECONDS_IN_DAY] <= getMaximum(UCAL_MILLISECONDS_IN_DAY)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_MILLISECOND] = millisInDay % 1000;
  U_ASSERT(getMinimum(UCAL_MILLISECOND) <= fFields[UCAL_MILLISECOND])(static_cast <bool> (getMinimum(UCAL_MILLISECOND) <=
 fFields[UCAL_MILLISECOND]) ? void (0) : __assert_fail ("getMinimum(UCAL_MILLISECOND) <= fFields[UCAL_MILLISECOND]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_MILLISECOND] <= getMaximum(UCAL_MILLISECOND))(static_cast <bool> (fFields[UCAL_MILLISECOND] <= getMaximum
(UCAL_MILLISECOND)) ? void (0) : __assert_fail ("fFields[UCAL_MILLISECOND] <= getMaximum(UCAL_MILLISECOND)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  millisInDay /= 1000;
  fFields[UCAL_SECOND] = millisInDay % 60;
  U_ASSERT(getMinimum(UCAL_SECOND) <= fFields[UCAL_SECOND])(static_cast <bool> (getMinimum(UCAL_SECOND) <= fFields
[UCAL_SECOND]) ? void (0) : __assert_fail ("getMinimum(UCAL_SECOND) <= fFields[UCAL_SECOND]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_SECOND] <= getMaximum(UCAL_SECOND))(static_cast <bool> (fFields[UCAL_SECOND] <= getMaximum
(UCAL_SECOND)) ? void (0) : __assert_fail ("fFields[UCAL_SECOND] <= getMaximum(UCAL_SECOND)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  millisInDay /= 60;
  fFields[UCAL_MINUTE] = millisInDay % 60;
  U_ASSERT(getMinimum(UCAL_MINUTE) <= fFields[UCAL_MINUTE])(static_cast <bool> (getMinimum(UCAL_MINUTE) <= fFields
[UCAL_MINUTE]) ? void (0) : __assert_fail ("getMinimum(UCAL_MINUTE) <= fFields[UCAL_MINUTE]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_MINUTE] <= getMaximum(UCAL_MINUTE))(static_cast <bool> (fFields[UCAL_MINUTE] <= getMaximum
(UCAL_MINUTE)) ? void (0) : __assert_fail ("fFields[UCAL_MINUTE] <= getMaximum(UCAL_MINUTE)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  millisInDay /= 60;
  fFields[UCAL_HOUR_OF_DAY] = millisInDay;
  U_ASSERT(getMinimum(UCAL_HOUR_OF_DAY) <= fFields[UCAL_HOUR_OF_DAY])(static_cast <bool> (getMinimum(UCAL_HOUR_OF_DAY) <=
 fFields[UCAL_HOUR_OF_DAY]) ? void (0) : __assert_fail ("getMinimum(UCAL_HOUR_OF_DAY) <= fFields[UCAL_HOUR_OF_DAY]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_HOUR_OF_DAY] <= getMaximum(UCAL_HOUR_OF_DAY))(static_cast <bool> (fFields[UCAL_HOUR_OF_DAY] <= getMaximum
(UCAL_HOUR_OF_DAY)) ? void (0) : __assert_fail ("fFields[UCAL_HOUR_OF_DAY] <= getMaximum(UCAL_HOUR_OF_DAY)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_AM_PM] = millisInDay / 12; // Assume AM == 0
  U_ASSERT(getMinimum(UCAL_AM_PM) <= fFields[UCAL_AM_PM])(static_cast <bool> (getMinimum(UCAL_AM_PM) <= fFields
[UCAL_AM_PM]) ? void (0) : __assert_fail ("getMinimum(UCAL_AM_PM) <= fFields[UCAL_AM_PM]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_AM_PM] <= getMaximum(UCAL_AM_PM))(static_cast <bool> (fFields[UCAL_AM_PM] <= getMaximum
(UCAL_AM_PM)) ? void (0) : __assert_fail ("fFields[UCAL_AM_PM] <= getMaximum(UCAL_AM_PM)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_HOUR] = millisInDay % 12;
  U_ASSERT(getMinimum(UCAL_HOUR) <= fFields[UCAL_HOUR])(static_cast <bool> (getMinimum(UCAL_HOUR) <= fFields
[UCAL_HOUR]) ? void (0) : __assert_fail ("getMinimum(UCAL_HOUR) <= fFields[UCAL_HOUR]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_HOUR] <= getMaximum(UCAL_HOUR))(static_cast <bool> (fFields[UCAL_HOUR] <= getMaximum
(UCAL_HOUR)) ? void (0) : __assert_fail ("fFields[UCAL_HOUR] <= getMaximum(UCAL_HOUR)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_ZONE_OFFSET] = rawOffset;
  U_ASSERT(getMinimum(UCAL_ZONE_OFFSET) <= fFields[UCAL_ZONE_OFFSET])(static_cast <bool> (getMinimum(UCAL_ZONE_OFFSET) <=
 fFields[UCAL_ZONE_OFFSET]) ? void (0) : __assert_fail ("getMinimum(UCAL_ZONE_OFFSET) <= fFields[UCAL_ZONE_OFFSET]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_ZONE_OFFSET] <= getMaximum(UCAL_ZONE_OFFSET))(static_cast <bool> (fFields[UCAL_ZONE_OFFSET] <= getMaximum
(UCAL_ZONE_OFFSET)) ? void (0) : __assert_fail ("fFields[UCAL_ZONE_OFFSET] <= getMaximum(UCAL_ZONE_OFFSET)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_DST_OFFSET] = dstOffset;
  U_ASSERT(getMinimum(UCAL_DST_OFFSET) <= fFields[UCAL_DST_OFFSET])(static_cast <bool> (getMinimum(UCAL_DST_OFFSET) <= fFields
[UCAL_DST_OFFSET]) ? void (0) : __assert_fail ("getMinimum(UCAL_DST_OFFSET) <= fFields[UCAL_DST_OFFSET]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_DST_OFFSET] <= getMaximum(UCAL_DST_OFFSET))(static_cast <bool> (fFields[UCAL_DST_OFFSET] <= getMaximum
(UCAL_DST_OFFSET)) ? void (0) : __assert_fail ("fFields[UCAL_DST_OFFSET] <= getMaximum(UCAL_DST_OFFSET)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
1504}

1506uint8_t Calendar::julianDayToDayOfWeek(int32_t julian)
1507{
  // If julian is negative, then julian%7 will be negative, so we adjust
  // accordingly.  We add 1 because Julian day 0 is Monday.
  int8_t dayOfWeek = static_cast<int8_t>((julian + 1LL) % 7);

  uint8_t result = static_cast<uint8_t>(dayOfWeek + ((dayOfWeek < 0) ? (7 + UCAL_SUNDAY) : UCAL_SUNDAY));
  return result;
1514}

1516/**
1517* Compute the Gregorian calendar year, month, and day of month from the
1518* Julian day.  These values are not stored in fields, but in member
1519* variables gregorianXxx.  They are used for time zone computations and by
1520* subclasses that are Gregorian derivatives.  Subclasses may call this
1521* method to perform a Gregorian calendar millis->fields computation.
1522*/
1523void Calendar::computeGregorianFields(int32_t julianDay, UErrorCode& ec) {
  if (U_FAILURE(ec)) {
      return;
  }
  if (uprv_add32_overflowuprv_add32_overflow_77(
          julianDay, -kEpochStartAsJulianDay2440588, &julianDay)) {
      ec = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  Grego::dayToFields(julianDay, fGregorianYear, fGregorianMonth,
                     fGregorianDayOfMonth,
                     fGregorianDayOfYear, ec);
1535}

1537/**
1538* Compute the fields WEEK_OF_YEAR, YEAR_WOY, WEEK_OF_MONTH,
1539* DAY_OF_WEEK_IN_MONTH, and DOW_LOCAL from EXTENDED_YEAR, YEAR,
1540* DAY_OF_WEEK, and DAY_OF_YEAR.  The latter fields are computed by the
1541* subclass based on the calendar system.
1542*
1543* <p>The YEAR_WOY field is computed simplistically.  It is equal to YEAR
1544* most of the time, but at the year boundary it may be adjusted to YEAR-1
1545* or YEAR+1 to reflect the overlap of a week into an adjacent year.  In
1546* this case, a simple increment or decrement is performed on YEAR, even
1547* though this may yield an invalid YEAR value.  For instance, if the YEAR
1548* is part of a calendar system with an N-year cycle field CYCLE, then
1549* incrementing the YEAR may involve incrementing CYCLE and setting YEAR
1550* back to 0 or 1.  This is not handled by this code, and in fact cannot be
1551* simply handled without having subclasses define an entire parallel set of
1552* fields for fields larger than or equal to a year.  This additional
1553* complexity is not warranted, since the intention of the YEAR_WOY field is
1554* to support ISO 8601 notation, so it will typically be used with a
1555* proleptic Gregorian calendar, which has no field larger than a year.
1556*/
1557void Calendar::computeWeekFields(UErrorCode &ec) {
  if(U_FAILURE(ec)) {
      return;
  }

  // Compute day of week: JD 0 = Monday
  int32_t dayOfWeek = julianDayToDayOfWeek(fFields[UCAL_JULIAN_DAY]);
  internalSet(UCAL_DAY_OF_WEEK, dayOfWeek);
  int32_t firstDayOfWeek = getFirstDayOfWeek();
  // Calculate 1-based localized day of week
  int32_t dowLocal = dayOfWeek - firstDayOfWeek + 1;
  if (dowLocal < 1) {
      dowLocal += 7;
  }
  internalSet(UCAL_DOW_LOCAL,dowLocal);

  int32_t eyear = fFields[UCAL_EXTENDED_YEAR];
  int32_t dayOfYear = fFields[UCAL_DAY_OF_YEAR];

  // WEEK_OF_YEAR start
  // Compute the week of the year.  For the Gregorian calendar, valid week
  // numbers run from 1 to 52 or 53, depending on the year, the first day
  // of the week, and the minimal days in the first week.  For other
  // calendars, the valid range may be different -- it depends on the year
  // length.  Days at the start of the year may fall into the last week of
  // the previous year; days at the end of the year may fall into the
  // first week of the next year.  ASSUME that the year length is less than
  // 7000 days.
  int32_t yearOfWeekOfYear = eyear;
  int32_t relDow = (dayOfWeek + 7 - firstDayOfWeek) % 7; // 0..6
  int32_t relDowJan1 = (dayOfWeek - dayOfYear + 7001 - firstDayOfWeek) % 7; // 0..6
  int32_t woy = (dayOfYear - 1 + relDowJan1) / 7; // 0..53
  int32_t minimalDaysInFirstWeek = getMinimalDaysInFirstWeek();
  if ((7 - relDowJan1) >= minimalDaysInFirstWeek) {
      ++woy;
  }

  // Adjust for weeks at the year end that overlap into the previous or
  // next calendar year.
  if (woy == 0) {
      // We are the last week of the previous year.
      // Check to see if we are in the last week; if so, we need
      // to handle the case in which we are the first week of the
      // next year.

      int32_t prevDoy = dayOfYear + handleGetYearLength(eyear - 1, ec);
      if(U_FAILURE(ec)) return;
      woy = weekNumber(prevDoy, dayOfWeek);
      yearOfWeekOfYear--;
  } else {
      int32_t lastDoy = handleGetYearLength(eyear, ec);
      if(U_FAILURE(ec)) return;
      // Fast check: For it to be week 1 of the next year, the DOY
      // must be on or after L-5, where L is yearLength(), then it
      // cannot possibly be week 1 of the next year:
      //          L-5                  L
      // doy: 359 360 361 362 363 364 365 001
      // dow:      1   2   3   4   5   6   7
      if (dayOfYear >= (lastDoy - 5)) {
          int32_t lastRelDow = (relDow + lastDoy - dayOfYear) % 7;
          if (lastRelDow < 0) {
              lastRelDow += 7;
          }
          if (((6 - lastRelDow) >= minimalDaysInFirstWeek) &&
              ((dayOfYear + 7 - relDow) > lastDoy)) {
                  woy = 1;
                  yearOfWeekOfYear++;
              }
      }
  }
  fFields[UCAL_WEEK_OF_YEAR] = woy;
  fFields[UCAL_YEAR_WOY] = yearOfWeekOfYear;
  // min/max of years are not constrains for caller, so not assert here.
  // WEEK_OF_YEAR end

  int32_t dayOfMonth = fFields[UCAL_DAY_OF_MONTH];
  fFields[UCAL_WEEK_OF_MONTH] = weekNumber(dayOfMonth, dayOfWeek);
  U_ASSERT(getMinimum(UCAL_WEEK_OF_MONTH) <= fFields[UCAL_WEEK_OF_MONTH])(static_cast <bool> (getMinimum(UCAL_WEEK_OF_MONTH) <=
 fFields[UCAL_WEEK_OF_MONTH]) ? void (0) : __assert_fail ("getMinimum(UCAL_WEEK_OF_MONTH) <= fFields[UCAL_WEEK_OF_MONTH]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_WEEK_OF_MONTH] <= getMaximum(UCAL_WEEK_OF_MONTH))(static_cast <bool> (fFields[UCAL_WEEK_OF_MONTH] <= getMaximum
(UCAL_WEEK_OF_MONTH)) ? void (0) : __assert_fail ("fFields[UCAL_WEEK_OF_MONTH] <= getMaximum(UCAL_WEEK_OF_MONTH)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

  fFields[UCAL_DAY_OF_WEEK_IN_MONTH] = (dayOfMonth-1) / 7 + 1;
  U_ASSERT(getMinimum(UCAL_DAY_OF_WEEK_IN_MONTH) <=(static_cast <bool> (getMinimum(UCAL_DAY_OF_WEEK_IN_MONTH
) <= fFields[UCAL_DAY_OF_WEEK_IN_MONTH]) ? void (0) : __assert_fail
 ("getMinimum(UCAL_DAY_OF_WEEK_IN_MONTH) <= fFields[UCAL_DAY_OF_WEEK_IN_MONTH]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           fFields[UCAL_DAY_OF_WEEK_IN_MONTH])(static_cast <bool> (getMinimum(UCAL_DAY_OF_WEEK_IN_MONTH
) <= fFields[UCAL_DAY_OF_WEEK_IN_MONTH]) ? void (0) : __assert_fail
 ("getMinimum(UCAL_DAY_OF_WEEK_IN_MONTH) <= fFields[UCAL_DAY_OF_WEEK_IN_MONTH]"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  U_ASSERT(fFields[UCAL_DAY_OF_WEEK_IN_MONTH] <=(static_cast <bool> (fFields[UCAL_DAY_OF_WEEK_IN_MONTH]
 <= getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH)) ? void (0) : __assert_fail
 ("fFields[UCAL_DAY_OF_WEEK_IN_MONTH] <= getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH))(static_cast <bool> (fFields[UCAL_DAY_OF_WEEK_IN_MONTH]
 <= getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH)) ? void (0) : __assert_fail
 ("fFields[UCAL_DAY_OF_WEEK_IN_MONTH] <= getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

1643#if defined (U_DEBUG_CAL)
  if(fFields[UCAL_DAY_OF_WEEK_IN_MONTH]==0) fprintf(stderrstderr, "%s:%d: DOWIM %d on %g\n",
      __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__1645,fFields[UCAL_DAY_OF_WEEK_IN_MONTH], fTime);
1646#endif
1647}


1650int32_t Calendar::weekNumber(int32_t desiredDay, int32_t dayOfPeriod, int32_t dayOfWeek)
1651{
  // Determine the day of the week of the first day of the period
  // in question (either a year or a month).  Zero represents the
  // first day of the week on this calendar.
  int32_t periodStartDayOfWeek = (dayOfWeek - getFirstDayOfWeek() - dayOfPeriod + 1) % 7;
  if (periodStartDayOfWeek < 0) periodStartDayOfWeek += 7;

  // Compute the week number.  Initially, ignore the first week, which
  // may be fractional (or may not be).  We add periodStartDayOfWeek in
  // order to fill out the first week, if it is fractional.
  int32_t weekNo = (desiredDay + periodStartDayOfWeek - 1)/7;

  // If the first week is long enough, then count it.  If
  // the minimal days in the first week is one, or if the period start
  // is zero, we always increment weekNo.
  if ((7 - periodStartDayOfWeek) >= getMinimalDaysInFirstWeek()) ++weekNo;

  return weekNo;
1669}

1671void Calendar::handleComputeFields(int32_t /* julianDay */, UErrorCode& status)
1672{
  if (U_FAILURE(status)) {
      return;
  }
  int32_t month = getGregorianMonth();
  internalSet(UCAL_MONTH, month);
  internalSet(UCAL_ORDINAL_MONTH, month);
  internalSet(UCAL_DAY_OF_MONTH, getGregorianDayOfMonth());
  internalSet(UCAL_DAY_OF_YEAR, getGregorianDayOfYear());
  int32_t eyear = getGregorianYear();
  internalSet(UCAL_EXTENDED_YEAR, eyear);
  int32_t era = GregorianCalendar::AD;
  if (eyear < 1) {
      era = GregorianCalendar::BC;
      eyear = 1 - eyear;
  }
  internalSet(UCAL_ERA, era);
  internalSet(UCAL_YEAR, eyear);
1690}
1691// -------------------------------------


1694void Calendar::roll(EDateFields field, int32_t amount, UErrorCode& status)
1695{
  roll(static_cast<UCalendarDateFields>(field), amount, status);
1697}

1699void Calendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) UPRV_NO_SANITIZE_UNDEFINED__attribute__((no_sanitize("undefined"))) {
  if (amount == 0) {
      return; // Nothing to do
  }

  complete(status);

  if(U_FAILURE(status)) {
      return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
     status = U_ILLEGAL_ARGUMENT_ERROR;
     return;
  }
  switch (field) {
  case UCAL_DAY_OF_MONTH:
  case UCAL_AM_PM:
  case UCAL_MINUTE:
  case UCAL_SECOND:
  case UCAL_MILLISECOND:
  case UCAL_MILLISECONDS_IN_DAY:
  case UCAL_ERA:
      // These are the standard roll instructions.  These work for all
      // simple cases, that is, cases in which the limits are fixed, such
      // as the hour, the day of the month, and the era.
      {
          int32_t min = getActualMinimum(field,status);
          int32_t max = getActualMaximum(field,status);
          if (U_FAILURE(status)) {
             return;
          }
          int32_t gap = max - min + 1;

          int64_t value = internalGet(field);
          value = (value + amount - min) % gap;
          if (value < 0) {
              value += gap;
          }
          value += min;

          set(field, value);
          return;
      }

  case UCAL_HOUR:
  case UCAL_HOUR_OF_DAY:
      // Rolling the hour is difficult on the ONSET and CEASE days of
      // daylight savings.  For example, if the change occurs at
      // 2 AM, we have the following progression:
      // ONSET: 12 Std -> 1 Std -> 3 Dst -> 4 Dst
      // CEASE: 12 Dst -> 1 Dst -> 1 Std -> 2 Std
      // To get around this problem we don't use fields; we manipulate
      // the time in millis directly.
      {
          // Assume min == 0 in calculations below
          double start = getTimeInMillis(status);
          int64_t oldHour = internalGet(field);
          int32_t max = getMaximum(field);
          int32_t newHour = (oldHour + amount) % (max + 1);
          if (newHour < 0) {
              newHour += max + 1;
          }
          setTimeInMillis(start + kOneHour(60*60*1000) * (newHour - oldHour),status);
          return;
      }

  case UCAL_MONTH:
  case UCAL_ORDINAL_MONTH:
      // Rolling the month involves both pinning the final value
      // and adjusting the DAY_OF_MONTH if necessary.  We only adjust the
      // DAY_OF_MONTH if, after updating the MONTH field, it is illegal.
      // E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>.
      {
          int32_t max = getActualMaximum(UCAL_MONTH, status) + 1;
          int64_t mon = internalGet(UCAL_MONTH);
          mon = (mon + amount) % max;

          if (mon < 0) {
              mon += max;
          }
          set(UCAL_MONTH, mon);

          // Keep the day of month in range.  We don't want to spill over
          // into the next month; e.g., we don't want jan31 + 1 mo -> feb31 ->
          // mar3.
          pinField(UCAL_DAY_OF_MONTH,status);
          return;
      }

  case UCAL_YEAR:
  case UCAL_YEAR_WOY:
      {
          // * If era==0 and years go backwards in time, change sign of amount.
          // * Until we have new API per #9393, we temporarily hardcode knowledge of
          //   which calendars have era 0 years that go backwards.
          int32_t era = internalGet(UCAL_ERA);
          if (era == 0 && isEra0CountingBackward()) {
              if (uprv_mul32_overflowuprv_mul32_overflow_77(amount, -1, &amount)) {
                  status = U_ILLEGAL_ARGUMENT_ERROR;
                  return;
              }
          }
          int32_t newYear;
          if (uprv_add32_overflowuprv_add32_overflow_77(
              amount, internalGet(field), &newYear)) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
              return;
          }
          if (era > 0 || newYear >= 1) {
              int32_t maxYear = getActualMaximum(field, status);
              if (maxYear < 32768) {
                  // this era has real bounds, roll should wrap years
                  if (newYear < 1) {
                      newYear = maxYear - ((-newYear) % maxYear);
                  } else if (newYear > maxYear) {
                      newYear = ((newYear - 1) % maxYear) + 1;
                  }
              // else era is unbounded, just pin low year instead of wrapping
              } else if (newYear < 1) {
                  newYear = 1;
              }
          // else we are in era 0 with newYear < 1;
          // calendars with years that go backwards must pin the year value at 0,
          // other calendars can have years < 0 in era 0
          } else if (era == 0 && isEra0CountingBackward()) {
              newYear = 1;
          }
          set(field, newYear);
          pinField(UCAL_MONTH,status);
          pinField(UCAL_DAY_OF_MONTH,status);
          return;
      }

  case UCAL_EXTENDED_YEAR:
      // Rolling the year can involve pinning the DAY_OF_MONTH.
      if (uprv_add32_overflowuprv_add32_overflow_77(
          amount, internalGet(field), &amount)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      set(field, amount);
      pinField(UCAL_MONTH,status);
      pinField(UCAL_DAY_OF_MONTH,status);
      return;

  case UCAL_WEEK_OF_MONTH:
      {
          // This is tricky, because during the roll we may have to shift
          // to a different day of the week.  For example:

          //    s  m  t  w  r  f  s
          //          1  2  3  4  5
          //    6  7  8  9 10 11 12

          // When rolling from the 6th or 7th back one week, we go to the
          // 1st (assuming that the first partial week counts).  The same
          // thing happens at the end of the month.

          // The other tricky thing is that we have to figure out whether
          // the first partial week actually counts or not, based on the
          // minimal first days in the week.  And we have to use the
          // correct first day of the week to delineate the week
          // boundaries.

          // Here's our algorithm.  First, we find the real boundaries of
          // the month.  Then we discard the first partial week if it
          // doesn't count in this locale.  Then we fill in the ends with
          // phantom days, so that the first partial week and the last
          // partial week are full weeks.  We then have a nice square
          // block of weeks.  We do the usual rolling within this block,
          // as is done elsewhere in this method.  If we wind up on one of
          // the phantom days that we added, we recognize this and pin to
          // the first or the last day of the month.  Easy, eh?

          // Normalize the DAY_OF_WEEK so that 0 is the first day of the week
          // in this locale.  We have dow in 0..6.
          int32_t dow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
          if (dow < 0) dow += 7;

          // Find the day of the week (normalized for locale) for the first
          // of the month.
          int32_t fdm = (dow - internalGet(UCAL_DAY_OF_MONTH) + 1) % 7;
          if (fdm < 0) fdm += 7;

          // Get the first day of the first full week of the month,
          // including phantom days, if any.  Figure out if the first week
          // counts or not; if it counts, then fill in phantom days.  If
          // not, advance to the first real full week (skip the partial week).
          int32_t start;
          if ((7 - fdm) < getMinimalDaysInFirstWeek())
              start = 8 - fdm; // Skip the first partial week
          else
              start = 1 - fdm; // This may be zero or negative

          // Get the day of the week (normalized for locale) for the last
          // day of the month.
          int32_t monthLen = getActualMaximum(UCAL_DAY_OF_MONTH, status);
          int32_t ldm = (monthLen - internalGet(UCAL_DAY_OF_MONTH) + dow) % 7;
          // We know monthLen >= DAY_OF_MONTH so we skip the += 7 step here.

          // Get the limit day for the blocked-off rectangular month; that
          // is, the day which is one past the last day of the month,
          // after the month has already been filled in with phantom days
          // to fill out the last week.  This day has a normalized DOW of 0.
          int32_t limit = monthLen + 7 - ldm;

          // Now roll between start and (limit - 1).
          int32_t gap = limit - start;
          if (gap == 0) {
              status =  U_INTERNAL_PROGRAM_ERROR;
              return;
          }
          int32_t day_of_month = (internalGet(UCAL_DAY_OF_MONTH) + amount*7LL -
              start) % gap;
          if (day_of_month < 0) day_of_month += gap;
          day_of_month += start;

          // Finally, pin to the real start and end of the month.
          if (day_of_month < 1) day_of_month = 1;
          if (day_of_month > monthLen) day_of_month = monthLen;

          // Set the DAY_OF_MONTH.  We rely on the fact that this field
          // takes precedence over everything else (since all other fields
          // are also set at this point).  If this fact changes (if the
          // disambiguation algorithm changes) then we will have to unset
          // the appropriate fields here so that DAY_OF_MONTH is attended
          // to.
          set(UCAL_DAY_OF_MONTH, day_of_month);
          return;
      }
  case UCAL_WEEK_OF_YEAR:
      {
          // This follows the outline of WEEK_OF_MONTH, except it applies
          // to the whole year.  Please see the comment for WEEK_OF_MONTH
          // for general notes.

          // Normalize the DAY_OF_WEEK so that 0 is the first day of the week
          // in this locale.  We have dow in 0..6.
          int32_t dow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
          if (dow < 0) dow += 7;

          // Find the day of the week (normalized for locale) for the first
          // of the year.
          int32_t fdy = (dow - internalGet(UCAL_DAY_OF_YEAR) + 1) % 7;
          if (fdy < 0) fdy += 7;

          // Get the first day of the first full week of the year,
          // including phantom days, if any.  Figure out if the first week
          // counts or not; if it counts, then fill in phantom days.  If
          // not, advance to the first real full week (skip the partial week).
          int32_t start;
          if ((7 - fdy) < getMinimalDaysInFirstWeek())
              start = 8 - fdy; // Skip the first partial week
          else
              start = 1 - fdy; // This may be zero or negative

          // Get the day of the week (normalized for locale) for the last
          // day of the year.
          int32_t yearLen = getActualMaximum(UCAL_DAY_OF_YEAR,status);
          int32_t ldy = (yearLen - internalGet(UCAL_DAY_OF_YEAR) + dow) % 7;
          // We know yearLen >= DAY_OF_YEAR so we skip the += 7 step here.

          // Get the limit day for the blocked-off rectangular year; that
          // is, the day which is one past the last day of the year,
          // after the year has already been filled in with phantom days
          // to fill out the last week.  This day has a normalized DOW of 0.
          int32_t limit = yearLen + 7 - ldy;

          // Now roll between start and (limit - 1).
          int32_t gap = limit - start;
          if (gap == 0) {
              status =  U_INTERNAL_PROGRAM_ERROR;
              return;
          }
          int32_t day_of_year = (internalGet(UCAL_DAY_OF_YEAR) + amount*7LL -
              start) % gap;
          if (day_of_year < 0) day_of_year += gap;
          day_of_year += start;

          // Finally, pin to the real start and end of the month.
          if (day_of_year < 1) day_of_year = 1;
          if (day_of_year > yearLen) day_of_year = yearLen;

          // Make sure that the year and day of year are attended to by
          // clearing other fields which would normally take precedence.
          // If the disambiguation algorithm is changed, this section will
          // have to be updated as well.
          set(UCAL_DAY_OF_YEAR, day_of_year);
          clear(UCAL_MONTH);
          clear(UCAL_ORDINAL_MONTH);
          return;
      }
  case UCAL_DAY_OF_YEAR:
      {
          // Roll the day of year using millis.  Compute the millis for
          // the start of the year, and get the length of the year.
          double delta = amount * kOneDay(1.0 * (86400000)); // Scale up from days to millis
          double min2 = internalGet(UCAL_DAY_OF_YEAR)-1;
          min2 *= kOneDay(1.0 * (86400000));
          min2 = internalGetTime() - min2;

          //      double min2 = internalGetTime() - (internalGet(UCAL_DAY_OF_YEAR) - 1.0) * kOneDay;
          double newtime;

          double yearLength = getActualMaximum(UCAL_DAY_OF_YEAR,status);
          double oneYear = yearLength;
          oneYear *= kOneDay(1.0 * (86400000));
          newtime = uprv_fmoduprv_fmod_77((internalGetTime() + delta - min2), oneYear);
          if (newtime < 0) newtime += oneYear;
          setTimeInMillis(newtime + min2, status);
          return;
      }
  case UCAL_DAY_OF_WEEK:
  case UCAL_DOW_LOCAL:
      {
          // Roll the day of week using millis.  Compute the millis for
          // the start of the week, using the first day of week setting.
          // Restrict the millis to [start, start+7days).
          double delta = amount * kOneDay(1.0 * (86400000)); // Scale up from days to millis
          // Compute the number of days before the current day in this
          // week.  This will be a value 0..6.
          int32_t leadDays = internalGet(field);
          leadDays -= (field == UCAL_DAY_OF_WEEK) ? getFirstDayOfWeek() : 1;
          if (leadDays < 0) leadDays += 7;
          double min2 = internalGetTime() - leadDays * kOneDay(1.0 * (86400000));
          double newtime = uprv_fmoduprv_fmod_77((internalGetTime() + delta - min2), kOneWeek(7.0 * (1.0 * (86400000))));
          if (newtime < 0) newtime += kOneWeek(7.0 * (1.0 * (86400000)));
          setTimeInMillis(newtime + min2, status);
          return;
      }
  case UCAL_DAY_OF_WEEK_IN_MONTH:
      {
          // Roll the day of week in the month using millis.  Determine
          // the first day of the week in the month, and then the last,
          // and then roll within that range.
          double delta = amount * kOneWeek(7.0 * (1.0 * (86400000))); // Scale up from weeks to millis
          // Find the number of same days of the week before this one
          // in this month.
          int32_t preWeeks = (internalGet(UCAL_DAY_OF_MONTH) - 1) / 7;
          // Find the number of same days of the week after this one
          // in this month.
          int32_t postWeeks = (getActualMaximum(UCAL_DAY_OF_MONTH,status) -
              internalGet(UCAL_DAY_OF_MONTH)) / 7;
          // From these compute the min and gap millis for rolling.
          double min2 = internalGetTime() - preWeeks * kOneWeek(7.0 * (1.0 * (86400000)));
          double gap2 = kOneWeek(7.0 * (1.0 * (86400000))) * (preWeeks + postWeeks + 1); // Must add 1!
          // Roll within this range
          double newtime = uprv_fmoduprv_fmod_77((internalGetTime() + delta - min2), gap2);
          if (newtime < 0) newtime += gap2;
          setTimeInMillis(newtime + min2, status);
          return;
      }
  case UCAL_JULIAN_DAY:
      if (uprv_add32_overflowuprv_add32_overflow_77(
          amount, internalGet(field), &amount)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      set(field, amount);
      return;
  default:
      // Other fields cannot be rolled by this method
2061#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because of roll on non-rollable field %s\n",
          __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2063,fldName(field));
2064#endif
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2067}

2069void Calendar::add(EDateFields field, int32_t amount, UErrorCode& status)
2070{
  Calendar::add(static_cast<UCalendarDateFields>(field), amount, status);
2072}

2074// -------------------------------------
2075void Calendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status)
2076{
  if (U_FAILURE(status)) {
     return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if (amount == 0) {
      return;   // Do nothing!
  }

  // We handle most fields in the same way.  The algorithm is to add
  // a computed amount of millis to the current millis.  The only
  // wrinkle is with DST (and/or a change to the zone's UTC offset, which
  // we'll include with DST) -- for some fields, like the DAY_OF_MONTH,
  // we don't want the wall time to shift due to changes in DST.  If the
  // result of the add operation is to move from DST to Standard, or
  // vice versa, we need to adjust by an hour forward or back,
  // respectively.  For such fields we set keepWallTimeInvariant to true.

  // We only adjust the DST for fields larger than an hour.  For
  // fields smaller than an hour, we cannot adjust for DST without
  // causing problems.  for instance, if you add one hour to April 5,
  // 1998, 1:00 AM, in PST, the time becomes "2:00 AM PDT" (an
  // illegal value), but then the adjustment sees the change and
  // compensates by subtracting an hour.  As a result the time
  // doesn't advance at all.

  // For some fields larger than a day, such as a UCAL_MONTH, we pin the
  // UCAL_DAY_OF_MONTH.  This allows <March 31>.add(UCAL_MONTH, 1) to be
  // <April 30>, rather than <April 31> => <May 1>.

  double delta = amount; // delta in ms
  UBool keepWallTimeInvariant = true;

  switch (field) {
  case UCAL_ERA:
    {
      int32_t era = get(UCAL_ERA, status);
      if (U_FAILURE(status)) {
          return;
      }
      if (uprv_add32_overflowuprv_add32_overflow_77(era, amount, &era)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      set(UCAL_ERA, era);
      pinField(UCAL_ERA, status);
      return;
    }

  case UCAL_YEAR:
  case UCAL_YEAR_WOY:
    {
      // * If era=0 and years go backwards in time, change sign of amount.
      // * Until we have new API per #9393, we temporarily hardcode knowledge of
      //   which calendars have era 0 years that go backwards.
      // * Note that for UCAL_YEAR (but not UCAL_YEAR_WOY) we could instead handle
      //   this by applying the amount to the UCAL_EXTENDED_YEAR field; but since
      //   we would still need to handle UCAL_YEAR_WOY as below, might as well
      //   also handle UCAL_YEAR the same way.
      if (get(UCAL_ERA, status) == 0 && isEra0CountingBackward()) {
        if (uprv_mul32_overflowuprv_mul32_overflow_77(amount, -1, &amount)) {
            status = U_ILLEGAL_ARGUMENT_ERROR;
            return;
        }
      }
    }
    // Fall through into normal handling
    U_FALLTHROUGH[[clang::fallthrough]];
  case UCAL_EXTENDED_YEAR:
  case UCAL_MONTH:
  case UCAL_ORDINAL_MONTH:
    {
      UBool oldLenient = isLenient();
      setLenient(true);
      int32_t value = get(field, status);
      if (U_FAILURE(status)) {
          return;
      }
      if (uprv_add32_overflowuprv_add32_overflow_77(value, amount, &value)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      set(field, value);

      pinField(UCAL_DAY_OF_MONTH, status);
      if(oldLenient==false) {
        complete(status); /* force recalculate */
        setLenient(oldLenient);
      }
    }
    return;

  case UCAL_WEEK_OF_YEAR:
  case UCAL_WEEK_OF_MONTH:
  case UCAL_DAY_OF_WEEK_IN_MONTH:
      delta *= kOneWeek(7.0 * (1.0 * (86400000)));
      break;

  case UCAL_AM_PM:
      delta *= 12 * kOneHour(60*60*1000);
      break;

  case UCAL_DAY_OF_MONTH:
  case UCAL_DAY_OF_YEAR:
  case UCAL_DAY_OF_WEEK:
  case UCAL_DOW_LOCAL:
  case UCAL_JULIAN_DAY:
      delta *= kOneDay(1.0 * (86400000));
      break;

  case UCAL_HOUR_OF_DAY:
  case UCAL_HOUR:
      delta *= kOneHour(60*60*1000);
      keepWallTimeInvariant = false;
      break;

  case UCAL_MINUTE:
      delta *= kOneMinute60000;
      keepWallTimeInvariant = false;
      break;

  case UCAL_SECOND:
      delta *= kOneSecond1000;
      keepWallTimeInvariant = false;
      break;

  case UCAL_MILLISECOND:
  case UCAL_MILLISECONDS_IN_DAY:
      keepWallTimeInvariant = false;
      break;

  default:
2211#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s not addable",
          __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2213, fldName(field));
2214#endif
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
      //  throw new IllegalArgumentException("Calendar.add(" + fieldName(field) +
      //                                     ") not supported");
  }

  // In order to keep the wall time invariant (for fields where this is
  // appropriate), check the combined DST & ZONE offset before and
  // after the add() operation. If it changes, then adjust the millis
  // to compensate.
  int32_t prevOffset = 0;
  int32_t prevWallTime = 0;
  if (keepWallTimeInvariant) {
      prevOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
      prevWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
  }

  setTimeInMillis(getTimeInMillis(status) + delta, status);

  if (keepWallTimeInvariant) {
      int32_t newWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
      if (newWallTime != prevWallTime) {
          // There is at least one zone transition between the base
          // time and the result time. As the result, wall time has
          // changed.
          UDate t = internalGetTime();
          int32_t newOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
          if (newOffset != prevOffset) {
              // When the difference of the previous UTC offset and
              // the new UTC offset exceeds 1 full day, we do not want
              // to roll over/back the date. For now, this only happens
              // in Samoa (Pacific/Apia) on Dec 30, 2011. See ticket:9452.
              int32_t adjAmount = prevOffset - newOffset;
              adjAmount = adjAmount >= 0 ? adjAmount % static_cast<int32_t>(kOneDay(1.0 * (86400000))) : -(-adjAmount % static_cast<int32_t>(kOneDay(1.0 * (86400000))));
              if (adjAmount != 0) {
                  setTimeInMillis(t + adjAmount, status);
                  newWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
              }
              if (newWallTime != prevWallTime) {
                  // The result wall time or adjusted wall time was shifted because
                  // the target wall time does not exist on the result date.
                  switch (fSkippedWallTime) {
                  case UCAL_WALLTIME_FIRST:
                      if (adjAmount > 0) {
                          setTimeInMillis(t, status);
                      }
                      break;
                  case UCAL_WALLTIME_LAST:
                      if (adjAmount < 0) {
                          setTimeInMillis(t, status);
                      }
                      break;
                  case UCAL_WALLTIME_NEXT_VALID:
                      UDate tmpT = adjAmount > 0 ? internalGetTime() : t;
                      UDate immediatePrevTrans;
                      UBool hasTransition = getImmediatePreviousZoneTransition(tmpT, &immediatePrevTrans, status);
                      if (U_SUCCESS(status) && hasTransition) {
                          setTimeInMillis(immediatePrevTrans, status);
                      }
                      break;
                  }
              }
          }
      }
  }
2280}

2282// -------------------------------------
2283int32_t Calendar::fieldDifference(UDate when, EDateFields field, UErrorCode& status) {
  return fieldDifference(when, static_cast<UCalendarDateFields>(field), status);
2285}

2287int32_t Calendar::fieldDifference(UDate targetMs, UCalendarDateFields field, UErrorCode& ec) {
  if (U_FAILURE(ec)) {
      return 0;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      ec = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  int32_t min = 0;
  double startMs = getTimeInMillis(ec);
  // Always add from the start millis.  This accommodates
  // operations like adding years from February 29, 2000 up to
  // February 29, 2004.  If 1, 1, 1, 1 is added to the year
  // field, the DOM gets pinned to 28 and stays there, giving an
  // incorrect DOM difference of 1.  We have to add 1, reset, 2,
  // reset, 3, reset, 4.
  if (startMs < targetMs) {
      int32_t max = 1;
      // Find a value that is too large
      while (U_SUCCESS(ec)) {
          setTimeInMillis(startMs, ec);
          add(field, max, ec);
          double ms = getTimeInMillis(ec);
          if (ms == targetMs) {
              return max;
          } else if (ms > targetMs) {
              break;
          } else if (max < INT32_MAX(2147483647)) {
              min = max;
              max <<= 1;
              if (max < 0) {
                  max = INT32_MAX(2147483647);
              }
          } else {
              // Field difference too large to fit into int32_t
2322#if defined (U_DEBUG_CAL)
              fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
                  __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2324, fldName(field));
2325#endif
              ec = U_ILLEGAL_ARGUMENT_ERROR;
              return 0;
          }
      }
      // Do a binary search
      while ((max - min) > 1 && U_SUCCESS(ec)) {
          int32_t t = min + (max - min)/2; // make sure intermediate values don't exceed INT32_MAX
          setTimeInMillis(startMs, ec);
          add(field, t, ec);
          double ms = getTimeInMillis(ec);
          if (ms == targetMs) {
              return t;
          } else if (ms > targetMs) {
              max = t;
          } else {
              min = t;
          }
      }
  } else if (startMs > targetMs) {
      int32_t max = -1;
      // Find a value that is too small
      while (U_SUCCESS(ec)) {
          setTimeInMillis(startMs, ec);
          add(field, max, ec);
          double ms = getTimeInMillis(ec);
          if (ms == targetMs) {
              return max;
          } else if (ms < targetMs) {
              break;
          } else {
              min = max;
              max = static_cast<int32_t>(static_cast<uint32_t>(max) << 1);
              if (max == 0) {
                  // Field difference too large to fit into int32_t
2360#if defined (U_DEBUG_CAL)
                  fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
                      __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2362, fldName(field));
2363#endif
                  ec = U_ILLEGAL_ARGUMENT_ERROR;
                  return 0;
              }
          }
      }
      // Do a binary search
      while ((min - max) > 1 && U_SUCCESS(ec)) {
          int32_t t = min + (max - min)/2; // make sure intermediate values don't exceed INT32_MAX
          setTimeInMillis(startMs, ec);
          add(field, t, ec);
          double ms = getTimeInMillis(ec);
          if (ms == targetMs) {
              return t;
          } else if (ms < targetMs) {
              max = t;
          } else {
              min = t;
          }
      }
  }
  // Set calendar to end point
  setTimeInMillis(startMs, ec);
  add(field, min, ec);

  /* Test for buffer overflows */
  if(U_FAILURE(ec)) {
      return 0;
  }
  return min;
2393}

2395// -------------------------------------

2397void
2398Calendar::adoptTimeZone(TimeZone* zone)
2399{
  // Do nothing if passed-in zone is nullptr
  if (zone == nullptr) {
      return;
  }

  // fZone should always be non-null
  delete fZone;
  fZone = zone;

  // if the zone changes, we need to recompute the time fields
  fAreFieldsSet = false;
2411}

2413// -------------------------------------
2414void
2415Calendar::setTimeZone(const TimeZone& zone)
2416{
  adoptTimeZone(zone.clone());
2418}

2420// -------------------------------------

2422const TimeZone&
2423Calendar::getTimeZone() const
2424{
  U_ASSERT(fZone != nullptr)(static_cast <bool> (fZone != nullptr) ? void (0) : __assert_fail
 ("fZone != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  return *fZone;
2427}

2429// -------------------------------------

2431TimeZone*
2432Calendar::orphanTimeZone()
2433{
  // we let go of the time zone; the new time zone is the system default time zone
  TimeZone *defaultZone = TimeZone::createDefault();
  if (defaultZone == nullptr) {
      // No error handling available. Must keep fZone non-nullptr, there are many unchecked uses.
      return nullptr;
  }
  TimeZone *z = fZone;
  fZone = defaultZone;
  return z;
2443}

2445// -------------------------------------

2447void
2448Calendar::setLenient(UBool lenient)
2449{
  fLenient = lenient;
2451}

2453// -------------------------------------

2455UBool
2456Calendar::isLenient() const
2457{
  return fLenient;
2459}

2461// -------------------------------------

2463void
2464Calendar::setRepeatedWallTimeOption(UCalendarWallTimeOption option)
2465{
  if (option == UCAL_WALLTIME_LAST || option == UCAL_WALLTIME_FIRST) {
      fRepeatedWallTime = option;
  }
2469}

2471// -------------------------------------

2473UCalendarWallTimeOption
2474Calendar::getRepeatedWallTimeOption() const
2475{
  return fRepeatedWallTime;
2477}

2479// -------------------------------------

2481void
2482Calendar::setSkippedWallTimeOption(UCalendarWallTimeOption option)
2483{
  fSkippedWallTime = option;
2485}

2487// -------------------------------------

2489UCalendarWallTimeOption
2490Calendar::getSkippedWallTimeOption() const
2491{
  return fSkippedWallTime;
2493}

2495// -------------------------------------

2497void
2498Calendar::setFirstDayOfWeek(UCalendarDaysOfWeek value) UPRV_NO_SANITIZE_UNDEFINED__attribute__((no_sanitize("undefined"))) {
  if (fFirstDayOfWeek != value &&
      value >= UCAL_SUNDAY && value <= UCAL_SATURDAY) {
          fFirstDayOfWeek = value;
          fAreFieldsSet = false;
      }
2504}

2506// -------------------------------------

2508Calendar::EDaysOfWeek
2509Calendar::getFirstDayOfWeek() const
2510{
  return static_cast<Calendar::EDaysOfWeek>(fFirstDayOfWeek);
2512}

2514UCalendarDaysOfWeek
2515Calendar::getFirstDayOfWeek(UErrorCode & /*status*/) const
2516{
  return fFirstDayOfWeek;
2518}
2519// -------------------------------------

2521void
2522Calendar::setMinimalDaysInFirstWeek(uint8_t value)
2523{
  // Values less than 1 have the same effect as 1; values greater
  // than 7 have the same effect as 7. However, we normalize values
  // so operator== and so forth work.
  if (value < 1) {
      value = 1;
  } else if (value > 7) {
      value = 7;
  }
  if (fMinimalDaysInFirstWeek != value) {
      fMinimalDaysInFirstWeek = value;
      fAreFieldsSet = false;
  }
2536}

2538// -------------------------------------

2540uint8_t
2541Calendar::getMinimalDaysInFirstWeek() const
2542{
  return fMinimalDaysInFirstWeek;
2544}

2546// -------------------------------------
2547// weekend functions, just dummy implementations for now (for API freeze)

2549UCalendarWeekdayType
2550Calendar::getDayOfWeekType(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
2551{
  if (U_FAILURE(status)) {
      return UCAL_WEEKDAY;
  }
  if (dayOfWeek < UCAL_SUNDAY || dayOfWeek > UCAL_SATURDAY) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return UCAL_WEEKDAY;
  }
  if (fWeekendOnset == fWeekendCease) {
      if (dayOfWeek != fWeekendOnset)
          return UCAL_WEEKDAY;
      return (fWeekendOnsetMillis == 0) ? UCAL_WEEKEND : UCAL_WEEKEND_ONSET;
  }
  if (fWeekendOnset < fWeekendCease) {
      if (dayOfWeek < fWeekendOnset || dayOfWeek > fWeekendCease) {
          return UCAL_WEEKDAY;
      }
  } else {
      if (dayOfWeek > fWeekendCease && dayOfWeek < fWeekendOnset) {
          return UCAL_WEEKDAY;
      }
  }
  if (dayOfWeek == fWeekendOnset) {
      return (fWeekendOnsetMillis == 0) ? UCAL_WEEKEND : UCAL_WEEKEND_ONSET;
  }
  if (dayOfWeek == fWeekendCease) {
      return (fWeekendCeaseMillis >= 86400000) ? UCAL_WEEKEND : UCAL_WEEKEND_CEASE;
  }
  return UCAL_WEEKEND;
2580}

2582int32_t
2583Calendar::getWeekendTransition(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
2584{
  if (U_FAILURE(status)) {
      return 0;
  }
  if (dayOfWeek == fWeekendOnset) {
      return fWeekendOnsetMillis;
  } else if (dayOfWeek == fWeekendCease) {
      return fWeekendCeaseMillis;
  }
  status = U_ILLEGAL_ARGUMENT_ERROR;
  return 0;
2595}

2597UBool
2598Calendar::isWeekend(UDate date, UErrorCode &status) const
2599{
  if (U_FAILURE(status)) {
      return false;
  }
  // clone the calendar so we don't mess with the real one.
  Calendar *work = this->clone();
  if (work == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return false;
  }
  UBool result = false;
  work->setTime(date, status);
  if (U_SUCCESS(status)) {
      result = work->isWeekend();
  }
  delete work;
  return result;
2616}

2618UBool
2619Calendar::isWeekend() const
2620{
  UErrorCode status = U_ZERO_ERROR;
  UCalendarDaysOfWeek dayOfWeek = static_cast<UCalendarDaysOfWeek>(get(UCAL_DAY_OF_WEEK, status));
  UCalendarWeekdayType dayType = getDayOfWeekType(dayOfWeek, status);
  if (U_SUCCESS(status)) {
      switch (dayType) {
          case UCAL_WEEKDAY:
              return false;
          case UCAL_WEEKEND:
              return true;
          case UCAL_WEEKEND_ONSET:
          case UCAL_WEEKEND_CEASE:
              // Use internalGet() because the above call to get() populated all fields.
              {
                  int32_t millisInDay = internalGet(UCAL_MILLISECONDS_IN_DAY);
                  int32_t transitionMillis = getWeekendTransition(dayOfWeek, status);
                  if (U_SUCCESS(status)) {
                      return (dayType == UCAL_WEEKEND_ONSET)?
                          (millisInDay >= transitionMillis):
                          (millisInDay <  transitionMillis);
                  }
                  // else fall through, return false
                  U_FALLTHROUGH[[clang::fallthrough]];
              }
          default:
              break;
      }
  }
  return false;
2649}

2651// ------------------------------------- limits

2653int32_t
2654Calendar::getMinimum(EDateFields field) const {
  return getLimit(static_cast<UCalendarDateFields>(field), UCAL_LIMIT_MINIMUM);
2656}

2658int32_t
2659Calendar::getMinimum(UCalendarDateFields field) const
2660{
  return getLimit(field,UCAL_LIMIT_MINIMUM);
2662}

2664// -------------------------------------
2665int32_t
2666Calendar::getMaximum(EDateFields field) const
2667{
  return getLimit(static_cast<UCalendarDateFields>(field), UCAL_LIMIT_MAXIMUM);
2669}

2671int32_t
2672Calendar::getMaximum(UCalendarDateFields field) const
2673{
  return getLimit(field,UCAL_LIMIT_MAXIMUM);
2675}

2677// -------------------------------------
2678int32_t
2679Calendar::getGreatestMinimum(EDateFields field) const
2680{
  return getLimit(static_cast<UCalendarDateFields>(field), UCAL_LIMIT_GREATEST_MINIMUM);
2682}

2684int32_t
2685Calendar::getGreatestMinimum(UCalendarDateFields field) const
2686{
  return getLimit(field,UCAL_LIMIT_GREATEST_MINIMUM);
2688}

2690// -------------------------------------
2691int32_t
2692Calendar::getLeastMaximum(EDateFields field) const
2693{
  return getLimit(static_cast<UCalendarDateFields>(field), UCAL_LIMIT_LEAST_MAXIMUM);
2695}

2697int32_t
2698Calendar::getLeastMaximum(UCalendarDateFields field) const
2699{
  return getLimit( field,UCAL_LIMIT_LEAST_MAXIMUM);
2701}

2703// -------------------------------------
2704int32_t
2705Calendar::getActualMinimum(EDateFields field, UErrorCode& status) const
2706{
  return getActualMinimum(static_cast<UCalendarDateFields>(field), status);
2708}

2710int32_t Calendar::getLimit(UCalendarDateFields field, ELimitType limitType) const {
  switch (field) {
  case UCAL_DAY_OF_WEEK:
  case UCAL_AM_PM:
  case UCAL_HOUR:
  case UCAL_HOUR_OF_DAY:
  case UCAL_MINUTE:
  case UCAL_SECOND:
  case UCAL_MILLISECOND:
  case UCAL_ZONE_OFFSET:
  case UCAL_DST_OFFSET:
  case UCAL_DOW_LOCAL:
  case UCAL_JULIAN_DAY:
  case UCAL_MILLISECONDS_IN_DAY:
  case UCAL_IS_LEAP_MONTH:
      return kCalendarLimits[field][limitType];

  case UCAL_WEEK_OF_MONTH:
      {
          int32_t limit;
          if (limitType == UCAL_LIMIT_MINIMUM) {
              limit = getMinimalDaysInFirstWeek() == 1 ? 1 : 0;
          } else if (limitType == UCAL_LIMIT_GREATEST_MINIMUM) {
              limit = 1;
          } else {
              int32_t minDaysInFirst = getMinimalDaysInFirstWeek();
              int32_t daysInMonth = handleGetLimit(UCAL_DAY_OF_MONTH, limitType);
              if (limitType == UCAL_LIMIT_LEAST_MAXIMUM) {
                  limit = (daysInMonth + (7 - minDaysInFirst)) / 7;
              } else { // limitType == UCAL_LIMIT_MAXIMUM
                  limit = (daysInMonth + 6 + (7 - minDaysInFirst)) / 7;
              }
          }
          return limit;
      }
  default:
      return handleGetLimit(field, limitType);
  }
2748}

2750int32_t
2751Calendar::getActualMinimum(UCalendarDateFields field, UErrorCode& status) const
2752{
  if (U_FAILURE(status)) {
     return 0;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  int32_t fieldValue = getGreatestMinimum(field);
  int32_t endValue = getMinimum(field);

  // if we know that the minimum value is always the same, just return it
  if (fieldValue == endValue) {
      return fieldValue;
  }

  // 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();
  if (work == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return 0;
  }
  work->setLenient(true);

  // now try each value from getLeastMaximum() to getMaximum() one by one until
  // we get a value that normalizes to another value.  The last value that
  // normalizes to itself is the actual minimum for the current date
  int32_t result = fieldValue;

  do {
      work->set(field, fieldValue);
      if (work->get(field, status) != fieldValue) {
          break;
      }
      else {
          result = fieldValue;
          fieldValue--;
      }
  } while (fieldValue >= endValue);

  delete work;

  /* Test for buffer overflows */
  if(U_FAILURE(status)) {
      return 0;
  }
  return result;
2800}

2802// -------------------------------------

2804UBool
2805Calendar::inDaylightTime(UErrorCode& status) const
2806{
  if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) {
      return false;
  }

  // Force an update of the state of the Calendar.
  const_cast<Calendar*>(this)->complete(status); // cast away const

  return U_SUCCESS(status) ? internalGet(UCAL_DST_OFFSET) != 0 : false;
2815}

2817bool
2818Calendar::inTemporalLeapYear(UErrorCode& status) const
2819{
  // Default to Gregorian based leap year rule.
  return getActualMaximum(UCAL_DAY_OF_YEAR, status) == 366;
2822}

2824// -------------------------------------

2826static const char * const gTemporalMonthCodes[] = {
  "M01", "M02", "M03", "M04", "M05", "M06",
  "M07", "M08", "M09", "M10", "M11", "M12", nullptr
2829};

2831const char*
2832Calendar::getTemporalMonthCode(UErrorCode& status) const
2833{
  int32_t month = get(UCAL_MONTH, status);
  if (U_FAILURE(status)) {
      return nullptr;
  }
  U_ASSERT(month < 12)(static_cast <bool> (month < 12) ? void (0) : __assert_fail
 ("month < 12", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  U_ASSERT(internalGet(UCAL_IS_LEAP_MONTH) == 0)(static_cast <bool> (internalGet(UCAL_IS_LEAP_MONTH) ==
 0) ? void (0) : __assert_fail ("internalGet(UCAL_IS_LEAP_MONTH) == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  return gTemporalMonthCodes[month];
2841}

2843void
2844Calendar::setTemporalMonthCode(const char* code, UErrorCode& status )
2845{
  if (U_FAILURE(status)) {
      return;
  }
  int32_t len = static_cast<int32_t>(uprv_strlen(code):: strlen(code));
  if (len == 3 && code[0] == 'M') {
      for (int m = 0; gTemporalMonthCodes[m] != nullptr; m++) {
          if (uprv_strcmp(code, gTemporalMonthCodes[m]):: strcmp(code, gTemporalMonthCodes[m]) == 0) {
              set(UCAL_MONTH, m);
              set(UCAL_IS_LEAP_MONTH, 0);
              return;
          }
      }
  }
  status = U_ILLEGAL_ARGUMENT_ERROR;
2860}

2862// -------------------------------------

2864/**
2865* Ensure that each field is within its valid range by calling {@link
2866* #validateField(int)} on each field that has been set.  This method
2867* should only be called if this calendar is not lenient.
2868* @see #isLenient
2869* @see #validateField(int)
2870*/
2871void Calendar::validateFields(UErrorCode &status) {
  if (U_FAILURE(status)) {
     return;
  }
  for (int32_t field = 0; U_SUCCESS(status) && (field < UCAL_FIELD_COUNT); field++) {
      if (fStamp[field] >= kMinimumUserStamp) {
          validateField(static_cast<UCalendarDateFields>(field), status);
      }
  }
2880}

2882/**
2883* Validate a single field of this calendar.  Subclasses should
2884* override this method to validate any calendar-specific fields.
2885* Generic fields can be handled by
2886* <code>Calendar.validateField()</code>.
2887* @see #validateField(int, int, int)
2888*/
2889void Calendar::validateField(UCalendarDateFields field, UErrorCode &status) {
  if (U_FAILURE(status)) {
     return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  int32_t y;
  switch (field) {
  case UCAL_DAY_OF_MONTH:
      y = handleGetExtendedYear(status);
      if (U_FAILURE(status)) {
         return;
      }
      validateField(field, 1, handleGetMonthLength(y, internalGetMonth(status), status), status);
      break;
  case UCAL_DAY_OF_YEAR:
      y = handleGetExtendedYear(status);
      if (U_FAILURE(status)) {
         return;
      }
      validateField(field, 1, handleGetYearLength(y, status), status);
      break;
  case UCAL_DAY_OF_WEEK_IN_MONTH:
      if (internalGet(field) == 0) {
2915#if defined (U_DEBUG_CAL)
          fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because DOW in month cannot be 0\n",
              __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2917);
2918#endif
          status = U_ILLEGAL_ARGUMENT_ERROR; // "DAY_OF_WEEK_IN_MONTH cannot be zero"
          return;
      }
      validateField(field, getMinimum(field), getMaximum(field), status);
      break;
  default:
      validateField(field, getMinimum(field), getMaximum(field), status);
      break;
  }
2928}

2930/**
2931* Validate a single field of this calendar given its minimum and
2932* maximum allowed value.  If the field is out of range, throw a
2933* descriptive <code>IllegalArgumentException</code>.  Subclasses may
2934* use this method in their implementation of {@link
2935* #validateField(int)}.
2936*/
2937void Calendar::validateField(UCalendarDateFields field, int32_t min, int32_t max, UErrorCode& status)
2938{
  if (U_FAILURE(status)) {
     return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  int32_t value = fFields[field];
  if (value < min || value > max) {
2948#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because of field %s out of range %d..%d  at %d\n",
          __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__2950,fldName(field),min,max,value);
2951#endif
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
2955}

2957// -------------------------

2959const UFieldResolutionTable* Calendar::getFieldResolutionTable() const {
  return kDatePrecedence;
2961}


2964UCalendarDateFields Calendar::newerField(UCalendarDateFields defaultField, UCalendarDateFields alternateField) const
2965{
  if (fStamp[alternateField] > fStamp[defaultField]) {
      return alternateField;
  }
  return defaultField;
2970}

2972UCalendarDateFields Calendar::resolveFields(const UFieldResolutionTable* precedenceTable) const {
  int32_t bestField = UCAL_FIELD_COUNT;
  int32_t tempBestField;
  for (int32_t g=0; precedenceTable[g][0][0] != -1 && (bestField == UCAL_FIELD_COUNT); ++g) {
      int32_t bestStamp = kUnset;
      for (int32_t l=0; precedenceTable[g][l][0] != -1; ++l) {
          int32_t lineStamp = kUnset;
          // Skip over first entry if it is negative
          for (int32_t i=((precedenceTable[g][l][0]>=kResolveRemap)?1:0); precedenceTable[g][l][i]!=-1; ++i) {
              U_ASSERT(precedenceTable[g][l][i] < UCAL_FIELD_COUNT)(static_cast <bool> (precedenceTable[g][l][i] < UCAL_FIELD_COUNT
) ? void (0) : __assert_fail ("precedenceTable[g][l][i] < UCAL_FIELD_COUNT"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
              int32_t s = fStamp[precedenceTable[g][l][i]];
              // If any field is unset then don't use this line
              if (s == kUnset) {
                  goto linesInGroup;
              } else if(s > lineStamp) {
                  lineStamp = s;
              }
          }
          // Record new maximum stamp & field no.
          if (lineStamp > bestStamp) {
              tempBestField = precedenceTable[g][l][0]; // First field refers to entire line
              if (tempBestField >= kResolveRemap) {
                  tempBestField &= (kResolveRemap-1);
                  // This check is needed to resolve some issues with UCAL_YEAR precedence mapping
                  if (tempBestField != UCAL_DATE || (fStamp[UCAL_WEEK_OF_MONTH] < fStamp[tempBestField])) {
                      bestField = tempBestField;
                  }
              } else {
                  bestField = tempBestField;
              }

              if (bestField == tempBestField) {
                  bestStamp = lineStamp;
              }
          }
3007linesInGroup:
          ;
      }
  }
  return static_cast<UCalendarDateFields>(bestField);
3012}

3014const UFieldResolutionTable Calendar::kDatePrecedence[] =
3015{
  {
      { UCAL_DAY_OF_MONTH, kResolveSTOP },
      { UCAL_WEEK_OF_YEAR, UCAL_DAY_OF_WEEK, kResolveSTOP },
      { UCAL_WEEK_OF_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
      { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
      { UCAL_WEEK_OF_YEAR, UCAL_DOW_LOCAL, kResolveSTOP },
      { UCAL_WEEK_OF_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
      { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
      { UCAL_DAY_OF_YEAR, kResolveSTOP },
      { kResolveRemap | UCAL_DAY_OF_MONTH, UCAL_YEAR, kResolveSTOP },  // if YEAR is set over YEAR_WOY use DAY_OF_MONTH
      { kResolveRemap | UCAL_WEEK_OF_YEAR, UCAL_YEAR_WOY, kResolveSTOP },  // if YEAR_WOY is set,  calc based on WEEK_OF_YEAR
      { kResolveSTOP }
  },
  {
      { UCAL_WEEK_OF_YEAR, kResolveSTOP },
      { UCAL_WEEK_OF_MONTH, kResolveSTOP },
      { UCAL_DAY_OF_WEEK_IN_MONTH, kResolveSTOP },
      { 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}}
3038};


3041const UFieldResolutionTable Calendar::kMonthPrecedence[] =
3042{
  {
      { UCAL_MONTH,kResolveSTOP, kResolveSTOP },
      { UCAL_ORDINAL_MONTH,kResolveSTOP, kResolveSTOP },
      {kResolveSTOP}
  },
  {{kResolveSTOP}}
3049};

3051const UFieldResolutionTable Calendar::kDOWPrecedence[] =
3052{
  {
      { UCAL_DAY_OF_WEEK,kResolveSTOP, kResolveSTOP },
      { UCAL_DOW_LOCAL,kResolveSTOP, kResolveSTOP },
      {kResolveSTOP}
  },
  {{kResolveSTOP}}
3059};

3061// precedence for calculating a year
3062const UFieldResolutionTable Calendar::kYearPrecedence[] =
3063{
  {
      { UCAL_YEAR, kResolveSTOP },
      { UCAL_EXTENDED_YEAR, kResolveSTOP },
      { UCAL_YEAR_WOY, UCAL_WEEK_OF_YEAR, kResolveSTOP },  // YEAR_WOY is useless without WEEK_OF_YEAR
      { kResolveSTOP }
  },
  {{kResolveSTOP}}
3071};


3074// -------------------------


3077void Calendar::computeTime(UErrorCode& status) {
  if (U_FAILURE(status)) {
     return;
  }
  if (!isLenient()) {
      validateFields(status);
      if (U_FAILURE(status)) {
          return;
      }
  }

  // Compute the Julian day
  int32_t julianDay = computeJulianDay(status);
  if (U_FAILURE(status)) {
      return;
  }

  double millis = Grego::julianDayToMillis(julianDay);

3096#if defined (U_DEBUG_CAL)
  //  int32_t julianInsanityCheck =  (int32_t)ClockMath::floorDivide(millis, kOneDay);
  //  julianInsanityCheck += kEpochStartAsJulianDay;
  //  if(1 || julianInsanityCheck != julianDay) {
  //    fprintf(stderr, "%s:%d- D'oh- computed jules %d, to mills (%s)%.lf, recomputed %d\n",
  //            __FILE__, __LINE__, julianDay, millis<0.0?"NEG":"", millis, julianInsanityCheck);
  //  }
3103#endif

  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
  // time and call clear(MONTH) to reset the MONTH to January.  This
  // is legacy behavior.  Without this, clear(MONTH) has no effect,
  // since the internally set JULIAN_DAY is used.
  if (fStamp[UCAL_MILLISECONDS_IN_DAY] >= static_cast<int32_t>(kMinimumUserStamp) &&
          newestStamp(UCAL_AM_PM, UCAL_MILLISECOND, kUnset) <= fStamp[UCAL_MILLISECONDS_IN_DAY]) {
      millisInDay = internalGet(UCAL_MILLISECONDS_IN_DAY);
  } else {
      millisInDay = computeMillisInDay();
  }

  UDate t = 0;
  if (fStamp[UCAL_ZONE_OFFSET] >= static_cast<int32_t>(kMinimumUserStamp) ||
      fStamp[UCAL_DST_OFFSET] >= static_cast<int32_t>(kMinimumUserStamp)) {
      t = millis + millisInDay - internalGet(UCAL_ZONE_OFFSET) - internalGet(UCAL_DST_OFFSET);
  } else {
      // Compute the time zone offset and DST offset.  There are two potential
      // ambiguities here.  We'll assume a 2:00 am (wall time) switchover time
      // for discussion purposes here.
      //
      // 1. The positive offset change such as transition into DST.
      //    Here, a designated time of 2:00 am - 2:59 am does not actually exist.
      //    For this case, skippedWallTime option specifies the behavior.
      //    For example, 2:30 am is interpreted as;
      //      - WALLTIME_LAST(default): 3:30 am (DST) (interpreting 2:30 am as 31 minutes after 1:59 am (STD))
      //      - WALLTIME_FIRST: 1:30 am (STD) (interpreting 2:30 am as 30 minutes before 3:00 am (DST))
      //      - WALLTIME_NEXT_VALID: 3:00 am (DST) (next valid time after 2:30 am on a wall clock)
      // 2. The negative offset change such as transition out of DST.
      //    Here, a designated time of 1:00 am - 1:59 am can be in standard or DST.  Both are valid
      //    representations (the rep jumps from 1:59:59 DST to 1:00:00 Std).
      //    For this case, repeatedWallTime option specifies the behavior.
      //    For example, 1:30 am is interpreted as;
      //      - WALLTIME_LAST(default): 1:30 am (STD) - latter occurrence
      //      - WALLTIME_FIRST: 1:30 am (DST) - former occurrence
      //
      // In addition to above, when calendar is strict (not default), wall time falls into
      // the skipped time range will be processed as an error case.
      //
      // These special cases are mostly handled in #computeZoneOffset(long), except WALLTIME_NEXT_VALID
      // at positive offset change. The protected method computeZoneOffset(long) is exposed to Calendar
      // subclass implementations and marked as @stable. Strictly speaking, WALLTIME_NEXT_VALID
      // should be also handled in the same place, but we cannot change the code flow without deprecating
      // the protected method.
      //
      // We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
      // or DST_OFFSET fields; then we use those fields.

      if (!isLenient() || fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID) {
          // When strict, invalidate a wall time falls into a skipped wall time range.
          // When lenient and skipped wall time option is WALLTIME_NEXT_VALID,
          // the result time will be adjusted to the next valid time (on wall clock).
          int32_t zoneOffset = computeZoneOffset(millis, millisInDay, status);
          UDate tmpTime = millis + millisInDay - zoneOffset;

          int32_t raw, dst;
          fZone->getOffset(tmpTime, false, raw, dst, status);

          if (U_SUCCESS(status)) {
              // zoneOffset != (raw + dst) only when the given wall time fall into
              // a skipped wall time range caused by positive zone offset transition.
              if (zoneOffset != (raw + dst)) {
                  if (!isLenient()) {
                      status = U_ILLEGAL_ARGUMENT_ERROR;
                  } else {
                      U_ASSERT(fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID)(static_cast <bool> (fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID
) ? void (0) : __assert_fail ("fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
                      // Adjust time to the next valid wall clock time.
                      // At this point, tmpTime is on or after the zone offset transition causing
                      // the skipped time range.
                      UDate immediatePrevTransition;
                      UBool hasTransition = getImmediatePreviousZoneTransition(tmpTime, &immediatePrevTransition, status);
                      if (U_SUCCESS(status) && hasTransition) {
                          t = immediatePrevTransition;
                      }
                  }
              } else {
                  t = tmpTime;
              }
          }
      } else {
          t = millis + millisInDay - computeZoneOffset(millis, millisInDay, status);
      }
  }
  if (U_SUCCESS(status)) {
      internalSetTime(t);
  }
3193}

3195/**
* Find the previous zone transition near the given time.
*/
3198UBool Calendar::getImmediatePreviousZoneTransition(UDate base, UDate *transitionTime, UErrorCode& status) const {
  if (U_FAILURE(status)) {
     return false;
  }
  BasicTimeZone *btz = getBasicTimeZone();
  if (btz) {
      TimeZoneTransition trans;
      UBool hasTransition = btz->getPreviousTransition(base, true, trans);
      if (hasTransition) {
          *transitionTime = trans.getTime();
          return true;
      } else {
          // Could not find any transitions.
          // Note: This should never happen.
          status = U_INTERNAL_PROGRAM_ERROR;
      }
  } else {
      // If not BasicTimeZone, return unsupported error for now.
      // TODO: We may support non-BasicTimeZone in future.
      status = U_UNSUPPORTED_ERROR;
  }
  return false;
3220}

3222/**
3223* Compute the milliseconds in the day from the fields.  This is a
3224* value from 0 to 23:59:59.999 inclusive, unless fields are out of
3225* range, in which case it can be an arbitrary value.  This value
3226* reflects local zone wall time.
3227* @stable ICU 2.0
3228*/
3229double Calendar::computeMillisInDay() {
// Do the time portion of the conversion.

  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
  // AM_PM and the HOUR.
  int32_t hourOfDayStamp = fStamp[UCAL_HOUR_OF_DAY];
  int32_t hourStamp = (fStamp[UCAL_HOUR] > fStamp[UCAL_AM_PM])?fStamp[UCAL_HOUR]:fStamp[UCAL_AM_PM];
  int32_t bestStamp = (hourStamp > hourOfDayStamp) ? hourStamp : hourOfDayStamp;

  // Hours
  if (bestStamp != kUnset) {
      if (bestStamp == hourOfDayStamp) {
          // Don't normalize here; let overflow bump into the next period.
          // This is consistent with how we handle other fields.
          millisInDay += internalGet(UCAL_HOUR_OF_DAY);
      } else {
          // Don't normalize here; let overflow bump into the next period.
          // This is consistent with how we handle other fields.
          millisInDay += internalGet(UCAL_HOUR);
          // Treat even number as AM and odd nubmber as PM to align with the
          // logic in roll()
          millisInDay += (internalGet(UCAL_AM_PM) % 2 == 0) ? 0 : 12;
      }
  }

  // We use the fact that unset == 0; we start with millisInDay
  // == HOUR_OF_DAY.
  millisInDay *= 60;
  millisInDay += internalGet(UCAL_MINUTE); // now have minutes
  millisInDay *= 60;
  millisInDay += internalGet(UCAL_SECOND); // now have seconds
  millisInDay *= 1000;
  millisInDay += internalGet(UCAL_MILLISECOND); // now have millis

  return millisInDay;
3267}

3269/**
3270* This method can assume EXTENDED_YEAR has been set.
3271* @param millis milliseconds of the date fields
3272* @param millisInDay milliseconds of the time fields; may be out
3273* or range.
3274* @stable ICU 2.0
3275*/
3276int32_t Calendar::computeZoneOffset(double millis, double millisInDay, UErrorCode &ec) {
  if (U_FAILURE(ec)) {
     return 0;
  }
  int32_t rawOffset, dstOffset;
  UDate wall = millis + millisInDay;
  BasicTimeZone* btz = getBasicTimeZone();
  if (btz) {
      UTimeZoneLocalOption duplicatedTimeOpt = (fRepeatedWallTime == UCAL_WALLTIME_FIRST) ? UCAL_TZ_LOCAL_FORMER : UCAL_TZ_LOCAL_LATTER;
      UTimeZoneLocalOption nonExistingTimeOpt = (fSkippedWallTime == UCAL_WALLTIME_FIRST) ? UCAL_TZ_LOCAL_LATTER : UCAL_TZ_LOCAL_FORMER;
      btz->getOffsetFromLocal(wall, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, ec);
  } else {
      const TimeZone& tz = getTimeZone();
      // By default, TimeZone::getOffset behaves UCAL_WALLTIME_LAST for both.
      tz.getOffset(wall, true, rawOffset, dstOffset, ec);

      UBool sawRecentNegativeShift = false;
      if (fRepeatedWallTime == UCAL_WALLTIME_FIRST) {
          // Check if the given wall time falls into repeated time range
          UDate tgmt = wall - (rawOffset + dstOffset);

          // Any negative zone transition within last 6 hours?
          // Note: The maximum historic negative zone transition is -3 hours in the tz database.
          // 6 hour window would be sufficient for this purpose.
          int32_t tmpRaw, tmpDst;
          tz.getOffset(tgmt - 6*60*60*1000, false, tmpRaw, tmpDst, ec);
          int32_t offsetDelta = (rawOffset + dstOffset) - (tmpRaw + tmpDst);

          U_ASSERT(offsetDelta < -6*60*60*1000)(static_cast <bool> (offsetDelta < -6*60*60*1000) ? void
 (0) : __assert_fail ("offsetDelta < -6*60*60*1000", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          if (offsetDelta < 0) {
              sawRecentNegativeShift = true;
              // Negative shift within last 6 hours. When UCAL_WALLTIME_FIRST is used and the given wall time falls
              // into the repeated time range, use offsets before the transition.
              // Note: If it does not fall into the repeated time range, offsets remain unchanged below.
              tz.getOffset(wall + offsetDelta, true, rawOffset, dstOffset, ec);
          }
      }
      if (!sawRecentNegativeShift && fSkippedWallTime == UCAL_WALLTIME_FIRST) {
          // When skipped wall time option is WALLTIME_FIRST,
          // recalculate offsets from the resolved time (non-wall).
          // When the given wall time falls into skipped wall time,
          // the offsets will be based on the zone offsets AFTER
          // the transition (which means, earliest possible interpretation).
          UDate tgmt = wall - (rawOffset + dstOffset);
          tz.getOffset(tgmt, false, rawOffset, dstOffset, ec);
      }
  }
  return rawOffset + dstOffset;
3324}

3326int32_t Calendar::computeJulianDay(UErrorCode &status)
3327{
  // 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
  // the normal resolution.  We only use JULIAN_DAY if it has been
  // set by the user.  This makes it possible for the caller to set
  // the calendar to a time and call clear(MONTH) to reset the MONTH
  // to January.  This is legacy behavior.  Without this,
  // clear(MONTH) has no effect, since the internally set JULIAN_DAY
  // is used.
  if (fStamp[UCAL_JULIAN_DAY] >= static_cast<int32_t>(kMinimumUserStamp)) {
      int32_t bestStamp = newestStamp(UCAL_ERA, UCAL_DAY_OF_WEEK_IN_MONTH, kUnset);
      bestStamp = newestStamp(UCAL_YEAR_WOY, UCAL_EXTENDED_YEAR, bestStamp);
      bestStamp = newestStamp(UCAL_ORDINAL_MONTH, UCAL_ORDINAL_MONTH, bestStamp);
      if (bestStamp <= fStamp[UCAL_JULIAN_DAY]) {
          return internalGet(UCAL_JULIAN_DAY);
      }
  }

  UCalendarDateFields bestField = resolveFields(getFieldResolutionTable());
  if (bestField == UCAL_FIELD_COUNT) {
      bestField = UCAL_DAY_OF_MONTH;
  }

  return handleComputeJulianDay(bestField, status);
3351}

3353// -------------------------------------------

3355int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField, UErrorCode &status)  {
  if (U_FAILURE(status)) {
     return 0;
  }
  UBool useMonth = (bestField == UCAL_DAY_OF_MONTH ||
      bestField == UCAL_WEEK_OF_MONTH ||
      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);
  } else {
      year = handleGetExtendedYear(status);
      if (U_FAILURE(status)) {
         return 0;
      }
  }

  internalSet(UCAL_EXTENDED_YEAR, year);
  // Return U_ILLEGAL_ARGUMENT_ERROR if year is too large that may cuase int32_t overflow
  // later.
  if (year > INT32_MAX(2147483647) / 400) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }

3381#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "%s:%d: bestField= %s - y=%d\n", __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3382, fldName(bestField), year);
3383#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.

  // give calendar subclass a chance to have a default 'first' month
  int32_t month;

  if(isSet(UCAL_MONTH) || isSet(UCAL_ORDINAL_MONTH)) {
      month = internalGetMonth(status);
      if (U_FAILURE(status)) {
         return 0;
      }
  } else {
      month = getDefaultMonthInYear(year, status);
      if (U_FAILURE(status)) {
         return 0;
      }
  }

  int32_t julianDay = handleComputeMonthStart(year, useMonth ? month : 0, useMonth, status);
  if (U_FAILURE(status)) {
      return 0;
  }

  if (bestField == UCAL_DAY_OF_MONTH) {

      // give calendar subclass a chance to have a default 'first' dom
      int32_t dayOfMonth;
      if(isSet(UCAL_DAY_OF_MONTH)) {
          dayOfMonth = internalGet(UCAL_DAY_OF_MONTH,1);
      } else {
          dayOfMonth = getDefaultDayInMonth(year, month, status);
          if (U_FAILURE(status)) {
             return 0;
          }
      }
      if (uprv_add32_overflowuprv_add32_overflow_77(dayOfMonth, julianDay, &dayOfMonth)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return 0;
      }
      return dayOfMonth;
  }

  if (bestField == UCAL_DAY_OF_YEAR) {
      int32_t result;
      if (uprv_add32_overflowuprv_add32_overflow_77(internalGet(UCAL_DAY_OF_YEAR), julianDay, &result)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return 0;
      }
      return result;
  }

  int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw

  // At this point julianDay is the 0-based day BEFORE the first day of
  // January 1, year 1 of the given calendar.  If julianDay == 0, it
  // specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
  // or Gregorian). (or it is before the month we are in, if useMonth is True)

  // At this point we need to process the WEEK_OF_MONTH or
  // WEEK_OF_YEAR, which are similar, or the DAY_OF_WEEK_IN_MONTH.
  // First, perform initial shared computations.  These locate the
  // first week of the period.

  // Get the 0-based localized DOW of day one of the month or year.
  // Valid range 0..6.
  int32_t first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek;
  if (first < 0) {
      first += 7;
  }

  int32_t dowLocal = getLocalDOW(status);
  if (U_FAILURE(status)) {
      return 0;
  }

  // Find the first target DOW (dowLocal) in the month or year.
  // Actually, it may be just before the first of the month or year.
  // It will be an integer from -5..7.
  int32_t date = 1 - first + dowLocal;

  if (bestField == UCAL_DAY_OF_WEEK_IN_MONTH) {
      // Adjust the target DOW to be in the month or year.
      if (date < 1) {
          date += 7;
      }

      // The only trickiness occurs if the day-of-week-in-month is
      // negative.
      int32_t dim = internalGet(UCAL_DAY_OF_WEEK_IN_MONTH, 1);
      if (dim >= 0) {
          int32_t temp;
          if (uprv_mul32_overflowuprv_mul32_overflow_77(7, dim - 1, &temp)  ||
              uprv_add32_overflowuprv_add32_overflow_77(date, temp, &date)) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
              return 0;
          }

      } else {
          // Move date to the last of this day-of-week in this month,
          // then back up as needed.  If dim==-1, we don't back up at
          // all.  If dim==-2, we back up once, etc.  Don't back up
          // past the first of the given day-of-week in this month.
          // Note that we handle -2, -3, etc. correctly, even though
          // values < -1 are technically disallowed.
          int32_t m = internalGetMonth(UCAL_JANUARY, status);
          int32_t monthLength = handleGetMonthLength(year, m, status);
          if (U_FAILURE(status)) {
              return 0;
          }
          int32_t temp;
          if (uprv_add32_overflowuprv_add32_overflow_77((monthLength - date) / 7, dim+1, &temp) ||
              uprv_mul32_overflowuprv_mul32_overflow_77(temp, 7, &temp) ||
              uprv_add32_overflowuprv_add32_overflow_77(date, temp, &date)) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
              return 0;
          }
      }
  } else {
3503#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d - bf= %s\n", __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3504, fldName(bestField));
3505#endif

      if(bestField == UCAL_WEEK_OF_YEAR) {  // ------------------------------------- WOY -------------
          if(!isSet(UCAL_YEAR_WOY) ||  // YWOY not set at all or
              ( (resolveFields(kYearPrecedence) != UCAL_YEAR_WOY) // YWOY doesn't have precedence
              && (fStamp[UCAL_YEAR_WOY]!=kInternallySet) ) ) // (excluding where all fields are internally set - then YWOY is used)
          {
              // need to be sure to stay in 'real' year.
              int32_t woy = internalGet(bestField);

              int32_t nextJulianDay = handleComputeMonthStart(year+1, 0, false, status); // jd of day before jan 1
              if (U_FAILURE(status)) {
                  return 0;
              }
              int32_t nextFirst = julianDayToDayOfWeek(nextJulianDay + 1) - firstDayOfWeek;

              if (nextFirst < 0) { // 0..6 ldow of Jan 1
                  nextFirst += 7;
              }

              if(woy==1) {  // FIRST WEEK ---------------------------------
3526#if defined (U_DEBUG_CAL)
                  fprintf(stderrstderr, "%s:%d - woy=%d, yp=%d, nj(%d)=%d, nf=%d", __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3527,
                      internalGet(bestField), resolveFields(kYearPrecedence), year+1,
                      nextJulianDay, nextFirst);

                  fprintf(stderrstderr, " next: %d DFW,  min=%d   \n", (7-nextFirst), getMinimalDaysInFirstWeek() );
3532#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
3539#if defined (U_DEBUG_CAL)
                      fprintf(stderrstderr, "%s:%d - was going to move JD from %d to %d [d%d]\n", __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3540,
                          julianDay, nextJulianDay, (nextJulianDay-julianDay));
3542#endif
                      julianDay = nextJulianDay;

                      // recalculate 'first' [0-based local dow of jan 1]
                      first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek;
                      if (first < 0) {
                          first += 7;
                      }
                      // recalculate date.
                      date = 1 - first + dowLocal;
                  }
              } 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()) {
                      testDate += 7;
                  }

                  // Now adjust for the week number.
                  int32_t weeks;
                  if (uprv_mul32_overflowuprv_mul32_overflow_77(woy-1, 7, &weeks) ||
                      uprv_add32_overflowuprv_add32_overflow_77(weeks, testDate, &testDate)) {
                      status = U_ILLEGAL_ARGUMENT_ERROR;
                      return 0;
                  }

3568#if defined (U_DEBUG_CAL)
                  fprintf(stderrstderr, "%s:%d - y=%d, y-1=%d doy%d, njd%d (C.F. %d)\n",
                      __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3570, year, year-1, testDate, julianDay+testDate, nextJulianDay);
3571#endif
                  if (uprv_add32_overflowuprv_add32_overflow_77(julianDay, testDate, &testDate)) {
                      status = U_ILLEGAL_ARGUMENT_ERROR;
                      return 0;
                  }

                  if(testDate > nextJulianDay) { // is it past Dec 31?  (nextJulianDay is day BEFORE year+1's  Jan 1)
                      // Fire up the calculating engines.. retry YWOY = (year-1)
                      int32_t prevYear;
                      if (uprv_add32_overflowuprv_add32_overflow_77(year, -1, &prevYear)) {
                          status = U_ILLEGAL_ARGUMENT_ERROR;
                          return 0;
                      }
                      julianDay = handleComputeMonthStart(prevYear, 0, false, status); // jd before Jan 1 of previous year
                      if (U_FAILURE(status)) {
                          return 0;
                      }
                      first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek; // 0 based local dow   of first week

                      if(first < 0) { // 0..6
                          first += 7;
                      }
                      date = 1 - first + dowLocal;

3595#if defined (U_DEBUG_CAL)
                      fprintf(stderrstderr, "%s:%d - date now %d, jd%d, ywoy%d\n",
                          __FILE__"/root/firefox-clang/intl/icu/source/i18n/calendar.cpp", __LINE__3597, date, julianDay, year-1);
3598#endif


                  } /* correction needed */
              } /* leastmaximum */
          } /* resolvefields(year) != year_woy */
      } /* bestfield != week_of_year */

      // assert(bestField == WEEK_OF_MONTH || bestField == WEEK_OF_YEAR)
      // Adjust for minimal days in first week
      if ((7 - first) < getMinimalDaysInFirstWeek()) {
          date += 7;
      }

      // Now adjust for the week number.
      int32_t weeks = internalGet(bestField);
      if (uprv_add32_overflowuprv_add32_overflow_77(weeks, -1, &weeks) ||
          uprv_mul32_overflowuprv_mul32_overflow_77(7, weeks, &weeks) ||
          uprv_add32_overflowuprv_add32_overflow_77(date, weeks, &date)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return 0;
      }
  }

  if (uprv_add32_overflowuprv_add32_overflow_77(julianDay, date, &julianDay)) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  return julianDay;
3627}

3629int32_t
3630Calendar::getDefaultMonthInYear(int32_t /*eyear*/, UErrorCode& /* status */)
3631{
  return 0;
3633}

3635int32_t
3636Calendar::getDefaultDayInMonth(int32_t /*eyear*/, int32_t /*month*/, UErrorCode& /* status */)
3637{
  return 1;
3639}


3642int32_t Calendar::getLocalDOW(UErrorCode& status)
3643{
  if (U_FAILURE(status)) {
      return 0;
  }
  // Get zero-based localized DOW, valid range 0..6.  This is the DOW
  // we are looking for.
  int32_t dowLocal = 0;
  switch (resolveFields(kDOWPrecedence)) {
  case UCAL_DAY_OF_WEEK:
      dowLocal = internalGet(UCAL_DAY_OF_WEEK);
      if (uprv_add32_overflowuprv_add32_overflow_77(dowLocal, -fFirstDayOfWeek, &dowLocal)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return 0;
      }
      break;
  case UCAL_DOW_LOCAL:
      dowLocal = internalGet(UCAL_DOW_LOCAL);
      if (uprv_add32_overflowuprv_add32_overflow_77(dowLocal, -1, &dowLocal)) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return 0;
      }
      break;
  default:
      break;
  }
  dowLocal = dowLocal % 7;
  if (dowLocal < 0) {
      dowLocal += 7;
  }
  return dowLocal;
3673}

3675int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy, UErrorCode& status)
3676{
  if (U_FAILURE(status)) {
      return 0;
  }
  // 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

  // Now, a local DOW
  int32_t dowLocal = getLocalDOW(status); // 0..6
  if (U_FAILURE(status)) {
    return 0;
  }
  int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw
  int32_t jan1Start = handleComputeMonthStart(yearWoy, 0, false, status);
  int32_t yearWoyPlus1;
  if (uprv_add32_overflowuprv_add32_overflow_77(yearWoy, 1, &yearWoyPlus1)) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  int32_t nextJan1Start = handleComputeMonthStart(yearWoyPlus1, 0, false, status); // next year's Jan1 start
  if (U_FAILURE(status)) {
      return 0;
  }

  // At this point julianDay is the 0-based day BEFORE the first day of
  // January 1, year 1 of the given calendar.  If julianDay == 0, it
  // specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
  // or Gregorian). (or it is before the month we are in, if useMonth is True)

  // At this point we need to process the WEEK_OF_MONTH or
  // WEEK_OF_YEAR, which are similar, or the DAY_OF_WEEK_IN_MONTH.
  // First, perform initial shared computations.  These locate the
  // first week of the period.

  // Get the 0-based localized DOW of day one of the month or year.
  // Valid range 0..6.
  int32_t first = julianDayToDayOfWeek(jan1Start + 1) - firstDayOfWeek;
  if (first < 0) {
      first += 7;
  }

  //// (nextFirst was not used below)
  // int32_t nextFirst = julianDayToDayOfWeek(nextJan1Start + 1) - firstDayOfWeek;
  // if (nextFirst < 0) {
  //     nextFirst += 7;
  //}

  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?

  if((7 - first) < minDays) {
      jan1InPrevYear = true;
  }

  //   if((7 - nextFirst) < minDays) {
  //     nextJan1InPrevYear = true;
  //   }

  switch(bestField) {
  case UCAL_WEEK_OF_YEAR:
      if(woy == 1) {
          if(jan1InPrevYear) {
              // the first week of January is in the previous year
              // therefore WOY1 is always solidly within yearWoy
              return yearWoy;
          } else {
              // First WOY is split between two years
              if( dowLocal < first) { // we are prior to Jan 1
                  return yearWoy-1; // previous year
              } else {
                  return yearWoy; // in this year
              }
          }
      } 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.. )
              (woy-1)*7 + // add the weeks of the year
              dowLocal;   // the local dow (0..6) of last week
          if(jan1InPrevYear==false) {
              jd -= 7; // woy already includes Jan 1's week.
          }

          if( (jd+1) >= nextJan1Start ) {
              // we are in week 52 or 53 etc. - actual year is yearWoy+1
              return yearWoy+1;
          } else {
              // still in yearWoy;
              return yearWoy;
          }
      } else {
          // we're not possibly in the last week -must be ywoy
          return yearWoy;
      }

  case UCAL_DATE:
      {
          int32_t m = internalGetMonth(status);
          if (U_FAILURE(status)) {
              return 0;
          }
          if((m == 0) &&
          (woy >= getLeastMaximum(UCAL_WEEK_OF_YEAR))) {
              return yearWoy+1; // month 0, late woy = in the next year
          } else if(woy==1) {
              //if(nextJan1InPrevYear) {
              if(m == 0) {
                  return yearWoy;
              } else {
                  return yearWoy-1;
              }
              //}
          }
      }
      //(internalGet(UCAL_DATE) <= (7-first)) /* && in minDow  */ ) {
      //within 1st week and in this month..
      //return yearWoy+1;
      return yearWoy;

  default: // assume the year is appropriate
      return yearWoy;
  }
3805}

3807int32_t Calendar::handleGetMonthLength(int32_t extendedYear, int32_t month, UErrorCode& status) const
3808{
  int32_t nextMonth;
  if (uprv_add32_overflowuprv_add32_overflow_77(month, 1, &nextMonth)) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  return handleComputeMonthStart(extendedYear, nextMonth, true, status) -
      handleComputeMonthStart(extendedYear, month, true, status);
3816}

3818int32_t Calendar::handleGetYearLength(int32_t eyear, UErrorCode& status) const
3819{
  int32_t result = handleComputeMonthStart(eyear+1, 0, false, status) -
      handleComputeMonthStart(eyear, 0, false, status);
  if (U_FAILURE(status)) return 0;
  return result;
3824}

3826int32_t
3827Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
3828{
  if (U_FAILURE(status)) {
     return 0;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  int32_t result;
  switch (field) {
  case UCAL_DATE:
      {
          Calendar *cal = clone();
          if(!cal) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return 0;
          }
          cal->setLenient(true);
          cal->prepareGetActual(field,false,status);
          result = handleGetMonthLength(cal->get(UCAL_EXTENDED_YEAR, status), cal->get(UCAL_MONTH, status), status);
          delete cal;
      }
      break;

  case UCAL_DAY_OF_YEAR:
      {
          Calendar *cal = clone();
          if(!cal) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return 0;
          }
          cal->setLenient(true);
          cal->prepareGetActual(field,false,status);
          result = handleGetYearLength(cal->get(UCAL_EXTENDED_YEAR, status), status);
          delete cal;
      }
      break;

  case UCAL_DAY_OF_WEEK:
  case UCAL_AM_PM:
  case UCAL_HOUR:
  case UCAL_HOUR_OF_DAY:
  case UCAL_MINUTE:
  case UCAL_SECOND:
  case UCAL_MILLISECOND:
  case UCAL_ZONE_OFFSET:
  case UCAL_DST_OFFSET:
  case UCAL_DOW_LOCAL:
  case UCAL_JULIAN_DAY:
  case UCAL_MILLISECONDS_IN_DAY:
      // These fields all have fixed minima/maxima
      result = getMaximum(field);
      break;

  case UCAL_ORDINAL_MONTH:
      result = inTemporalLeapYear(status) ? getMaximum(UCAL_ORDINAL_MONTH) : getLeastMaximum(UCAL_ORDINAL_MONTH);
      break;

  default:
      // For all other fields, do it the hard way....
      result = getActualHelper(field, getLeastMaximum(field), getMaximum(field),status);
      break;
  }
  return result;
3892}


3895/**
3896* Prepare this calendar for computing the actual minimum or maximum.
3897* This method modifies this calendar's fields; it is called on a
3898* temporary calendar.
3899*
3900* <p>Rationale: The semantics of getActualXxx() is to return the
3901* maximum or minimum value that the given field can take, taking into
3902* account other relevant fields.  In general these other fields are
3903* larger fields.  For example, when computing the actual maximum
3904* DATE, the current value of DATE itself is ignored,
3905* as is the value of any field smaller.
3906*
3907* <p>The time fields all have fixed minima and maxima, so we don't
3908* need to worry about them.  This also lets us set the
3909* MILLISECONDS_IN_DAY to zero to erase any effects the time fields
3910* might have when computing date fields.
3911*
3912* <p>DAY_OF_WEEK is adjusted specially for the WEEK_OF_MONTH and
3913* WEEK_OF_YEAR fields to ensure that they are computed correctly.
3914* @internal
3915*/
3916void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErrorCode &status)
3917{
  if (U_FAILURE(status)) {
     return;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  set(UCAL_MILLISECONDS_IN_DAY, 0);

  switch (field) {
  case UCAL_YEAR:
  case UCAL_EXTENDED_YEAR:
      set(UCAL_DAY_OF_YEAR, getGreatestMinimum(UCAL_DAY_OF_YEAR));
      break;

  case UCAL_YEAR_WOY:
      set(UCAL_WEEK_OF_YEAR, getGreatestMinimum(UCAL_WEEK_OF_YEAR));
      U_FALLTHROUGH[[clang::fallthrough]];
  case UCAL_MONTH:
      set(UCAL_DATE, getGreatestMinimum(UCAL_DATE));
      break;

  case UCAL_DAY_OF_WEEK_IN_MONTH:
      // For dowim, the maximum occurs for the DOW of the first of the
      // month.
      set(UCAL_DATE, 1);
      set(UCAL_DAY_OF_WEEK, get(UCAL_DAY_OF_WEEK, status)); // Make this user set
      break;

  case UCAL_WEEK_OF_MONTH:
  case UCAL_WEEK_OF_YEAR:
      // If we're counting weeks, set the day of the week to either the
      // first or last localized DOW.  We know the last week of a month
      // or year will contain the first day of the week, and that the
      // first week will contain the last DOW.
      {
          int32_t dow = fFirstDayOfWeek;
          if (isMinimum) {
              dow = (dow + 6) % 7; // set to last DOW
              if (dow < UCAL_SUNDAY) {
                  dow += 7;
              }
          }
3961#if defined (U_DEBUG_CAL)
          fprintf(stderrstderr, "prepareGetActualHelper(WOM/WOY) - dow=%d\n", dow);
3963#endif
          set(UCAL_DAY_OF_WEEK, dow);
      }
      break;
  default:
      break;
  }

  // Do this last to give it the newest time stamp
  set(field, getGreatestMinimum(field));
3973}

3975int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue, int32_t endValue, UErrorCode &status) const
3976{
3977#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "getActualHelper(%d,%d .. %d, %s)\n", field, startValue, endValue, u_errorNameu_errorName_77(status));
3979#endif
  if (U_FAILURE(status)) {
     return 0;
  }
  if (field < 0 || field >= UCAL_FIELD_COUNT) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return 0;
  }
  if (startValue == endValue) {
      // if we know that the maximum value is always the same, just return it
      return startValue;
  }

  int32_t delta = (endValue > startValue) ? 1 : -1;

  // clone the calendar so we don't mess with the real one, and set it to
  // accept anything for the field values
  if(U_FAILURE(status)) {
      return startValue;
  }
  Calendar *work = clone();
  if(!work) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return startValue;
  }

  // need to resolve time here, otherwise, fields set for actual limit
  // may cause conflict with fields previously set (but not yet resolved).
  work->complete(status);

  work->setLenient(true);
  work->prepareGetActual(field, delta < 0, status);

  // now try each value from the start to the end one by one until
  // we get a value that normalizes to another value.  The last value that
  // normalizes to itself is the actual maximum for the current date
  work->set(field, startValue);

  // prepareGetActual sets the first day of week in the same week with
  // the first day of a month.  Unlike WEEK_OF_YEAR, week number for the
  // week which contains days from both previous and current month is
  // not unique.  For example, last several days in the previous month
  // is week 5, and the rest of week is week 1.
  int32_t result = startValue;
  if ((work->get(field, status) != startValue
       && field != UCAL_WEEK_OF_MONTH && delta > 0 ) || U_FAILURE(status)) {
4025#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "getActualHelper(fld %d) - got  %d (not %d) - %s\n", field, work->get(field,status), startValue, u_errorNameu_errorName_77(status));
4027#endif
  } else {
      do {
          startValue += delta;
          work->add(field, delta, status);
          if (work->get(field, status) != startValue || U_FAILURE(status)) {
4033#if defined (U_DEBUG_CAL)
              fprintf(stderrstderr, "getActualHelper(fld %d) - got  %d (not %d), BREAK - %s\n", field, work->get(field,status), startValue, u_errorNameu_errorName_77(status));
4035#endif
              break;
          }
          result = startValue;
      } while (startValue != endValue);
  }
  delete work;
4042#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "getActualHelper(%d) = %d\n", field, result);
4044#endif
  return result;
4046}




4051// -------------------------------------

4053void
4054Calendar::setWeekData(const Locale& desiredLocale, const char *type, UErrorCode& status)
4055{

  if (U_FAILURE(status)) {
      return;
  }

  fFirstDayOfWeek = UCAL_SUNDAY;
  fMinimalDaysInFirstWeek = 1;
  fWeekendOnset = UCAL_SATURDAY;
  fWeekendOnsetMillis = 0;
  fWeekendCease = UCAL_SUNDAY;
  fWeekendCeaseMillis = 86400000; // 24*60*60*1000

  // 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
  //     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 useLocale;
  if ( uprv_strlen(desiredLocale.getCountry()):: strlen(desiredLocale.getCountry()) == 0 ||
       (uprv_strlen(desiredLocale.getScript()):: strlen(desiredLocale.getScript()) > 0 && uprv_strlen(min.getScript()):: strlen(min.getScript()) == 0) ) {
      myStatus = U_ZERO_ERROR;
      Locale max(desiredLocale);
      max.addLikelySubtags(myStatus);
      useLocale = Locale(max.getLanguage(),max.getCountry());
  } else {
      useLocale = desiredLocale;
  }

  /* 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
     of week data, but this was moved to supplemental data under ticket 7755. (JCE) */

  // Get the monthNames resource bundle for the calendar 'type'. Fallback to gregorian if the resource is not
  // found.
  LocalUResourceBundlePointer calData(ures_openures_open_77(nullptr, useLocale.getBaseName(), &status));
  ures_getByKeyures_getByKey_77(calData.getAlias(), gCalendar, calData.getAlias(), &status);

  LocalUResourceBundlePointer monthNames;
  if (type != nullptr && *type != '\0' && uprv_strcmp(type, gGregorian):: strcmp(type, gGregorian) != 0) {
      monthNames.adoptInstead(ures_getByKeyWithFallbackures_getByKeyWithFallback_77(calData.getAlias(), type, nullptr, &status));
      ures_getByKeyWithFallbackures_getByKeyWithFallback_77(monthNames.getAlias(), gMonthNames,
                                monthNames.getAlias(), &status);
  }

  if (monthNames.isNull() || status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      monthNames.adoptInstead(ures_getByKeyWithFallbackures_getByKeyWithFallback_77(calData.getAlias(), gGregorian,
                                                        monthNames.orphan(), &status));
      ures_getByKeyWithFallbackures_getByKeyWithFallback_77(monthNames.getAlias(), gMonthNames,
                                monthNames.getAlias(), &status);
  }

  if (U_SUCCESS(status)) {
      U_LOCALE_BASED(locBased,*this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
      locBased.setLocaleIDs(ures_getLocaleByTypeures_getLocaleByType_77(monthNames.getAlias(), ULOC_VALID_LOCALE, &status),
                            ures_getLocaleByTypeures_getLocaleByType_77(monthNames.getAlias(), ULOC_ACTUAL_LOCALE, &status), status);
  } else {
      status = U_USING_FALLBACK_WARNING;
      return;
  }

  CharString region = ulocimp_getRegionForSupplementalDataulocimp_getRegionForSupplementalData_77(desiredLocale.getName(), true, status);

  // Read week data values from supplementalData week data
  UResourceBundle *rb = ures_openDirectures_openDirect_77(nullptr, "supplementalData", &status);
  ures_getByKeyures_getByKey_77(rb, "weekData", rb, &status);
  UResourceBundle *weekData = ures_getByKeyures_getByKey_77(rb, region.data(), nullptr, &status);
  if (status == U_MISSING_RESOURCE_ERROR && rb != nullptr) {
      status = U_ZERO_ERROR;
      weekData = ures_getByKeyures_getByKey_77(rb, "001", nullptr, &status);
  }

  if (U_FAILURE(status)) {
      status = U_USING_FALLBACK_WARNING;
  } else {
      int32_t arrLen;
      const int32_t *weekDataArr = ures_getIntVectorures_getIntVector_77(weekData,&arrLen,&status);
      if( U_SUCCESS(status) && arrLen == 6
              && 1 <= weekDataArr[0] && weekDataArr[0] <= 7
              && 1 <= weekDataArr[1] && weekDataArr[1] <= 7
              && 1 <= weekDataArr[2] && weekDataArr[2] <= 7
              && 1 <= weekDataArr[4] && weekDataArr[4] <= 7) {
          fFirstDayOfWeek = static_cast<UCalendarDaysOfWeek>(weekDataArr[0]);
          fMinimalDaysInFirstWeek = static_cast<uint8_t>(weekDataArr[1]);
          fWeekendOnset = static_cast<UCalendarDaysOfWeek>(weekDataArr[2]);
          fWeekendOnsetMillis = weekDataArr[3];
          fWeekendCease = static_cast<UCalendarDaysOfWeek>(weekDataArr[4]);
          fWeekendCeaseMillis = weekDataArr[5];
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }

      // Check if the locale has a "fw" u extension and we honor it if present.
      // And we don't change the overal status, as the presence / lack of "fw" is not an error.
      UErrorCode fwStatus = U_ZERO_ERROR;
      char fwExt[ULOC_FULLNAME_CAPACITY157] = "";
      desiredLocale.getKeywordValue("fw", fwExt, ULOC_FULLNAME_CAPACITY157, fwStatus);
      if (U_SUCCESS(fwStatus)) {
          if (uprv_strcmp(fwExt, "sun"):: strcmp(fwExt, "sun") == 0) {
              fFirstDayOfWeek = UCAL_SUNDAY;
          } else if (uprv_strcmp(fwExt, "mon"):: strcmp(fwExt, "mon") == 0) {
              fFirstDayOfWeek = UCAL_MONDAY;
          } else if (uprv_strcmp(fwExt, "tue"):: strcmp(fwExt, "tue") == 0) {
              fFirstDayOfWeek = UCAL_TUESDAY;
          } else if (uprv_strcmp(fwExt, "wed"):: strcmp(fwExt, "wed") == 0) {
              fFirstDayOfWeek = UCAL_WEDNESDAY;
          } else if (uprv_strcmp(fwExt, "thu"):: strcmp(fwExt, "thu") == 0) {
              fFirstDayOfWeek = UCAL_THURSDAY;
          } else if (uprv_strcmp(fwExt, "fri"):: strcmp(fwExt, "fri") == 0) {
              fFirstDayOfWeek = UCAL_FRIDAY;
          } else if (uprv_strcmp(fwExt, "sat"):: strcmp(fwExt, "sat") == 0) {
              fFirstDayOfWeek = UCAL_SATURDAY;
          }
      }
  }
  ures_closeures_close_77(weekData);
  ures_closeures_close_77(rb);
4182}

4184/**
4185* Recompute the time and update the status fields isTimeSet
4186* and areFieldsSet.  Callers should check isTimeSet and only
4187* call this method if isTimeSet is false.
4188*/
4189void
4190Calendar::updateTime(UErrorCode& status)
4191{
  computeTime(status);
  if(U_FAILURE(status))
      return;

  // 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)
      fAreFieldsSet = false;

  fIsTimeSet = true;
  fAreFieldsVirtuallySet = false;
4204}

4206Locale
4207Calendar::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
  return LocaleBased::getLocale(validLocale, actualLocale, type, status);
4209}

4211const char *
4212Calendar::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
  return LocaleBased::getLocaleID(validLocale, actualLocale, type, status);
4214}

4216void
4217Calendar::recalculateStamp() {
  int32_t index;
  int32_t currentValue;
  int32_t j, i;

  fNextStamp = kInternallySet;

  for (j = 0; j < UCAL_FIELD_COUNT; j++) {
      currentValue = STAMP_MAX127;
      index = -1;
      for (i = 0; i < UCAL_FIELD_COUNT; i++) {
          if (fStamp[i] > fNextStamp && fStamp[i] < currentValue) {
              currentValue = fStamp[i];
              index = i;
          }
      }

      if (index >= 0) {
          fStamp[index] = ++fNextStamp;
      } else {
          break;
      }
  }
  fNextStamp++;
4241}

4243// Deprecated function. This doesn't need to be inline.
4244void
4245Calendar::internalSet(EDateFields field, int32_t value)
4246{
  internalSet(static_cast<UCalendarDateFields>(field), value);
4248}

4250int32_t Calendar::internalGetMonth(UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return 0;
  }
  if (resolveFields(kMonthPrecedence) == UCAL_MONTH) {
      return internalGet(UCAL_MONTH, status);
  }
  return internalGet(UCAL_ORDINAL_MONTH, status);
4258}

4260int32_t Calendar::internalGetMonth(int32_t defaultValue, UErrorCode& /* status */) const {
  if (resolveFields(kMonthPrecedence) == UCAL_MONTH) {
      return internalGet(UCAL_MONTH, defaultValue);
  }
  return internalGet(UCAL_ORDINAL_MONTH);
4265}

4267BasicTimeZone*
4268Calendar::getBasicTimeZone() const {
  if (dynamic_cast<const OlsonTimeZone *>(fZone) != nullptr
      || dynamic_cast<const SimpleTimeZone *>(fZone) != nullptr
      || dynamic_cast<const RuleBasedTimeZone *>(fZone) != nullptr
      || dynamic_cast<const VTimeZone *>(fZone) != nullptr) {
      return (BasicTimeZone*)fZone;
  }
  return nullptr;
4276}

4278U_NAMESPACE_END}

4280#endif /* #if !UCONFIG_NO_FORMATTING */


4283//eof