// the official serial version ID which says cryptically

// which version we're compatible with

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;

/**

private int serialVersionOnStream = currentSerialVersion;

/**

private String pattern;

/**

transient private NumberFormat originalNumberFormat;

transient private String originalNumberPattern;

/**

transient private char minusSign = '-';

/**

transient private boolean hasFollowingMinusSign = false;

/**

transient private char[] compiledPattern;

/**

private final static int TAG_QUOTE_ASCII_CHAR = 100;

private final static int TAG_QUOTE_CHARS = 101;

/**

transient private char zeroDigit;

/**

private DateFormatSymbols formatData;

/**

private Date defaultCenturyStart;

transient private 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";

/**

private static final ConcurrentMap<Locale, String[]> cachedLocaleData

= new ConcurrentHashMap<Locale, String[]>(3);

/**

private static final ConcurrentMap<Locale, NumberFormat> cachedNumberFormatData

= new ConcurrentHashMap<Locale, NumberFormat>(3);

/**

private Locale locale;

/**

transient boolean useDateFormatSymbols;

/**

public SimpleDateFormat() {

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

}

/**

public SimpleDateFormat(String pattern)

{

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

}

/**

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

}

/**

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;

}

/* Package-private, called by DateFormat factory methods */

SimpleDateFormat(int timeStyle, int dateStyle, Locale loc) {

if (loc == null) {

throw new NullPointerException();

}

this.locale = loc;

// initialize calendar and related fields

initializeCalendar(loc);

/* try the cache first */

String[] dateTimePatterns = cachedLocaleData.get(loc);

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

ResourceBundle r = LocaleData.getDateFormatData(loc);

if (!isGregorianCalendar()) {

try {

dateTimePatterns = r.getStringArray(getCalendarName() + ".DateTimePatterns");

} catch (MissingResourceException e) {

}

}

if (dateTimePatterns == null) {

dateTimePatterns = r.getStringArray("DateTimePatterns");

}

/* update cache */

cachedLocaleData.putIfAbsent(loc, dateTimePatterns);

}

formatData = DateFormatSymbols.getInstanceRef(loc);

if ((timeStyle >= 0) && (dateStyle >= 0)) {

Object[] dateTimeArgs = {dateTimePatterns[timeStyle],

dateTimePatterns[dateStyle + 4]};

pattern = MessageFormat.format(dateTimePatterns[8], dateTimeArgs);

}

else if (timeStyle >= 0) {

pattern = dateTimePatterns[timeStyle];

}

else if (dateStyle >= 0) {

pattern = dateTimePatterns[dateStyle + 4];

}

else {

throw new IllegalArgumentException("No date or time style specified");

}

initialize(loc);

}

/* 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(TimeZone.getDefault(), loc);

}

}

/**

private char[] compile(String pattern) {

int length = pattern.length();

boolean inQuote = false;

StringBuilder compiledPattern = new StringBuilder(length * 2);

StringBuilder tmpBuffer = null;

int count = 0;

int lastTag = -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, compiledPattern);

lastTag = -1;

count = 0;

}

if (inQuote) {

tmpBuffer.append(c);

} else {

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

}

continue;

}

}

if (!inQuote) {

if (count != 0) {

encode(lastTag, count, compiledPattern);

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) {

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

} else {

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

compiledPattern.append(ch);

}

} else {

encode(TAG_QUOTE_CHARS, len, compiledPattern);

compiledPattern.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, compiledPattern);

lastTag = -1;

count = 0;

}

if (c < 128) {

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

compiledPattern.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;

}

}

compiledPattern.append((char)(TAG_QUOTE_CHARS << 8 | (j - i)));

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

compiledPattern.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, compiledPattern);

lastTag = tag;

count = 1;

}

if (inQuote) {

throw new IllegalArgumentException("Unterminated quote");

}

if (count != 0) {

encode(lastTag, count, compiledPattern);

}

// Copy the compiled pattern to a char array

int len = compiledPattern.length();

char[] r = new char[len];

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

return r;

}

/**

private static final 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

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

private void parseAmbiguousDatesAsAfter(Date startDate) {

defaultCenturyStart = startDate;

calendar.setTime(startDate);

defaultCenturyStartYear = calendar.get(Calendar.YEAR);

}

/**

public void set2DigitYearStart(Date startDate) {

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

}

/**

public Date get2DigitYearStart() {

return (Date) defaultCenturyStart.clone();

}

/**

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;

}

/**