../deps/icu-small/source/i18n/calendar.cpp

Bug Summary

File:	out/../deps/icu-small/source/i18n/calendar.cpp
Warning:	line 1027, column 5 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-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 -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/i18n/calendar.cpp

../deps/icu-small/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 "chnsecal.h"
49#include "coptccal.h"
50#include "dangical.h"
51#include "ethpccal.h"
52#include "unicode/calendar.h"
53#include "cpputils.h"
54#include "servloc.h"
55#include "ucln_in.h"
56#include "cstring.h"
57#include "locbased.h"
58#include "uresimp.h"
59#include "ustrenum.h"
60#include "uassert.h"
61#include "olsontz.h"
62#include "sharedcalendar.h"
63#include "unifiedcache.h"
64#include "ulocimp.h"

66#if !UCONFIG_NO_SERVICE1
67static icu::ICULocaleService* gService = NULL__null;
68static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};

70// INTERNAL - for cleanup
71U_CDECL_BEGINextern "C" {
72static UBool calendar_cleanup(void) {
73#if !UCONFIG_NO_SERVICE1
  if (gService) {
      delete gService;
      gService = NULL__null;
  }
  gServiceInitOnce.reset();
79#endif
  return TRUE1;
81}
82U_CDECL_END}
83#endif

85// ------------------------------------------
86//
87// Registration
88//
89//-------------------------------------------
90//#define U_DEBUG_CALSVC 1
91//

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

95/**
* 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)
*/
102#include "udbgutil.h"
103#include <stdio.h>

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

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

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

122void 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");

  }
147}

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

154#endif

156/* Max value for stamp allowable before recalculation */
157#define STAMP_MAX10000 10000

159static 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",
  NULL__null
179};

181// Must be in the order of gCalTypes above
182typedef 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
202} ECalType;

204U_NAMESPACE_BEGINnamespace icu_71 {

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

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

227static ECalType getCalendarType(const char *s) {
  for (int i = 0; gCalTypes[i] != NULL__null; i++) {
      if (uprv_stricmpuprv_stricmp_71(s, gCalTypes[i]) == 0) {
          return (ECalType)i;
      }
  }
  return CALTYPE_UNKNOWN;
234}

236#if !UCONFIG_NO_SERVICE1
237// Only used with service registration.
238static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) {
  if(U_FAILURE(status)) {
      return FALSE0;
  }
  ECalType calType = getCalendarType(keyword);
  return (calType != CALTYPE_UNKNOWN);
244}

246// only used with service registration.
247static void getCalendarKeyword(const UnicodeString &id, char *targetBuffer, int32_t targetBufferSize) {
  UnicodeString calendarKeyword = UNICODE_STRING_SIMPLE("calendar=")icu::UnicodeString(true, u"calendar=", -1);
  int32_t calKeyLen = calendarKeyword.length();
  int32_t keyLen = 0;

  int32_t keywordIdx = id.indexOf((UChar)0x003D); /* '=' */
  if (id[0] == 0x40/*'@'*/
      && id.compareBetween(1, keywordIdx+1, calendarKeyword, 0, calKeyLen) == 0)
  {
      keyLen = id.extract(keywordIdx+1, id.length(), targetBuffer, targetBufferSize, US_INVicu::UnicodeString::kInvariant);
  }
  targetBuffer[keyLen] = 0;
259}
260#endif

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

  //TODO: ULOC_FULL_NAME is out of date and too small..
  char canonicalName[256];

  // 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.
  int32_t canonicalLen = uloc_canonicalizeuloc_canonicalize_71(locid, canonicalName, sizeof(canonicalName) - 1, &status);
  if (U_FAILURE(status)) {
      return CALTYPE_GREGORIAN;
  }
  canonicalName[canonicalLen] = 0;    // terminate

  char calTypeBuf[32];
  int32_t calTypeBufLen;

  calTypeBufLen = uloc_getKeywordValueuloc_getKeywordValue_71(canonicalName, "calendar", calTypeBuf, sizeof(calTypeBuf) - 1, &status);
  if (U_SUCCESS(status)) {
      calTypeBuf[calTypeBufLen] = 0;
      calType = getCalendarType(calTypeBuf);
      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
  char region[ULOC_COUNTRY_CAPACITY4];
  (void)ulocimp_getRegionForSupplementalDataulocimp_getRegionForSupplementalData_71(canonicalName, TRUE1, region, sizeof(region), &status);
  if (U_FAILURE(status)) {
      return CALTYPE_GREGORIAN;
  }

  // Read preferred calendar values from supplementalData calendarPreference
  UResourceBundle *rb = ures_openDirectures_openDirect_71(NULL__null, "supplementalData", &status);
  ures_getByKeyures_getByKey_71(rb, "calendarPreferenceData", rb, &status);
  UResourceBundle *order = ures_getByKeyures_getByKey_71(rb, region, NULL__null, &status);
  if (status == U_MISSING_RESOURCE_ERROR && rb != NULL__null) {
      status = U_ZERO_ERROR;
      order = ures_getByKeyures_getByKey_71(rb, "001", NULL__null, &status);
  }

  calTypeBuf[0] = 0;
  if (U_SUCCESS(status) && order != NULL__null) {
      // the first calendar type is the default for the region
      int32_t len = 0;
      const UChar *uCalType = ures_getStringByIndexures_getStringByIndex_71(order, 0, &len, &status);
      if (len < (int32_t)sizeof(calTypeBuf)) {
          u_UCharsToCharsu_UCharsToChars_71(uCalType, calTypeBuf, len);
          *(calTypeBuf + len) = 0; // terminate;
          calType = getCalendarType(calTypeBuf);
      }
  }

  ures_closeures_close_71(order);
  ures_closeures_close_71(rb);

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

331static 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 IslamicCalendar(loc, status, IslamicCalendar::TBLA), status);
          break;
      case CALTYPE_ISLAMIC_CIVIL:
          cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::CIVIL), status);
          break;
      case CALTYPE_ISLAMIC_RGSA:
          // default any region specific not handled individually to islamic
      case CALTYPE_ISLAMIC:
          cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::ASTRONOMICAL), status);
          break;
      case CALTYPE_ISLAMIC_UMALQURA:
          cal.adoptInsteadAndCheckErrorCode(new IslamicCalendar(loc, status, IslamicCalendar::UMALQURA), 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, EthiopicCalendar::AMETE_MIHRET_ERA), status);
          break;
      case CALTYPE_ETHIOPIC_AMETE_ALEM:
          cal.adoptInsteadAndCheckErrorCode(new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_ALEM_ERA), status);
          break;
      case CALTYPE_ISO8601:
          cal.adoptInsteadAndCheckErrorCode(new GregorianCalendar(loc, status), status);
          if (cal.isValid()) {
              cal->setFirstDayOfWeek(UCAL_MONDAY);
              cal->setMinimalDaysInFirstWeek(4);
          }
          break;
      case CALTYPE_DANGI:
          cal.adoptInsteadAndCheckErrorCode(new DangiCalendar(loc, status), status);
          break;
      default:
          status = U_UNSUPPORTED_ERROR;
  }
  return cal.orphan();
399}


402#if !UCONFIG_NO_SERVICE1

404// -------------------------------------

406/**
407* a Calendar Factory which creates the "basic" calendar types, that is, those
408* shipped with ICU.
409*/
410class BasicCalendarFactory : public LocaleKeyFactory {
411public:
  /**
  * @param calendarType static const string (caller owns storage - will be aliased) to calendar type
  */
  BasicCalendarFactory()
      : LocaleKeyFactory(LocaleKeyFactory::INVISIBLE) { }

  virtual ~BasicCalendarFactory();

420protected:
  //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] != NULL__null;i++) {
              UnicodeString id((UChar)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 {
443#ifdef U_DEBUG_CALSVC
      if(dynamic_cast<const LocaleKey*>(&key) == NULL__null) {
          fprintf(stderrstderr, "::create - not a LocaleKey!\n");
      }
447#endif
      const LocaleKey& lkey = (LocaleKey&)key;
      Locale curLoc;  // current locale
      Locale canLoc;  // Canonical locale

      lkey.currentLocale(curLoc);
      lkey.canonicalLocale(canLoc);

      char keyword[ULOC_FULLNAME_CAPACITY157];
      UnicodeString str;

      key.currentID(str);
      getCalendarKeyword(str, keyword, (int32_t) sizeof(keyword));

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

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

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

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

477BasicCalendarFactory::~BasicCalendarFactory() {}

479/**
480* A factory which looks up the DefaultCalendar resource to determine which class of calendar to use
481*/

483class DefaultCalendarFactory : public ICUResourceBundleFactory {
484public:
  DefaultCalendarFactory() : ICUResourceBundleFactory() { }
  virtual ~DefaultCalendarFactory();
487protected:
  virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const override {

      LocaleKey &lkey = (LocaleKey&)key;
      Locale loc;
      lkey.currentLocale(loc);

      UnicodeString *ret = new UnicodeString();
      if (ret == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
      } else {
          ret->append((UChar)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;
  }
504};

506DefaultCalendarFactory::~DefaultCalendarFactory() {}

508// -------------------------------------
509class CalendarService : public ICULocaleService {
510public:
  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 != NULL__null) {
          return s->clone();
      } else {
525#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));
528#endif
          return ((Calendar*)instance)->clone();
      }
  }

  virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const override {
      LocaleKey& lkey = (LocaleKey&)key;
      //int32_t kind = lkey.kind();

      Locale loc;
      lkey.canonicalLocale(loc);

540#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());
544#endif
      Calendar *nc =  new GregorianCalendar(loc, status);
      if (nc == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return nc;
      }

551#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));
554#endif
      return nc;
  }

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

563CalendarService::~CalendarService() {}

565// -------------------------------------

567static inline UBool
568isCalendarServiceUsed() {
  return !gServiceInitOnce.isReset();
570}

572// -------------------------------------

574static void U_CALLCONV
575initCalendarService(UErrorCode &status)
576{
577#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Spinning up Calendar Service\n");
579#endif
  ucln_i18n_registerCleanupucln_i18n_registerCleanup_71(UCLN_I18N_CALENDAR, calendar_cleanup);
  gService = new CalendarService();
  if (gService == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
      return;
      }
586#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Registering classes..\n");
588#endif

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

593#ifdef U_DEBUG_CALSVC
      fprintf(stderrstderr, "Done..\n");
595#endif

      if(U_FAILURE(status)) {
598#ifdef U_DEBUG_CALSVC
          fprintf(stderrstderr, "err (%s) registering classes, deleting service.....\n", u_errorNameu_errorName_71(status));
600#endif
      delete gService;
      gService = NULL__null;
  }
      }

606static ICULocaleService*
607getCalendarService(UErrorCode &status)
608{
  umtx_initOnce(gServiceInitOnce, &initCalendarService, status);
  return gService;
611}

613URegistryKey Calendar::registerFactory(ICUServiceFactory* toAdopt, UErrorCode& status)
614{
  return getCalendarService(status)->registerFactory(toAdopt, status);
616}

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

623// -------------------------------------

625static 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
  {-12*kOneHour(60*60*1000), -12*kOneHour(60*60*1000),   12*kOneHour(60*60*1000),   15*kOneHour(60*60*1000)  }, // ZONE_OFFSET
  {           0,            0,    1*kOneHour(60*60*1000),    1*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
650};

652// Resource bundle tags read by this class
653static const char gCalendar[] = "calendar";
654static const char gMonthNames[] = "monthNames";
655static const char gGregorian[] = "gregorian";

657// Data flow in Calendar
658// ---------------------

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

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

676//   local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
677//           |
678//           | Using Calendar-specific algorithm
679//           V
680//   local standard millis
681//           |
682//           | Using TimeZone or user-set ZONE_OFFSET / DST_OFFSET
683//           V
684//   UTC millis (in time data member)

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

690//   UTC millis (in time data member)
691//           |
692//           | Using TimeZone getOffset()
693//           V
694//   local standard millis
695//           |
696//           | Using Calendar-specific algorithm
697//           V
698//   local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)

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

707// -------------------------------------

709Calendar::Calendar(UErrorCode& success)
  UObject(),
711fIsTimeSet(FALSE0),
712fAreFieldsSet(FALSE0),
713fAreAllFieldsSet(FALSE0),
714fAreFieldsVirtuallySet(FALSE0),
715fNextStamp((int32_t)kMinimumUserStamp),
716fTime(0),
717fLenient(TRUE1),
718fZone(NULL__null),
719fRepeatedWallTime(UCAL_WALLTIME_LAST),
720fSkippedWallTime(UCAL_WALLTIME_LAST)
721{
  validLocale[0] = 0;
  actualLocale[0] = 0;
  clear();
  if (U_FAILURE(success)) {
      return;
  }
  fZone = TimeZone::createDefault();
  if (fZone == NULL__null) {
      success = U_MEMORY_ALLOCATION_ERROR;
  }
  setWeekData(Locale::getDefault(), NULL__null, success);
733}

735// -------------------------------------

737Calendar::Calendar(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
  UObject(),
739fIsTimeSet(FALSE0),
740fAreFieldsSet(FALSE0),
741fAreAllFieldsSet(FALSE0),
742fAreFieldsVirtuallySet(FALSE0),
743fNextStamp((int32_t)kMinimumUserStamp),
744fTime(0),
745fLenient(TRUE1),
746fZone(NULL__null),
747fRepeatedWallTime(UCAL_WALLTIME_LAST),
748fSkippedWallTime(UCAL_WALLTIME_LAST)
749{
  validLocale[0] = 0;
  actualLocale[0] = 0;
  if (U_FAILURE(success)) {
      delete zone;
      return;
  }
  if(zone == 0) {
757#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because timezone cannot be 0\n",
          __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__759);
760#endif
      success = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  clear();
  fZone = zone;
  setWeekData(aLocale, NULL__null, success);
768}

770// -------------------------------------

772Calendar::Calendar(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
  UObject(),
774fIsTimeSet(FALSE0),
775fAreFieldsSet(FALSE0),
776fAreAllFieldsSet(FALSE0),
777fAreFieldsVirtuallySet(FALSE0),
778fNextStamp((int32_t)kMinimumUserStamp),
779fTime(0),
780fLenient(TRUE1),
781fZone(NULL__null),
782fRepeatedWallTime(UCAL_WALLTIME_LAST),
783fSkippedWallTime(UCAL_WALLTIME_LAST)
784{
  validLocale[0] = 0;
  actualLocale[0] = 0;
  if (U_FAILURE(success)) {
      return;
  }
  clear();
  fZone = zone.clone();
  if (fZone == NULL__null) {
      success = U_MEMORY_ALLOCATION_ERROR;
  }
  setWeekData(aLocale, NULL__null, success);
796}

798// -------------------------------------

800Calendar::~Calendar()
801{
  delete fZone;
803}

805// -------------------------------------

807Calendar::Calendar(const Calendar &source)
  UObject(source)
809{
  fZone = NULL__null;
  *this = source;
812}

814// -------------------------------------

816Calendar &
817Calendar::operator=(const Calendar &right)
818{
  if (this != &right) {
      uprv_arrayCopy(right.fFields, fFields, UCAL_FIELD_COUNT);
      uprv_arrayCopy(right.fIsSet, fIsSet, 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 = NULL__null;
      if (right.fZone != NULL__null) {
          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;
      uprv_strncpy(validLocale, right.validLocale, sizeof(validLocale)):: strncpy(validLocale, right.validLocale, sizeof(validLocale
));
      uprv_strncpy(actualLocale, right.actualLocale, sizeof(actualLocale)):: strncpy(actualLocale, right.actualLocale, sizeof(actualLocale
));
      validLocale[sizeof(validLocale)-1] = 0;
      actualLocale[sizeof(validLocale)-1] = 0;
  }

  return *this;
850}

852// -------------------------------------

854Calendar* U_EXPORT2
855Calendar::createInstance(UErrorCode& success)
856{
  return createInstance(TimeZone::createDefault(), Locale::getDefault(), success);
858}

860// -------------------------------------

862Calendar* U_EXPORT2
863Calendar::createInstance(const TimeZone& zone, UErrorCode& success)
864{
  return createInstance(zone, Locale::getDefault(), success);
866}

868// -------------------------------------

870Calendar* U_EXPORT2
871Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
872{
  return createInstance(TimeZone::forLocaleOrDefault(aLocale), aLocale, success);
874}

876// ------------------------------------- Adopting

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

880Calendar * U_EXPORT2
881Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
  if (U_FAILURE(success)) {
      return NULL__null;
  }

  Locale actualLoc;
  UObject* u = NULL__null;

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

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

907#if !UCONFIG_NO_SERVICE1
  const UnicodeString* str = dynamic_cast<const UnicodeString*>(u);
  if(str != NULL__null) {
      // 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);

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

      Locale actualLoc2;
      delete u;
      u = NULL__null;

      // 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 NULL__null;
      }

      str = dynamic_cast<const UnicodeString*>(c);
      if(str != NULL__null) {
          // recursed! Second lookup returned a UnicodeString.
          // Perhaps DefaultCalendar{} was set to another locale.
939#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);
951#endif
          success = U_MISSING_RESOURCE_ERROR;  // requested a calendar type which could NOT be found.
          delete c;
          return NULL__null;
      }
956#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());
958#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
970#endif /* UCONFIG_NO_SERVICE */
  {
      // a calendar was returned - we assume the factory did the right thing.
      c = (Calendar*)u;
  }

  return c;
977}

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

  // 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;
1000}

1002// -------------------------------------

1004Calendar* U_EXPORT2
1005Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
1006{
  Calendar* c = createInstance(aLocale, success);
  if(U_SUCCESS(success) && c) {
      c->setTimeZone(zone);
  }
  return c;
1012}

1014// -------------------------------------

1016void U_EXPORT2
1017Calendar::getCalendarTypeFromLocale(
      const Locale &aLocale,
      char *typeBuffer,
      int32_t typeBufferSize,
      UErrorCode &success) {
  const SharedCalendar *shared = NULL__null;
1
'shared' initialized to a null pointer value→
  UnifiedCache::getByLocale(aLocale, shared, success);
2
←
Calling 'UnifiedCache::getByLocale'→
19
←
Returning from 'UnifiedCache::getByLocale'→
  if (U_FAILURE(success)) {
20
←
Taking false branch→
      return;
  }
  uprv_strncpy(typeBuffer, (*shared)->getType(), typeBufferSize):: strncpy(typeBuffer, (*shared)->getType(), typeBufferSize
);
21
←
Called C++ object pointer is null
  shared->removeRef();
  if (typeBuffer[typeBufferSize - 1]) {
      success = U_BUFFER_OVERFLOW_ERROR;
  }
1032}

1034bool
1035Calendar::operator==(const Calendar& that) const
1036{
  UErrorCode status = U_ZERO_ERROR;
  return isEquivalentTo(that) &&
      getTimeInMillis(status) == that.getTimeInMillis(status) &&
      U_SUCCESS(status);
1041}

1043UBool
1044Calendar::isEquivalentTo(const Calendar& other) const
1045{
  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;
1057}

1059// -------------------------------------

1061UBool
1062Calendar::equals(const Calendar& when, UErrorCode& status) const
1063{
  return (this == &when ||
      getTime(status) == when.getTime(status));
1066}

1068// -------------------------------------

1070UBool
1071Calendar::before(const Calendar& when, UErrorCode& status) const
1072{
  return (this != &when &&
      getTimeInMillis(status) < when.getTimeInMillis(status));
1075}

1077// -------------------------------------

1079UBool
1080Calendar::after(const Calendar& when, UErrorCode& status) const
1081{
  return (this != &when &&
      getTimeInMillis(status) > when.getTimeInMillis(status));
1084}

1086// -------------------------------------


1089const Locale* U_EXPORT2
1090Calendar::getAvailableLocales(int32_t& count)
1091{
  return Locale::getAvailableLocales(count);
1093}

1095// -------------------------------------

1097StringEnumeration* U_EXPORT2
1098Calendar::getKeywordValuesForLocale(const char* key,
                  const Locale& locale, UBool commonlyUsed, UErrorCode& status)
1100{
  // This is a wrapper over ucal_getKeywordValuesForLocale
  UEnumeration *uenum = ucal_getKeywordValuesForLocaleucal_getKeywordValuesForLocale_71(key, locale.getName(),
                                                      commonlyUsed, &status);
  if (U_FAILURE(status)) {
      uenum_closeuenum_close_71(uenum);
      return NULL__null;
  }
  UStringEnumeration* ustringenum = new UStringEnumeration(uenum);
  if (ustringenum == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }
  return ustringenum;
1113}

1115// -------------------------------------

1117UDate U_EXPORT2
1118Calendar::getNow()
1119{
  return uprv_getUTCtimeuprv_getUTCtime_71(); // return as milliseconds
1121}

1123// -------------------------------------

1125/**
1126* Gets this Calendar's current time as a long.
1127* @return the current time as UTC milliseconds from the epoch.
1128*/
1129double
1130Calendar::getTimeInMillis(UErrorCode& status) const
1131{
  if(U_FAILURE(status))
      return 0.0;

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

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

1145// -------------------------------------

1147/**
1148* Sets this Calendar's current time from the given long value.
1149* A status of U_ILLEGAL_ARGUMENT_ERROR is set when millis is
1150* outside the range permitted by a Calendar object when not in lenient mode.
1151* when in lenient mode the out of range values are pinned to their respective min/max.
1152* @param date the new time in UTC milliseconds from the epoch.
1153*/
1154void
1155Calendar::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;
      }
  }

  fTime = millis;
  fAreFieldsSet = fAreAllFieldsSet = FALSE0;
  fIsTimeSet = fAreFieldsVirtuallySet = TRUE1;

  for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
      fFields[i]     = 0;
      fStamp[i]     = kUnset;
      fIsSet[i]     = FALSE0;
  }


1186}

1188// -------------------------------------

1190int32_t
1191Calendar::get(UCalendarDateFields field, UErrorCode& status) const
1192{
  // 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)) ((Calendar*)this)->complete(status); // Cast away const
  return U_SUCCESS(status) ? fFields[field] : 0;
1198}

1200// -------------------------------------

1202void
1203Calendar::set(UCalendarDateFields field, int32_t value)
1204{
  if (fAreFieldsVirtuallySet) {
      UErrorCode ec = U_ZERO_ERROR;
      computeFields(ec);
  }
  fFields[field]     = value;
  /* Ensure that the fNextStamp value doesn't go pass max value for int32_t */
  if (fNextStamp == STAMP_MAX10000) {
      recalculateStamp();
  }
  fStamp[field]     = fNextStamp++;
  fIsSet[field]     = TRUE1; // Remove later
  fIsTimeSet = fAreFieldsSet = fAreFieldsVirtuallySet = FALSE0;
1217}

1219// -------------------------------------

1221void
1222Calendar::set(int32_t year, int32_t month, int32_t date)
1223{
  set(UCAL_YEAR, year);
  set(UCAL_MONTH, month);
  set(UCAL_DATE, date);
1227}

1229// -------------------------------------

1231void
1232Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute)
1233{
  set(UCAL_YEAR, year);
  set(UCAL_MONTH, month);
  set(UCAL_DATE, date);
  set(UCAL_HOUR_OF_DAY, hour);
  set(UCAL_MINUTE, minute);
1239}

1241// -------------------------------------

1243void
1244Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute, int32_t second)
1245{
  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);
1252}

1254// -------------------------------------
1255// For now the full getRelatedYear implementation is here;
1256// per #10752 move the non-default implementation to subclasses
1257// (default implementation will do no year adjustment)

1259static int32_t gregoYearFromIslamicStart(int32_t year) {
  // ad hoc conversion, improve under #10752
  // rough est for now, ok for grego 1846-2138,
  // otherwise occasionally wrong (for 3% of years)
  int cycle, offset, shift = 0;
  if (year >= 1397) {
      cycle = (year - 1397) / 67;
      offset = (year - 1397) % 67;
      shift = 2*cycle + ((offset >= 33)? 1: 0);
  } else {
      cycle = (year - 1396) / 67 - 1;
      offset = -(year - 1396) % 67;
      shift = 2*cycle + ((offset <= 33)? 1: 0);
  }
  return year + 579 - shift;
1274}

1276int32_t Calendar::getRelatedYear(UErrorCode &status) const
1277{
  if (U_FAILURE(status)) {
      return 0;
  }
  int32_t year = get(UCAL_EXTENDED_YEAR, status);
  if (U_FAILURE(status)) {
      return 0;
  }
  // modify for calendar type
  ECalType type = getCalendarType(getType());
  switch (type) {
      case CALTYPE_PERSIAN:
          year += 622; break;
      case CALTYPE_HEBREW:
          year -= 3760; break;
      case CALTYPE_CHINESE:
          year -= 2637; break;
      case CALTYPE_INDIAN:
          year += 79; break;
      case CALTYPE_COPTIC:
          year += 284; break;
      case CALTYPE_ETHIOPIC:
          year += 8; break;
      case CALTYPE_ETHIOPIC_AMETE_ALEM:
          year -=5492; break;
      case CALTYPE_DANGI:
          year -= 2333; break;
      case CALTYPE_ISLAMIC_CIVIL:
      case CALTYPE_ISLAMIC:
      case CALTYPE_ISLAMIC_UMALQURA:
      case CALTYPE_ISLAMIC_TBLA:
      case CALTYPE_ISLAMIC_RGSA:
          year = gregoYearFromIslamicStart(year); break;
      default:
          // CALTYPE_GREGORIAN
          // CALTYPE_JAPANESE
          // CALTYPE_BUDDHIST
          // CALTYPE_ROC
          // CALTYPE_ISO8601
          // do nothing, EXTENDED_YEAR same as Gregorian
          break;
  }
  return year;
1320}

1322// -------------------------------------
1323// For now the full setRelatedYear implementation is here;
1324// per #10752 move the non-default implementation to subclasses
1325// (default implementation will do no year adjustment)

1327static int32_t firstIslamicStartYearFromGrego(int32_t year) {
  // ad hoc conversion, improve under #10752
  // rough est for now, ok for grego 1846-2138,
  // otherwise occasionally wrong (for 3% of years)
  int cycle, offset, shift = 0;
  if (year >= 1977) {
      cycle = (year - 1977) / 65;
      offset = (year - 1977) % 65;
      shift = 2*cycle + ((offset >= 32)? 1: 0);
  } else {
      cycle = (year - 1976) / 65 - 1;
      offset = -(year - 1976) % 65;
      shift = 2*cycle + ((offset <= 32)? 1: 0);
  }
  return year - 579 + shift;
1342}
1343void Calendar::setRelatedYear(int32_t year)
1344{
  // modify for calendar type
  ECalType type = getCalendarType(getType());
  switch (type) {
      case CALTYPE_PERSIAN:
          year -= 622; break;
      case CALTYPE_HEBREW:
          year += 3760; break;
      case CALTYPE_CHINESE:
          year += 2637; break;
      case CALTYPE_INDIAN:
          year -= 79; break;
      case CALTYPE_COPTIC:
          year -= 284; break;
      case CALTYPE_ETHIOPIC:
          year -= 8; break;
      case CALTYPE_ETHIOPIC_AMETE_ALEM:
          year +=5492; break;
      case CALTYPE_DANGI:
          year += 2333; break;
      case CALTYPE_ISLAMIC_CIVIL:
      case CALTYPE_ISLAMIC:
      case CALTYPE_ISLAMIC_UMALQURA:
      case CALTYPE_ISLAMIC_TBLA:
      case CALTYPE_ISLAMIC_RGSA:
          year = firstIslamicStartYearFromGrego(year); break;
      default:
          // CALTYPE_GREGORIAN
          // CALTYPE_JAPANESE
          // CALTYPE_BUDDHIST
          // CALTYPE_ROC
          // CALTYPE_ISO8601
          // do nothing, EXTENDED_YEAR same as Gregorian
          break;
  }
  // set extended year
  set(UCAL_EXTENDED_YEAR, year);
1381}

1383// -------------------------------------

1385void
1386Calendar::clear()
1387{
  for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
      fFields[i]     = 0; // Must do this; other code depends on it
      fStamp[i]     = kUnset;
      fIsSet[i]     = FALSE0; // Remove later
  }
  fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = FALSE0;
  // fTime is not 'cleared' - may be used if no fields are set.
1395}

1397// -------------------------------------

1399void
1400Calendar::clear(UCalendarDateFields field)
1401{
  if (fAreFieldsVirtuallySet) {
      UErrorCode ec = U_ZERO_ERROR;
      computeFields(ec);
  }
  fFields[field]         = 0;
  fStamp[field]         = kUnset;
  fIsSet[field]         = FALSE0; // Remove later
  fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = FALSE0;
1410}

1412// -------------------------------------

1414UBool
1415Calendar::isSet(UCalendarDateFields field) const
1416{
  return fAreFieldsVirtuallySet || (fStamp[field] != kUnset);
1418}


1421int32_t Calendar::newestStamp(UCalendarDateFields first, UCalendarDateFields last, int32_t bestStampSoFar) const
1422{
  int32_t bestStamp = bestStampSoFar;
  for (int32_t i=(int32_t)first; i<=(int32_t)last; ++i) {
      if (fStamp[i] > bestStamp) {
          bestStamp = fStamp[i];
      }
  }
  return bestStamp;
1430}


1433// -------------------------------------

1435void
1436Calendar::complete(UErrorCode& status)
1437{
  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         = TRUE1;
      fAreAllFieldsSet     = TRUE1;
  }
1454}

1456//-------------------------------------------------------------------------
1457// Protected utility methods for use by subclasses.  These are very handy
1458// for implementing add, roll, and computeFields.
1459//-------------------------------------------------------------------------

1461/**
1462* Adjust the specified field so that it is within
1463* the allowable range for the date to which this calendar is set.
1464* For example, in a Gregorian calendar pinning the {@link #DAY_OF_MONTH DAY_OF_MONTH}
1465* field for a calendar set to April 31 would cause it to be set
1466* to April 30.
1467* <p>
1468* <b>Subclassing:</b>
1469* <br>
1470* This utility method is intended for use by subclasses that need to implement
1471* their own overrides of {@link #roll roll} and {@link #add add}.
1472* <p>
1473* <b>Note:</b>
1474* <code>pinField</code> is implemented in terms of
1475* {@link #getActualMinimum getActualMinimum}
1476* and {@link #getActualMaximum getActualMaximum}.  If either of those methods uses
1477* a slow, iterative algorithm for a particular field, it would be
1478* unwise to attempt to call <code>pinField</code> for that field.  If you
1479* really do need to do so, you should override this method to do
1480* something more efficient for that field.
1481* <p>
1482* @param field The calendar field whose value should be pinned.
1483*
1484* @see #getActualMinimum
1485* @see #getActualMaximum
1486* @stable ICU 2.0
1487*/
1488void Calendar::pinField(UCalendarDateFields field, UErrorCode& status) {
  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);
  }
1497}


1500void Calendar::computeFields(UErrorCode &ec)
1501{
if (U_FAILURE(ec)) {
      return;
  }
  // Compute local wall millis
  double localMillis = internalGetTime();
  int32_t rawOffset, dstOffset;
  getTimeZone().getOffset(localMillis, FALSE0, rawOffset, dstOffset, ec);
  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);

  for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
      if ((mask & 1) == 0) {
          fStamp[i] = kInternallySet;
          fIsSet[i] = TRUE1; // Remove later
      } else {
          fStamp[i] = kUnset;
          fIsSet[i] = FALSE0; // Remove later
      }
      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 days =  (int32_t)ClockMath::floorDivide(localMillis, (double)kOneDay(1.0 * (86400000)));

  internalSet(UCAL_JULIAN_DAY,days + kEpochStartAsJulianDay2440588);

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

  computeGregorianAndDOWFields(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.
  int32_t millisInDay =  (int32_t) (localMillis - (days * kOneDay(1.0 * (86400000))));
  fFields[UCAL_MILLISECONDS_IN_DAY] = millisInDay;
  fFields[UCAL_MILLISECOND] = millisInDay % 1000;
  millisInDay /= 1000;
  fFields[UCAL_SECOND] = millisInDay % 60;
  millisInDay /= 60;
  fFields[UCAL_MINUTE] = millisInDay % 60;
  millisInDay /= 60;
  fFields[UCAL_HOUR_OF_DAY] = millisInDay;
  fFields[UCAL_AM_PM] = millisInDay / 12; // Assume AM == 0
  fFields[UCAL_HOUR] = millisInDay % 12;
  fFields[UCAL_ZONE_OFFSET] = rawOffset;
  fFields[UCAL_DST_OFFSET] = dstOffset;
1577}

1579uint8_t Calendar::julianDayToDayOfWeek(double julian)
1580{
  // 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 = (int8_t) uprv_fmoduprv_fmod_71(julian + 1, 7);

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

1589/**
1590* Compute the Gregorian calendar year, month, and day of month from
1591* the given Julian day.  These values are not stored in fields, but in
1592* member variables gregorianXxx.  Also compute the DAY_OF_WEEK and
1593* DOW_LOCAL fields.
1594*/
1595void Calendar::computeGregorianAndDOWFields(int32_t julianDay, UErrorCode &ec)
1596{
  computeGregorianFields(julianDay, ec);

  // Compute day of week: JD 0 = Monday
  int32_t dow = julianDayToDayOfWeek(julianDay);
  internalSet(UCAL_DAY_OF_WEEK,dow);

  // Calculate 1-based localized day of week
  int32_t dowLocal = dow - getFirstDayOfWeek() + 1;
  if (dowLocal < 1) {
      dowLocal += 7;
  }
  internalSet(UCAL_DOW_LOCAL,dowLocal);
  fFields[UCAL_DOW_LOCAL] = dowLocal;
1610}

1612/**
1613* Compute the Gregorian calendar year, month, and day of month from the
1614* Julian day.  These values are not stored in fields, but in member
1615* variables gregorianXxx.  They are used for time zone computations and by
1616* subclasses that are Gregorian derivatives.  Subclasses may call this
1617* method to perform a Gregorian calendar millis->fields computation.
1618*/
1619void Calendar::computeGregorianFields(int32_t julianDay, UErrorCode & /* ec */) {
  int32_t gregorianDayOfWeekUnused;
  Grego::dayToFields(julianDay - kEpochStartAsJulianDay2440588, fGregorianYear, fGregorianMonth, fGregorianDayOfMonth, gregorianDayOfWeekUnused, fGregorianDayOfYear);
1622}

1624/**
1625* Compute the fields WEEK_OF_YEAR, YEAR_WOY, WEEK_OF_MONTH,
1626* DAY_OF_WEEK_IN_MONTH, and DOW_LOCAL from EXTENDED_YEAR, YEAR,
1627* DAY_OF_WEEK, and DAY_OF_YEAR.  The latter fields are computed by the
1628* subclass based on the calendar system.
1629*
1630* <p>The YEAR_WOY field is computed simplistically.  It is equal to YEAR
1631* most of the time, but at the year boundary it may be adjusted to YEAR-1
1632* or YEAR+1 to reflect the overlap of a week into an adjacent year.  In
1633* this case, a simple increment or decrement is performed on YEAR, even
1634* though this may yield an invalid YEAR value.  For instance, if the YEAR
1635* is part of a calendar system with an N-year cycle field CYCLE, then
1636* incrementing the YEAR may involve incrementing CYCLE and setting YEAR
1637* back to 0 or 1.  This is not handled by this code, and in fact cannot be
1638* simply handled without having subclasses define an entire parallel set of
1639* fields for fields larger than or equal to a year.  This additional
1640* complexity is not warranted, since the intention of the YEAR_WOY field is
1641* to support ISO 8601 notation, so it will typically be used with a
1642* proleptic Gregorian calendar, which has no field larger than a year.
1643*/
1644void Calendar::computeWeekFields(UErrorCode &ec) {
  if(U_FAILURE(ec)) {
      return;
  }
  int32_t eyear = fFields[UCAL_EXTENDED_YEAR];
  int32_t dayOfWeek = fFields[UCAL_DAY_OF_WEEK];
  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 - getFirstDayOfWeek()) % 7; // 0..6
  int32_t relDowJan1 = (dayOfWeek - dayOfYear + 7001 - getFirstDayOfWeek()) % 7; // 0..6
  int32_t woy = (dayOfYear - 1 + relDowJan1) / 7; // 0..53
  if ((7 - relDowJan1) >= getMinimalDaysInFirstWeek()) {
      ++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);
      woy = weekNumber(prevDoy, dayOfWeek);
      yearOfWeekOfYear--;
  } else {
      int32_t lastDoy = handleGetYearLength(eyear);
      // 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) >= getMinimalDaysInFirstWeek()) &&
              ((dayOfYear + 7 - relDow) > lastDoy)) {
                  woy = 1;
                  yearOfWeekOfYear++;
              }
      }
  }
  fFields[UCAL_WEEK_OF_YEAR] = woy;
  fFields[UCAL_YEAR_WOY] = yearOfWeekOfYear;
  // WEEK_OF_YEAR end

  int32_t dayOfMonth = fFields[UCAL_DAY_OF_MONTH];
  fFields[UCAL_WEEK_OF_MONTH] = weekNumber(dayOfMonth, dayOfWeek);
  fFields[UCAL_DAY_OF_WEEK_IN_MONTH] = (dayOfMonth-1) / 7 + 1;
1707#if defined (U_DEBUG_CAL)
  if(fFields[UCAL_DAY_OF_WEEK_IN_MONTH]==0) fprintf(stderrstderr, "%s:%d: DOWIM %d on %g\n",
      __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__1709,fFields[UCAL_DAY_OF_WEEK_IN_MONTH], fTime);
1710#endif
1711}


1714int32_t Calendar::weekNumber(int32_t desiredDay, int32_t dayOfPeriod, int32_t dayOfWeek)
1715{
  // 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;
1733}

1735void Calendar::handleComputeFields(int32_t /* julianDay */, UErrorCode &/* status */)
1736{
  internalSet(UCAL_MONTH, getGregorianMonth());
  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);
1749}
1750// -------------------------------------


1753void Calendar::roll(EDateFields field, int32_t amount, UErrorCode& status)
1754{
  roll((UCalendarDateFields)field, amount, status);
1756}

1758void Calendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status)
1759{
  if (amount == 0) {
      return; // Nothing to do
  }

  complete(status);

  if(U_FAILURE(status)) {
      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);
          int32_t gap = max - min + 1;

          int32_t value = internalGet(field) + amount;
          value = (value - 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);
          int32_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:
      // 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);
          int32_t mon = (internalGet(UCAL_MONTH) + amount) % (max+1);

          if (mon < 0) {
              mon += (max + 1);
          }
          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.
          UBool era0WithYearsThatGoBackwards = FALSE0;
          int32_t era = get(UCAL_ERA, status);
          if (era == 0) {
              const char * calType = getType();
              if ( uprv_strcmp(calType,"gregorian"):: strcmp(calType, "gregorian")==0 || uprv_strcmp(calType,"roc"):: strcmp(calType, "roc")==0 || uprv_strcmp(calType,"coptic"):: strcmp(calType, "coptic")==0 ) {
                  amount = -amount;
                  era0WithYearsThatGoBackwards = TRUE1;
              }
          }
          int32_t newYear = internalGet(field) + amount;
          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 (era0WithYearsThatGoBackwards) {
              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.
      set(field, internalGet(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;
          int32_t day_of_month = (internalGet(UCAL_DAY_OF_MONTH) + amount*7 -
              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;
          int32_t day_of_year = (internalGet(UCAL_DAY_OF_YEAR) + amount*7 -
              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);
          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_71((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_71((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_71((internalGetTime() + delta - min2), gap2);
          if (newtime < 0) newtime += gap2;
          setTimeInMillis(newtime + min2, status);
          return;
      }
  case UCAL_JULIAN_DAY:
      set(field, internalGet(field) + amount);
      return;
  default:
      // Other fields cannot be rolled by this method
2090#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because of roll on non-rollable field %s\n",
          __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2092,fldName(field));
2093#endif
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2096}

2098void Calendar::add(EDateFields field, int32_t amount, UErrorCode& status)
2099{
  Calendar::add((UCalendarDateFields)field, amount, status);
2101}

2103// -------------------------------------
2104void Calendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status)
2105{
  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 = TRUE1;

  switch (field) {
  case UCAL_ERA:
      set(field, get(field, status) + amount);
      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.
      int32_t era = get(UCAL_ERA, status);
      if (era == 0) {
        const char * calType = getType();
        if ( uprv_strcmp(calType,"gregorian"):: strcmp(calType, "gregorian")==0 || uprv_strcmp(calType,"roc"):: strcmp(calType, "roc")==0 || uprv_strcmp(calType,"coptic"):: strcmp(calType, "coptic")==0 ) {
          amount = -amount;
        }
      }
    }
    // Fall through into normal handling
    U_FALLTHROUGH[[clang::fallthrough]];
  case UCAL_EXTENDED_YEAR:
  case UCAL_MONTH:
    {
      UBool oldLenient = isLenient();
      setLenient(TRUE1);
      set(field, get(field, status) + amount);
      pinField(UCAL_DAY_OF_MONTH, status);
      if(oldLenient==FALSE0) {
        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 = FALSE0;
      break;

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

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

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

  default:
2214#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s not addable",
          __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2216, fldName(field));
2217#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 % (int32_t)kOneDay(1.0 * (86400000)) : -(-adjAmount % (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;
                  }
              }
          }
      }
  }
2283}

2285// -------------------------------------
2286int32_t Calendar::fieldDifference(UDate when, EDateFields field, UErrorCode& status) {
  return fieldDifference(when, (UCalendarDateFields) field, status);
2288}

2290int32_t Calendar::fieldDifference(UDate targetMs, UCalendarDateFields field, UErrorCode& ec) {
  if (U_FAILURE(ec)) 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
2319#if defined (U_DEBUG_CAL)
              fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
                  __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2321, fldName(field));
2322#endif
              ec = U_ILLEGAL_ARGUMENT_ERROR;
          }
      }
      // 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 <<= 1;
              if (max == 0) {
                  // Field difference too large to fit into int32_t
2356#if defined (U_DEBUG_CAL)
                  fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
                      __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2358, fldName(field));
2359#endif
                  ec = U_ILLEGAL_ARGUMENT_ERROR;
              }
          }
      }
      // 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;
2388}

2390// -------------------------------------

2392void
2393Calendar::adoptTimeZone(TimeZone* zone)
2394{
  // Do nothing if passed-in zone is NULL
  if (zone == NULL__null) return;

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

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

2406// -------------------------------------
2407void
2408Calendar::setTimeZone(const TimeZone& zone)
2409{
  adoptTimeZone(zone.clone());
2411}

2413// -------------------------------------

2415const TimeZone&
2416Calendar::getTimeZone() const
2417{
  U_ASSERT(fZone != NULL)(void)0;
  return *fZone;
2420}

2422// -------------------------------------

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

2438// -------------------------------------

2440void
2441Calendar::setLenient(UBool lenient)
2442{
  fLenient = lenient;
2444}

2446// -------------------------------------

2448UBool
2449Calendar::isLenient() const
2450{
  return fLenient;
2452}

2454// -------------------------------------

2456void
2457Calendar::setRepeatedWallTimeOption(UCalendarWallTimeOption option)
2458{
  if (option == UCAL_WALLTIME_LAST || option == UCAL_WALLTIME_FIRST) {
      fRepeatedWallTime = option;
  }
2462}

2464// -------------------------------------

2466UCalendarWallTimeOption
2467Calendar::getRepeatedWallTimeOption(void) const
2468{
  return fRepeatedWallTime;
2470}

2472// -------------------------------------

2474void
2475Calendar::setSkippedWallTimeOption(UCalendarWallTimeOption option)
2476{
  fSkippedWallTime = option;
2478}

2480// -------------------------------------

2482UCalendarWallTimeOption
2483Calendar::getSkippedWallTimeOption(void) const
2484{
  return fSkippedWallTime;
2486}

2488// -------------------------------------

2490void
2491Calendar::setFirstDayOfWeek(UCalendarDaysOfWeek value)
2492{
  if (fFirstDayOfWeek != value &&
      value >= UCAL_SUNDAY && value <= UCAL_SATURDAY) {
          fFirstDayOfWeek = value;
          fAreFieldsSet = FALSE0;
      }
2498}

2500// -------------------------------------

2502Calendar::EDaysOfWeek
2503Calendar::getFirstDayOfWeek() const
2504{
  return (Calendar::EDaysOfWeek)fFirstDayOfWeek;
2506}

2508UCalendarDaysOfWeek
2509Calendar::getFirstDayOfWeek(UErrorCode & /*status*/) const
2510{
  return fFirstDayOfWeek;
2512}
2513// -------------------------------------

2515void
2516Calendar::setMinimalDaysInFirstWeek(uint8_t value)
2517{
  // 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 = FALSE0;
  }
2530}

2532// -------------------------------------

2534uint8_t
2535Calendar::getMinimalDaysInFirstWeek() const
2536{
  return fMinimalDaysInFirstWeek;
2538}

2540// -------------------------------------
2541// weekend functions, just dummy implementations for now (for API freeze)

2543UCalendarWeekdayType
2544Calendar::getDayOfWeekType(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
2545{
  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;
2574}

2576int32_t
2577Calendar::getWeekendTransition(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
2578{
  if (U_FAILURE(status)) {
      return 0;
  }
  if (dayOfWeek == fWeekendOnset) {
      return fWeekendOnsetMillis;
  } else if (dayOfWeek == fWeekendCease) {
      return fWeekendCeaseMillis;
  }
  status = U_ILLEGAL_ARGUMENT_ERROR;
  return 0;
2589}

2591UBool
2592Calendar::isWeekend(UDate date, UErrorCode &status) const
2593{
  if (U_FAILURE(status)) {
      return FALSE0;
  }
  // clone the calendar so we don't mess with the real one.
  Calendar *work = this->clone();
  if (work == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return FALSE0;
  }
  UBool result = FALSE0;
  work->setTime(date, status);
  if (U_SUCCESS(status)) {
      result = work->isWeekend();
  }
  delete work;
  return result;
2610}

2612UBool
2613Calendar::isWeekend(void) const
2614{
  UErrorCode status = U_ZERO_ERROR;
  UCalendarDaysOfWeek dayOfWeek = (UCalendarDaysOfWeek)get(UCAL_DAY_OF_WEEK, status);
  UCalendarWeekdayType dayType = getDayOfWeekType(dayOfWeek, status);
  if (U_SUCCESS(status)) {
      switch (dayType) {
          case UCAL_WEEKDAY:
              return FALSE0;
          case UCAL_WEEKEND:
              return TRUE1;
          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 FALSE0;
2643}

2645// ------------------------------------- limits

2647int32_t
2648Calendar::getMinimum(EDateFields field) const {
  return getLimit((UCalendarDateFields) field,UCAL_LIMIT_MINIMUM);
2650}

2652int32_t
2653Calendar::getMinimum(UCalendarDateFields field) const
2654{
  return getLimit(field,UCAL_LIMIT_MINIMUM);
2656}

2658// -------------------------------------
2659int32_t
2660Calendar::getMaximum(EDateFields field) const
2661{
  return getLimit((UCalendarDateFields) field,UCAL_LIMIT_MAXIMUM);
2663}

2665int32_t
2666Calendar::getMaximum(UCalendarDateFields field) const
2667{
  return getLimit(field,UCAL_LIMIT_MAXIMUM);
2669}

2671// -------------------------------------
2672int32_t
2673Calendar::getGreatestMinimum(EDateFields field) const
2674{
  return getLimit((UCalendarDateFields)field,UCAL_LIMIT_GREATEST_MINIMUM);
2676}

2678int32_t
2679Calendar::getGreatestMinimum(UCalendarDateFields field) const
2680{
  return getLimit(field,UCAL_LIMIT_GREATEST_MINIMUM);
2682}

2684// -------------------------------------
2685int32_t
2686Calendar::getLeastMaximum(EDateFields field) const
2687{
  return getLimit((UCalendarDateFields) field,UCAL_LIMIT_LEAST_MAXIMUM);
2689}

2691int32_t
2692Calendar::getLeastMaximum(UCalendarDateFields field) const
2693{
  return getLimit( field,UCAL_LIMIT_LEAST_MAXIMUM);
2695}

2697// -------------------------------------
2698int32_t
2699Calendar::getActualMinimum(EDateFields field, UErrorCode& status) const
2700{
  return getActualMinimum((UCalendarDateFields) field, status);
2702}

2704int32_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);
  }
2742}


2745int32_t
2746Calendar::getActualMinimum(UCalendarDateFields field, UErrorCode& status) const
2747{
  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 == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return 0;
  }
  work->setLenient(TRUE1);

  // 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;
2788}

2790// -------------------------------------



2794/**
2795* Ensure that each field is within its valid range by calling {@link
2796* #validateField(int)} on each field that has been set.  This method
2797* should only be called if this calendar is not lenient.
2798* @see #isLenient
2799* @see #validateField(int)
2800*/
2801void Calendar::validateFields(UErrorCode &status) {
  for (int32_t field = 0; U_SUCCESS(status) && (field < UCAL_FIELD_COUNT); field++) {
      if (fStamp[field] >= kMinimumUserStamp) {
          validateField((UCalendarDateFields)field, status);
      }
  }
2807}

2809/**
2810* Validate a single field of this calendar.  Subclasses should
2811* override this method to validate any calendar-specific fields.
2812* Generic fields can be handled by
2813* <code>Calendar.validateField()</code>.
2814* @see #validateField(int, int, int)
2815*/
2816void Calendar::validateField(UCalendarDateFields field, UErrorCode &status) {
  int32_t y;
  switch (field) {
  case UCAL_DAY_OF_MONTH:
      y = handleGetExtendedYear();
      validateField(field, 1, handleGetMonthLength(y, internalGet(UCAL_MONTH)), status);
      break;
  case UCAL_DAY_OF_YEAR:
      y = handleGetExtendedYear();
      validateField(field, 1, handleGetYearLength(y), status);
      break;
  case UCAL_DAY_OF_WEEK_IN_MONTH:
      if (internalGet(field) == 0) {
2829#if defined (U_DEBUG_CAL)
          fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because DOW in month cannot be 0\n",
              __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2831);
2832#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;
  }
2842}

2844/**
2845* Validate a single field of this calendar given its minimum and
2846* maximum allowed value.  If the field is out of range, throw a
2847* descriptive <code>IllegalArgumentException</code>.  Subclasses may
2848* use this method in their implementation of {@link
2849* #validateField(int)}.
2850*/
2851void Calendar::validateField(UCalendarDateFields field, int32_t min, int32_t max, UErrorCode& status)
2852{
  int32_t value = fFields[field];
  if (value < min || value > max) {
2855#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d: ILLEGAL ARG because of field %s out of range %d..%d  at %d\n",
          __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__2857,fldName(field),min,max,value);
2858#endif
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
2862}

2864// -------------------------

2866const UFieldResolutionTable* Calendar::getFieldResolutionTable() const {
  return kDatePrecedence;
2868}


2871UCalendarDateFields Calendar::newerField(UCalendarDateFields defaultField, UCalendarDateFields alternateField) const
2872{
  if (fStamp[alternateField] > fStamp[defaultField]) {
      return alternateField;
  }
  return defaultField;
2877}

2879UCalendarDateFields Calendar::resolveFields(const UFieldResolutionTable* precedenceTable) {
  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)(void)0;
              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;
              }
          }
2914linesInGroup:
          ;
      }
  }
  return (UCalendarDateFields)bestField;
2919}

2921const UFieldResolutionTable Calendar::kDatePrecedence[] =
2922{
  {
      { 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}}
2945};


2948const UFieldResolutionTable Calendar::kDOWPrecedence[] =
2949{
  {
      { UCAL_DAY_OF_WEEK,kResolveSTOP, kResolveSTOP },
      { UCAL_DOW_LOCAL,kResolveSTOP, kResolveSTOP },
      {kResolveSTOP}
  },
  {{kResolveSTOP}}
2956};

2958// precedence for calculating a year
2959const UFieldResolutionTable Calendar::kYearPrecedence[] =
2960{
  {
      { 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}}
2968};


2971// -------------------------


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

  // Compute the Julian day
  int32_t julianDay = computeJulianDay();

  double millis = Grego::julianDayToMillis(julianDay);

2987#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);
  //  }
2994#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] >= ((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] >= ((int32_t)kMinimumUserStamp) || fStamp[UCAL_DST_OFFSET] >= ((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, FALSE0, 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)(void)0;
                      // 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);
  }
3083}

3085/**
* Find the previous zone transition near the given time.
*/
3088UBool Calendar::getImmediatePreviousZoneTransition(UDate base, UDate *transitionTime, UErrorCode& status) const {
  BasicTimeZone *btz = getBasicTimeZone();
  if (btz) {
      TimeZoneTransition trans;
      UBool hasTransition = btz->getPreviousTransition(base, TRUE1, trans);
      if (hasTransition) {
          *transitionTime = trans.getTime();
          return TRUE1;
      } 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 FALSE0;
3107}

3109/**
3110* Compute the milliseconds in the day from the fields.  This is a
3111* value from 0 to 23:59:59.999 inclusive, unless fields are out of
3112* range, in which case it can be an arbitrary value.  This value
3113* reflects local zone wall time.
3114* @stable ICU 2.0
3115*/
3116double 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);
          millisInDay += 12 * internalGet(UCAL_AM_PM); // Default works for unset AM_PM
      }
  }

  // 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;
3152}

3154/**
3155* This method can assume EXTENDED_YEAR has been set.
3156* @param millis milliseconds of the date fields
3157* @param millisInDay milliseconds of the time fields; may be out
3158* or range.
3159* @stable ICU 2.0
3160*/
3161int32_t Calendar::computeZoneOffset(double millis, double millisInDay, UErrorCode &ec) {
  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, TRUE1, rawOffset, dstOffset, ec);

      UBool sawRecentNegativeShift = FALSE0;
      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, FALSE0, tmpRaw, tmpDst, ec);
          int32_t offsetDelta = (rawOffset + dstOffset) - (tmpRaw + tmpDst);

          U_ASSERT(offsetDelta < -6*60*60*1000)(void)0;
          if (offsetDelta < 0) {
              sawRecentNegativeShift = TRUE1;
              // 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, TRUE1, 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, FALSE0, rawOffset, dstOffset, ec);
      }
  }
  return rawOffset + dstOffset;
3206}

3208int32_t Calendar::computeJulianDay()
3209{
  // 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] >= (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);
      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);
3232}

3234// -------------------------------------------

3236int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField)  {
  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();
  }

  internalSet(UCAL_EXTENDED_YEAR, year);

3250#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "%s:%d: bestField= %s - y=%d\n", __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__3251, fldName(bestField), year);
3252#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)) {
      month = internalGet(UCAL_MONTH);
  } else {
      month = getDefaultMonthInYear(year);
  }

  int32_t julianDay = handleComputeMonthStart(year, useMonth ? month : 0, useMonth);

  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);
      }
      return julianDay + dayOfMonth;
  }

  if (bestField == UCAL_DAY_OF_YEAR) {
      return julianDay + internalGet(UCAL_DAY_OF_YEAR);
  }

  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();

  // 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) {
          date += 7*(dim - 1);

      } 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 = internalGet(UCAL_MONTH, UCAL_JANUARY);
          int32_t monthLength = handleGetMonthLength(year, m);
          date += ((monthLength - date) / 7 + dim + 1) * 7;
      }
  } else {
3334#if defined (U_DEBUG_CAL)
      fprintf(stderrstderr, "%s:%d - bf= %s\n", __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__3335, fldName(bestField));
3336#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, FALSE0); // jd of day before jan 1
              int32_t nextFirst = julianDayToDayOfWeek(nextJulianDay + 1) - firstDayOfWeek;

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

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

                  fprintf(stderrstderr, " next: %d DFW,  min=%d   \n", (7-nextFirst), getMinimalDaysInFirstWeek() );
3360#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
3367#if defined (U_DEBUG_CAL)
                      fprintf(stderrstderr, "%s:%d - was going to move JD from %d to %d [d%d]\n", __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__3368,
                          julianDay, nextJulianDay, (nextJulianDay-julianDay));
3370#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.
                  testDate += 7 * (woy - 1);

3391#if defined (U_DEBUG_CAL)
                  fprintf(stderrstderr, "%s:%d - y=%d, y-1=%d doy%d, njd%d (C.F. %d)\n",
                      __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__3393, year, year-1, testDate, julianDay+testDate, nextJulianDay);
3394#endif
                  if(julianDay+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)
                      julianDay = handleComputeMonthStart(year-1, 0, FALSE0); // jd before Jan 1 of previous year
                      first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek; // 0 based local dow   of first week

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

3405#if defined (U_DEBUG_CAL)
                      fprintf(stderrstderr, "%s:%d - date now %d, jd%d, ywoy%d\n",
                          __FILE__"../deps/icu-small/source/i18n/calendar.cpp", __LINE__3407, date, julianDay, year-1);
3408#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.
      date += 7 * (internalGet(bestField) - 1);
  }

  return julianDay + date;
3427}

3429int32_t
3430Calendar::getDefaultMonthInYear(int32_t /*eyear*/)
3431{
  return 0;
3433}

3435int32_t
3436Calendar::getDefaultDayInMonth(int32_t /*eyear*/, int32_t /*month*/)
3437{
  return 1;
3439}


3442int32_t Calendar::getLocalDOW()
3443{
// 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) - fFirstDayOfWeek;
      break;
  case UCAL_DOW_LOCAL:
      dowLocal = internalGet(UCAL_DOW_LOCAL) - 1;
      break;
  default:
      break;
  }
  dowLocal = dowLocal % 7;
  if (dowLocal < 0) {
      dowLocal += 7;
  }
  return dowLocal;
3462}

3464int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy)
3465{
  // 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(); // 0..6
  int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw
  int32_t jan1Start = handleComputeMonthStart(yearWoy, 0, FALSE0);
  int32_t nextJan1Start = handleComputeMonthStart(yearWoy+1, 0, FALSE0); // next year's Jan1 start

  // 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 = FALSE0;  // 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 = TRUE1;
  }

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

  switch(bestField) {
  case UCAL_WEEK_OF_YEAR:
      if(woy == 1) {
          if(jan1InPrevYear == TRUE1) {
              // 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==FALSE0) {
              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:
      if((internalGet(UCAL_MONTH)==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(internalGet(UCAL_MONTH)==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;
  }
3575}

3577int32_t Calendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const
3578{
  return handleComputeMonthStart(extendedYear, month+1, TRUE1) -
      handleComputeMonthStart(extendedYear, month, TRUE1);
3581}

3583int32_t Calendar::handleGetYearLength(int32_t eyear) const  {
  return handleComputeMonthStart(eyear+1, 0, FALSE0) -
      handleComputeMonthStart(eyear, 0, FALSE0);
3586}

3588int32_t
3589Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
3590{
  int32_t result;
  switch (field) {
  case UCAL_DATE:
      {
          if(U_FAILURE(status)) return 0;
          Calendar *cal = clone();
          if(!cal) { status = U_MEMORY_ALLOCATION_ERROR; return 0; }
          cal->setLenient(TRUE1);
          cal->prepareGetActual(field,FALSE0,status);
          result = handleGetMonthLength(cal->get(UCAL_EXTENDED_YEAR, status), cal->get(UCAL_MONTH, status));
          delete cal;
      }
      break;

  case UCAL_DAY_OF_YEAR:
      {
          if(U_FAILURE(status)) return 0;
          Calendar *cal = clone();
          if(!cal) { status = U_MEMORY_ALLOCATION_ERROR; return 0; }
          cal->setLenient(TRUE1);
          cal->prepareGetActual(field,FALSE0,status);
          result = handleGetYearLength(cal->get(UCAL_EXTENDED_YEAR, 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;

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


3642/**
3643* Prepare this calendar for computing the actual minimum or maximum.
3644* This method modifies this calendar's fields; it is called on a
3645* temporary calendar.
3646*
3647* <p>Rationale: The semantics of getActualXxx() is to return the
3648* maximum or minimum value that the given field can take, taking into
3649* account other relevant fields.  In general these other fields are
3650* larger fields.  For example, when computing the actual maximum
3651* DATE, the current value of DATE itself is ignored,
3652* as is the value of any field smaller.
3653*
3654* <p>The time fields all have fixed minima and maxima, so we don't
3655* need to worry about them.  This also lets us set the
3656* MILLISECONDS_IN_DAY to zero to erase any effects the time fields
3657* might have when computing date fields.
3658*
3659* <p>DAY_OF_WEEK is adjusted specially for the WEEK_OF_MONTH and
3660* WEEK_OF_YEAR fields to ensure that they are computed correctly.
3661* @internal
3662*/
3663void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErrorCode &status)
3664{
  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;
              }
          }
3701#if defined (U_DEBUG_CAL)
          fprintf(stderrstderr, "prepareGetActualHelper(WOM/WOY) - dow=%d\n", dow);
3703#endif
          set(UCAL_DAY_OF_WEEK, dow);
      }
      break;
  default:
      break;
  }

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

3715int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue, int32_t endValue, UErrorCode &status) const
3716{
3717#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "getActualHelper(%d,%d .. %d, %s)\n", field, startValue, endValue, u_errorNameu_errorName_71(status));
3719#endif
  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(TRUE1);
  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)) {
3753#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_71(status));
3755#endif
  } else {
      do {
          startValue += delta;
          work->add(field, delta, status);
          if (work->get(field, status) != startValue || U_FAILURE(status)) {
3761#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_71(status));
3763#endif
              break;
          }
          result = startValue;
      } while (startValue != endValue);
  }
  delete work;
3770#if defined (U_DEBUG_CAL)
  fprintf(stderrstderr, "getActualHelper(%d) = %d\n", field, result);
3772#endif
  return result;
3774}




3779// -------------------------------------

3781void
3782Calendar::setWeekData(const Locale& desiredLocale, const char *type, UErrorCode& status)
3783{

  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_71(NULL__null, useLocale.getBaseName(), &status));
  ures_getByKeyures_getByKey_71(calData.getAlias(), gCalendar, calData.getAlias(), &status);

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

  if (monthNames.isNull() || status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      monthNames.adoptInstead(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(calData.getAlias(), gGregorian,
                                                        monthNames.orphan(), &status));
      ures_getByKeyWithFallbackures_getByKeyWithFallback_71(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_71(monthNames.getAlias(), ULOC_VALID_LOCALE, &status),
                            ures_getLocaleByTypeures_getLocaleByType_71(monthNames.getAlias(), ULOC_ACTUAL_LOCALE, &status));
  } else {
      status = U_USING_FALLBACK_WARNING;
      return;
  }

  char region[ULOC_COUNTRY_CAPACITY4];
  (void)ulocimp_getRegionForSupplementalDataulocimp_getRegionForSupplementalData_71(desiredLocale.getName(), TRUE1, region, sizeof(region), &status);

  // Read week data values from supplementalData week data
  UResourceBundle *rb = ures_openDirectures_openDirect_71(NULL__null, "supplementalData", &status);
  ures_getByKeyures_getByKey_71(rb, "weekData", rb, &status);
  UResourceBundle *weekData = ures_getByKeyures_getByKey_71(rb, region, NULL__null, &status);
  if (status == U_MISSING_RESOURCE_ERROR && rb != NULL__null) {
      status = U_ZERO_ERROR;
      weekData = ures_getByKeyures_getByKey_71(rb, "001", NULL__null, &status);
  }

  if (U_FAILURE(status)) {
      status = U_USING_FALLBACK_WARNING;
  } else {
      int32_t arrLen;
      const int32_t *weekDataArr = ures_getIntVectorures_getIntVector_71(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 = (UCalendarDaysOfWeek)weekDataArr[0];
          fMinimalDaysInFirstWeek = (uint8_t)weekDataArr[1];
          fWeekendOnset = (UCalendarDaysOfWeek)weekDataArr[2];
          fWeekendOnsetMillis = weekDataArr[3];
          fWeekendCease = (UCalendarDaysOfWeek)weekDataArr[4];
          fWeekendCeaseMillis = weekDataArr[5];
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }
  }
  ures_closeures_close_71(weekData);
  ures_closeures_close_71(rb);
3886}

3888/**
3889* Recompute the time and update the status fields isTimeSet
3890* and areFieldsSet.  Callers should check isTimeSet and only
3891* call this method if isTimeSet is false.
3892*/
3893void
3894Calendar::updateTime(UErrorCode& status)
3895{
  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 = FALSE0;

  fIsTimeSet = TRUE1;
  fAreFieldsVirtuallySet = FALSE0;
3908}

3910Locale
3911Calendar::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
  U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
  return locBased.getLocale(type, status);
3914}

3916const char *
3917Calendar::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
  U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
  return locBased.getLocaleID(type, status);
3920}

3922void
3923Calendar::recalculateStamp() {
  int32_t index;
  int32_t currentValue;
  int32_t j, i;

  fNextStamp = 1;

  for (j = 0; j < UCAL_FIELD_COUNT; j++) {
      currentValue = STAMP_MAX10000;
      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++;
3947}

3949// Deprecated function. This doesn't need to be inline.
3950void
3951Calendar::internalSet(EDateFields field, int32_t value)
3952{
  internalSet((UCalendarDateFields) field, value);
3954}

3956BasicTimeZone*
3957Calendar::getBasicTimeZone(void) const {
  if (dynamic_cast<const OlsonTimeZone *>(fZone) != NULL__null
      || dynamic_cast<const SimpleTimeZone *>(fZone) != NULL__null
      || dynamic_cast<const RuleBasedTimeZone *>(fZone) != NULL__null
      || dynamic_cast<const VTimeZone *>(fZone) != NULL__null) {
      return (BasicTimeZone*)fZone;
  }
  return NULL__null;
3965}

3967U_NAMESPACE_END}

3969#endif /* #if !UCONFIG_NO_FORMATTING */


3972//eof

←

../deps/icu-small/source/common/unifiedcache.h

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 2015, International Business Machines Corporation and
6* others. All Rights Reserved.
7******************************************************************************
8*
9* File UNIFIEDCACHE.H - The ICU Unified cache.
10******************************************************************************
11*/

13#ifndef __UNIFIED_CACHE_H__
14#define __UNIFIED_CACHE_H__

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

18#include "unicode/uobject.h"
19#include "unicode/locid.h"
20#include "sharedobject.h"
21#include "unicode/unistr.h"
22#include "cstring.h"
23#include "ustr_imp.h"

25struct UHashtable;
26struct UHashElement;

28U_NAMESPACE_BEGINnamespace icu_71 {

30class UnifiedCache;

32/**
* A base class for all cache keys.
*/
35class U_COMMON_API CacheKeyBase : public UObject {
public:
 CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsPrimary(false) {}

 /**
  * Copy constructor. Needed to support cloning.
  */
 CacheKeyBase(const CacheKeyBase &other) 
         : UObject(other), fCreationStatus(other.fCreationStatus), fIsPrimary(false) { }
 virtual ~CacheKeyBase();

 /**
  * Returns the hash code for this object.
  */
 virtual int32_t hashCode() const = 0;

 /**
  * Clones this object polymorphically. Caller owns returned value.
  */
 virtual CacheKeyBase *clone() const = 0;

 /**
  * Create a new object for this key. Called by cache on cache miss.
  * createObject must add a reference to the object it returns. Note
  * that getting an object from the cache and returning it without calling
  * removeRef on it satisfies this requirement. It can also return NULL
  * and set status to an error.
  *
  * @param creationContext the context in which the object is being
  *                        created. May be NULL.
  * @param status          Implementations can return a failure here.
  *                        In addition, implementations may return a
  *                        non NULL object and set a warning status.
  */
 virtual const SharedObject *createObject(
         const void *creationContext, UErrorCode &status) const = 0;

 /**
  * Writes a description of this key to buffer and returns buffer. Written
  * description is NULL terminated.
  */
 virtual char *writeDescription(char *buffer, int32_t bufSize) const = 0;

 friend inline bool operator==(const CacheKeyBase& lhs,
                               const CacheKeyBase& rhs) {
     return lhs.equals(rhs);
 }

 friend inline bool operator!=(const CacheKeyBase& lhs,
                               const CacheKeyBase& rhs) {
     return !lhs.equals(rhs);
 }

protected:
 virtual bool equals(const CacheKeyBase& other) const = 0;

private:
 mutable UErrorCode fCreationStatus;
 mutable UBool fIsPrimary;
 friend class UnifiedCache;
95};



99/**
* Templated version of CacheKeyBase. 
* A key of type LocaleCacheKey<T> maps to a value of type T.
*/
103template<typename T>
104class CacheKey : public CacheKeyBase {
public:
 virtual ~CacheKey() { }
 /**
  * The template parameter, T, determines the hash code returned.
  */
 virtual int32_t hashCode() const override {
     const char *s = typeid(T).name();
     return ustr_hashCharsNustr_hashCharsN_71(s, static_cast<int32_t>(uprv_strlen(s):: strlen(s)));
 }

 /**
  * Use the value type, T,  as the description.
  */
 virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
     const char *s = typeid(T).name();
     uprv_strncpy(buffer, s, bufLen):: strncpy(buffer, s, bufLen);
     buffer[bufLen - 1] = 0;
     return buffer;
 }

protected:
 /**
  * Two objects are equal if they are of the same type.
  */
 virtual bool equals(const CacheKeyBase &other) const override {
     return this == &other || typeid(*this) == typeid(other);
 }
132};

134/**
* Cache key based on locale.
* A key of type LocaleCacheKey<T> maps to a value of type T.
*/
138template<typename T>
139class LocaleCacheKey : public CacheKey<T> {
protected:
 Locale   fLoc;
 virtual bool equals(const CacheKeyBase &other) const override {
     if (!CacheKey<T>::equals(other)) {
         return false;
     }
     // We know this and other are of same class because equals() on
     // CacheKey returned true.
     return operator==(static_cast<const LocaleCacheKey<T> &>(other));
 }
public:
 LocaleCacheKey(const Locale &loc) : fLoc(loc) {}
 LocaleCacheKey(const LocaleCacheKey<T> &other)
         : CacheKey<T>(other), fLoc(other.fLoc) { }
 virtual ~LocaleCacheKey() { }
 virtual int32_t hashCode() const override {
     return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
 }
 inline bool operator == (const LocaleCacheKey<T> &other) const {
     return fLoc == other.fLoc;
 }
 virtual CacheKeyBase *clone() const override {
     return new LocaleCacheKey<T>(*this);
 }
 virtual const T *createObject(
         const void *creationContext, UErrorCode &status) const override;
 /**
  * Use the locale id as the description.
  */
 virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
     const char *s = fLoc.getName();
     uprv_strncpy(buffer, s, bufLen):: strncpy(buffer, s, bufLen);
     buffer[bufLen - 1] = 0;
     return buffer;
 }

176};

178/**
* The unified cache. A singleton type.
* Design doc here:
* https://docs.google.com/document/d/1RwGQJs4N4tawNbf809iYDRCvXoMKqDJihxzYt1ysmd8/edit?usp=sharing
*/
183class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
public:
 /**
  * @internal
  * Do not call directly. Instead use UnifiedCache::getInstance() as
  * there should be only one UnifiedCache in an application.
  */
 UnifiedCache(UErrorCode &status);

 /**
  * Return a pointer to the global cache instance.
  */
 static UnifiedCache *getInstance(UErrorCode &status);

 /**
  * Fetches a value from the cache by key. Equivalent to
  * get(key, NULL, ptr, status);
  */
 template<typename T>
 void get(
         const CacheKey<T>& key,
         const T *&ptr,
         UErrorCode &status) const {
     get(key, NULL__null, ptr, status);
5
←
Calling 'UnifiedCache::get'→
15
←
Returning from 'UnifiedCache::get'→
 }
16
←
Returning without writing to 'ptr'→

 /**
  * Fetches value from the cache by key.
  *
  * @param key             the cache key.
  * @param creationContext passed verbatim to createObject method of key
  * @param ptr             On entry, ptr must be NULL or be included if
  *                        the reference count of the object it points
  *                        to. On exit, ptr points to the fetched object
  *                        from the cache or is left unchanged on
  *                        failure. Caller must call removeRef on ptr
  *                        if set to a non NULL value.
  * @param status          Any error returned here. May be set to a
  *                        warning value even if ptr is set.
  */
 template<typename T>
 void get(
         const CacheKey<T>& key,
         const void *creationContext,
         const T *&ptr,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
6
←
Taking false branch→
         return;
     }
     UErrorCode creationStatus = U_ZERO_ERROR;
     const SharedObject *value = NULL__null;
     _get(key, value, creationContext, creationStatus);
     const T *tvalue = (const T *) value;
     if (U_SUCCESS(creationStatus)) {
7
←
Taking true branch→
         SharedObject::copyPtr(tvalue, ptr);
8
←
Calling 'SharedObject::copyPtr'→
12
←
Returning from 'SharedObject::copyPtr'→
     }
     SharedObject::clearPtr(tvalue);
     // Take care not to overwrite a warning status passed in with
     // another warning or U_ZERO_ERROR.
     if (status == U_ZERO_ERROR || U_FAILURE(creationStatus)) {
13
←
Assuming 'status' is equal to U_ZERO_ERROR→
         status = creationStatus;
     }
 }
14
←
Returning without writing to 'ptr'→

247#ifdef UNIFIED_CACHE_DEBUG
 /**
  * Dumps the contents of this cache to standard error. Used for testing of
  * cache only.
  */
 void dumpContents() const;
253#endif

 /**
  * Convenience method to get a value of type T from cache for a
  * particular locale with creationContext == NULL.
  * @param loc    the locale
  * @param ptr    On entry, must be NULL or included in the ref count
  *               of the object to which it points.
  *               On exit, fetched value stored here or is left
  *               unchanged on failure. Caller must call removeRef on
  *               ptr if set to a non NULL value.
  * @param status Any error returned here. May be set to a
  *               warning value even if ptr is set.
  */
 template<typename T>
 static void getByLocale(
         const Locale &loc, const T *&ptr, UErrorCode &status) {
     const UnifiedCache *cache = getInstance(status);
     if (U_FAILURE(status)) {
3
←
Taking false branch→
         return;
     }
     cache->get(LocaleCacheKey<T>(loc), ptr, status);
4
←
Calling 'UnifiedCache::get'→
17
←
Returning from 'UnifiedCache::get'→
 }
18
←
Returning without writing to 'ptr'→

277#ifdef UNIFIED_CACHE_DEBUG
 /**
  * Dumps the cache contents to stderr. For testing only.
  */
 static void dump();
282#endif

 /**
  * Returns the number of keys in this cache. For testing only.
  */
 int32_t keyCount() const;

 /**
  * Removes any values from cache that are not referenced outside
  * the cache.
  */
 void flush() const;

 /**
  * Configures at what point eviction of unused entries will begin.
  * Eviction is triggered whenever the number of evictable keys exceeds
  * BOTH count AND (number of in-use items) * (percentageOfInUseItems / 100).
  * Once the number of unused entries drops below one of these,
  * eviction ceases. Because eviction happens incrementally,
  * the actual unused entry count may exceed both these numbers
  * from time to time.
  *
  * A cache entry is defined as unused if it is not essential to guarantee
  * that for a given key X, the cache returns the same reference to the
  * same value as long as the client already holds a reference to that
  * value.
  *
  * If this method is never called, the default settings are 1000 and 100%.
  *
  * Although this method is thread-safe, it is designed to be called at
  * application startup. If it is called in the middle of execution, it
  * will have no immediate effect on the cache. However over time, the
  * cache will perform eviction slices in an attempt to honor the new
  * settings.
  *
  * If a client already holds references to many different unique values
  * in the cache such that the number of those unique values far exceeds
  * "count" then the cache may not be able to maintain this maximum.
  * However, if this happens, the cache still guarantees that the number of
  * unused entries will remain only a small percentage of the total cache
  * size.
  *
  * If the parameters passed are negative, setEvctionPolicy sets status to
  * U_ILLEGAL_ARGUMENT_ERROR.
  */
 void setEvictionPolicy(
         int32_t count, int32_t percentageOfInUseItems, UErrorCode &status);


 /**
  * Returns how many entries have been auto evicted during the lifetime
  * of this cache. This only includes auto evicted entries, not
  * entries evicted because of a call to flush().
  */
 int64_t autoEvictedCount() const;

 /**
  * Returns the unused entry count in this cache. For testing only,
  * Regular clients will not need this.
  */
 int32_t unusedCount() const;

 virtual void handleUnreferencedObject() const override;
 virtual ~UnifiedCache();
 
private:
 UHashtable *fHashtable;
 mutable int32_t fEvictPos;
 mutable int32_t fNumValuesTotal;
 mutable int32_t fNumValuesInUse;
 int32_t fMaxUnused;
 int32_t fMaxPercentageOfInUse;
 mutable int64_t fAutoEvictedCount;
 SharedObject *fNoValue;
 
 UnifiedCache(const UnifiedCache &other);
 UnifiedCache &operator=(const UnifiedCache &other);
 
 /**
  * Flushes the contents of the cache. If cache values hold references to other
  * cache values then _flush should be called in a loop until it returns false.
  * 
  * On entry, gCacheMutex must be held.
  * On exit, those values with are evictable are flushed.
  * 
  *  @param all if false flush evictable items only, which are those with no external
  *                    references, plus those that can be safely recreated.<br>
  *            if true, flush all elements. Any values (sharedObjects) with remaining
  *                     hard (external) references are not deleted, but are detached from
  *                     the cache, so that a subsequent removeRefs can delete them.
  *                     _flush is not thread safe when all is true.
  *   @return true if any value in cache was flushed or false otherwise.
  */
 UBool _flush(UBool all) const;
 
 /**
  * Gets value out of cache.
  * On entry. gCacheMutex must not be held. value must be NULL. status
  * must be U_ZERO_ERROR.
  * On exit. value and status set to what is in cache at key or on cache
  * miss the key's createObject() is called and value and status are set to
  * the result of that. In this latter case, best effort is made to add the
  * value and status to the cache. If createObject() fails to create a value,
  * fNoValue is stored in cache, and value is set to NULL. Caller must call
  * removeRef on value if non NULL.
  */
 void _get(
         const CacheKeyBase &key,
         const SharedObject *&value,
         const void *creationContext,
         UErrorCode &status) const;

  /**
   * Attempts to fetch value and status for key from cache.
   * On entry, gCacheMutex must not be held value must be NULL and status must
   * be U_ZERO_ERROR.
   * On exit, either returns false (In this
   * case caller should try to create the object) or returns true with value
   * pointing to the fetched value and status set to fetched status. When
   * false is returned status may be set to failure if an in progress hash
   * entry could not be made but value will remain unchanged. When true is
   * returned, caller must call removeRef() on value.
   */
  UBool _poll(
          const CacheKeyBase &key,
          const SharedObject *&value,
          UErrorCode &status) const;
  
  /**
   * Places a new value and creationStatus in the cache for the given key.
   * On entry, gCacheMutex must be held. key must not exist in the cache. 
   * On exit, value and creation status placed under key. Soft reference added
   * to value on successful add. On error sets status.
   */
  void _putNew(
      const CacheKeyBase &key,
      const SharedObject *value,
      const UErrorCode creationStatus,
      UErrorCode &status) const;
         
  /**
   * Places value and status at key if there is no value at key or if cache
   * entry for key is in progress. Otherwise, it leaves the current value and
   * status there.
   * 
   * On entry. gCacheMutex must not be held. Value must be
   * included in the reference count of the object to which it points.
   * 
   * On exit, value and status are changed to what was already in the cache if
   * something was there and not in progress. Otherwise, value and status are left
   * unchanged in which case they are placed in the cache on a best-effort basis.
   * Caller must call removeRef() on value.
   */
 void _putIfAbsentAndGet(
         const CacheKeyBase &key,
         const SharedObject *&value,
         UErrorCode &status) const;

  /**
   * Returns the next element in the cache round robin style.
   * Returns nullptr if the cache is empty.
   * On entry, gCacheMutex must be held.
   */
  const UHashElement *_nextElement() const;
 
 /**
  * Return the number of cache items that would need to be evicted
  * to bring usage into conformance with eviction policy.
  * 
  * An item corresponds to an entry in the hash table, a hash table element.
  * 
  * On entry, gCacheMutex must be held.
  */
 int32_t _computeCountOfItemsToEvict() const;
 
 /**
  * Run an eviction slice.
  * On entry, gCacheMutex must be held.
  * _runEvictionSlice runs a slice of the evict pipeline by examining the next
  * 10 entries in the cache round robin style evicting them if they are eligible.
  */
 void _runEvictionSlice() const;

 /**
  * Register a primary cache entry. A primary key is the first key to create
  * a given  SharedObject value. Subsequent keys whose create function
  * produce references to an already existing SharedObject are not primary -
  * they can be evicted and subsequently recreated.
  * 
  * On entry, gCacheMutex must be held.
  * On exit, items in use count incremented, entry is marked as a primary
  * entry, and value registered with cache so that subsequent calls to
  * addRef() and removeRef() on it correctly interact with the cache.
  */
 void _registerPrimary(const CacheKeyBase *theKey, const SharedObject *value) const;
      
 /**
  * Store a value and creation error status in given hash entry.
  * On entry, gCacheMutex must be held. Hash entry element must be in progress.
  * value must be non NULL.
  * On Exit, soft reference added to value. value and status stored in hash
  * entry. Soft reference removed from previous stored value. Waiting
  * threads notified.
  */
 void _put(
         const UHashElement *element,
         const SharedObject *value,
         const UErrorCode status) const;
  /**
   * Remove a soft reference, and delete the SharedObject if no references remain.
   * To be used from within the UnifiedCache implementation only.
   * gCacheMutex must be held by caller.
   * @param value the SharedObject to be acted on.
   */
 void removeSoftRef(const SharedObject *value) const;
 
 /**
  * Increment the hard reference count of the given SharedObject.
  * gCacheMutex must be held by the caller.
  * Update numValuesEvictable on transitions between zero and one reference.
  * 
  * @param value The SharedObject to be referenced.
  * @return the hard reference count after the addition.
  */
 int32_t addHardRef(const SharedObject *value) const;
 
/**
  * Decrement the hard reference count of the given SharedObject.
  * gCacheMutex must be held by the caller.
  * Update numValuesEvictable on transitions between one and zero reference.
  * 
  * @param value The SharedObject to be referenced.
  * @return the hard reference count after the removal.
  */
 int32_t removeHardRef(const SharedObject *value) const;

 
519#ifdef UNIFIED_CACHE_DEBUG
 void _dumpContents() const;
521#endif
 
 /**
  *  Fetch value and error code from a particular hash entry.
  *  On entry, gCacheMutex must be held. value must be either NULL or must be
  *  included in the ref count of the object to which it points.
  *  On exit, value and status set to what is in the hash entry. Caller must
  *  eventually call removeRef on value.
  *  If hash entry is in progress, value will be set to gNoValue and status will
  *  be set to U_ZERO_ERROR.
  */
 void _fetch(const UHashElement *element, const SharedObject *&value,
                     UErrorCode &status) const;
                     
  /**
   * Determine if given hash entry is in progress.
   * On entry, gCacheMutex must be held.
   */
 UBool _inProgress(const UHashElement *element) const;
 
 /**
  * Determine if given hash entry is in progress.
  * On entry, gCacheMutex must be held.
  */
 UBool _inProgress(const SharedObject *theValue, UErrorCode creationStatus) const;
 
 /**
  * Determine if given hash entry is eligible for eviction.
  * On entry, gCacheMutex must be held.
  */
 UBool _isEvictable(const UHashElement *element) const;
552};

554U_NAMESPACE_END}

556#endif

←

../deps/icu-small/source/common/sharedobject.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 2015-2016, International Business Machines
6* Corporation and others.  All Rights Reserved.
7******************************************************************************
8* sharedobject.h
9*/

11#ifndef __SHAREDOBJECT_H__
12#define __SHAREDOBJECT_H__


15#include "unicode/uobject.h"
16#include "umutex.h"

18U_NAMESPACE_BEGINnamespace icu_71 {

20class SharedObject;

22/**
* Base class for unified cache exposing enough methods to SharedObject
* instances to allow their addRef() and removeRef() methods to
* update cache metrics. No other part of ICU, except for SharedObject,
* should directly call the methods of this base class.
*/
28class U_COMMON_API UnifiedCacheBase : public UObject {
29public:
  UnifiedCacheBase() { }

  /**
   * Notify the cache implementation that an object was seen transitioning to
   * zero hard references. The cache may use this to keep track the number of
   * unreferenced SharedObjects, and to trigger evictions.
   */
  virtual void handleUnreferencedObject() const = 0;

  virtual ~UnifiedCacheBase();
40private:
  UnifiedCacheBase(const UnifiedCacheBase &);
  UnifiedCacheBase &operator=(const UnifiedCacheBase &);
43};

45/**
* Base class for shared, reference-counted, auto-deleted objects.
* Subclasses can be immutable.
* If they are mutable, then they must implement their copy constructor
* so that copyOnWrite() works.
*
* Either stack-allocate, use LocalPointer, or use addRef()/removeRef().
* Sharing requires reference-counting.
*/
54class U_COMMON_API SharedObject : public UObject {
55public:
  /** Initializes totalRefCount, softRefCount to 0. */
  SharedObject() :
          softRefCount(0),
          hardRefCount(0),
          cachePtr(NULL__null) {}

  /** Initializes totalRefCount, softRefCount to 0. */
  SharedObject(const SharedObject &other) :
          UObject(other),
          softRefCount(0),
          hardRefCount(0),
          cachePtr(NULL__null) {}

  virtual ~SharedObject();

  /**
   * Increments the number of hard references to this object. Thread-safe.
   * Not for use from within the Unified Cache implementation.
   */
  void addRef() const;

  /**
   * Decrements the number of hard references to this object, and
   * arrange for possible cache-eviction and/or deletion if ref
   * count goes to zero. Thread-safe.
   * 
   * Not for use from within the UnifiedCache implementation.
   */
  void removeRef() const;

  /**
   * Returns the number of hard references for this object.
   * Uses a memory barrier.
   */
  int32_t getRefCount() const;

  /**
   * If noHardReferences() == true then this object has no hard references.
   * Must be called only from within the internals of UnifiedCache.
   */
  inline UBool noHardReferences() const { return getRefCount() == 0; }

  /**
   * If hasHardReferences() == true then this object has hard references.
   * Must be called only from within the internals of UnifiedCache.
   */
  inline UBool hasHardReferences() const { return getRefCount() != 0; }

  /**
   * Deletes this object if it has no references.
   * Available for non-cached SharedObjects only. Ownership of cached objects
   * is with the UnifiedCache, which is solely responsible for eviction and deletion.
   */
  void deleteIfZeroRefCount() const;

      
  /**
   * Returns a writable version of ptr.
   * If there is exactly one owner, then ptr itself is returned as a
   *  non-const pointer.
   * If there are multiple owners, then ptr is replaced with a 
   * copy-constructed clone,
   * and that is returned.
   * Returns NULL if cloning failed.
   *
   * T must be a subclass of SharedObject.
   */
  template<typename T>
  static T *copyOnWrite(const T *&ptr) {
      const T *p = ptr;
      if(p->getRefCount() <= 1) { return const_cast<T *>(p); }
      T *p2 = new T(*p);
      if(p2 == NULL__null) { return NULL__null; }
      p->removeRef();
      ptr = p2;
      p2->addRef();
      return p2;
  }

  /**
   * Makes dest an owner of the object pointed to by src while adjusting
   * reference counts and deleting the previous object dest pointed to
   * if necessary. Before this call is made, dest must either be NULL or
   * be included in the reference count of the object it points to. 
   *
   * T must be a subclass of SharedObject.
   */
  template<typename T>
  static void copyPtr(const T *src, const T *&dest) {
      if(src != dest) {
9
←
Assuming 'src' is equal to 'dest'→
10
←
Taking false branch→
          if(dest != NULL__null) { dest->removeRef(); }
          dest = src;
          if(src != NULL__null) { src->addRef(); }
      }
  }
11
←
Returning without writing to 'dest'→

  /**
   * Equivalent to copyPtr(NULL, dest).
   */
  template<typename T>
  static void clearPtr(const T *&ptr) {
      if (ptr != NULL__null) {
          ptr->removeRef();
          ptr = NULL__null;
      }
  }

163private:
  /**
   * The number of references from the UnifiedCache, which is
   * the number of times that the sharedObject is stored as a hash table value.
   * For use by UnifiedCache implementation code only.
   * All access is synchronized by UnifiedCache's gCacheMutex
   */
  mutable int32_t softRefCount;
  friend class UnifiedCache;

  /**
   * Reference count, excluding references from within the UnifiedCache implementation.
   */
  mutable u_atomic_int32_t hardRefCount;
  
  mutable const UnifiedCacheBase *cachePtr;

180};

182U_NAMESPACE_END}

184#endif