Back to index...

	/*
	* Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* (C) Copyright Taligent, Inc. 1996-1998 - All Rights Reserved
	* (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved
	*
	* The original version of this source code and documentation is copyrighted
	* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
	* materials are provided under terms of a License Agreement between Taligent
	* and Sun. This technology is protected by multiple US and International
	* patents. This notice and attribution to Taligent may not be removed.
	* Taligent is a registered trademark of Taligent, Inc.
	*
	*/

	package java.util;

	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.time.Instant;
	import java.time.ZonedDateTime;
	import java.time.temporal.ChronoField;
	import sun.util.calendar.BaseCalendar;
	import sun.util.calendar.CalendarDate;
	import sun.util.calendar.CalendarSystem;
	import sun.util.calendar.CalendarUtils;
	import sun.util.calendar.Era;
	import sun.util.calendar.Gregorian;
	import sun.util.calendar.JulianCalendar;
	import sun.util.calendar.ZoneInfo;

	/**
	* <code>GregorianCalendar</code> is a concrete subclass of
	* <code>Calendar</code> and provides the standard calendar system
	* used by most of the world.
	*
	* <p> <code>GregorianCalendar</code> is a hybrid calendar that
	* supports both the Julian and Gregorian calendar systems with the
	* support of a single discontinuity, which corresponds by default to
	* the Gregorian date when the Gregorian calendar was instituted
	* (October 15, 1582 in some countries, later in others). The cutover
	* date may be changed by the caller by calling {@link
	* #setGregorianChange(Date) setGregorianChange()}.
	*
	* <p>
	* Historically, in those countries which adopted the Gregorian calendar first,
	* October 4, 1582 (Julian) was thus followed by October 15, 1582 (Gregorian). This calendar models
	* this correctly. Before the Gregorian cutover, <code>GregorianCalendar</code>
	* implements the Julian calendar. The only difference between the Gregorian
	* and the Julian calendar is the leap year rule. The Julian calendar specifies
	* leap years every four years, whereas the Gregorian calendar omits century
	* years which are not divisible by 400.
	*
	* <p>
	* <code>GregorianCalendar</code> implements <em>proleptic</em> Gregorian and
	* Julian calendars. That is, dates are computed by extrapolating the current
	* rules indefinitely far backward and forward in time. As a result,
	* <code>GregorianCalendar</code> may be used for all years to generate
	* meaningful and consistent results. However, dates obtained using
	* <code>GregorianCalendar</code> are historically accurate only from March 1, 4
	* AD onward, when modern Julian calendar rules were adopted. Before this date,
	* leap year rules were applied irregularly, and before 45 BC the Julian
	* calendar did not even exist.
	*
	* <p>
	* Prior to the institution of the Gregorian calendar, New Year's Day was
	* March 25. To avoid confusion, this calendar always uses January 1. A manual
	* adjustment may be made if desired for dates that are prior to the Gregorian
	* changeover and which fall between January 1 and March 24.
	*
	* <h3><a id="week_and_year">Week Of Year and Week Year</a></h3>
	*
	* <p>Values calculated for the {@link Calendar#WEEK_OF_YEAR
	* WEEK_OF_YEAR} field range from 1 to 53. The first week of a
	* calendar year is the earliest seven day period starting on {@link
	* Calendar#getFirstDayOfWeek() getFirstDayOfWeek()} that contains at
	* least {@link Calendar#getMinimalDaysInFirstWeek()
	* getMinimalDaysInFirstWeek()} days from that year. It thus depends
	* on the values of {@code getMinimalDaysInFirstWeek()}, {@code
	* getFirstDayOfWeek()}, and the day of the week of January 1. Weeks
	* between week 1 of one year and week 1 of the following year
	* (exclusive) are numbered sequentially from 2 to 52 or 53 (except
	* for year(s) involved in the Julian-Gregorian transition).
	*
	* <p>The {@code getFirstDayOfWeek()} and {@code
	* getMinimalDaysInFirstWeek()} values are initialized using
	* locale-dependent resources when constructing a {@code
	* GregorianCalendar}. <a id="iso8601_compatible_setting">The week
	* determination is compatible</a> with the ISO 8601 standard when {@code
	* getFirstDayOfWeek()} is {@code MONDAY} and {@code
	* getMinimalDaysInFirstWeek()} is 4, which values are used in locales
	* where the standard is preferred. These values can explicitly be set by
	* calling {@link Calendar#setFirstDayOfWeek(int) setFirstDayOfWeek()} and
	* {@link Calendar#setMinimalDaysInFirstWeek(int)
	* setMinimalDaysInFirstWeek()}.
	*
	* <p>A <a id="week_year"><em>week year</em></a> is in sync with a
	* {@code WEEK_OF_YEAR} cycle. All weeks between the first and last
	* weeks (inclusive) have the same <em>week year</em> value.
	* Therefore, the first and last days of a week year may have
	* different calendar year values.
	*
	* <p>For example, January 1, 1998 is a Thursday. If {@code
	* getFirstDayOfWeek()} is {@code MONDAY} and {@code
	* getMinimalDaysInFirstWeek()} is 4 (ISO 8601 standard compatible
	* setting), then week 1 of 1998 starts on December 29, 1997, and ends
	* on January 4, 1998. The week year is 1998 for the last three days
	* of calendar year 1997. If, however, {@code getFirstDayOfWeek()} is
	* {@code SUNDAY}, then week 1 of 1998 starts on January 4, 1998, and
	* ends on January 10, 1998; the first three days of 1998 then are
	* part of week 53 of 1997 and their week year is 1997.
	*
	* <h4>Week Of Month</h4>
	*
	* <p>Values calculated for the <code>WEEK_OF_MONTH</code> field range from 0
	* to 6. Week 1 of a month (the days with <code>WEEK_OF_MONTH =
	* 1</code>) is the earliest set of at least
	* <code>getMinimalDaysInFirstWeek()</code> contiguous days in that month,
	* ending on the day before <code>getFirstDayOfWeek()</code>. Unlike
	* week 1 of a year, week 1 of a month may be shorter than 7 days, need
	* not start on <code>getFirstDayOfWeek()</code>, and will not include days of
	* the previous month. Days of a month before week 1 have a
	* <code>WEEK_OF_MONTH</code> of 0.
	*
	* <p>For example, if <code>getFirstDayOfWeek()</code> is <code>SUNDAY</code>
	* and <code>getMinimalDaysInFirstWeek()</code> is 4, then the first week of
	* January 1998 is Sunday, January 4 through Saturday, January 10. These days
	* have a <code>WEEK_OF_MONTH</code> of 1. Thursday, January 1 through
	* Saturday, January 3 have a <code>WEEK_OF_MONTH</code> of 0. If
	* <code>getMinimalDaysInFirstWeek()</code> is changed to 3, then January 1
	* through January 3 have a <code>WEEK_OF_MONTH</code> of 1.
	*
	* <h4>Default Fields Values</h4>
	*
	* <p>The <code>clear</code> method sets calendar field(s)
	* undefined. <code>GregorianCalendar</code> uses the following
	* default value for each calendar field if its value is undefined.
	*
	* <table class="striped" style="text-align: left; width: 66%;">
	* <caption style="display:none">GregorianCalendar default field values</caption>
	* <thead>
	* <tr>
	* <th scope="col">
	* Field
	* </th>
	* <th scope="col">
	Default Value
	* </th>
	* </tr>
	* </thead>
	* <tbody>
	* <tr>
	* <th scope="row">
	* <code>ERA</code>
	* </th>
	* <td>
	* <code>AD</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>YEAR</code>
	* </th>
	* <td>
	* <code>1970</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>MONTH</code>
	* </th>
	* <td>
	* <code>JANUARY</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>DAY_OF_MONTH</code>
	* </th>
	* <td>
	* <code>1</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>DAY_OF_WEEK</code>
	* </th>
	* <td>
	* <code>the first day of week</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>WEEK_OF_MONTH</code>
	* </th>
	* <td>
	* <code>0</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>DAY_OF_WEEK_IN_MONTH</code>
	* </th>
	* <td>
	* <code>1</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>AM_PM</code>
	* </th>
	* <td>
	* <code>AM</code>
	* </td>
	* </tr>
	* <tr>
	* <th scope="row">
	* <code>HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND</code>
	* </th>
	* <td>
	* <code>0</code>
	* </td>
	* </tr>
	* </tbody>
	* </table>
	* <br>Default values are not applicable for the fields not listed above.
	*
	* <p>
	* <strong>Example:</strong>
	* <blockquote>
	* <pre>
	* // get the supported ids for GMT-08:00 (Pacific Standard Time)
	* String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
	* // if no ids were returned, something is wrong. get out.
	* if (ids.length == 0)
	* System.exit(0);
	*
	* // begin output
	* System.out.println("Current Time");
	*
	* // create a Pacific Standard Time time zone
	* SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
	*
	* // set up rules for Daylight Saving Time
	* pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
	* pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
	*
	* // create a GregorianCalendar with the Pacific Daylight time zone
	* // and the current date and time
	* Calendar calendar = new GregorianCalendar(pdt);
	* Date trialTime = new Date();
	* calendar.setTime(trialTime);
	*
	* // print out a bunch of interesting things
	* System.out.println("ERA: " + calendar.get(Calendar.ERA));
	* System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
	* System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
	* System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
	* System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
	* System.out.println("DATE: " + calendar.get(Calendar.DATE));
	* System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
	* System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
	* System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
	* System.out.println("DAY_OF_WEEK_IN_MONTH: "
	* + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
	* System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
	* System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
	* System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
	* System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
	* System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
	* System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
	* System.out.println("ZONE_OFFSET: "
	* + (calendar.get(Calendar.ZONE_OFFSET)/(60601000)));
	* System.out.println("DST_OFFSET: "
	* + (calendar.get(Calendar.DST_OFFSET)/(60601000)));

	* System.out.println("Current Time, with hour reset to 3");
	* calendar.clear(Calendar.HOUR_OF_DAY); // so doesn't override
	* calendar.set(Calendar.HOUR, 3);
	* System.out.println("ERA: " + calendar.get(Calendar.ERA));
	* System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
	* System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
	* System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
	* System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
	* System.out.println("DATE: " + calendar.get(Calendar.DATE));
	* System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
	* System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
	* System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
	* System.out.println("DAY_OF_WEEK_IN_MONTH: "
	* + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
	* System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
	* System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
	* System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
	* System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
	* System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
	* System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
	* System.out.println("ZONE_OFFSET: "
	* + (calendar.get(Calendar.ZONE_OFFSET)/(60601000))); // in hours
	* System.out.println("DST_OFFSET: "
	* + (calendar.get(Calendar.DST_OFFSET)/(60601000))); // in hours
	* </pre>
	* </blockquote>
	*
	* @see TimeZone
	* @author David Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu
	* @since 1.1
	*/
	public class GregorianCalendar extends Calendar {
	/*
	* Implementation Notes
	*
	* The epoch is the number of days or milliseconds from some defined
	* starting point. The epoch for java.util.Date is used here; that is,
	* milliseconds from January 1, 1970 (Gregorian), midnight UTC. Other
	* epochs which are used are January 1, year 1 (Gregorian), which is day 1
	* of the Gregorian calendar, and December 30, year 0 (Gregorian), which is
	* day 1 of the Julian calendar.
	*
	* We implement the proleptic Julian and Gregorian calendars. This means we
	* implement the modern definition of the calendar even though the
	* historical usage differs. For example, if the Gregorian change is set
	* to new Date(Long.MIN_VALUE), we have a pure Gregorian calendar which
	* labels dates preceding the invention of the Gregorian calendar in 1582 as
	* if the calendar existed then.
	*
	* Likewise, with the Julian calendar, we assume a consistent
	* 4-year leap year rule, even though the historical pattern of
	* leap years is irregular, being every 3 years from 45 BCE
	* through 9 BCE, then every 4 years from 8 CE onwards, with no
	* leap years in-between. Thus date computations and functions
	* such as isLeapYear() are not intended to be historically
	* accurate.
	*/

	//////////////////
	// Class Variables
	//////////////////

	/**
	* Value of the <code>ERA</code> field indicating
	* the period before the common era (before Christ), also known as BCE.
	* The sequence of years at the transition from <code>BC</code> to <code>AD</code> is
	* ..., 2 BC, 1 BC, 1 AD, 2 AD,...
	*
	* @see #ERA
	*/
	public static final int BC = 0;

	/**
	* Value of the {@link #ERA} field indicating
	* the period before the common era, the same value as {@link #BC}.
	*
	* @see #CE
	*/
	static final int BCE = 0;

	/**
	* Value of the <code>ERA</code> field indicating
	* the common era (Anno Domini), also known as CE.
	* The sequence of years at the transition from <code>BC</code> to <code>AD</code> is
	* ..., 2 BC, 1 BC, 1 AD, 2 AD,...
	*
	* @see #ERA
	*/
	public static final int AD = 1;

	/**
	* Value of the {@link #ERA} field indicating
	* the common era, the same value as {@link #AD}.
	*
	* @see #BCE
	*/
	static final int CE = 1;

	private static final int EPOCH_OFFSET = 719163; // Fixed date of January 1, 1970 (Gregorian)
	private static final int EPOCH_YEAR = 1970;

	static final int MONTH_LENGTH[]
	= {31,28,31,30,31,30,31,31,30,31,30,31}; // 0-based
	static final int LEAP_MONTH_LENGTH[]
	= {31,29,31,30,31,30,31,31,30,31,30,31}; // 0-based

	// Useful millisecond constants. Although ONE_DAY and ONE_WEEK can fit
	// into ints, they must be longs in order to prevent arithmetic overflow
	// when performing (bug 4173516).
	private static final int ONE_SECOND = 1000;
	private static final int ONE_MINUTE = 60*ONE_SECOND;
	private static final int ONE_HOUR = 60*ONE_MINUTE;
	private static final long ONE_DAY = 24*ONE_HOUR;
	private static final long ONE_WEEK = 7*ONE_DAY;

	/*
	* <pre>
	* Greatest Least
	* Field name Minimum Minimum Maximum Maximum
	* ---------- ------- ------- ------- -------
	* ERA 0 0 1 1
	* YEAR 1 1 292269054 292278994
	* MONTH 0 0 11 11
	* WEEK_OF_YEAR 1 1 52* 53
	* WEEK_OF_MONTH 0 0 4* 6
	* DAY_OF_MONTH 1 1 28* 31
	* DAY_OF_YEAR 1 1 365* 366
	* DAY_OF_WEEK 1 1 7 7
	* DAY_OF_WEEK_IN_MONTH 1 1 4* 6
	* AM_PM 0 0 1 1
	* HOUR 0 0 11 11
	* HOUR_OF_DAY 0 0 23 23
	* MINUTE 0 0 59 59
	* SECOND 0 0 59 59
	* MILLISECOND 0 0 999 999
	* ZONE_OFFSET -13:00 -13:00 14:00 14:00
	* DST_OFFSET 0:00 0:00 0:20 2:00
	* </pre>
	* *: depends on the Gregorian change date
	*/
	static final int MIN_VALUES[] = {
	BCE, // ERA
	1, // YEAR
	JANUARY, // MONTH
	1, // WEEK_OF_YEAR
	0, // WEEK_OF_MONTH
	1, // DAY_OF_MONTH
	1, // DAY_OF_YEAR
	SUNDAY, // DAY_OF_WEEK
	1, // DAY_OF_WEEK_IN_MONTH
	AM, // AM_PM
	0, // HOUR
	0, // HOUR_OF_DAY
	0, // MINUTE
	0, // SECOND
	0, // MILLISECOND
	-13*ONE_HOUR, // ZONE_OFFSET (UNIX compatibility)
	0 // DST_OFFSET
	};
	static final int LEAST_MAX_VALUES[] = {
	CE, // ERA
	292269054, // YEAR
	DECEMBER, // MONTH
	52, // WEEK_OF_YEAR
	4, // WEEK_OF_MONTH
	28, // DAY_OF_MONTH
	365, // DAY_OF_YEAR
	SATURDAY, // DAY_OF_WEEK
	4, // DAY_OF_WEEK_IN
	PM, // AM_PM
	11, // HOUR
	23, // HOUR_OF_DAY
	59, // MINUTE
	59, // SECOND
	999, // MILLISECOND
	14*ONE_HOUR, // ZONE_OFFSET
	20*ONE_MINUTE // DST_OFFSET (historical least maximum)
	};
	static final int MAX_VALUES[] = {
	CE, // ERA
	292278994, // YEAR
	DECEMBER, // MONTH
	53, // WEEK_OF_YEAR
	6, // WEEK_OF_MONTH
	31, // DAY_OF_MONTH
	366, // DAY_OF_YEAR
	SATURDAY, // DAY_OF_WEEK
	6, // DAY_OF_WEEK_IN
	PM, // AM_PM
	11, // HOUR
	23, // HOUR_OF_DAY
	59, // MINUTE
	59, // SECOND
	999, // MILLISECOND
	14*ONE_HOUR, // ZONE_OFFSET
	2*ONE_HOUR // DST_OFFSET (double summer time)
	};

	// Proclaim serialization compatibility with JDK 1.1
	@SuppressWarnings("FieldNameHidesFieldInSuperclass")
	static final long serialVersionUID = -8125100834729963327L;

	// Reference to the sun.util.calendar.Gregorian instance (singleton).
	private static final Gregorian gcal =
	CalendarSystem.getGregorianCalendar();

	// Reference to the JulianCalendar instance (singleton), set as needed. See
	// getJulianCalendarSystem().
	private static JulianCalendar jcal;

	// JulianCalendar eras. See getJulianCalendarSystem().
	private static Era[] jeras;

	// The default value of gregorianCutover.
	static final long DEFAULT_GREGORIAN_CUTOVER = -12219292800000L;

	/////////////////////
	// Instance Variables
	/////////////////////

	/**
	* The point at which the Gregorian calendar rules are used, measured in
	* milliseconds from the standard epoch. Default is October 15, 1582
	* (Gregorian) 00:00:00 UTC or -12219292800000L. For this value, October 4,
	* 1582 (Julian) is followed by October 15, 1582 (Gregorian). This
	* corresponds to Julian day number 2299161.
	* @serial
	*/
	private long gregorianCutover = DEFAULT_GREGORIAN_CUTOVER;

	/**
	* The fixed date of the gregorianCutover.
	*/
	private transient long gregorianCutoverDate =
	(((DEFAULT_GREGORIAN_CUTOVER + 1)/ONE_DAY) - 1) + EPOCH_OFFSET; // == 577736

	/**
	* The normalized year of the gregorianCutover in Gregorian, with
	* 0 representing 1 BCE, -1 representing 2 BCE, etc.
	*/
	private transient int gregorianCutoverYear = 1582;

	/**
	* The normalized year of the gregorianCutover in Julian, with 0
	* representing 1 BCE, -1 representing 2 BCE, etc.
	*/
	private transient int gregorianCutoverYearJulian = 1582;

	/**
	* gdate always has a sun.util.calendar.Gregorian.Date instance to
	* avoid overhead of creating it. The assumption is that most
	* applications will need only Gregorian calendar calculations.
	*/
	private transient BaseCalendar.Date gdate;

	/**
	* Reference to either gdate or a JulianCalendar.Date
	* instance. After calling complete(), this value is guaranteed to
	* be set.
	*/
	private transient BaseCalendar.Date cdate;

	/**
	* The CalendarSystem used to calculate the date in cdate. After
	* calling complete(), this value is guaranteed to be set and
	* consistent with the cdate value.
	*/
	private transient BaseCalendar calsys;

	/**
	* Temporary int[2] to get time zone offsets. zoneOffsets[0] gets
	* the GMT offset value and zoneOffsets[1] gets the DST saving
	* value.
	*/
	private transient int[] zoneOffsets;

	/**
	* Temporary storage for saving original fields[] values in
	* non-lenient mode.
	*/
	private transient int[] originalFields;

	///////////////
	// Constructors
	///////////////

	/**
	* Constructs a default <code>GregorianCalendar</code> using the current time
	* in the default time zone with the default
	* {@link Locale.Category#FORMAT FORMAT} locale.
	*/
	public GregorianCalendar() {
	this(TimeZone.getDefaultRef(), Locale.getDefault(Locale.Category.FORMAT));
	setZoneShared(true);
	}

	/**
	* Constructs a <code>GregorianCalendar</code> based on the current time
	* in the given time zone with the default
	* {@link Locale.Category#FORMAT FORMAT} locale.
	*
	* @param zone the given time zone.
	*/
	public GregorianCalendar(TimeZone zone) {
	this(zone, Locale.getDefault(Locale.Category.FORMAT));
	}

	/**
	* Constructs a <code>GregorianCalendar</code> based on the current time
	* in the default time zone with the given locale.
	*
	* @param aLocale the given locale.
	*/
	public GregorianCalendar(Locale aLocale) {
	this(TimeZone.getDefaultRef(), aLocale);
	setZoneShared(true);
	}

	/**
	* Constructs a <code>GregorianCalendar</code> based on the current time
	* in the given time zone with the given locale.
	*
	* @param zone the given time zone.
	* @param aLocale the given locale.
	*/
	public GregorianCalendar(TimeZone zone, Locale aLocale) {
	super(zone, aLocale);
	gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone);
	setTimeInMillis(System.currentTimeMillis());
	}

	/**
	* Constructs a <code>GregorianCalendar</code> with the given date set
	* in the default time zone with the default locale.
	*
	* @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
	* @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
	* Month value is 0-based. e.g., 0 for January.
	* @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
	*/
	public GregorianCalendar(int year, int month, int dayOfMonth) {
	this(year, month, dayOfMonth, 0, 0, 0, 0);
	}

	/**
	* Constructs a <code>GregorianCalendar</code> with the given date
	* and time set for the default time zone with the default locale.
	*
	* @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
	* @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
	* Month value is 0-based. e.g., 0 for January.
	* @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
	* @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
	* in the calendar.
	* @param minute the value used to set the <code>MINUTE</code> calendar field
	* in the calendar.
	*/
	public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay,
	int minute) {
	this(year, month, dayOfMonth, hourOfDay, minute, 0, 0);
	}

	/**
	* Constructs a GregorianCalendar with the given date
	* and time set for the default time zone with the default locale.
	*
	* @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
	* @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
	* Month value is 0-based. e.g., 0 for January.
	* @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
	* @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
	* in the calendar.
	* @param minute the value used to set the <code>MINUTE</code> calendar field
	* in the calendar.
	* @param second the value used to set the <code>SECOND</code> calendar field
	* in the calendar.
	*/
	public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay,
	int minute, int second) {
	this(year, month, dayOfMonth, hourOfDay, minute, second, 0);
	}

	/**
	* Constructs a <code>GregorianCalendar</code> with the given date
	* and time set for the default time zone with the default locale.
	*
	* @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
	* @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
	* Month value is 0-based. e.g., 0 for January.
	* @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
	* @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
	* in the calendar.
	* @param minute the value used to set the <code>MINUTE</code> calendar field
	* in the calendar.
	* @param second the value used to set the <code>SECOND</code> calendar field
	* in the calendar.
	* @param millis the value used to set the <code>MILLISECOND</code> calendar field
	*/
	GregorianCalendar(int year, int month, int dayOfMonth,
	int hourOfDay, int minute, int second, int millis) {
	super();
	gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
	this.set(YEAR, year);
	this.set(MONTH, month);
	this.set(DAY_OF_MONTH, dayOfMonth);

	// Set AM_PM and HOUR here to set their stamp values before
	// setting HOUR_OF_DAY (6178071).
	if (hourOfDay >= 12 && hourOfDay <= 23) {
	// If hourOfDay is a valid PM hour, set the correct PM values
	// so that it won't throw an exception in case it's set to
	// non-lenient later.
	this.internalSet(AM_PM, PM);
	this.internalSet(HOUR, hourOfDay - 12);
	} else {
	// The default value for AM_PM is AM.
	// We don't care any out of range value here for leniency.
	this.internalSet(HOUR, hourOfDay);
	}
	// The stamp values of AM_PM and HOUR must be COMPUTED. (6440854)
	setFieldsComputed(HOUR_MASK\|AM_PM_MASK);

	this.set(HOUR_OF_DAY, hourOfDay);
	this.set(MINUTE, minute);
	this.set(SECOND, second);
	// should be changed to set() when this constructor is made
	// public.
	this.internalSet(MILLISECOND, millis);
	}

	/**
	* Constructs an empty GregorianCalendar.
	*
	* @param zone the given time zone
	* @param aLocale the given locale
	* @param flag the flag requesting an empty instance
	*/
	GregorianCalendar(TimeZone zone, Locale locale, boolean flag) {
	super(zone, locale);
	gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
	}

	/////////////////
	// Public methods
	/////////////////

	/**
	* Sets the <code>GregorianCalendar</code> change date. This is the point when the switch
	* from Julian dates to Gregorian dates occurred. Default is October 15,
	* 1582 (Gregorian). Previous to this, dates will be in the Julian calendar.
	* <p>
	* To obtain a pure Julian calendar, set the change date to
	* <code>Date(Long.MAX_VALUE)</code>. To obtain a pure Gregorian calendar,
	* set the change date to <code>Date(Long.MIN_VALUE)</code>.
	*
	* @param date the given Gregorian cutover date.
	*/
	public void setGregorianChange(Date date) {
	long cutoverTime = date.getTime();
	if (cutoverTime == gregorianCutover) {
	return;
	}
	// Before changing the cutover date, make sure to have the
	// time of this calendar.
	complete();
	setGregorianChange(cutoverTime);
	}

	private void setGregorianChange(long cutoverTime) {
	gregorianCutover = cutoverTime;
	gregorianCutoverDate = CalendarUtils.floorDivide(cutoverTime, ONE_DAY)
	+ EPOCH_OFFSET;

	// To provide the "pure" Julian calendar as advertised.
	// Strictly speaking, the last millisecond should be a
	// Gregorian date. However, the API doc specifies that setting
	// the cutover date to Long.MAX_VALUE will make this calendar
	// a pure Julian calendar. (See 4167995)
	if (cutoverTime == Long.MAX_VALUE) {
	gregorianCutoverDate++;
	}

	BaseCalendar.Date d = getGregorianCutoverDate();

	// Set the cutover year (in the Gregorian year numbering)
	gregorianCutoverYear = d.getYear();

	BaseCalendar julianCal = getJulianCalendarSystem();
	d = (BaseCalendar.Date) julianCal.newCalendarDate(TimeZone.NO_TIMEZONE);
	julianCal.getCalendarDateFromFixedDate(d, gregorianCutoverDate - 1);
	gregorianCutoverYearJulian = d.getNormalizedYear();

	if (time < gregorianCutover) {
	// The field values are no longer valid under the new
	// cutover date.
	setUnnormalized();
	}
	}

	/**
	* Gets the Gregorian Calendar change date. This is the point when the
	* switch from Julian dates to Gregorian dates occurred. Default is
	* October 15, 1582 (Gregorian). Previous to this, dates will be in the Julian
	* calendar.
	*
	* @return the Gregorian cutover date for this <code>GregorianCalendar</code> object.
	*/
	public final Date getGregorianChange() {
	return new Date(gregorianCutover);
	}

	/**
	* Determines if the given year is a leap year. Returns <code>true</code> if
	* the given year is a leap year. To specify BC year numbers,
	* <code>1 - year number</code> must be given. For example, year BC 4 is
	* specified as -3.
	*
	* @param year the given year.
	* @return <code>true</code> if the given year is a leap year; <code>false</code> otherwise.
	*/
	public boolean isLeapYear(int year) {
	if ((year & 3) != 0) {
	return false;
	}

	if (year > gregorianCutoverYear) {
	return (year%100 != 0) \|\| (year%400 == 0); // Gregorian
	}
	if (year < gregorianCutoverYearJulian) {
	return true; // Julian
	}
	boolean gregorian;
	// If the given year is the Gregorian cutover year, we need to
	// determine which calendar system to be applied to February in the year.
	if (gregorianCutoverYear == gregorianCutoverYearJulian) {
	BaseCalendar.Date d = getCalendarDate(gregorianCutoverDate); // Gregorian
	gregorian = d.getMonth() < BaseCalendar.MARCH;
	} else {
	gregorian = year == gregorianCutoverYear;
	}
	return gregorian ? (year%100 != 0) \|\| (year%400 == 0) : true;
	}

	/**
	* Returns {@code "gregory"} as the calendar type.
	*
	* @return {@code "gregory"}
	* @since 1.8
	*/
	@Override
	public String getCalendarType() {
	return "gregory";
	}

	/**
	* Compares this <code>GregorianCalendar</code> to the specified
	* <code>Object</code>. The result is <code>true</code> if and
	* only if the argument is a <code>GregorianCalendar</code> object
	* that represents the same time value (millisecond offset from
	* the <a href="Calendar.html#Epoch">Epoch</a>) under the same
	* <code>Calendar</code> parameters and Gregorian change date as
	* this object.
	*
	* @param obj the object to compare with.
	* @return <code>true</code> if this object is equal to <code>obj</code>;
	* <code>false</code> otherwise.
	* @see Calendar#compareTo(Calendar)
	*/
	@Override
	public boolean equals(Object obj) {
	return obj instanceof GregorianCalendar &&
	super.equals(obj) &&
	gregorianCutover == ((GregorianCalendar)obj).gregorianCutover;
	}

	/**
	* Generates the hash code for this <code>GregorianCalendar</code> object.
	*/
	@Override
	public int hashCode() {
	return super.hashCode() ^ (int)gregorianCutoverDate;
	}

	/**
	* Adds the specified (signed) amount of time to the given calendar field,
	* based on the calendar's rules.
	*
	* <p><em>Add rule 1</em>. The value of <code>field</code>
	* after the call minus the value of <code>field</code> before the
	* call is <code>amount</code>, modulo any overflow that has occurred in
	* <code>field</code>. Overflow occurs when a field value exceeds its
	* range and, as a result, the next larger field is incremented or
	* decremented and the field value is adjusted back into its range.</p>
	*
	* <p><em>Add rule 2</em>. If a smaller field is expected to be
	* invariant, but it is impossible for it to be equal to its
	* prior value because of changes in its minimum or maximum after
	* <code>field</code> is changed, then its value is adjusted to be as close
	* as possible to its expected value. A smaller field represents a
	* smaller unit of time. <code>HOUR</code> is a smaller field than
	* <code>DAY_OF_MONTH</code>. No adjustment is made to smaller fields
	* that are not expected to be invariant. The calendar system
	* determines what fields are expected to be invariant.</p>
	*
	* @param field the calendar field.
	* @param amount the amount of date or time to be added to the field.
	* @exception IllegalArgumentException if <code>field</code> is
	* <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
	* or if any calendar fields have out-of-range values in
	* non-lenient mode.
	*/
	@Override
	public void add(int field, int amount) {
	// If amount == 0, do nothing even the given field is out of
	// range. This is tested by JCK.
	if (amount == 0) {
	return; // Do nothing!
	}

	if (field < 0 \|\| field >= ZONE_OFFSET) {
	throw new IllegalArgumentException();
	}

	// Sync the time and calendar fields.
	complete();

	if (field == YEAR) {
	int year = internalGet(YEAR);
	if (internalGetEra() == CE) {
	year += amount;
	if (year > 0) {
	set(YEAR, year);
	} else { // year <= 0
	set(YEAR, 1 - year);
	// if year == 0, you get 1 BCE.
	set(ERA, BCE);
	}
	}
	else { // era == BCE
	year -= amount;
	if (year > 0) {
	set(YEAR, year);
	} else { // year <= 0
	set(YEAR, 1 - year);
	// if year == 0, you get 1 CE
	set(ERA, CE);
	}
	}
	pinDayOfMonth();
	} else if (field == MONTH) {
	int month = internalGet(MONTH) + amount;
	int year = internalGet(YEAR);
	int y_amount;

	if (month >= 0) {
	y_amount = month/12;
	} else {
	y_amount = (month+1)/12 - 1;
	}
	if (y_amount != 0) {
	if (internalGetEra() == CE) {
	year += y_amount;
	if (year > 0) {
	set(YEAR, year);
	} else { // year <= 0
	set(YEAR, 1 - year);
	// if year == 0, you get 1 BCE
	set(ERA, BCE);
	}
	}
	else { // era == BCE
	year -= y_amount;
	if (year > 0) {
	set(YEAR, year);
	} else { // year <= 0
	set(YEAR, 1 - year);
	// if year == 0, you get 1 CE
	set(ERA, CE);
	}
	}
	}

	if (month >= 0) {
	set(MONTH, month % 12);
	} else {
	// month < 0
	month %= 12;
	if (month < 0) {
	month += 12;
	}
	set(MONTH, JANUARY + month);
	}
	pinDayOfMonth();
	} else if (field == ERA) {
	int era = internalGet(ERA) + amount;
	if (era < 0) {
	era = 0;
	}
	if (era > 1) {
	era = 1;
	}
	set(ERA, era);
	} else {
	long delta = amount;
	long timeOfDay = 0;
	switch (field) {
	// Handle the time fields here. Convert the given
	// amount to milliseconds and call setTimeInMillis.
	case HOUR:
	case HOUR_OF_DAY:
	delta = 60 60 * 1000; // hours to minutes
	break;

	case MINUTE:
	delta = 60 1000; // minutes to seconds
	break;

	case SECOND:
	delta *= 1000; // seconds to milliseconds
	break;

	case MILLISECOND:
	break;

	// Handle week, day and AM_PM fields which involves
	// time zone offset change adjustment. Convert the
	// given amount to the number of days.
	case WEEK_OF_YEAR:
	case WEEK_OF_MONTH:
	case DAY_OF_WEEK_IN_MONTH:
	delta *= 7;
	break;

	case DAY_OF_MONTH: // synonym of DATE
	case DAY_OF_YEAR:
	case DAY_OF_WEEK:
	break;

	case AM_PM:
	// Convert the amount to the number of days (delta)
	// and +12 or -12 hours (timeOfDay).
	delta = amount / 2;
	timeOfDay = 12 * (amount % 2);
	break;
	}

	// The time fields don't require time zone offset change
	// adjustment.
	if (field >= HOUR) {
	setTimeInMillis(time + delta);
	return;
	}

	// The rest of the fields (week, day or AM_PM fields)
	// require time zone offset (both GMT and DST) change
	// adjustment.

	// Translate the current time to the fixed date and time
	// of the day.
	long fd = getCurrentFixedDate();
	timeOfDay += internalGet(HOUR_OF_DAY);
	timeOfDay *= 60;
	timeOfDay += internalGet(MINUTE);
	timeOfDay *= 60;
	timeOfDay += internalGet(SECOND);
	timeOfDay *= 1000;
	timeOfDay += internalGet(MILLISECOND);
	if (timeOfDay >= ONE_DAY) {
	fd++;
	timeOfDay -= ONE_DAY;
	} else if (timeOfDay < 0) {
	fd--;
	timeOfDay += ONE_DAY;
	}

	fd += delta; // fd is the expected fixed date after the calculation
	int zoneOffset = internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
	setTimeInMillis((fd - EPOCH_OFFSET) * ONE_DAY + timeOfDay - zoneOffset);
	zoneOffset -= internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
	// If the time zone offset has changed, then adjust the difference.
	if (zoneOffset != 0) {
	setTimeInMillis(time + zoneOffset);
	long fd2 = getCurrentFixedDate();
	// If the adjustment has changed the date, then take
	// the previous one.
	if (fd2 != fd) {
	setTimeInMillis(time - zoneOffset);
	}
	}
	}
	}

	/**
	* Adds or subtracts (up/down) a single unit of time on the given time
	* field without changing larger fields.
	* <p>
	* <em>Example</em>: Consider a <code>GregorianCalendar</code>
	* originally set to December 31, 1999. Calling {@link #roll(int,boolean) roll(Calendar.MONTH, true)}
	* sets the calendar to January 31, 1999. The <code>YEAR</code> field is unchanged
	* because it is a larger field than <code>MONTH</code>.</p>
	*
	* @param up indicates if the value of the specified calendar field is to be
	* rolled up or rolled down. Use <code>true</code> if rolling up, <code>false</code> otherwise.
	* @exception IllegalArgumentException if <code>field</code> is
	* <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
	* or if any calendar fields have out-of-range values in
	* non-lenient mode.
	* @see #add(int,int)
	* @see #set(int,int)
	*/
	@Override
	public void roll(int field, boolean up) {
	roll(field, up ? +1 : -1);
	}

	/**
	* Adds a signed amount to the specified calendar field without changing larger fields.
	* A negative roll amount means to subtract from field without changing
	* larger fields. If the specified amount is 0, this method performs nothing.
	*
	* <p>This method calls {@link #complete()} before adding the
	* amount so that all the calendar fields are normalized. If there
	* is any calendar field having an out-of-range value in non-lenient mode, then an
	* <code>IllegalArgumentException</code> is thrown.
	*
	* <p>
	* <em>Example</em>: Consider a <code>GregorianCalendar</code>
	* originally set to August 31, 1999. Calling <code>roll(Calendar.MONTH,
	* 8)</code> sets the calendar to April 30, <strong>1999</strong>. Using a
	* <code>GregorianCalendar</code>, the <code>DAY_OF_MONTH</code> field cannot
	* be 31 in the month April. <code>DAY_OF_MONTH</code> is set to the closest possible
	* value, 30. The <code>YEAR</code> field maintains the value of 1999 because it
	* is a larger field than <code>MONTH</code>.
	* <p>
	* <em>Example</em>: Consider a <code>GregorianCalendar</code>
	* originally set to Sunday June 6, 1999. Calling
	* <code>roll(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to
	* Tuesday June 1, 1999, whereas calling
	* <code>add(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to
	* Sunday May 30, 1999. This is because the roll rule imposes an
	* additional constraint: The <code>MONTH</code> must not change when the
	* <code>WEEK_OF_MONTH</code> is rolled. Taken together with add rule 1,
	* the resultant date must be between Tuesday June 1 and Saturday June
	* 5. According to add rule 2, the <code>DAY_OF_WEEK</code>, an invariant
	* when changing the <code>WEEK_OF_MONTH</code>, is set to Tuesday, the
	* closest possible value to Sunday (where Sunday is the first day of the
	* week).</p>
	*
	* @param field the calendar field.
	* @param amount the signed amount to add to <code>field</code>.
	* @exception IllegalArgumentException if <code>field</code> is
	* <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
	* or if any calendar fields have out-of-range values in
	* non-lenient mode.
	* @see #roll(int,boolean)
	* @see #add(int,int)
	* @see #set(int,int)
	* @since 1.2
	*/
	@Override
	public void roll(int field, int amount) {
	// If amount == 0, do nothing even the given field is out of
	// range. This is tested by JCK.
	if (amount == 0) {
	return;
	}

	if (field < 0 \|\| field >= ZONE_OFFSET) {
	throw new IllegalArgumentException();
	}

	// Sync the time and calendar fields.
	complete();

	int min = getMinimum(field);
	int max = getMaximum(field);

	switch (field) {
	case AM_PM:
	case ERA:
	case YEAR:
	case MINUTE:
	case SECOND:
	case MILLISECOND:
	// These fields are handled simply, since they have fixed minima
	// and maxima. The field DAY_OF_MONTH is almost as simple. Other
	// fields are complicated, since the range within they must roll
	// varies depending on the date.
	break;

	case HOUR:
	case HOUR_OF_DAY:
	{
	int rolledValue = getRolledValue(internalGet(field), amount, min, max);
	int hourOfDay = rolledValue;
	if (field == HOUR && internalGet(AM_PM) == PM) {
	hourOfDay += 12;
	}

	// Create the current date/time value to perform wall-clock-based
	// roll.
	CalendarDate d = calsys.getCalendarDate(time, getZone());
	d.setHours(hourOfDay);
	time = calsys.getTime(d);

	// If we stay on the same wall-clock time, try the next or previous hour.
	if (internalGet(HOUR_OF_DAY) == d.getHours()) {
	hourOfDay = getRolledValue(rolledValue, amount > 0 ? +1 : -1, min, max);
	if (field == HOUR && internalGet(AM_PM) == PM) {
	hourOfDay += 12;
	}
	d.setHours(hourOfDay);
	time = calsys.getTime(d);
	}
	// Get the new hourOfDay value which might have changed due to a DST transition.
	hourOfDay = d.getHours();
	// Update the hour related fields
	internalSet(HOUR_OF_DAY, hourOfDay);
	internalSet(AM_PM, hourOfDay / 12);
	internalSet(HOUR, hourOfDay % 12);

	// Time zone offset and/or daylight saving might have changed.
	int zoneOffset = d.getZoneOffset();
	int saving = d.getDaylightSaving();
	internalSet(ZONE_OFFSET, zoneOffset - saving);
	internalSet(DST_OFFSET, saving);
	return;
	}

	case MONTH:
	// Rolling the month involves both pinning the final value to [0, 11]
	// 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>.
	{
	if (!isCutoverYear(cdate.getNormalizedYear())) {
	int mon = (internalGet(MONTH) + amount) % 12;
	if (mon < 0) {
	mon += 12;
	}
	set(MONTH, mon);

	// Keep the day of month in the range. We don't want to spill over
	// into the next month; e.g., we don't want jan31 + 1 mo -> feb31 ->
	// mar3.
	int monthLen = monthLength(mon);
	if (internalGet(DAY_OF_MONTH) > monthLen) {
	set(DAY_OF_MONTH, monthLen);
	}
	} else {
	// We need to take care of different lengths in
	// year and month due to the cutover.
	int yearLength = getActualMaximum(MONTH) + 1;
	int mon = (internalGet(MONTH) + amount) % yearLength;
	if (mon < 0) {
	mon += yearLength;
	}
	set(MONTH, mon);
	int monthLen = getActualMaximum(DAY_OF_MONTH);
	if (internalGet(DAY_OF_MONTH) > monthLen) {
	set(DAY_OF_MONTH, monthLen);
	}
	}
	return;
	}

	case WEEK_OF_YEAR:
	{
	int y = cdate.getNormalizedYear();
	max = getActualMaximum(WEEK_OF_YEAR);
	set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK));
	int woy = internalGet(WEEK_OF_YEAR);
	int value = woy + amount;
	if (!isCutoverYear(y)) {
	int weekYear = getWeekYear();
	if (weekYear == y) {
	// If the new value is in between min and max
	// (exclusive), then we can use the value.
	if (value > min && value < max) {
	set(WEEK_OF_YEAR, value);
	return;
	}
	long fd = getCurrentFixedDate();
	// Make sure that the min week has the current DAY_OF_WEEK
	// in the calendar year
	long day1 = fd - (7 * (woy - min));
	if (calsys.getYearFromFixedDate(day1) != y) {
	min++;
	}

	// Make sure the same thing for the max week
	fd += 7 * (max - internalGet(WEEK_OF_YEAR));
	if (calsys.getYearFromFixedDate(fd) != y) {
	max--;
	}
	} else {
	// When WEEK_OF_YEAR and YEAR are out of sync,
	// adjust woy and amount to stay in the calendar year.
	if (weekYear > y) {
	if (amount < 0) {
	amount++;
	}
	woy = max;
	} else {
	if (amount > 0) {
	amount -= woy - max;
	}
	woy = min;
	}
	}
	set(field, getRolledValue(woy, amount, min, max));
	return;
	}

	// Handle cutover here.
	long fd = getCurrentFixedDate();
	BaseCalendar cal;
	if (gregorianCutoverYear == gregorianCutoverYearJulian) {
	cal = getCutoverCalendarSystem();
	} else if (y == gregorianCutoverYear) {
	cal = gcal;
	} else {
	cal = getJulianCalendarSystem();
	}
	long day1 = fd - (7 * (woy - min));
	// Make sure that the min week has the current DAY_OF_WEEK
	if (cal.getYearFromFixedDate(day1) != y) {
	min++;
	}

	// Make sure the same thing for the max week
	fd += 7 * (max - woy);
	cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
	if (cal.getYearFromFixedDate(fd) != y) {
	max--;
	}
	// value: the new WEEK_OF_YEAR which must be converted
	// to month and day of month.
	value = getRolledValue(woy, amount, min, max) - 1;
	BaseCalendar.Date d = getCalendarDate(day1 + value * 7);
	set(MONTH, d.getMonth() - 1);
	set(DAY_OF_MONTH, d.getDayOfMonth());
	return;
	}

	case WEEK_OF_MONTH:
	{
	boolean isCutoverYear = isCutoverYear(cdate.getNormalizedYear());
	// dow: relative day of week from first day of week
	int dow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek();
	if (dow < 0) {
	dow += 7;
	}

	long fd = getCurrentFixedDate();
	long month1; // fixed date of the first day (usually 1) of the month
	int monthLength; // actual month length
	if (isCutoverYear) {
	month1 = getFixedDateMonth1(cdate, fd);
	monthLength = actualMonthLength();
	} else {
	month1 = fd - internalGet(DAY_OF_MONTH) + 1;
	monthLength = calsys.getMonthLength(cdate);
	}

	// the first day of week of the month.
	long monthDay1st = BaseCalendar.getDayOfWeekDateOnOrBefore(month1 + 6,
	getFirstDayOfWeek());
	// if the week has enough days to form a week, the
	// week starts from the previous month.
	if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) {
	monthDay1st -= 7;
	}
	max = getActualMaximum(field);

	// value: the new WEEK_OF_MONTH value
	int value = getRolledValue(internalGet(field), amount, 1, max) - 1;

	// nfd: fixed date of the rolled date
	long nfd = monthDay1st + value * 7 + dow;

	// Unlike WEEK_OF_YEAR, we need to change day of week if the
	// nfd is out of the month.
	if (nfd < month1) {
	nfd = month1;
	} else if (nfd >= (month1 + monthLength)) {
	nfd = month1 + monthLength - 1;
	}
	int dayOfMonth;
	if (isCutoverYear) {
	// If we are in the cutover year, convert nfd to
	// its calendar date and use dayOfMonth.
	BaseCalendar.Date d = getCalendarDate(nfd);
	dayOfMonth = d.getDayOfMonth();
	} else {
	dayOfMonth = (int)(nfd - month1) + 1;
	}
	set(DAY_OF_MONTH, dayOfMonth);
	return;
	}

	case DAY_OF_MONTH:
	{
	if (!isCutoverYear(cdate.getNormalizedYear())) {
	max = calsys.getMonthLength(cdate);
	break;
	}

	// Cutover year handling
	long fd = getCurrentFixedDate();
	long month1 = getFixedDateMonth1(cdate, fd);
	// It may not be a regular month. Convert the date and range to
	// the relative values, perform the roll, and
	// convert the result back to the rolled date.
	int value = getRolledValue((int)(fd - month1), amount, 0, actualMonthLength() - 1);
	BaseCalendar.Date d = getCalendarDate(month1 + value);
	assert d.getMonth()-1 == internalGet(MONTH);
	set(DAY_OF_MONTH, d.getDayOfMonth());
	return;
	}

	case DAY_OF_YEAR:
	{
	max = getActualMaximum(field);
	if (!isCutoverYear(cdate.getNormalizedYear())) {
	break;
	}

	// Handle cutover here.
	long fd = getCurrentFixedDate();
	long jan1 = fd - internalGet(DAY_OF_YEAR) + 1;
	int value = getRolledValue((int)(fd - jan1) + 1, amount, min, max);
	BaseCalendar.Date d = getCalendarDate(jan1 + value - 1);
	set(MONTH, d.getMonth() - 1);
	set(DAY_OF_MONTH, d.getDayOfMonth());
	return;
	}

	case DAY_OF_WEEK:
	{
	if (!isCutoverYear(cdate.getNormalizedYear())) {
	// If the week of year is in the same year, we can
	// just change DAY_OF_WEEK.
	int weekOfYear = internalGet(WEEK_OF_YEAR);
	if (weekOfYear > 1 && weekOfYear < 52) {
	set(WEEK_OF_YEAR, weekOfYear); // update stamp[WEEK_OF_YEAR]
	max = SATURDAY;
	break;
	}
	}

	// We need to handle it in a different way around year
	// boundaries and in the cutover year. Note that
	// changing era and year values violates the roll
	// rule: not changing larger calendar fields...
	amount %= 7;
	if (amount == 0) {
	return;
	}
	long fd = getCurrentFixedDate();
	long dowFirst = BaseCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
	fd += amount;
	if (fd < dowFirst) {
	fd += 7;
	} else if (fd >= dowFirst + 7) {
	fd -= 7;
	}
	BaseCalendar.Date d = getCalendarDate(fd);
	set(ERA, (d.getNormalizedYear() <= 0 ? BCE : CE));
	set(d.getYear(), d.getMonth() - 1, d.getDayOfMonth());
	return;
	}

	case DAY_OF_WEEK_IN_MONTH:
	{
	min = 1; // after normalized, min should be 1.
	if (!isCutoverYear(cdate.getNormalizedYear())) {
	int dom = internalGet(DAY_OF_MONTH);
	int monthLength = calsys.getMonthLength(cdate);
	int lastDays = monthLength % 7;
	max = monthLength / 7;
	int x = (dom - 1) % 7;
	if (x < lastDays) {
	max++;
	}
	set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK));
	break;
	}

	// Cutover year handling
	long fd = getCurrentFixedDate();
	long month1 = getFixedDateMonth1(cdate, fd);
	int monthLength = actualMonthLength();
	int lastDays = monthLength % 7;
	max = monthLength / 7;
	int x = (int)(fd - month1) % 7;
	if (x < lastDays) {
	max++;
	}
	int value = getRolledValue(internalGet(field), amount, min, max) - 1;
	fd = month1 + value * 7 + x;
	BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
	BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
	cal.getCalendarDateFromFixedDate(d, fd);
	set(DAY_OF_MONTH, d.getDayOfMonth());
	return;
	}
	}

	set(field, getRolledValue(internalGet(field), amount, min, max));
	}

	/**
	* Returns the minimum value for the given calendar field of this
	* <code>GregorianCalendar</code> instance. The minimum value is
	* defined as the smallest value returned by the {@link
	* Calendar#get(int) get} method for any possible time value,
	* taking into consideration the current values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	*
	* @param field the calendar field.
	* @return the minimum value for the given calendar field.
	* @see #getMaximum(int)
	* @see #getGreatestMinimum(int)
	* @see #getLeastMaximum(int)
	* @see #getActualMinimum(int)
	* @see #getActualMaximum(int)
	*/
	@Override
	public int getMinimum(int field) {
	return MIN_VALUES[field];
	}

	/**
	* Returns the maximum value for the given calendar field of this
	* <code>GregorianCalendar</code> instance. The maximum value is
	* defined as the largest value returned by the {@link
	* Calendar#get(int) get} method for any possible time value,
	* taking into consideration the current values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	*
	* @param field the calendar field.
	* @return the maximum value for the given calendar field.
	* @see #getMinimum(int)
	* @see #getGreatestMinimum(int)
	* @see #getLeastMaximum(int)
	* @see #getActualMinimum(int)
	* @see #getActualMaximum(int)
	*/
	@Override
	public int getMaximum(int field) {
	switch (field) {
	case MONTH:
	case DAY_OF_MONTH:
	case DAY_OF_YEAR:
	case WEEK_OF_YEAR:
	case WEEK_OF_MONTH:
	case DAY_OF_WEEK_IN_MONTH:
	case YEAR:
	{
	// On or after Gregorian 200-3-1, Julian and Gregorian
	// calendar dates are the same or Gregorian dates are
	// larger (i.e., there is a "gap") after 300-3-1.
	if (gregorianCutoverYear > 200) {
	break;
	}
	// There might be "overlapping" dates.
	GregorianCalendar gc = (GregorianCalendar) clone();
	gc.setLenient(true);
	gc.setTimeInMillis(gregorianCutover);
	int v1 = gc.getActualMaximum(field);
	gc.setTimeInMillis(gregorianCutover-1);
	int v2 = gc.getActualMaximum(field);
	return Math.max(MAX_VALUES[field], Math.max(v1, v2));
	}
	}
	return MAX_VALUES[field];
	}

	/**
	* Returns the highest minimum value for the given calendar field
	* of this <code>GregorianCalendar</code> instance. The highest
	* minimum value is defined as the largest value returned by
	* {@link #getActualMinimum(int)} for any possible time value,
	* taking into consideration the current values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	*
	* @param field the calendar field.
	* @return the highest minimum value for the given calendar field.
	* @see #getMinimum(int)
	* @see #getMaximum(int)
	* @see #getLeastMaximum(int)
	* @see #getActualMinimum(int)
	* @see #getActualMaximum(int)
	*/
	@Override
	public int getGreatestMinimum(int field) {
	if (field == DAY_OF_MONTH) {
	BaseCalendar.Date d = getGregorianCutoverDate();
	long mon1 = getFixedDateMonth1(d, gregorianCutoverDate);
	d = getCalendarDate(mon1);
	return Math.max(MIN_VALUES[field], d.getDayOfMonth());
	}
	return MIN_VALUES[field];
	}

	/**
	* Returns the lowest maximum value for the given calendar field
	* of this <code>GregorianCalendar</code> instance. The lowest
	* maximum value is defined as the smallest value returned by
	* {@link #getActualMaximum(int)} for any possible time value,
	* taking into consideration the current values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	*
	* @param field the calendar field
	* @return the lowest maximum value for the given calendar field.
	* @see #getMinimum(int)
	* @see #getMaximum(int)
	* @see #getGreatestMinimum(int)
	* @see #getActualMinimum(int)
	* @see #getActualMaximum(int)
	*/
	@Override
	public int getLeastMaximum(int field) {
	switch (field) {
	case MONTH:
	case DAY_OF_MONTH:
	case DAY_OF_YEAR:
	case WEEK_OF_YEAR:
	case WEEK_OF_MONTH:
	case DAY_OF_WEEK_IN_MONTH:
	case YEAR:
	{
	GregorianCalendar gc = (GregorianCalendar) clone();
	gc.setLenient(true);
	gc.setTimeInMillis(gregorianCutover);
	int v1 = gc.getActualMaximum(field);
	gc.setTimeInMillis(gregorianCutover-1);
	int v2 = gc.getActualMaximum(field);
	return Math.min(LEAST_MAX_VALUES[field], Math.min(v1, v2));
	}
	}
	return LEAST_MAX_VALUES[field];
	}

	/**
	* Returns the minimum value that this calendar field could have,
	* taking into consideration the given time value and the current
	* values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	*
	* <p>For example, if the Gregorian change date is January 10,
	* 1970 and the date of this <code>GregorianCalendar</code> is
	* January 20, 1970, the actual minimum value of the
	* <code>DAY_OF_MONTH</code> field is 10 because the previous date
	* of January 10, 1970 is December 27, 1996 (in the Julian
	* calendar). Therefore, December 28, 1969 to January 9, 1970
	* don't exist.
	*
	* @param field the calendar field
	* @return the minimum of the given field for the time value of
	* this <code>GregorianCalendar</code>
	* @see #getMinimum(int)
	* @see #getMaximum(int)
	* @see #getGreatestMinimum(int)
	* @see #getLeastMaximum(int)
	* @see #getActualMaximum(int)
	* @since 1.2
	*/
	@Override
	public int getActualMinimum(int field) {
	if (field == DAY_OF_MONTH) {
	GregorianCalendar gc = getNormalizedCalendar();
	int year = gc.cdate.getNormalizedYear();
	if (year == gregorianCutoverYear \|\| year == gregorianCutoverYearJulian) {
	long month1 = getFixedDateMonth1(gc.cdate, gc.calsys.getFixedDate(gc.cdate));
	BaseCalendar.Date d = getCalendarDate(month1);
	return d.getDayOfMonth();
	}
	}
	return getMinimum(field);
	}

	/**
	* Returns the maximum value that this calendar field could have,
	* taking into consideration the given time value and the current
	* values of the
	* {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
	* {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
	* {@link #getGregorianChange() getGregorianChange} and
	* {@link Calendar#getTimeZone() getTimeZone} methods.
	* For example, if the date of this instance is February 1, 2004,
	* the actual maximum value of the <code>DAY_OF_MONTH</code> field
	* is 29 because 2004 is a leap year, and if the date of this
	* instance is February 1, 2005, it's 28.
	*
	* <p>This method calculates the maximum value of {@link
	* Calendar#WEEK_OF_YEAR WEEK_OF_YEAR} based on the {@link
	* Calendar#YEAR YEAR} (calendar year) value, not the <a
	* href="#week_year">week year</a>. Call {@link
	* #getWeeksInWeekYear()} to get the maximum value of {@code
	* WEEK_OF_YEAR} in the week year of this {@code GregorianCalendar}.
	*
	* @param field the calendar field
	* @return the maximum of the given field for the time value of
	* this <code>GregorianCalendar</code>
	* @see #getMinimum(int)
	* @see #getMaximum(int)
	* @see #getGreatestMinimum(int)
	* @see #getLeastMaximum(int)
	* @see #getActualMinimum(int)
	* @since 1.2
	*/
	@Override
	public int getActualMaximum(int field) {
	final int fieldsForFixedMax = ERA_MASK\|DAY_OF_WEEK_MASK\|HOUR_MASK\|AM_PM_MASK\|
	HOUR_OF_DAY_MASK\|MINUTE_MASK\|SECOND_MASK\|MILLISECOND_MASK\|
	ZONE_OFFSET_MASK\|DST_OFFSET_MASK;
	if ((fieldsForFixedMax & (1<<field)) != 0) {
	return getMaximum(field);
	}

	GregorianCalendar gc = getNormalizedCalendar();
	BaseCalendar.Date date = gc.cdate;
	BaseCalendar cal = gc.calsys;
	int normalizedYear = date.getNormalizedYear();

	int value = -1;
	switch (field) {
	case MONTH:
	{
	if (!gc.isCutoverYear(normalizedYear)) {
	value = DECEMBER;
	break;
	}

	// January 1 of the next year may or may not exist.
	long nextJan1;
	do {
	nextJan1 = gcal.getFixedDate(++normalizedYear, BaseCalendar.JANUARY, 1, null);
	} while (nextJan1 < gregorianCutoverDate);
	BaseCalendar.Date d = (BaseCalendar.Date) date.clone();
	cal.getCalendarDateFromFixedDate(d, nextJan1 - 1);
	value = d.getMonth() - 1;
	}
	break;

	case DAY_OF_MONTH:
	{
	value = cal.getMonthLength(date);
	if (!gc.isCutoverYear(normalizedYear) \|\| date.getDayOfMonth() == value) {
	break;
	}

	// Handle cutover year.
	long fd = gc.getCurrentFixedDate();
	if (fd >= gregorianCutoverDate) {
	break;
	}
	int monthLength = gc.actualMonthLength();
	long monthEnd = gc.getFixedDateMonth1(gc.cdate, fd) + monthLength - 1;
	// Convert the fixed date to its calendar date.
	BaseCalendar.Date d = gc.getCalendarDate(monthEnd);
	value = d.getDayOfMonth();
	}
	break;

	case DAY_OF_YEAR:
	{
	if (!gc.isCutoverYear(normalizedYear)) {
	value = cal.getYearLength(date);
	break;
	}

	// Handle cutover year.
	long jan1;
	if (gregorianCutoverYear == gregorianCutoverYearJulian) {
	BaseCalendar cocal = gc.getCutoverCalendarSystem();
	jan1 = cocal.getFixedDate(normalizedYear, 1, 1, null);
	} else if (normalizedYear == gregorianCutoverYearJulian) {
	jan1 = cal.getFixedDate(normalizedYear, 1, 1, null);
	} else {
	jan1 = gregorianCutoverDate;
	}
	// January 1 of the next year may or may not exist.
	long nextJan1 = gcal.getFixedDate(++normalizedYear, 1, 1, null);
	if (nextJan1 < gregorianCutoverDate) {
	nextJan1 = gregorianCutoverDate;
	}
	assert jan1 <= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(),
	date.getDayOfMonth(), date);
	assert nextJan1 >= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(),
	date.getDayOfMonth(), date);
	value = (int)(nextJan1 - jan1);
	}
	break;

	case WEEK_OF_YEAR:
	{
	if (!gc.isCutoverYear(normalizedYear)) {
	// Get the day of week of January 1 of the year
	CalendarDate d = cal.newCalendarDate(TimeZone.NO_TIMEZONE);
	d.setDate(date.getYear(), BaseCalendar.JANUARY, 1);
	int dayOfWeek = cal.getDayOfWeek(d);
	// Normalize the day of week with the firstDayOfWeek value
	dayOfWeek -= getFirstDayOfWeek();
	if (dayOfWeek < 0) {
	dayOfWeek += 7;
	}
	value = 52;
	int magic = dayOfWeek + getMinimalDaysInFirstWeek() - 1;
	if ((magic == 6) \|\|
	(date.isLeapYear() && (magic == 5 \|\| magic == 12))) {
	value++;
	}
	break;
	}

	if (gc == this) {
	gc = (GregorianCalendar) gc.clone();
	}
	int maxDayOfYear = getActualMaximum(DAY_OF_YEAR);
	gc.set(DAY_OF_YEAR, maxDayOfYear);
	value = gc.get(WEEK_OF_YEAR);
	if (internalGet(YEAR) != gc.getWeekYear()) {
	gc.set(DAY_OF_YEAR, maxDayOfYear - 7);
	value = gc.get(WEEK_OF_YEAR);
	}
	}
	break;

	case WEEK_OF_MONTH:
	{
	if (!gc.isCutoverYear(normalizedYear)) {
	CalendarDate d = cal.newCalendarDate(null);
	d.setDate(date.getYear(), date.getMonth(), 1);
	int dayOfWeek = cal.getDayOfWeek(d);
	int monthLength = cal.getMonthLength(d);
	dayOfWeek -= getFirstDayOfWeek();
	if (dayOfWeek < 0) {
	dayOfWeek += 7;
	}
	int nDaysFirstWeek = 7 - dayOfWeek; // # of days in the first week
	value = 3;
	if (nDaysFirstWeek >= getMinimalDaysInFirstWeek()) {
	value++;
	}
	monthLength -= nDaysFirstWeek + 7 * 3;
	if (monthLength > 0) {
	value++;
	if (monthLength > 7) {
	value++;
	}
	}
	break;
	}

	// Cutover year handling
	if (gc == this) {
	gc = (GregorianCalendar) gc.clone();
	}
	int y = gc.internalGet(YEAR);
	int m = gc.internalGet(MONTH);
	do {
	value = gc.get(WEEK_OF_MONTH);
	gc.add(WEEK_OF_MONTH, +1);
	} while (gc.get(YEAR) == y && gc.get(MONTH) == m);
	}
	break;

	case DAY_OF_WEEK_IN_MONTH:
	{
	// may be in the Gregorian cutover month
	int ndays, dow1;
	int dow = date.getDayOfWeek();
	if (!gc.isCutoverYear(normalizedYear)) {
	BaseCalendar.Date d = (BaseCalendar.Date) date.clone();
	ndays = cal.getMonthLength(d);
	d.setDayOfMonth(1);
	cal.normalize(d);
	dow1 = d.getDayOfWeek();
	} else {
	// Let a cloned GregorianCalendar take care of the cutover cases.
	if (gc == this) {
	gc = (GregorianCalendar) clone();
	}
	ndays = gc.actualMonthLength();
	gc.set(DAY_OF_MONTH, gc.getActualMinimum(DAY_OF_MONTH));
	dow1 = gc.get(DAY_OF_WEEK);
	}
	int x = dow - dow1;
	if (x < 0) {
	x += 7;
	}
	ndays -= x;
	value = (ndays + 6) / 7;
	}
	break;

	case YEAR:
	/* The year computation is no different, in principle, from the
	* others, however, the range of possible maxima is large. In
	* addition, the way we know we've exceeded the range is different.
	* For these reasons, we use the special case code below to handle
	* this field.
	*
	* The actual maxima for YEAR depend on the type of calendar:
	*
	* Gregorian = May 17, 292275056 BCE - Aug 17, 292278994 CE
	* Julian = Dec 2, 292269055 BCE - Jan 3, 292272993 CE
	* Hybrid = Dec 2, 292269055 BCE - Aug 17, 292278994 CE
	*
	* We know we've exceeded the maximum when either the month, date,
	* time, or era changes in response to setting the year. We don't
	* check for month, date, and time here because the year and era are
	* sufficient to detect an invalid year setting. NOTE: If code is
	* added to check the month and date in the future for some reason,
	* Feb 29 must be allowed to shift to Mar 1 when setting the year.
	*/
	{
	if (gc == this) {
	gc = (GregorianCalendar) clone();
	}

	// Calculate the millisecond offset from the beginning
	// of the year of this calendar and adjust the max
	// year value if we are beyond the limit in the max
	// year.
	long current = gc.getYearOffsetInMillis();

	if (gc.internalGetEra() == CE) {
	gc.setTimeInMillis(Long.MAX_VALUE);
	value = gc.get(YEAR);
	long maxEnd = gc.getYearOffsetInMillis();
	if (current > maxEnd) {
	value--;
	}
	} else {
	CalendarSystem mincal = gc.getTimeInMillis() >= gregorianCutover ?
	gcal : getJulianCalendarSystem();
	CalendarDate d = mincal.getCalendarDate(Long.MIN_VALUE, getZone());
	long maxEnd = (cal.getDayOfYear(d) - 1) * 24 + d.getHours();
	maxEnd *= 60;
	maxEnd += d.getMinutes();
	maxEnd *= 60;
	maxEnd += d.getSeconds();
	maxEnd *= 1000;
	maxEnd += d.getMillis();
	value = d.getYear();
	if (value <= 0) {
	assert mincal == gcal;
	value = 1 - value;
	}
	if (current < maxEnd) {
	value--;
	}
	}
	}
	break;

	default:
	throw new ArrayIndexOutOfBoundsException(field);
	}
	return value;
	}

	/**
	* Returns the millisecond offset from the beginning of this
	* year. This Calendar object must have been normalized.
	*/
	private long getYearOffsetInMillis() {
	long t = (internalGet(DAY_OF_YEAR) - 1) * 24;
	t += internalGet(HOUR_OF_DAY);
	t *= 60;
	t += internalGet(MINUTE);
	t *= 60;
	t += internalGet(SECOND);
	t *= 1000;
	return t + internalGet(MILLISECOND) -
	(internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET));
	}

	@Override
	public Object clone()
	{
	GregorianCalendar other = (GregorianCalendar) super.clone();

	other.gdate = (BaseCalendar.Date) gdate.clone();
	if (cdate != null) {
	if (cdate != gdate) {
	other.cdate = (BaseCalendar.Date) cdate.clone();
	} else {
	other.cdate = other.gdate;
	}
	}
	other.originalFields = null;
	other.zoneOffsets = null;
	return other;
	}

	@Override
	public TimeZone getTimeZone() {
	TimeZone zone = super.getTimeZone();
	// To share the zone by CalendarDates
	gdate.setZone(zone);
	if (cdate != null && cdate != gdate) {
	cdate.setZone(zone);
	}
	return zone;
	}

	@Override
	public void setTimeZone(TimeZone zone) {
	super.setTimeZone(zone);
	// To share the zone by CalendarDates
	gdate.setZone(zone);
	if (cdate != null && cdate != gdate) {
	cdate.setZone(zone);
	}
	}

	/**
	* Returns {@code true} indicating this {@code GregorianCalendar}
	* supports week dates.
	*
	* @return {@code true} (always)
	* @see #getWeekYear()
	* @see #setWeekDate(int,int,int)
	* @see #getWeeksInWeekYear()
	* @since 1.7
	*/
	@Override
	public final boolean isWeekDateSupported() {
	return true;
	}

	/**
	* Returns the <a href="#week_year">week year</a> represented by this
	* {@code GregorianCalendar}. The dates in the weeks between 1 and the
	* maximum week number of the week year have the same week year value
	* that may be one year before or after the {@link Calendar#YEAR YEAR}
	* (calendar year) value.
	*
	* <p>This method calls {@link Calendar#complete()} before
	* calculating the week year.
	*
	* @return the week year represented by this {@code GregorianCalendar}.
	* If the {@link Calendar#ERA ERA} value is {@link #BC}, the year is
	* represented by 0 or a negative number: BC 1 is 0, BC 2
	* is -1, BC 3 is -2, and so on.
	* @throws IllegalArgumentException
	* if any of the calendar fields is invalid in non-lenient mode.
	* @see #isWeekDateSupported()
	* @see #getWeeksInWeekYear()
	* @see Calendar#getFirstDayOfWeek()
	* @see Calendar#getMinimalDaysInFirstWeek()
	* @since 1.7
	*/
	@Override
	public int getWeekYear() {
	int year = get(YEAR); // implicitly calls complete()
	if (internalGetEra() == BCE) {
	year = 1 - year;
	}

	// Fast path for the Gregorian calendar years that are never
	// affected by the Julian-Gregorian transition
	if (year > gregorianCutoverYear + 1) {
	int weekOfYear = internalGet(WEEK_OF_YEAR);
	if (internalGet(MONTH) == JANUARY) {
	if (weekOfYear >= 52) {
	--year;
	}
	} else {
	if (weekOfYear == 1) {
	++year;
	}
	}
	return year;
	}

	// General (slow) path
	int dayOfYear = internalGet(DAY_OF_YEAR);
	int maxDayOfYear = getActualMaximum(DAY_OF_YEAR);
	int minimalDays = getMinimalDaysInFirstWeek();

	// Quickly check the possibility of year adjustments before
	// cloning this GregorianCalendar.
	if (dayOfYear > minimalDays && dayOfYear < (maxDayOfYear - 6)) {
	return year;
	}

	// Create a clone to work on the calculation
	GregorianCalendar cal = (GregorianCalendar) clone();
	cal.setLenient(true);
	// Use GMT so that intermediate date calculations won't
	// affect the time of day fields.
	cal.setTimeZone(TimeZone.getTimeZone("GMT"));
	// Go to the first day of the year, which is usually January 1.
	cal.set(DAY_OF_YEAR, 1);
	cal.complete();

	// Get the first day of the first day-of-week in the year.
	int delta = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK);
	if (delta != 0) {
	if (delta < 0) {
	delta += 7;
	}
	cal.add(DAY_OF_YEAR, delta);
	}
	int minDayOfYear = cal.get(DAY_OF_YEAR);
	if (dayOfYear < minDayOfYear) {
	if (minDayOfYear <= minimalDays) {
	--year;
	}
	} else {
	cal.set(YEAR, year + 1);
	cal.set(DAY_OF_YEAR, 1);
	cal.complete();
	int del = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK);
	if (del != 0) {
	if (del < 0) {
	del += 7;
	}
	cal.add(DAY_OF_YEAR, del);
	}
	minDayOfYear = cal.get(DAY_OF_YEAR) - 1;
	if (minDayOfYear == 0) {
	minDayOfYear = 7;
	}
	if (minDayOfYear >= minimalDays) {
	int days = maxDayOfYear - dayOfYear + 1;
	if (days <= (7 - minDayOfYear)) {
	++year;
	}
	}
	}
	return year;
	}

	/**
	* Sets this {@code GregorianCalendar} to the date given by the
	* date specifiers - <a href="#week_year">{@code weekYear}</a>,
	* {@code weekOfYear}, and {@code dayOfWeek}. {@code weekOfYear}
	* follows the <a href="#week_and_year">{@code WEEK_OF_YEAR}
	* numbering</a>. The {@code dayOfWeek} value must be one of the
	* {@link Calendar#DAY_OF_WEEK DAY_OF_WEEK} values: {@link
	* Calendar#SUNDAY SUNDAY} to {@link Calendar#SATURDAY SATURDAY}.
	*
	* <p>Note that the numeric day-of-week representation differs from
	* the ISO 8601 standard, and that the {@code weekOfYear}
	* numbering is compatible with the standard when {@code
	* getFirstDayOfWeek()} is {@code MONDAY} and {@code
	* getMinimalDaysInFirstWeek()} is 4.
	*
	* <p>Unlike the {@code set} method, all of the calendar fields
	* and the instant of time value are calculated upon return.
	*
	* <p>If {@code weekOfYear} is out of the valid week-of-year
	* range in {@code weekYear}, the {@code weekYear}
	* and {@code weekOfYear} values are adjusted in lenient
	* mode, or an {@code IllegalArgumentException} is thrown in
	* non-lenient mode.
	*
	* @param weekYear the week year
	* @param weekOfYear the week number based on {@code weekYear}
	* @param dayOfWeek the day of week value: one of the constants
	* for the {@link #DAY_OF_WEEK DAY_OF_WEEK} field:
	* {@link Calendar#SUNDAY SUNDAY}, ...,
	* {@link Calendar#SATURDAY SATURDAY}.
	* @exception IllegalArgumentException
	* if any of the given date specifiers is invalid,
	* or if any of the calendar fields are inconsistent
	* with the given date specifiers in non-lenient mode
	* @see GregorianCalendar#isWeekDateSupported()
	* @see Calendar#getFirstDayOfWeek()
	* @see Calendar#getMinimalDaysInFirstWeek()
	* @since 1.7
	*/
	@Override
	public void setWeekDate(int weekYear, int weekOfYear, int dayOfWeek) {
	if (dayOfWeek < SUNDAY \|\| dayOfWeek > SATURDAY) {
	throw new IllegalArgumentException("invalid dayOfWeek: " + dayOfWeek);
	}

	// To avoid changing the time of day fields by date
	// calculations, use a clone with the GMT time zone.
	GregorianCalendar gc = (GregorianCalendar) clone();
	gc.setLenient(true);
	int era = gc.get(ERA);
	gc.clear();
	gc.setTimeZone(TimeZone.getTimeZone("GMT"));
	gc.set(ERA, era);
	gc.set(YEAR, weekYear);
	gc.set(WEEK_OF_YEAR, 1);
	gc.set(DAY_OF_WEEK, getFirstDayOfWeek());
	int days = dayOfWeek - getFirstDayOfWeek();
	if (days < 0) {
	days += 7;
	}
	days += 7 * (weekOfYear - 1);
	if (days != 0) {
	gc.add(DAY_OF_YEAR, days);
	} else {
	gc.complete();
	}

	if (!isLenient() &&
	(gc.getWeekYear() != weekYear
	\|\| gc.internalGet(WEEK_OF_YEAR) != weekOfYear
	\|\| gc.internalGet(DAY_OF_WEEK) != dayOfWeek)) {
	throw new IllegalArgumentException();
	}

	set(ERA, gc.internalGet(ERA));
	set(YEAR, gc.internalGet(YEAR));
	set(MONTH, gc.internalGet(MONTH));
	set(DAY_OF_MONTH, gc.internalGet(DAY_OF_MONTH));

	// to avoid throwing an IllegalArgumentException in
	// non-lenient, set WEEK_OF_YEAR internally
	internalSet(WEEK_OF_YEAR, weekOfYear);
	complete();
	}

	/**
	* Returns the number of weeks in the <a href="#week_year">week year</a>
	* represented by this {@code GregorianCalendar}.
	*
	* <p>For example, if this {@code GregorianCalendar}'s date is
	* December 31, 2008 with <a href="#iso8601_compatible_setting">the ISO
	* 8601 compatible setting</a>, this method will return 53 for the
	* period: December 29, 2008 to January 3, 2010 while {@link
	* #getActualMaximum(int) getActualMaximum(WEEK_OF_YEAR)} will return
	* 52 for the period: December 31, 2007 to December 28, 2008.
	*
	* @return the number of weeks in the week year.
	* @see Calendar#WEEK_OF_YEAR
	* @see #getWeekYear()
	* @see #getActualMaximum(int)
	* @since 1.7
	*/
	@Override
	public int getWeeksInWeekYear() {
	GregorianCalendar gc = getNormalizedCalendar();
	int weekYear = gc.getWeekYear();
	if (weekYear == gc.internalGet(YEAR)) {
	return gc.getActualMaximum(WEEK_OF_YEAR);
	}

	// Use the 2nd week for calculating the max of WEEK_OF_YEAR
	if (gc == this) {
	gc = (GregorianCalendar) gc.clone();
	}
	gc.setWeekDate(weekYear, 2, internalGet(DAY_OF_WEEK));
	return gc.getActualMaximum(WEEK_OF_YEAR);
	}

	/////////////////////////////
	// Time => Fields computation
	/////////////////////////////

	/**
	* The fixed date corresponding to gdate. If the value is
	* Long.MIN_VALUE, the fixed date value is unknown. Currently,
	* Julian calendar dates are not cached.
	*/
	private transient long cachedFixedDate = Long.MIN_VALUE;

	/**
	* Converts the time value (millisecond offset from the <a
	* href="Calendar.html#Epoch">Epoch</a>) to calendar field values.
	* The time is <em>not</em>
	* recomputed first; to recompute the time, then the fields, call the
	* <code>complete</code> method.
	*
	* @see Calendar#complete
	*/
	@Override
	protected void computeFields() {
	int mask;
	if (isPartiallyNormalized()) {
	// Determine which calendar fields need to be computed.
	mask = getSetStateFields();
	int fieldMask = ~mask & ALL_FIELDS;
	// We have to call computTime in case calsys == null in
	// order to set calsys and cdate. (6263644)
	if (fieldMask != 0 \|\| calsys == null) {
	mask \|= computeFields(fieldMask,
	mask & (ZONE_OFFSET_MASK\|DST_OFFSET_MASK));
	assert mask == ALL_FIELDS;
	}
	} else {
	mask = ALL_FIELDS;
	computeFields(mask, 0);
	}
	// After computing all the fields, set the field state to `COMPUTED'.
	setFieldsComputed(mask);
	}

	/**
	* This computeFields implements the conversion from UTC
	* (millisecond offset from the Epoch) to calendar
	* field values. fieldMask specifies which fields to change the
	* setting state to COMPUTED, although all fields are set to
	* the correct values. This is required to fix 4685354.
	*
	* @param fieldMask a bit mask to specify which fields to change
	* the setting state.
	* @param tzMask a bit mask to specify which time zone offset
	* fields to be used for time calculations
	* @return a new field mask that indicates what field values have
	* actually been set.
	*/
	private int computeFields(int fieldMask, int tzMask) {
	int zoneOffset = 0;
	TimeZone tz = getZone();
	if (zoneOffsets == null) {
	zoneOffsets = new int[2];
	}
	if (tzMask != (ZONE_OFFSET_MASK\|DST_OFFSET_MASK)) {
	if (tz instanceof ZoneInfo) {
	zoneOffset = ((ZoneInfo)tz).getOffsets(time, zoneOffsets);
	} else {
	zoneOffset = tz.getOffset(time);
	zoneOffsets[0] = tz.getRawOffset();
	zoneOffsets[1] = zoneOffset - zoneOffsets[0];
	}
	}
	if (tzMask != 0) {
	if (isFieldSet(tzMask, ZONE_OFFSET)) {
	zoneOffsets[0] = internalGet(ZONE_OFFSET);
	}
	if (isFieldSet(tzMask, DST_OFFSET)) {
	zoneOffsets[1] = internalGet(DST_OFFSET);
	}
	zoneOffset = zoneOffsets[0] + zoneOffsets[1];
	}

	// By computing time and zoneOffset separately, we can take
	// the wider range of time+zoneOffset than the previous
	// implementation.
	long fixedDate = zoneOffset / ONE_DAY;
	int timeOfDay = zoneOffset % (int)ONE_DAY;
	fixedDate += time / ONE_DAY;
	timeOfDay += (int) (time % ONE_DAY);
	if (timeOfDay >= ONE_DAY) {
	timeOfDay -= ONE_DAY;
	++fixedDate;
	} else {
	while (timeOfDay < 0) {
	timeOfDay += ONE_DAY;
	--fixedDate;
	}
	}
	fixedDate += EPOCH_OFFSET;

	int era = CE;
	int year;
	if (fixedDate >= gregorianCutoverDate) {
	// Handle Gregorian dates.
	assert cachedFixedDate == Long.MIN_VALUE \|\| gdate.isNormalized()
	: "cache control: not normalized";
	assert cachedFixedDate == Long.MIN_VALUE \|\|
	gcal.getFixedDate(gdate.getNormalizedYear(),
	gdate.getMonth(),
	gdate.getDayOfMonth(), gdate)
	== cachedFixedDate
	: "cache control: inconsictency" +
	", cachedFixedDate=" + cachedFixedDate +
	", computed=" +
	gcal.getFixedDate(gdate.getNormalizedYear(),
	gdate.getMonth(),
	gdate.getDayOfMonth(),
	gdate) +
	", date=" + gdate;

	// See if we can use gdate to avoid date calculation.
	if (fixedDate != cachedFixedDate) {
	gcal.getCalendarDateFromFixedDate(gdate, fixedDate);
	cachedFixedDate = fixedDate;
	}

	year = gdate.getYear();
	if (year <= 0) {
	year = 1 - year;
	era = BCE;
	}
	calsys = gcal;
	cdate = gdate;
	assert cdate.getDayOfWeek() > 0 : "dow="+cdate.getDayOfWeek()+", date="+cdate;
	} else {
	// Handle Julian calendar dates.
	calsys = getJulianCalendarSystem();
	cdate = (BaseCalendar.Date) jcal.newCalendarDate(getZone());
	jcal.getCalendarDateFromFixedDate(cdate, fixedDate);
	Era e = cdate.getEra();
	if (e == jeras[0]) {
	era = BCE;
	}
	year = cdate.getYear();
	}

	// Always set the ERA and YEAR values.
	internalSet(ERA, era);
	internalSet(YEAR, year);
	int mask = fieldMask \| (ERA_MASK\|YEAR_MASK);

	int month = cdate.getMonth() - 1; // 0-based
	int dayOfMonth = cdate.getDayOfMonth();

	// Set the basic date fields.
	if ((fieldMask & (MONTH_MASK\|DAY_OF_MONTH_MASK\|DAY_OF_WEEK_MASK))
	!= 0) {
	internalSet(MONTH, month);
	internalSet(DAY_OF_MONTH, dayOfMonth);
	internalSet(DAY_OF_WEEK, cdate.getDayOfWeek());
	mask \|= MONTH_MASK\|DAY_OF_MONTH_MASK\|DAY_OF_WEEK_MASK;
	}

	if ((fieldMask & (HOUR_OF_DAY_MASK\|AM_PM_MASK\|HOUR_MASK
	\|MINUTE_MASK\|SECOND_MASK\|MILLISECOND_MASK)) != 0) {
	if (timeOfDay != 0) {
	int hours = timeOfDay / ONE_HOUR;
	internalSet(HOUR_OF_DAY, hours);
	internalSet(AM_PM, hours / 12); // Assume AM == 0
	internalSet(HOUR, hours % 12);
	int r = timeOfDay % ONE_HOUR;
	internalSet(MINUTE, r / ONE_MINUTE);
	r %= ONE_MINUTE;
	internalSet(SECOND, r / ONE_SECOND);
	internalSet(MILLISECOND, r % ONE_SECOND);
	} else {
	internalSet(HOUR_OF_DAY, 0);
	internalSet(AM_PM, AM);
	internalSet(HOUR, 0);
	internalSet(MINUTE, 0);
	internalSet(SECOND, 0);
	internalSet(MILLISECOND, 0);
	}
	mask \|= (HOUR_OF_DAY_MASK\|AM_PM_MASK\|HOUR_MASK
	\|MINUTE_MASK\|SECOND_MASK\|MILLISECOND_MASK);
	}

	if ((fieldMask & (ZONE_OFFSET_MASK\|DST_OFFSET_MASK)) != 0) {
	internalSet(ZONE_OFFSET, zoneOffsets[0]);
	internalSet(DST_OFFSET, zoneOffsets[1]);
	mask \|= (ZONE_OFFSET_MASK\|DST_OFFSET_MASK);
	}

	if ((fieldMask & (DAY_OF_YEAR_MASK\|WEEK_OF_YEAR_MASK\|WEEK_OF_MONTH_MASK\|DAY_OF_WEEK_IN_MONTH_MASK)) != 0) {
	int normalizedYear = cdate.getNormalizedYear();
	long fixedDateJan1 = calsys.getFixedDate(normalizedYear, 1, 1, cdate);
	int dayOfYear = (int)(fixedDate - fixedDateJan1) + 1;
	long fixedDateMonth1 = fixedDate - dayOfMonth + 1;
	int cutoverGap = 0;
	int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian;
	int relativeDayOfMonth = dayOfMonth - 1;

	// If we are in the cutover year, we need some special handling.
	if (normalizedYear == cutoverYear) {
	// Need to take care of the "missing" days.
	if (gregorianCutoverYearJulian <= gregorianCutoverYear) {
	// We need to find out where we are. The cutover
	// gap could even be more than one year. (One
	// year difference in ~48667 years.)
	fixedDateJan1 = getFixedDateJan1(cdate, fixedDate);
	if (fixedDate >= gregorianCutoverDate) {
	fixedDateMonth1 = getFixedDateMonth1(cdate, fixedDate);
	}
	}
	int realDayOfYear = (int)(fixedDate - fixedDateJan1) + 1;
	cutoverGap = dayOfYear - realDayOfYear;
	dayOfYear = realDayOfYear;
	relativeDayOfMonth = (int)(fixedDate - fixedDateMonth1);
	}
	internalSet(DAY_OF_YEAR, dayOfYear);
	internalSet(DAY_OF_WEEK_IN_MONTH, relativeDayOfMonth / 7 + 1);

	int weekOfYear = getWeekNumber(fixedDateJan1, fixedDate);

	// The spec is to calculate WEEK_OF_YEAR in the
	// ISO8601-style. This creates problems, though.
	if (weekOfYear == 0) {
	// If the date belongs to the last week of the
	// previous year, use the week number of "12/31" of
	// the "previous" year. Again, if the previous year is
	// the Gregorian cutover year, we need to take care of
	// it. Usually the previous day of January 1 is
	// December 31, which is not always true in
	// GregorianCalendar.
	long fixedDec31 = fixedDateJan1 - 1;
	long prevJan1 = fixedDateJan1 - 365;
	if (normalizedYear > (cutoverYear + 1)) {
	if (CalendarUtils.isGregorianLeapYear(normalizedYear - 1)) {
	--prevJan1;
	}
	} else if (normalizedYear <= gregorianCutoverYearJulian) {
	if (CalendarUtils.isJulianLeapYear(normalizedYear - 1)) {
	--prevJan1;
	}
	} else {
	BaseCalendar calForJan1 = calsys;
	//int prevYear = normalizedYear - 1;
	int prevYear = getCalendarDate(fixedDec31).getNormalizedYear();
	if (prevYear == gregorianCutoverYear) {
	calForJan1 = getCutoverCalendarSystem();
	if (calForJan1 == jcal) {
	prevJan1 = calForJan1.getFixedDate(prevYear,
	BaseCalendar.JANUARY,
	1,
	null);
	} else {
	prevJan1 = gregorianCutoverDate;
	calForJan1 = gcal;
	}
	} else if (prevYear <= gregorianCutoverYearJulian) {
	calForJan1 = getJulianCalendarSystem();
	prevJan1 = calForJan1.getFixedDate(prevYear,
	BaseCalendar.JANUARY,
	1,
	null);
	}
	}
	weekOfYear = getWeekNumber(prevJan1, fixedDec31);
	} else {
	if (normalizedYear > gregorianCutoverYear \|\|
	normalizedYear < (gregorianCutoverYearJulian - 1)) {
	// Regular years
	if (weekOfYear >= 52) {
	long nextJan1 = fixedDateJan1 + 365;
	if (cdate.isLeapYear()) {
	nextJan1++;
	}
	long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
	getFirstDayOfWeek());
	int ndays = (int)(nextJan1st - nextJan1);
	if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
	// The first days forms a week in which the date is included.
	weekOfYear = 1;
	}
	}
	} else {
	BaseCalendar calForJan1 = calsys;
	int nextYear = normalizedYear + 1;
	if (nextYear == (gregorianCutoverYearJulian + 1) &&
	nextYear < gregorianCutoverYear) {
	// In case the gap is more than one year.
	nextYear = gregorianCutoverYear;
	}
	if (nextYear == gregorianCutoverYear) {
	calForJan1 = getCutoverCalendarSystem();
	}

	long nextJan1;
	if (nextYear > gregorianCutoverYear
	\|\| gregorianCutoverYearJulian == gregorianCutoverYear
	\|\| nextYear == gregorianCutoverYearJulian) {
	nextJan1 = calForJan1.getFixedDate(nextYear,
	BaseCalendar.JANUARY,
	1,
	null);
	} else {
	nextJan1 = gregorianCutoverDate;
	calForJan1 = gcal;
	}

	long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
	getFirstDayOfWeek());
	int ndays = (int)(nextJan1st - nextJan1);
	if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
	// The first days forms a week in which the date is included.
	weekOfYear = 1;
	}
	}
	}
	internalSet(WEEK_OF_YEAR, weekOfYear);
	internalSet(WEEK_OF_MONTH, getWeekNumber(fixedDateMonth1, fixedDate));
	mask \|= (DAY_OF_YEAR_MASK\|WEEK_OF_YEAR_MASK\|WEEK_OF_MONTH_MASK\|DAY_OF_WEEK_IN_MONTH_MASK);
	}
	return mask;
	}

	/**
	* Returns the number of weeks in a period between fixedDay1 and
	* fixedDate. The getFirstDayOfWeek-getMinimalDaysInFirstWeek rule
	* is applied to calculate the number of weeks.
	*
	* @param fixedDay1 the fixed date of the first day of the period
	* @param fixedDate the fixed date of the last day of the period
	* @return the number of weeks of the given period
	*/
	private int getWeekNumber(long fixedDay1, long fixedDate) {
	// We can always use `gcal' since Julian and Gregorian are the
	// same thing for this calculation.
	long fixedDay1st = Gregorian.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
	getFirstDayOfWeek());
	int ndays = (int)(fixedDay1st - fixedDay1);
	assert ndays <= 7;
	if (ndays >= getMinimalDaysInFirstWeek()) {
	fixedDay1st -= 7;
	}
	int normalizedDayOfPeriod = (int)(fixedDate - fixedDay1st);
	if (normalizedDayOfPeriod >= 0) {
	return normalizedDayOfPeriod / 7 + 1;
	}
	return CalendarUtils.floorDivide(normalizedDayOfPeriod, 7) + 1;
	}

	/**
	* Converts calendar field values to the time value (millisecond
	* offset from the <a href="Calendar.html#Epoch">Epoch</a>).
	*
	* @exception IllegalArgumentException if any calendar fields are invalid.
	*/
	@Override
	protected void computeTime() {
	// In non-lenient mode, perform brief checking of calendar
	// fields which have been set externally. Through this
	// checking, the field values are stored in originalFields[]
	// to see if any of them are normalized later.
	if (!isLenient()) {
	if (originalFields == null) {
	originalFields = new int[FIELD_COUNT];
	}
	for (int field = 0; field < FIELD_COUNT; field++) {
	int value = internalGet(field);
	if (isExternallySet(field)) {
	// Quick validation for any out of range values
	if (value < getMinimum(field) \|\| value > getMaximum(field)) {
	throw new IllegalArgumentException(getFieldName(field));
	}
	}
	originalFields[field] = value;
	}
	}

	// Let the super class determine which calendar fields to be
	// used to calculate the time.
	int fieldMask = selectFields();

	// The year defaults to the epoch start. We don't check
	// fieldMask for YEAR because YEAR is a mandatory field to
	// determine the date.
	int year = isSet(YEAR) ? internalGet(YEAR) : EPOCH_YEAR;

	int era = internalGetEra();
	if (era == BCE) {
	year = 1 - year;
	} else if (era != CE) {
	// Even in lenient mode we disallow ERA values other than CE & BCE.
	// (The same normalization rule as add()/roll() could be
	// applied here in lenient mode. But this checking is kept
	// unchanged for compatibility as of 1.5.)
	throw new IllegalArgumentException("Invalid era");
	}

	// If year is 0 or negative, we need to set the ERA value later.
	if (year <= 0 && !isSet(ERA)) {
	fieldMask \|= ERA_MASK;
	setFieldsComputed(ERA_MASK);
	}

	// Calculate the time of day. We rely on the convention that
	// an UNSET field has 0.
	long timeOfDay = 0;
	if (isFieldSet(fieldMask, HOUR_OF_DAY)) {
	timeOfDay += (long) internalGet(HOUR_OF_DAY);
	} else {
	timeOfDay += internalGet(HOUR);
	// The default value of AM_PM is 0 which designates AM.
	if (isFieldSet(fieldMask, AM_PM)) {
	timeOfDay += 12 * internalGet(AM_PM);
	}
	}
	timeOfDay *= 60;
	timeOfDay += internalGet(MINUTE);
	timeOfDay *= 60;
	timeOfDay += internalGet(SECOND);
	timeOfDay *= 1000;
	timeOfDay += internalGet(MILLISECOND);

	// Convert the time of day to the number of days and the
	// millisecond offset from midnight.
	long fixedDate = timeOfDay / ONE_DAY;
	timeOfDay %= ONE_DAY;
	while (timeOfDay < 0) {
	timeOfDay += ONE_DAY;
	--fixedDate;
	}

	// Calculate the fixed date since January 1, 1 (Gregorian).
	calculateFixedDate: {
	long gfd, jfd;
	if (year > gregorianCutoverYear && year > gregorianCutoverYearJulian) {
	gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
	if (gfd >= gregorianCutoverDate) {
	fixedDate = gfd;
	break calculateFixedDate;
	}
	jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
	} else if (year < gregorianCutoverYear && year < gregorianCutoverYearJulian) {
	jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
	if (jfd < gregorianCutoverDate) {
	fixedDate = jfd;
	break calculateFixedDate;
	}
	gfd = jfd;
	} else {
	jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
	gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
	}

	// Now we have to determine which calendar date it is.

	// If the date is relative from the beginning of the year
	// in the Julian calendar, then use jfd;
	if (isFieldSet(fieldMask, DAY_OF_YEAR) \|\| isFieldSet(fieldMask, WEEK_OF_YEAR)) {
	if (gregorianCutoverYear == gregorianCutoverYearJulian) {
	fixedDate = jfd;
	break calculateFixedDate;
	} else if (year == gregorianCutoverYear) {
	fixedDate = gfd;
	break calculateFixedDate;
	}
	}

	if (gfd >= gregorianCutoverDate) {
	if (jfd >= gregorianCutoverDate) {
	fixedDate = gfd;
	} else {
	// The date is in an "overlapping" period. No way
	// to disambiguate it. Determine it using the
	// previous date calculation.
	if (calsys == gcal \|\| calsys == null) {
	fixedDate = gfd;
	} else {
	fixedDate = jfd;
	}
	}
	} else {
	if (jfd < gregorianCutoverDate) {
	fixedDate = jfd;
	} else {
	// The date is in a "missing" period.
	if (!isLenient()) {
	throw new IllegalArgumentException("the specified date doesn't exist");
	}
	// Take the Julian date for compatibility, which
	// will produce a Gregorian date.
	fixedDate = jfd;
	}
	}
	}

	// millis represents local wall-clock time in milliseconds.
	long millis = (fixedDate - EPOCH_OFFSET) * ONE_DAY + timeOfDay;

	// 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 transition into DST. Here, a designated time of 2:00 am - 2:59 am
	// can be in standard or in DST depending. However, 2:00 am is an invalid
	// representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST).
	// We assume standard time.
	// 2. The 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).
	// Again, we assume standard time.
	// We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
	// or DST_OFFSET fields; then we use those fields.
	TimeZone zone = getZone();
	if (zoneOffsets == null) {
	zoneOffsets = new int[2];
	}
	int tzMask = fieldMask & (ZONE_OFFSET_MASK\|DST_OFFSET_MASK);
	if (tzMask != (ZONE_OFFSET_MASK\|DST_OFFSET_MASK)) {
	if (zone instanceof ZoneInfo) {
	((ZoneInfo)zone).getOffsetsByWall(millis, zoneOffsets);
	} else {
	int gmtOffset = isFieldSet(fieldMask, ZONE_OFFSET) ?
	internalGet(ZONE_OFFSET) : zone.getRawOffset();
	zone.getOffsets(millis - gmtOffset, zoneOffsets);
	}
	}
	if (tzMask != 0) {
	if (isFieldSet(tzMask, ZONE_OFFSET)) {
	zoneOffsets[0] = internalGet(ZONE_OFFSET);
	}
	if (isFieldSet(tzMask, DST_OFFSET)) {
	zoneOffsets[1] = internalGet(DST_OFFSET);
	}
	}

	// Adjust the time zone offset values to get the UTC time.
	millis -= zoneOffsets[0] + zoneOffsets[1];

	// Set this calendar's time in milliseconds
	time = millis;

	int mask = computeFields(fieldMask \| getSetStateFields(), tzMask);

	if (!isLenient()) {
	for (int field = 0; field < FIELD_COUNT; field++) {
	if (!isExternallySet(field)) {
	continue;
	}
	if (originalFields[field] != internalGet(field)) {
	String s = originalFields[field] + " -> " + internalGet(field);
	// Restore the original field values
	System.arraycopy(originalFields, 0, fields, 0, fields.length);
	throw new IllegalArgumentException(getFieldName(field) + ": " + s);
	}
	}
	}
	setFieldsNormalized(mask);
	}

	/**
	* Computes the fixed date under either the Gregorian or the
	* Julian calendar, using the given year and the specified calendar fields.
	*
	* @param cal the CalendarSystem to be used for the date calculation
	* @param year the normalized year number, with 0 indicating the
	* year 1 BCE, -1 indicating 2 BCE, etc.
	* @param fieldMask the calendar fields to be used for the date calculation
	* @return the fixed date
	* @see Calendar#selectFields
	*/
	private long getFixedDate(BaseCalendar cal, int year, int fieldMask) {
	int month = JANUARY;
	if (isFieldSet(fieldMask, MONTH)) {
	// No need to check if MONTH has been set (no isSet(MONTH)
	// call) since its unset value happens to be JANUARY (0).
	month = internalGet(MONTH);

	// If the month is out of range, adjust it into range
	if (month > DECEMBER) {
	year += month / 12;
	month %= 12;
	} else if (month < JANUARY) {
	int[] rem = new int[1];
	year += CalendarUtils.floorDivide(month, 12, rem);
	month = rem[0];
	}
	}

	// Get the fixed date since Jan 1, 1 (Gregorian). We are on
	// the first day of either `month' or January in 'year'.
	long fixedDate = cal.getFixedDate(year, month + 1, 1,
	cal == gcal ? gdate : null);
	if (isFieldSet(fieldMask, MONTH)) {
	// Month-based calculations
	if (isFieldSet(fieldMask, DAY_OF_MONTH)) {
	// We are on the first day of the month. Just add the
	// offset if DAY_OF_MONTH is set. If the isSet call
	// returns false, that means DAY_OF_MONTH has been
	// selected just because of the selected
	// combination. We don't need to add any since the
	// default value is the 1st.
	if (isSet(DAY_OF_MONTH)) {
	// To avoid underflow with DAY_OF_MONTH-1, add
	// DAY_OF_MONTH, then subtract 1.
	fixedDate += internalGet(DAY_OF_MONTH);
	fixedDate--;
	}
	} else {
	if (isFieldSet(fieldMask, WEEK_OF_MONTH)) {
	long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
	getFirstDayOfWeek());
	// If we have enough days in the first week, then
	// move to the previous week.
	if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
	firstDayOfWeek -= 7;
	}
	if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
	firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
	internalGet(DAY_OF_WEEK));
	}
	// In lenient mode, we treat days of the previous
	// months as a part of the specified
	// WEEK_OF_MONTH. See 4633646.
	fixedDate = firstDayOfWeek + 7 * (internalGet(WEEK_OF_MONTH) - 1);
	} else {
	int dayOfWeek;
	if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
	dayOfWeek = internalGet(DAY_OF_WEEK);
	} else {
	dayOfWeek = getFirstDayOfWeek();
	}
	// We are basing this on the day-of-week-in-month. The only
	// trickiness occurs if the day-of-week-in-month is
	// negative.
	int dowim;
	if (isFieldSet(fieldMask, DAY_OF_WEEK_IN_MONTH)) {
	dowim = internalGet(DAY_OF_WEEK_IN_MONTH);
	} else {
	dowim = 1;
	}
	if (dowim >= 0) {
	fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
	dayOfWeek);
	} else {
	// Go to the first day of the next week of
	// the specified week boundary.
	int lastDate = monthLength(month, year) + (7 * (dowim + 1));
	// Then, get the day of week date on or before the last date.
	fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
	dayOfWeek);
	}
	}
	}
	} else {
	if (year == gregorianCutoverYear && cal == gcal
	&& fixedDate < gregorianCutoverDate
	&& gregorianCutoverYear != gregorianCutoverYearJulian) {
	// January 1 of the year doesn't exist. Use
	// gregorianCutoverDate as the first day of the
	// year.
	fixedDate = gregorianCutoverDate;
	}
	// We are on the first day of the year.
	if (isFieldSet(fieldMask, DAY_OF_YEAR)) {
	// Add the offset, then subtract 1. (Make sure to avoid underflow.)
	fixedDate += internalGet(DAY_OF_YEAR);
	fixedDate--;
	} else {
	long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
	getFirstDayOfWeek());
	// If we have enough days in the first week, then move
	// to the previous week.
	if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
	firstDayOfWeek -= 7;
	}
	if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
	int dayOfWeek = internalGet(DAY_OF_WEEK);
	if (dayOfWeek != getFirstDayOfWeek()) {
	firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
	dayOfWeek);
	}
	}
	fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1);
	}
	}

	return fixedDate;
	}

	/**
	* Returns this object if it's normalized (all fields and time are
	* in sync). Otherwise, a cloned object is returned after calling
	* complete() in lenient mode.
	*/
	private GregorianCalendar getNormalizedCalendar() {
	GregorianCalendar gc;
	if (isFullyNormalized()) {
	gc = this;
	} else {
	// Create a clone and normalize the calendar fields
	gc = (GregorianCalendar) this.clone();
	gc.setLenient(true);
	gc.complete();
	}
	return gc;
	}

	/**
	* Returns the Julian calendar system instance (singleton). 'jcal'
	* and 'jeras' are set upon the return.
	*/
	private static synchronized BaseCalendar getJulianCalendarSystem() {
	if (jcal == null) {
	jcal = (JulianCalendar) CalendarSystem.forName("julian");
	jeras = jcal.getEras();
	}
	return jcal;
	}

	/**
	* Returns the calendar system for dates before the cutover date
	* in the cutover year. If the cutover date is January 1, the
	* method returns Gregorian. Otherwise, Julian.
	*/
	private BaseCalendar getCutoverCalendarSystem() {
	if (gregorianCutoverYearJulian < gregorianCutoverYear) {
	return gcal;
	}
	return getJulianCalendarSystem();
	}

	/**
	* Determines if the specified year (normalized) is the Gregorian
	* cutover year. This object must have been normalized.
	*/
	private boolean isCutoverYear(int normalizedYear) {
	int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian;
	return normalizedYear == cutoverYear;
	}

	/**
	* Returns the fixed date of the first day of the year (usually
	* January 1) before the specified date.
	*
	* @param date the date for which the first day of the year is
	* calculated. The date has to be in the cut-over year (Gregorian
	* or Julian).
	* @param fixedDate the fixed date representation of the date
	*/
	private long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) {
	assert date.getNormalizedYear() == gregorianCutoverYear \|\|
	date.getNormalizedYear() == gregorianCutoverYearJulian;
	if (gregorianCutoverYear != gregorianCutoverYearJulian) {
	if (fixedDate >= gregorianCutoverDate) {
	// Dates before the cutover date don't exist
	// in the same (Gregorian) year. So, no
	// January 1 exists in the year. Use the
	// cutover date as the first day of the year.
	return gregorianCutoverDate;
	}
	}
	// January 1 of the normalized year should exist.
	BaseCalendar juliancal = getJulianCalendarSystem();
	return juliancal.getFixedDate(date.getNormalizedYear(), BaseCalendar.JANUARY, 1, null);
	}

	/**
	* Returns the fixed date of the first date of the month (usually
	* the 1st of the month) before the specified date.
	*
	* @param date the date for which the first day of the month is
	* calculated. The date has to be in the cut-over year (Gregorian
	* or Julian).
	* @param fixedDate the fixed date representation of the date
	*/
	private long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) {
	assert date.getNormalizedYear() == gregorianCutoverYear \|\|
	date.getNormalizedYear() == gregorianCutoverYearJulian;
	BaseCalendar.Date gCutover = getGregorianCutoverDate();
	if (gCutover.getMonth() == BaseCalendar.JANUARY
	&& gCutover.getDayOfMonth() == 1) {
	// The cutover happened on January 1.
	return fixedDate - date.getDayOfMonth() + 1;
	}

	long fixedDateMonth1;
	// The cutover happened sometime during the year.
	if (date.getMonth() == gCutover.getMonth()) {
	// The cutover happened in the month.
	BaseCalendar.Date jLastDate = getLastJulianDate();
	if (gregorianCutoverYear == gregorianCutoverYearJulian
	&& gCutover.getMonth() == jLastDate.getMonth()) {
	// The "gap" fits in the same month.
	fixedDateMonth1 = jcal.getFixedDate(date.getNormalizedYear(),
	date.getMonth(),
	1,
	null);
	} else {
	// Use the cutover date as the first day of the month.
	fixedDateMonth1 = gregorianCutoverDate;
	}
	} else {
	// The cutover happened before the month.
	fixedDateMonth1 = fixedDate - date.getDayOfMonth() + 1;
	}

	return fixedDateMonth1;
	}

	/**
	* Returns a CalendarDate produced from the specified fixed date.
	*
	* @param fd the fixed date
	*/
	private BaseCalendar.Date getCalendarDate(long fd) {
	BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
	BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
	cal.getCalendarDateFromFixedDate(d, fd);
	return d;
	}

	/**
	* Returns the Gregorian cutover date as a BaseCalendar.Date. The
	* date is a Gregorian date.
	*/
	private BaseCalendar.Date getGregorianCutoverDate() {
	return getCalendarDate(gregorianCutoverDate);
	}

	/**
	* Returns the day before the Gregorian cutover date as a
	* BaseCalendar.Date. The date is a Julian date.
	*/
	private BaseCalendar.Date getLastJulianDate() {
	return getCalendarDate(gregorianCutoverDate - 1);
	}

	/**
	* Returns the length of the specified month in the specified
	* year. The year number must be normalized.
	*
	* @see #isLeapYear(int)
	*/
	private int monthLength(int month, int year) {
	return isLeapYear(year) ? LEAP_MONTH_LENGTH[month] : MONTH_LENGTH[month];
	}

	/**
	* Returns the length of the specified month in the year provided
	* by internalGet(YEAR).
	*
	* @see #isLeapYear(int)
	*/
	private int monthLength(int month) {
	int year = internalGet(YEAR);
	if (internalGetEra() == BCE) {
	year = 1 - year;
	}
	return monthLength(month, year);
	}

	private int actualMonthLength() {
	int year = cdate.getNormalizedYear();
	if (year != gregorianCutoverYear && year != gregorianCutoverYearJulian) {
	return calsys.getMonthLength(cdate);
	}
	BaseCalendar.Date date = (BaseCalendar.Date) cdate.clone();
	long fd = calsys.getFixedDate(date);
	long month1 = getFixedDateMonth1(date, fd);
	long next1 = month1 + calsys.getMonthLength(date);
	if (next1 < gregorianCutoverDate) {
	return (int)(next1 - month1);
	}
	if (cdate != gdate) {
	date = (BaseCalendar.Date) gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
	}
	gcal.getCalendarDateFromFixedDate(date, next1);
	next1 = getFixedDateMonth1(date, next1);
	return (int)(next1 - month1);
	}

	/**
	* Returns the length (in days) of the specified year. The year
	* must be normalized.
	*/
	private int yearLength(int year) {
	return isLeapYear(year) ? 366 : 365;
	}

	/**
	* Returns the length (in days) of the year provided by
	* internalGet(YEAR).
	*/
	private int yearLength() {
	int year = internalGet(YEAR);
	if (internalGetEra() == BCE) {
	year = 1 - year;
	}
	return yearLength(year);
	}

	/**
	* After adjustments such as add(MONTH), add(YEAR), we don't want the
	* month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar
	* 3, we want it to go to Feb 28. Adjustments which might run into this
	* problem call this method to retain the proper month.
	*/
	private void pinDayOfMonth() {
	int year = internalGet(YEAR);
	int monthLen;
	if (year > gregorianCutoverYear \|\| year < gregorianCutoverYearJulian) {
	monthLen = monthLength(internalGet(MONTH));
	} else {
	GregorianCalendar gc = getNormalizedCalendar();
	monthLen = gc.getActualMaximum(DAY_OF_MONTH);
	}
	int dom = internalGet(DAY_OF_MONTH);
	if (dom > monthLen) {
	set(DAY_OF_MONTH, monthLen);
	}
	}

	/**
	* Returns the fixed date value of this object. The time value and
	* calendar fields must be in synch.
	*/
	private long getCurrentFixedDate() {
	return (calsys == gcal) ? cachedFixedDate : calsys.getFixedDate(cdate);
	}

	/**
	* Returns the new value after 'roll'ing the specified value and amount.
	*/
	private static int getRolledValue(int value, int amount, int min, int max) {
	assert value >= min && value <= max;
	int range = max - min + 1;
	amount %= range;
	int n = value + amount;
	if (n > max) {
	n -= range;
	} else if (n < min) {
	n += range;
	}
	assert n >= min && n <= max;
	return n;
	}

	/**
	* Returns the ERA. We need a special method for this because the
	* default ERA is CE, but a zero (unset) ERA is BCE.
	*/
	private int internalGetEra() {
	return isSet(ERA) ? internalGet(ERA) : CE;
	}

	/**
	* Updates internal state.
	*/
	private void readObject(ObjectInputStream stream)
	throws IOException, ClassNotFoundException {
	stream.defaultReadObject();
	if (gdate == null) {
	gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
	cachedFixedDate = Long.MIN_VALUE;
	}
	setGregorianChange(gregorianCutover);
	}

	/**
	* Converts this object to a {@code ZonedDateTime} that represents
	* the same point on the time-line as this {@code GregorianCalendar}.
	* <p>
	* Since this object supports a Julian-Gregorian cutover date and
	* {@code ZonedDateTime} does not, it is possible that the resulting year,
	* month and day will have different values. The result will represent the
	* correct date in the ISO calendar system, which will also be the same value
	* for Modified Julian Days.
	*
	* @return a zoned date-time representing the same point on the time-line
	* as this gregorian calendar
	* @since 1.8
	*/
	public ZonedDateTime toZonedDateTime() {
	return ZonedDateTime.ofInstant(Instant.ofEpochMilli(getTimeInMillis()),
	getTimeZone().toZoneId());
	}

	/**
	* Obtains an instance of {@code GregorianCalendar} with the default locale
	* from a {@code ZonedDateTime} object.
	* <p>
	* Since {@code ZonedDateTime} does not support a Julian-Gregorian cutover
	* date and uses ISO calendar system, the return GregorianCalendar is a pure
	* Gregorian calendar and uses ISO 8601 standard for week definitions,
	* which has {@code MONDAY} as the {@link Calendar#getFirstDayOfWeek()
	* FirstDayOfWeek} and {@code 4} as the value of the
	* {@link Calendar#getMinimalDaysInFirstWeek() MinimalDaysInFirstWeek}.
	* <p>
	* {@code ZoneDateTime} can store points on the time-line further in the
	* future and further in the past than {@code GregorianCalendar}. In this
	* scenario, this method will throw an {@code IllegalArgumentException}
	* exception.
	*
	* @param zdt the zoned date-time object to convert
	* @return the gregorian calendar representing the same point on the
	* time-line as the zoned date-time provided
	* @exception NullPointerException if {@code zdt} is null
	* @exception IllegalArgumentException if the zoned date-time is too
	* large to represent as a {@code GregorianCalendar}
	* @since 1.8
	*/
	public static GregorianCalendar from(ZonedDateTime zdt) {
	GregorianCalendar cal = new GregorianCalendar(TimeZone.getTimeZone(zdt.getZone()));
	cal.setGregorianChange(new Date(Long.MIN_VALUE));
	cal.setFirstDayOfWeek(MONDAY);
	cal.setMinimalDaysInFirstWeek(4);
	try {
	cal.setTimeInMillis(Math.addExact(Math.multiplyExact(zdt.toEpochSecond(), 1000),
	zdt.get(ChronoField.MILLI_OF_SECOND)));
	} catch (ArithmeticException ex) {
	throw new IllegalArgumentException(ex);
	}
	return cal;
	}
	}

Back to index...