/*

 * Copyright (c) 1996, 2021, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * (C) Copyright Taligent, Inc. 1996 - 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.text;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectInputStream;

import static java.text.DateFormatSymbols.*;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.Locale;

import java.util.Map;

import java.util.SimpleTimeZone;

import java.util.SortedMap;

import java.util.TimeZone;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import sun.util.calendar.CalendarUtils;

import sun.util.calendar.ZoneInfoFile;

import sun.util.locale.provider.LocaleProviderAdapter;

import sun.util.locale.provider.TimeZoneNameUtility;

/**

 * {@code SimpleDateFormat} is a concrete class for formatting and

 * parsing dates in a locale-sensitive manner. It allows for formatting

 * (date → text), parsing (text → date), and normalization.

 *

 * <p>

 * {@code SimpleDateFormat} allows you to start by choosing

 * any user-defined patterns for date-time formatting. However, you

 * are encouraged to create a date-time formatter with either

 * {@code getTimeInstance}, {@code getDateInstance}, or

 * {@code getDateTimeInstance} in {@code DateFormat}. Each

 * of these class methods can return a date/time formatter initialized

 * with a default format pattern. You may modify the format pattern

 * using the {@code applyPattern} methods as desired.

 * For more information on using these methods, see

 * {@link DateFormat}.

 *

 * <h2>Date and Time Patterns</h2>

 * <p>

 * Date and time formats are specified by <em>date and time pattern</em>

 * strings.

 * Within date and time pattern strings, unquoted letters from

 * {@code 'A'} to {@code 'Z'} and from {@code 'a'} to

 * {@code 'z'} are interpreted as pattern letters representing the

 * components of a date or time string.

 * Text can be quoted using single quotes ({@code '}) to avoid

 * interpretation.

 * {@code "''"} represents a single quote.

 * All other characters are not interpreted; they're simply copied into the

 * output string during formatting or matched against the input string

 * during parsing.

 * <p>

 * The following pattern letters are defined (all other characters from

 * {@code 'A'} to {@code 'Z'} and from {@code 'a'} to

 * {@code 'z'} are reserved):

 * <blockquote>

 * <table class="striped">

 * <caption style="display:none">Chart shows pattern letters, date/time component, presentation, and examples.</caption>

 * <thead>

 *     <tr>

 *         <th scope="col" style="text-align:left">Letter

 *         <th scope="col" style="text-align:left">Date or Time Component

 *         <th scope="col" style="text-align:left">Presentation

 *         <th scope="col" style="text-align:left">Examples

 * </thead>

 * <tbody>

 *     <tr>

 *         <th scope="row">{@code G}

 *         <td>Era designator

 *         <td><a href="#text">Text</a>

 *         <td>{@code AD}

 *     <tr>

 *         <th scope="row">{@code y}

 *         <td>Year

 *         <td><a href="#year">Year</a>

 *         <td>{@code 1996}; {@code 96}

 *     <tr>

 *         <th scope="row">{@code Y}

 *         <td>Week year

 *         <td><a href="#year">Year</a>

 *         <td>{@code 2009}; {@code 09}

 *     <tr>

 *         <th scope="row">{@code M}

 *         <td>Month in year (context sensitive)

 *         <td><a href="#month">Month</a>

 *         <td>{@code July}; {@code Jul}; {@code 07}

 *     <tr>

 *         <th scope="row">{@code L}

 *         <td>Month in year (standalone form)

 *         <td><a href="#month">Month</a>

 *         <td>{@code July}; {@code Jul}; {@code 07}

 *     <tr>

 *         <th scope="row">{@code w}

 *         <td>Week in year

 *         <td><a href="#number">Number</a>

 *         <td>{@code 27}

 *     <tr>

 *         <th scope="row">{@code W}

 *         <td>Week in month

 *         <td><a href="#number">Number</a>

 *         <td>{@code 2}

 *     <tr>

 *         <th scope="row">{@code D}

 *         <td>Day in year

 *         <td><a href="#number">Number</a>

 *         <td>{@code 189}

 *     <tr>

 *         <th scope="row">{@code d}

 *         <td>Day in month

 *         <td><a href="#number">Number</a>

 *         <td>{@code 10}

 *     <tr>

 *         <th scope="row">{@code F}

 *         <td>Day of week in month

 *         <td><a href="#number">Number</a>

 *         <td>{@code 2}

 *     <tr>

 *         <th scope="row">{@code E}

 *         <td>Day name in week

 *         <td><a href="#text">Text</a>

 *         <td>{@code Tuesday}; {@code Tue}

 *     <tr>

 *         <th scope="row">{@code u}

 *         <td>Day number of week (1 = Monday, ..., 7 = Sunday)

 *         <td><a href="#number">Number</a>

 *         <td>{@code 1}

 *     <tr>

 *         <th scope="row">{@code a}

 *         <td>Am/pm marker

 *         <td><a href="#text">Text</a>

 *         <td>{@code PM}

 *     <tr>

 *         <th scope="row">{@code H}

 *         <td>Hour in day (0-23)

 *         <td><a href="#number">Number</a>

 *         <td>{@code 0}

 *     <tr>

 *         <th scope="row">{@code k}

 *         <td>Hour in day (1-24)

 *         <td><a href="#number">Number</a>

 *         <td>{@code 24}

 *     <tr>

 *         <th scope="row">{@code K}

 *         <td>Hour in am/pm (0-11)

 *         <td><a href="#number">Number</a>

 *         <td>{@code 0}

 *     <tr>

 *         <th scope="row">{@code h}

 *         <td>Hour in am/pm (1-12)

 *         <td><a href="#number">Number</a>

 *         <td>{@code 12}

 *     <tr>

 *         <th scope="row">{@code m}

 *         <td>Minute in hour

 *         <td><a href="#number">Number</a>

 *         <td>{@code 30}

 *     <tr>

 *         <th scope="row">{@code s}

 *         <td>Second in minute

 *         <td><a href="#number">Number</a>

 *         <td>{@code 55}

 *     <tr>

 *         <th scope="row">{@code S}

 *         <td>Millisecond

 *         <td><a href="#number">Number</a>

 *         <td>{@code 978}

 *     <tr>

 *         <th scope="row">{@code z}

 *         <td>Time zone

 *         <td><a href="#timezone">General time zone</a>

 *         <td>{@code Pacific Standard Time}; {@code PST}; {@code GMT-08:00}

 *     <tr>

 *         <th scope="row">{@code Z}

 *         <td>Time zone

 *         <td><a href="#rfc822timezone">RFC 822 time zone</a>

 *         <td>{@code -0800}

 *     <tr>

 *         <th scope="row">{@code X}

 *         <td>Time zone

 *         <td><a href="#iso8601timezone">ISO 8601 time zone</a>

 *         <td>{@code -08}; {@code -0800};  {@code -08:00}

 * </tbody>

 * </table>

 * </blockquote>

 * Pattern letters are usually repeated, as their number determines the

 * exact presentation:

 * <ul>

 * <li><strong><a id="text">Text:</a></strong>

 *     For formatting, if the number of pattern letters is 4 or more,

 *     the full form is used; otherwise a short or abbreviated form

 *     is used if available.

 *     For parsing, both forms are accepted, independent of the number

 *     of pattern letters.<br><br></li>

 * <li><strong><a id="number">Number:</a></strong>

 *     For formatting, the number of pattern letters is the minimum

 *     number of digits, and shorter numbers are zero-padded to this amount.

 *     For parsing, the number of pattern letters is ignored unless

 *     it's needed to separate two adjacent fields.<br><br></li>

 * <li><strong><a id="year">Year:</a></strong>

 *     If the formatter's {@link #getCalendar() Calendar} is the Gregorian

 *     calendar, the following rules are applied.<br>

 *     <ul>

 *     <li>For formatting, if the number of pattern letters is 2, the year

 *         is truncated to 2 digits; otherwise it is interpreted as a

 *         <a href="#number">number</a>.

 *     <li>For parsing, if the number of pattern letters is more than 2,

 *         the year is interpreted literally, regardless of the number of

 *         digits. So using the pattern "MM/dd/yyyy", "01/11/12" parses to

 *         Jan 11, 12 A.D.

 *     <li>For parsing with the abbreviated year pattern ("y" or "yy"),

 *         {@code SimpleDateFormat} must interpret the abbreviated year

 *         relative to some century.  It does this by adjusting dates to be

 *         within 80 years before and 20 years after the time the {@code SimpleDateFormat}

 *         instance is created. For example, using a pattern of "MM/dd/yy" and a

 *         {@code SimpleDateFormat} instance created on Jan 1, 1997,  the string

 *         "01/11/12" would be interpreted as Jan 11, 2012 while the string "05/04/64"

 *         would be interpreted as May 4, 1964.

 *         During parsing, only strings consisting of exactly two digits, as defined by

 *         {@link Character#isDigit(char)}, will be parsed into the default century.

 *         Any other numeric string, such as a one digit string, a three or more digit

 *         string, or a two digit string that isn't all digits (for example, "-1"), is

 *         interpreted literally.  So "01/02/3" or "01/02/003" are parsed, using the

 *         same pattern, as Jan 2, 3 AD.  Likewise, "01/02/-3" is parsed as Jan 2, 4 BC.

 *     </ul>

 *     Otherwise, calendar system specific forms are applied.

 *     For both formatting and parsing, if the number of pattern

 *     letters is 4 or more, a calendar specific {@linkplain

 *     Calendar#LONG long form} is used. Otherwise, a calendar

 *     specific {@linkplain Calendar#SHORT short or abbreviated form}

 *     is used.<br>

 *     <br>

 *     If week year {@code 'Y'} is specified and the {@linkplain

 *     #getCalendar() calendar} doesn't support any <a

 *     href="../util/GregorianCalendar.html#week_year"> week

 *     years</a>, the calendar year ({@code 'y'}) is used instead. The

 *     support of week years can be tested with a call to {@link

 *     DateFormat#getCalendar() getCalendar()}.{@link

 *     java.util.Calendar#isWeekDateSupported()

 *     isWeekDateSupported()}.<br><br></li>

 * <li><strong><a id="month">Month:</a></strong>

 *     If the number of pattern letters is 3 or more, the month is

 *     interpreted as <a href="#text">text</a>; otherwise,

 *     it is interpreted as a <a href="#number">number</a>.<br>

 *     <ul>

 *     <li>Letter <em>M</em> produces context-sensitive month names, such as the

 *         embedded form of names. Letter <em>M</em> is context-sensitive in the

 *         sense that when it is used in the standalone pattern, for example,

 *         "MMMM", it gives the standalone form of a month name and when it is

 *         used in the pattern containing other field(s), for example, "d MMMM",

 *         it gives the format form of a month name. For example, January in the

 *         Catalan language is "de gener" in the format form while it is "gener"

 *         in the standalone form. In this case, "MMMM" will produce "gener" and

 *         the month part of the "d MMMM" will produce "de gener". If a

 *         {@code DateFormatSymbols} has been set explicitly with constructor

 *         {@link #SimpleDateFormat(String,DateFormatSymbols)} or method {@link

 *         #setDateFormatSymbols(DateFormatSymbols)}, the month names given by

 *         the {@code DateFormatSymbols} are used.</li>

 *     <li>Letter <em>L</em> produces the standalone form of month names.</li>

 *     </ul>

 *     <br></li>

 * <li><strong><a id="timezone">General time zone:</a></strong>

 *     Time zones are interpreted as <a href="#text">text</a> if they have

 *     names. For time zones representing a GMT offset value, the

 *     following syntax is used:

 *     <pre>

 *     <a id="GMTOffsetTimeZone"><i>GMTOffsetTimeZone:</i></a>

 *             {@code GMT} <i>Sign</i> <i>Hours</i> {@code :} <i>Minutes</i>

 *     <i>Sign:</i> one of

 *             {@code + -}

 *     <i>Hours:</i>

 *             <i>Digit</i>

 *             <i>Digit</i> <i>Digit</i>

 *     <i>Minutes:</i>

 *             <i>Digit</i> <i>Digit</i>

 *     <i>Digit:</i> one of

 *             {@code 0 1 2 3 4 5 6 7 8 9}</pre>

 *     <i>Hours</i> must be between 0 and 23, and <i>Minutes</i> must be between

 *     00 and 59. The format is locale independent and digits must be taken

 *     from the Basic Latin block of the Unicode standard.

 *     <p>For parsing, <a href="#rfc822timezone">RFC 822 time zones</a> are also

 *     accepted.<br><br></li>

 * <li><strong><a id="rfc822timezone">RFC 822 time zone:</a></strong>

 *     For formatting, the RFC 822 4-digit time zone format is used:

 *

 *     <pre>

 *     <i>RFC822TimeZone:</i>

 *             <i>Sign</i> <i>TwoDigitHours</i> <i>Minutes</i>

 *     <i>TwoDigitHours:</i>

 *             <i>Digit Digit</i></pre>

 *     <i>TwoDigitHours</i> must be between 00 and 23. Other definitions

 *     are as for <a href="#timezone">general time zones</a>.

 *

 *     <p>For parsing, <a href="#timezone">general time zones</a> are also

 *     accepted.

 * <li><strong><a id="iso8601timezone">ISO 8601 Time zone:</a></strong>

 *     The number of pattern letters designates the format for both formatting

 *     and parsing as follows:

 *     <pre>

 *     <i>ISO8601TimeZone:</i>

 *             <i>OneLetterISO8601TimeZone</i>

 *             <i>TwoLetterISO8601TimeZone</i>

 *             <i>ThreeLetterISO8601TimeZone</i>

 *     <i>OneLetterISO8601TimeZone:</i>

 *             <i>Sign</i> <i>TwoDigitHours</i>

 *             {@code Z}

 *     <i>TwoLetterISO8601TimeZone:</i>

 *             <i>Sign</i> <i>TwoDigitHours</i> <i>Minutes</i>

 *             {@code Z}

 *     <i>ThreeLetterISO8601TimeZone:</i>

 *             <i>Sign</i> <i>TwoDigitHours</i> {@code :} <i>Minutes</i>

 *             {@code Z}</pre>

 *     Other definitions are as for <a href="#timezone">general time zones</a> or

 *     <a href="#rfc822timezone">RFC 822 time zones</a>.

 *

 *     <p>For formatting, if the offset value from GMT is 0, {@code "Z"} is

 *     produced. If the number of pattern letters is 1, any fraction of an hour

 *     is ignored. For example, if the pattern is {@code "X"} and the time zone is

 *     {@code "GMT+05:30"}, {@code "+05"} is produced.

 *

 *     <p>For parsing, {@code "Z"} is parsed as the UTC time zone designator.

 *     <a href="#timezone">General time zones</a> are <em>not</em> accepted.

 *

 *     <p>If the number of pattern letters is 4 or more, {@link

 *     IllegalArgumentException} is thrown when constructing a {@code

 *     SimpleDateFormat} or {@linkplain #applyPattern(String) applying a

 *     pattern}.

 * </ul>

 * {@code SimpleDateFormat} also supports <em>localized date and time

 * pattern</em> strings. In these strings, the pattern letters described above

 * may be replaced with other, locale dependent, pattern letters.

 * {@code SimpleDateFormat} does not deal with the localization of text

 * other than the pattern letters; that's up to the client of the class.

 *

 * <h3>Examples</h3>

 *

 * The following examples show how date and time patterns are interpreted in

 * the U.S. locale. The given date and time are 2001-07-04 12:08:56 local time

 * in the U.S. Pacific Time time zone.

 * <blockquote>

 * <table class="striped">

 * <caption style="display:none">Examples of date and time patterns interpreted in the U.S. locale</caption>

 * <thead>

 *     <tr>

 *         <th scope="col" style="text-align:left">Date and Time Pattern

 *         <th scope="col" style="text-align:left">Result

 * </thead>

 * <tbody>

 *     <tr>

 *         <th scope="row">{@code "yyyy.MM.dd G 'at' HH:mm:ss z"}

 *         <td>{@code 2001.07.04 AD at 12:08:56 PDT}

 *     <tr>

 *         <th scope="row">{@code "EEE, MMM d, ''yy"}

 *         <td>{@code Wed, Jul 4, '01}

 *     <tr>

 *         <th scope="row">{@code "h:mm a"}

 *         <td>{@code 12:08 PM}

 *     <tr>

 *         <th scope="row">{@code "hh 'o''clock' a, zzzz"}

 *         <td>{@code 12 o'clock PM, Pacific Daylight Time}

 *     <tr>

 *         <th scope="row">{@code "K:mm a, z"}

 *         <td>{@code 0:08 PM, PDT}

 *     <tr>

 *         <th scope="row">{@code "yyyyy.MMMMM.dd GGG hh:mm aaa"}

 *         <td>{@code 02001.July.04 AD 12:08 PM}

 *     <tr>

 *         <th scope="row">{@code "EEE, d MMM yyyy HH:mm:ss Z"}

 *         <td>{@code Wed, 4 Jul 2001 12:08:56 -0700}

 *     <tr>

 *         <th scope="row">{@code "yyMMddHHmmssZ"}

 *         <td>{@code 010704120856-0700}

 *     <tr>

 *         <th scope="row">{@code "yyyy-MM-dd'T'HH:mm:ss.SSSZ"}

 *         <td>{@code 2001-07-04T12:08:56.235-0700}

 *     <tr>

 *         <th scope="row">{@code "yyyy-MM-dd'T'HH:mm:ss.SSSXXX"}

 *         <td>{@code 2001-07-04T12:08:56.235-07:00}

 *     <tr>

 *         <th scope="row">{@code "YYYY-'W'ww-u"}

 *         <td>{@code 2001-W27-3}

 * </tbody>

 * </table>

 * </blockquote>

 *

 * <h3><a id="synchronization">Synchronization</a></h3>

 *

 * <p>

 * Date formats are not synchronized.

 * It is recommended to create separate format instances for each thread.

 * If multiple threads access a format concurrently, it must be synchronized

 * externally.

 * @apiNote Consider using {@link java.time.format.DateTimeFormatter} as an

 * immutable and thread-safe alternative.

 *

 * @see          <a href="http://docs.oracle.com/javase/tutorial/i18n/format/simpleDateFormat.html">Java Tutorial</a>

 * @see          java.util.Calendar

 * @see          java.util.TimeZone

 * @see          DateFormat

 * @see          DateFormatSymbols

 * @see          java.time.format.DateTimeFormatter

 * @author       Mark Davis, Chen-Lieh Huang, Alan Liu

 * @since 1.1

 */

public class SimpleDateFormat extends DateFormat {

    // the official serial version ID which says cryptically

    // which version we're compatible with

    @java.io.Serial

    static final long serialVersionUID = 4774881970558875024L;

    // the internal serial version which says which version was written

    // - 0 (default) for version up to JDK 1.1.3

    // - 1 for version from JDK 1.1.4, which includes a new field

    static final int currentSerialVersion = 1;

    /**

     * The version of the serialized data on the stream.  Possible values:

     * <ul>

     * <li><b>0</b> or not present on stream: JDK 1.1.3.  This version

     * has no {@code defaultCenturyStart} on stream.

     * <li><b>1</b> JDK 1.1.4 or later.  This version adds

     * {@code defaultCenturyStart}.

     * </ul>

     * When streaming out this class, the most recent format

     * and the highest allowable {@code serialVersionOnStream}

     * is written.

     * @serial

     * @since 1.1.4

     */

    private int serialVersionOnStream = currentSerialVersion;

    /**

     * The pattern string of this formatter.  This is always a non-localized

     * pattern.  May not be null.  See class documentation for details.

     * @serial

     */

    private String pattern;

    /**

     * Saved numberFormat and pattern.

     * @see SimpleDateFormat#checkNegativeNumberExpression

     */

    private transient NumberFormat originalNumberFormat;

    private transient String originalNumberPattern;

    /**

     * The minus sign to be used with format and parse.

     */

    private transient char minusSign = '-';

    /**

     * True when a negative sign follows a number.

     * (True as default in Arabic.)

     */

    private transient boolean hasFollowingMinusSign = false;

    /**

     * True if standalone form needs to be used.

     */

    private transient boolean forceStandaloneForm = false;

    /**

     * The compiled pattern.

     */

    private transient char[] compiledPattern;

    /**

     * Tags for the compiled pattern.

     */

    private static final int TAG_QUOTE_ASCII_CHAR       = 100;

    private static final int TAG_QUOTE_CHARS            = 101;

    /**

     * Locale dependent digit zero.

     * @see #zeroPaddingNumber

     * @see java.text.DecimalFormatSymbols#getZeroDigit

     */

    private transient char zeroDigit;

    /**

     * The symbols used by this formatter for week names, month names,

     * etc.  May not be null.

     * @serial

     * @see java.text.DateFormatSymbols

     */

    private DateFormatSymbols formatData;

    /**

     * We map dates with two-digit years into the century starting at

     * {@code defaultCenturyStart}, which may be any date.  May

     * not be null.

     * @serial

     * @since 1.1.4

     */

    private Date defaultCenturyStart;

    private transient int defaultCenturyStartYear;

    private static final int MILLIS_PER_MINUTE = 60 * 1000;

    // For time zones that have no names, use strings GMT+minutes and

    // GMT-minutes. For instance, in France the time zone is GMT+60.

    private static final String GMT = "GMT";

    /**

     * Cache NumberFormat instances with Locale key.

     */

    private static final ConcurrentMap<Locale, NumberFormat> cachedNumberFormatData

        = new ConcurrentHashMap<>(3);

    /**

     * The Locale used to instantiate this

     * {@code SimpleDateFormat}. The value may be null if this object

     * has been created by an older {@code SimpleDateFormat} and

     * deserialized.

     *

     * @serial

     * @since 1.6

     */

    private Locale locale;

    /**

     * Indicates whether this {@code SimpleDateFormat} should use

     * the DateFormatSymbols. If true, the format and parse methods

     * use the DateFormatSymbols values. If false, the format and

     * parse methods call Calendar.getDisplayName or

     * Calendar.getDisplayNames.

     */

    transient boolean useDateFormatSymbols;

    /**

     * Constructs a {@code SimpleDateFormat} using the default pattern and

     * date format symbols for the default

     * {@link java.util.Locale.Category#FORMAT FORMAT} locale.

     * <b>Note:</b> This constructor may not support all locales.

     * For full coverage, use the factory methods in the {@link DateFormat}

     * class.

     */

    public SimpleDateFormat() {

        this("", Locale.getDefault(Locale.Category.FORMAT));

        applyPatternImpl(LocaleProviderAdapter.getResourceBundleBased().getLocaleResources(locale)

                         .getDateTimePattern(SHORT, SHORT, calendar));

    }

    /**

     * Constructs a {@code SimpleDateFormat} using the given pattern and

     * the default date format symbols for the default

     * {@link java.util.Locale.Category#FORMAT FORMAT} locale.

     * <b>Note:</b> This constructor may not support all locales.

     * For full coverage, use the factory methods in the {@link DateFormat}

     * class.

     * <p>This is equivalent to calling

     * {@link #SimpleDateFormat(String, Locale)

     *     SimpleDateFormat(pattern, Locale.getDefault(Locale.Category.FORMAT))}.

     *

     * @see java.util.Locale#getDefault(java.util.Locale.Category)

     * @see java.util.Locale.Category#FORMAT

     * @param pattern the pattern describing the date and time format

     * @throws    NullPointerException if the given pattern is null

     * @throws    IllegalArgumentException if the given pattern is invalid

     */

    public SimpleDateFormat(String pattern)

    {

        this(pattern, Locale.getDefault(Locale.Category.FORMAT));

    }

    /**

     * Constructs a {@code SimpleDateFormat} using the given pattern and

     * the default date format symbols for the given locale.

     * <b>Note:</b> This constructor may not support all locales.

     * For full coverage, use the factory methods in the {@link DateFormat}

     * class.

     *

     * @param pattern the pattern describing the date and time format

     * @param locale the locale whose date format symbols should be used

     * @throws    NullPointerException if the given pattern or locale is null

     * @throws    IllegalArgumentException if the given pattern is invalid

     */

    public SimpleDateFormat(String pattern, Locale locale)

    {

        if (pattern == null || locale == null) {

            throw new NullPointerException();

        }

        initializeCalendar(locale);

        this.pattern = pattern;

        this.formatData = DateFormatSymbols.getInstanceRef(locale);

        this.locale = locale;

        initialize(locale);

    }

    /**

     * Constructs a {@code SimpleDateFormat} using the given pattern and

     * date format symbols.

     *

     * @param pattern the pattern describing the date and time format

     * @param formatSymbols the date format symbols to be used for formatting

     * @throws    NullPointerException if the given pattern or formatSymbols is null

     * @throws    IllegalArgumentException if the given pattern is invalid

     */

    public SimpleDateFormat(String pattern, DateFormatSymbols formatSymbols)

    {

        if (pattern == null || formatSymbols == null) {

            throw new NullPointerException();

        }

        this.pattern = pattern;

        this.formatData = (DateFormatSymbols) formatSymbols.clone();

        this.locale = Locale.getDefault(Locale.Category.FORMAT);

        initializeCalendar(this.locale);

        initialize(this.locale);

        useDateFormatSymbols = true;

    }

    /* Initialize compiledPattern and numberFormat fields */

    private void initialize(Locale loc) {

        // Verify and compile the given pattern.

        compiledPattern = compile(pattern);

        /* try the cache first */

        numberFormat = cachedNumberFormatData.get(loc);

        if (numberFormat == null) { /* cache miss */

            numberFormat = NumberFormat.getIntegerInstance(loc);

            numberFormat.setGroupingUsed(false);

            /* update cache */

            cachedNumberFormatData.putIfAbsent(loc, numberFormat);

        }

        numberFormat = (NumberFormat) numberFormat.clone();

        initializeDefaultCentury();

    }

    private void initializeCalendar(Locale loc) {

        if (calendar == null) {

            assert loc != null;

            // The format object must be constructed using the symbols for this zone.

            // However, the calendar should use the current default TimeZone.

            // If this is not contained in the locale zone strings, then the zone

            // will be formatted using generic GMT+/-H:MM nomenclature.

            calendar = Calendar.getInstance(loc);

        }

    }

    /**

     * Returns the compiled form of the given pattern. The syntax of

     * the compiled pattern is:

     * <blockquote>

     * CompiledPattern:

     *     EntryList

     * EntryList:

     *     Entry

     *     EntryList Entry

     * Entry:

     *     TagField

     *     TagField data

     * TagField:

     *     Tag Length

     *     TaggedData

     * Tag:

     *     pattern_char_index

     *     TAG_QUOTE_CHARS

     * Length:

     *     short_length

     *     long_length

     * TaggedData:

     *     TAG_QUOTE_ASCII_CHAR ascii_char

     *

     * </blockquote>

     *

     * where `short_length' is an 8-bit unsigned integer between 0 and

     * 254.  `long_length' is a sequence of an 8-bit integer 255 and a

     * 32-bit signed integer value which is split into upper and lower

     * 16-bit fields in two char's. `pattern_char_index' is an 8-bit

     * integer between 0 and 18. `ascii_char' is an 7-bit ASCII

     * character value. `data' depends on its Tag value.

     * <p>

     * If Length is short_length, Tag and short_length are packed in a

     * single char, as illustrated below.

     * <blockquote>

     *     char[0] = (Tag << 8) | short_length;

     * </blockquote>

     *

     * If Length is long_length, Tag and 255 are packed in the first

     * char and a 32-bit integer, as illustrated below.

     * <blockquote>

     *     char[0] = (Tag << 8) | 255;

     *     char[1] = (char) (long_length >>> 16);

     *     char[2] = (char) (long_length & 0xffff);

     * </blockquote>

     * <p>

     * If Tag is a pattern_char_index, its Length is the number of

     * pattern characters. For example, if the given pattern is

     * "yyyy", Tag is 1 and Length is 4, followed by no data.

     * <p>

     * If Tag is TAG_QUOTE_CHARS, its Length is the number of char's

     * following the TagField. For example, if the given pattern is

     * "'o''clock'", Length is 7 followed by a char sequence of

     * <code>o&nbs;'&nbs;c&nbs;l&nbs;o&nbs;c&nbs;k</code>.

     * <p>

     * TAG_QUOTE_ASCII_CHAR is a special tag and has an ASCII

     * character in place of Length. For example, if the given pattern

     * is "'o'", the TaggedData entry is

     * <code>((TAG_QUOTE_ASCII_CHAR&nbs;<<&nbs;8)&nbs;|&nbs;'o')</code>.

     *

     * @throws    NullPointerException if the given pattern is null

     * @throws    IllegalArgumentException if the given pattern is invalid

     */

    private char[] compile(String pattern) {

        int length = pattern.length();

        boolean inQuote = false;

        StringBuilder compiledCode = new StringBuilder(length * 2);

        StringBuilder tmpBuffer = null;

        int count = 0, tagcount = 0;

        int lastTag = -1, prevTag = -1;

        for (int i = 0; i < length; i++) {

            char c = pattern.charAt(i);

            if (c == '\'') {

                // '' is treated as a single quote regardless of being

                // in a quoted section.

                if ((i + 1) < length) {

                    c = pattern.charAt(i + 1);

                    if (c == '\'') {

                        i++;

                        if (count != 0) {

                            encode(lastTag, count, compiledCode);

                            tagcount++;

                            prevTag = lastTag;

                            lastTag = -1;

                            count = 0;

                        }

                        if (inQuote) {

                            tmpBuffer.append(c);

                        } else {

                            compiledCode.append((char)(TAG_QUOTE_ASCII_CHAR << 8 | c));

                        }

                        continue;

                    }

                }

                if (!inQuote) {

                    if (count != 0) {

                        encode(lastTag, count, compiledCode);

                        tagcount++;

                        prevTag = lastTag;

                        lastTag = -1;

                        count = 0;

                    }

                    if (tmpBuffer == null) {

                        tmpBuffer = new StringBuilder(length);

                    } else {

                        tmpBuffer.setLength(0);

                    }

                    inQuote = true;

                } else {

                    int len = tmpBuffer.length();

                    if (len == 1) {

                        char ch = tmpBuffer.charAt(0);

                        if (ch < 128) {

                            compiledCode.append((char)(TAG_QUOTE_ASCII_CHAR << 8 | ch));

                        } else {

                            compiledCode.append((char)(TAG_QUOTE_CHARS << 8 | 1));

                            compiledCode.append(ch);

                        }

                    } else {

                        encode(TAG_QUOTE_CHARS, len, compiledCode);

                        compiledCode.append(tmpBuffer);

                    }

                    inQuote = false;

                }

                continue;

            }

            if (inQuote) {

                tmpBuffer.append(c);

                continue;

            }

            if (!(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')) {

                if (count != 0) {

                    encode(lastTag, count, compiledCode);

                    tagcount++;

                    prevTag = lastTag;

                    lastTag = -1;

                    count = 0;

                }

                if (c < 128) {

                    // In most cases, c would be a delimiter, such as ':'.

                    compiledCode.append((char)(TAG_QUOTE_ASCII_CHAR << 8 | c));

                } else {

                    // Take any contiguous non-ASCII alphabet characters and

                    // put them in a single TAG_QUOTE_CHARS.

                    int j;

                    for (j = i + 1; j < length; j++) {

                        char d = pattern.charAt(j);

                        if (d == '\'' || (d >= 'a' && d <= 'z' || d >= 'A' && d <= 'Z')) {

                            break;

                        }

                    }

                    encode(TAG_QUOTE_CHARS, j - i, compiledCode);

                    for (; i < j; i++) {

                        compiledCode.append(pattern.charAt(i));

                    }

                    i--;

                }

                continue;

            }

            int tag;

            if ((tag = DateFormatSymbols.patternChars.indexOf(c)) == -1) {

                throw new IllegalArgumentException("Illegal pattern character " +

                                                   "'" + c + "'");

            }

            if (lastTag == -1 || lastTag == tag) {

                lastTag = tag;

                count++;

                continue;

            }

            encode(lastTag, count, compiledCode);

            tagcount++;

            prevTag = lastTag;

            lastTag = tag;

            count = 1;

        }

        if (inQuote) {

            throw new IllegalArgumentException("Unterminated quote");

        }

        if (count != 0) {

            encode(lastTag, count, compiledCode);

            tagcount++;

            prevTag = lastTag;

        }

        forceStandaloneForm = (tagcount == 1 && prevTag == PATTERN_MONTH);

        // Copy the compiled pattern to a char array

        int len = compiledCode.length();

        char[] r = new char[len];

        compiledCode.getChars(0, len, r, 0);

        return r;

    }

    /**

     * Encodes the given tag and length and puts encoded char(s) into buffer.

     */

    private static void encode(int tag, int length, StringBuilder buffer) {

        if (tag == PATTERN_ISO_ZONE && length >= 4) {

            throw new IllegalArgumentException("invalid ISO 8601 format: length=" + length);

        }

        if (length < 255) {

            buffer.append((char)(tag << 8 | length));

        } else {

            buffer.append((char)((tag << 8) | 0xff));

            buffer.append((char)(length >>> 16));

            buffer.append((char)(length & 0xffff));

        }

    }

    /* Initialize the fields we use to disambiguate ambiguous years. Separate

     * so we can call it from readObject().

     */

    private void initializeDefaultCentury() {

        calendar.setTimeInMillis(System.currentTimeMillis());

        calendar.add( Calendar.YEAR, -80 );

        parseAmbiguousDatesAsAfter(calendar.getTime());

    }

    /* Define one-century window into which to disambiguate dates using

     * two-digit years.

     */

    private void parseAmbiguousDatesAsAfter(Date startDate) {

        defaultCenturyStart = startDate;

        calendar.setTime(startDate);

        defaultCenturyStartYear = calendar.get(Calendar.YEAR);

    }

    /**

     * Sets the 100-year period 2-digit years will be interpreted as being in

     * to begin on the date the user specifies.

     *

     * @param startDate During parsing, two digit years will be placed in the range

     * {@code startDate} to {@code startDate + 100 years}.

     * @see #get2DigitYearStart

     * @throws NullPointerException if {@code startDate} is {@code null}.

     * @since 1.2

     */

    public void set2DigitYearStart(Date startDate) {

        parseAmbiguousDatesAsAfter(new Date(startDate.getTime()));

    }

    /**

     * Returns the beginning date of the 100-year period 2-digit years are interpreted

     * as being within.

     *

     * @return the start of the 100-year period into which two digit years are

     * parsed

     * @see #set2DigitYearStart

     * @since 1.2

     */

    public Date get2DigitYearStart() {

        return (Date) defaultCenturyStart.clone();

    }

    /**

     * Formats the given {@code Date} into a date/time string and appends

     * the result to the given {@code StringBuffer}.

     *

     * @param date the date-time value to be formatted into a date-time string.

     * @param toAppendTo where the new date-time text is to be appended.

     * @param pos keeps track on the position of the field within

     * the returned string. For example, given a date-time text

     * {@code "1996.07.10 AD at 15:08:56 PDT"}, if the given {@code fieldPosition}

     * is {@link DateFormat#YEAR_FIELD}, the begin index and end index of

     * {@code fieldPosition} will be set to 0 and 4, respectively.

     * Notice that if the same date-time field appears more than once in a

     * pattern, the {@code fieldPosition} will be set for the first occurrence

     * of that date-time field. For instance, formatting a {@code Date} to the

     * date-time string {@code "1 PM PDT (Pacific Daylight Time)"} using the

     * pattern {@code "h a z (zzzz)"} and the alignment field

     * {@link DateFormat#TIMEZONE_FIELD}, the begin index and end index of

     * {@code fieldPosition} will be set to 5 and 8, respectively, for the

     * first occurrence of the timezone pattern character {@code 'z'}.

     * @return the formatted date-time string.

     * @throws    NullPointerException if any of the parameters is {@code null}.

     */

    @Override

    public StringBuffer format(Date date, StringBuffer toAppendTo,

                               FieldPosition pos)

    {

        pos.beginIndex = pos.endIndex = 0;

        return format(date, toAppendTo, pos.getFieldDelegate());

    }

    // Called from Format after creating a FieldDelegate

    private StringBuffer format(Date date, StringBuffer toAppendTo,

                                FieldDelegate delegate) {

        // Convert input date to time field list

        calendar.setTime(date);

        boolean useDateFormatSymbols = useDateFormatSymbols();

        for (int i = 0; i < compiledPattern.length; ) {

            int tag = compiledPattern[i] >>> 8;

            int count = compiledPattern[i++] & 0xff;

            if (count == 255) {

                count = compiledPattern[i++] << 16;

                count |= compiledPattern[i++];

            }

            switch (tag) {

            case TAG_QUOTE_ASCII_CHAR:

                toAppendTo.append((char)count);

                break;

            case TAG_QUOTE_CHARS:

                toAppendTo.append(compiledPattern, i, count);

                i += count;

                break;

            default:

                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);

                break;

            }

        }

        return toAppendTo;

    }

    /**

     * Formats an Object producing an {@code AttributedCharacterIterator}.

     * You can use the returned {@code AttributedCharacterIterator}

     * to build the resulting String, as well as to determine information

     * about the resulting String.

     * <p>

     * Each attribute key of the AttributedCharacterIterator will be of type

     * {@code DateFormat.Field}, with the corresponding attribute value

     * being the same as the attribute key.

     *

     * @throws    NullPointerException if obj is null.

     * @throws    IllegalArgumentException if the Format cannot format the

     *            given object, or if the Format's pattern string is invalid.

     * @param obj The object to format

     * @return AttributedCharacterIterator describing the formatted value.

     * @since 1.4

     */

    @Override

    public AttributedCharacterIterator formatToCharacterIterator(Object obj) {

        StringBuffer sb = new StringBuffer();

        CharacterIteratorFieldDelegate delegate = new

                         CharacterIteratorFieldDelegate();

        if (obj instanceof Date) {

            format((Date)obj, sb, delegate);

        }

        else if (obj instanceof Number) {

            format(new Date(((Number)obj).longValue()), sb, delegate);

        }

        else if (obj == null) {

            throw new NullPointerException(

                   "formatToCharacterIterator must be passed non-null object");

        }

        else {

            throw new IllegalArgumentException(

                             "Cannot format given Object as a Date");

        }

        return delegate.getIterator(sb.toString());

    }

    // Map index into pattern character string to Calendar field number

    private static final int[] PATTERN_INDEX_TO_CALENDAR_FIELD = {

        Calendar.ERA,

        Calendar.YEAR,

        Calendar.MONTH,

        Calendar.DATE,

        Calendar.HOUR_OF_DAY,

        Calendar.HOUR_OF_DAY,

        Calendar.MINUTE,

        Calendar.SECOND,

        Calendar.MILLISECOND,

        Calendar.DAY_OF_WEEK,

        Calendar.DAY_OF_YEAR,

        Calendar.DAY_OF_WEEK_IN_MONTH,

        Calendar.WEEK_OF_YEAR,

        Calendar.WEEK_OF_MONTH,

        Calendar.AM_PM,

        Calendar.HOUR,

        Calendar.HOUR,

        Calendar.ZONE_OFFSET,

        Calendar.ZONE_OFFSET,

        CalendarBuilder.WEEK_YEAR,         // Pseudo Calendar field

        CalendarBuilder.ISO_DAY_OF_WEEK,   // Pseudo Calendar field

        Calendar.ZONE_OFFSET,

        Calendar.MONTH

    };

    // Map index into pattern character string to DateFormat field number

    private static final int[] PATTERN_INDEX_TO_DATE_FORMAT_FIELD = {

        DateFormat.ERA_FIELD,

        DateFormat.YEAR_FIELD,

        DateFormat.MONTH_FIELD,

        DateFormat.DATE_FIELD,

        DateFormat.HOUR_OF_DAY1_FIELD,

        DateFormat.HOUR_OF_DAY0_FIELD,

        DateFormat.MINUTE_FIELD,

        DateFormat.SECOND_FIELD,

        DateFormat.MILLISECOND_FIELD,

        DateFormat.DAY_OF_WEEK_FIELD,

        DateFormat.DAY_OF_YEAR_FIELD,

        DateFormat.DAY_OF_WEEK_IN_MONTH_FIELD,

        DateFormat.WEEK_OF_YEAR_FIELD,

        DateFormat.WEEK_OF_MONTH_FIELD,

        DateFormat.AM_PM_FIELD,

        DateFormat.HOUR1_FIELD,

        DateFormat.HOUR0_FIELD,

        DateFormat.TIMEZONE_FIELD,

        DateFormat.TIMEZONE_FIELD,

        DateFormat.YEAR_FIELD,

        DateFormat.DAY_OF_WEEK_FIELD,

        DateFormat.TIMEZONE_FIELD,

        DateFormat.MONTH_FIELD

    };

    // Maps from DecimalFormatSymbols index to Field constant

    private static final Field[] PATTERN_INDEX_TO_DATE_FORMAT_FIELD_ID = {

        Field.ERA,

        Field.YEAR,

        Field.MONTH,

        Field.DAY_OF_MONTH,

        Field.HOUR_OF_DAY1,

        Field.HOUR_OF_DAY0,

        Field.MINUTE,

        Field.SECOND,

        Field.MILLISECOND,

        Field.DAY_OF_WEEK,

        Field.DAY_OF_YEAR,

        Field.DAY_OF_WEEK_IN_MONTH,

        Field.WEEK_OF_YEAR,

        Field.WEEK_OF_MONTH,

        Field.AM_PM,

        Field.HOUR1,

        Field.HOUR0,

        Field.TIME_ZONE,

        Field.TIME_ZONE,

        Field.YEAR,

        Field.DAY_OF_WEEK,

        Field.TIME_ZONE,

        Field.MONTH

    };

    /**

     * Private member function that does the real date/time formatting.

     */

    private void subFormat(int patternCharIndex, int count,

                           FieldDelegate delegate, StringBuffer buffer,

                           boolean useDateFormatSymbols)

    {

        int     maxIntCount = Integer.MAX_VALUE;

        String  current = null;

        int     beginOffset = buffer.length();

        int field = PATTERN_INDEX_TO_CALENDAR_FIELD[patternCharIndex];

        int value;

        if (field == CalendarBuilder.WEEK_YEAR) {

            if (calendar.isWeekDateSupported()) {

                value = calendar.getWeekYear();

            } else {

                // use calendar year 'y' instead

                patternCharIndex = PATTERN_YEAR;

                field = PATTERN_INDEX_TO_CALENDAR_FIELD[patternCharIndex];

                value = calendar.get(field);

            }

        } else if (field == CalendarBuilder.ISO_DAY_OF_WEEK) {

            value = CalendarBuilder.toISODayOfWeek(calendar.get(Calendar.DAY_OF_WEEK));

        } else {

            value = calendar.get(field);

        }

        int style = (count >= 4) ? Calendar.LONG : Calendar.SHORT;

        if (!useDateFormatSymbols && field < Calendar.ZONE_OFFSET

            && patternCharIndex != PATTERN_MONTH_STANDALONE) {

            current = calendar.getDisplayName(field, style, locale);

        }

        // Note: zeroPaddingNumber() assumes that maxDigits is either

        // 2 or maxIntCount. If we make any changes to this,

        // zeroPaddingNumber() must be fixed.

        switch (patternCharIndex) {

        case PATTERN_ERA: // 'G'

            if (useDateFormatSymbols) {

                String[] eras = formatData.getEras();

                if (value < eras.length) {

                    current = eras[value];

                }

            }

            if (current == null) {

                current = "";

            }

            break;

        case PATTERN_WEEK_YEAR: // 'Y'

        case PATTERN_YEAR:      // 'y'

            if (calendar instanceof GregorianCalendar) {

                if (count != 2) {

                    zeroPaddingNumber(value, count, maxIntCount, buffer);

                } else {

                    zeroPaddingNumber(value, 2, 2, buffer);

                } // clip 1996 to 96

            } else {

                if (current == null) {

                    zeroPaddingNumber(value, style == Calendar.LONG ? 1 : count,

                                      maxIntCount, buffer);

                }

            }

            break;

        case PATTERN_MONTH:            // 'M' (context sensitive)

            if (useDateFormatSymbols) {

                String[] months;

                if (count >= 4) {

                    months = formatData.getMonths();

                    current = months[value];

                } else if (count == 3) {

                    months = formatData.getShortMonths();

                    current = months[value];

                }

            } else {

                if (count < 3) {

                    current = null;

                } else if (forceStandaloneForm) {

                    current = calendar.getDisplayName(field, style | 0x8000, locale);

                    if (current == null) {

                        current = calendar.getDisplayName(field, style, locale);

                    }

                }

            }

            if (current == null) {

                zeroPaddingNumber(value+1, count, maxIntCount, buffer);

            }

            break;

        case PATTERN_MONTH_STANDALONE: // 'L'

            assert current == null;

            if (locale == null) {

                String[] months;

                if (count >= 4) {

                    months = formatData.getMonths();

                    current = months[value];

                } else if (count == 3) {

                    months = formatData.getShortMonths();

                    current = months[value];

                }

            } else {

                if (count >= 3) {

                    current = calendar.getDisplayName(field, style | 0x8000, locale);

                }

            }

            if (current == null) {

                zeroPaddingNumber(value+1, count, maxIntCount, buffer);

            }

            break;

        case PATTERN_HOUR_OF_DAY1: // 'k' 1-based.  eg, 23:59 + 1 hour =>> 24:59

            if (current == null) {

                if (value == 0) {

                    zeroPaddingNumber(calendar.getMaximum(Calendar.HOUR_OF_DAY) + 1,

                                      count, maxIntCount, buffer);

                } else {

                    zeroPaddingNumber(value, count, maxIntCount, buffer);

                }