• GregorianCalendar


    GregorianCalendar

    /*
     * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
     * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
     */
    
    /*
     * (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 name="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 name="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 name="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 cellpadding="0" cellspacing="3" border="0"
     *        summary="GregorianCalendar default field values"
     *        style="text-align: left;  66%;">
     *   <tbody>
     *     <tr>
     *       <th style="vertical-align: top; background-color: rgb(204, 204, 255);
     *           text-align: center;">Field<br>
     *       </th>
     *       <th style="vertical-align: top; background-color: rgb(204, 204, 255);
     *           text-align: center;">Default Value<br>
     *       </th>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle;">
     *              <code>ERA<br></code>
     *       </td>
     *       <td style="vertical-align: middle;">
     *              <code>AD<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle; background-color: rgb(238, 238, 255);">
     *              <code>YEAR<br></code>
     *       </td>
     *       <td style="vertical-align: middle; background-color: rgb(238, 238, 255);">
     *              <code>1970<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle;">
     *              <code>MONTH<br></code>
     *       </td>
     *       <td style="vertical-align: middle;">
     *              <code>JANUARY<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: top; background-color: rgb(238, 238, 255);">
     *              <code>DAY_OF_MONTH<br></code>
     *       </td>
     *       <td style="vertical-align: top; background-color: rgb(238, 238, 255);">
     *              <code>1<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle;">
     *              <code>DAY_OF_WEEK<br></code>
     *       </td>
     *       <td style="vertical-align: middle;">
     *              <code>the first day of week<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: top; background-color: rgb(238, 238, 255);">
     *              <code>WEEK_OF_MONTH<br></code>
     *       </td>
     *       <td style="vertical-align: top; background-color: rgb(238, 238, 255);">
     *              <code>0<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: top;">
     *              <code>DAY_OF_WEEK_IN_MONTH<br></code>
     *       </td>
     *       <td style="vertical-align: top;">
     *              <code>1<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle; background-color: rgb(238, 238, 255);">
     *              <code>AM_PM<br></code>
     *       </td>
     *       <td style="vertical-align: middle; background-color: rgb(238, 238, 255);">
     *              <code>AM<br></code>
     *       </td>
     *     </tr>
     *     <tr>
     *       <td style="vertical-align: middle;">
     *              <code>HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND<br></code>
     *       </td>
     *       <td style="vertical-align: middle;">
     *              <code>0<br></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)/(60*60*1000)));
     * System.out.println("DST_OFFSET: "
     *                    + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000)));
    
     * 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)/(60*60*1000))); // in hours
     * System.out.println("DST_OFFSET: "
     *        + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000))); // in hours
     * </pre>
     * </blockquote>
     *
     * @see          TimeZone
     * @author David Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu
     * @since JDK1.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 unit = max + 1; // 12 or 24 hours
                    int h = internalGet(field);
                    int nh = (h + amount) % unit;
                    if (nh < 0) {
                        nh += unit;
                    }
                    time += ONE_HOUR * (nh - h);
    
                    // The day might have changed, which could happen if
                    // the daylight saving time transition brings it to
                    // the next day, although it's very unlikely. But we
                    // have to make sure not to change the larger fields.
                    CalendarDate d = calsys.getCalendarDate(time, getZone());
                    if (internalGet(DAY_OF_MONTH) != d.getDayOfMonth()) {
                        d.setDate(internalGet(YEAR),
                                  internalGet(MONTH) + 1,
                                  internalGet(DAY_OF_MONTH));
                        if (field == HOUR) {
                            assert (internalGet(AM_PM) == PM);
                            d.addHours(+12); // restore PM
                        }
                        time = calsys.getTime(d);
                    }
                    int hourOfDay = d.getHours();
                    internalSet(field, hourOfDay % unit);
                    if (field == HOUR) {
                        internalSet(HOUR_OF_DAY, hourOfDay);
                    } else {
                        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.
         */
        transient private 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;
        }
    }
    

      

    ########################

  • 相关阅读:
    Using a custom AxisRenderer object
    进度条
    flex 自定义tooltip
    深入理解JAVA虚拟机 垃圾收集器和内存分配策略
    深入理解JAVA虚拟机 自动内存管理机制
    oracle pl/sql 程序设计 历史笔记整理
    oracle sql 高级编程 历史笔记整理
    JAVA并发编程的艺术 Java并发容器和框架
    JAVA并发编程的艺术 JMM内存模型
    Java并发编程实战 第16章 Java内存模型
  • 原文地址:https://www.cnblogs.com/herd/p/16268404.html
Copyright © 2020-2023  润新知