// 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 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 millisPerHour = 60 * 60 * 1000;

private static final int millisPerMinute = 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 Hashtable<String,String[]> cachedLocaleData

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

/**

private static Hashtable<Locale,NumberFormat> cachedNumberFormatData

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

/**

private Locale locale;

/**

transient boolean useDateFormatSymbols;

/**

public SimpleDateFormat() {

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

}

/**

public SimpleDateFormat(String pattern)

{

this(pattern, Locale.getDefault());

}

/**

public SimpleDateFormat(String pattern, Locale locale)

{

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

throw new NullPointerException();

}

initializeCalendar(locale);

this.pattern = pattern;

this.formatData = DateFormatSymbols.getInstance(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();

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 key = getKey();

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

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.put(key, dateTimePatterns);

}

formatData = DateFormatSymbols.getInstance(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.put(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 String getKey() {

StringBuilder sb = new StringBuilder();

sb.append(getCalendarName()).append('.');

sb.append(locale.getLanguage()).append('_').append(locale.getCountry()).append('_').append(locale.getVariant());

return sb.toString();

}

/**

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 (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.setTime( new Date() );

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

}

/**

public Date get2DigitYearStart() {

return defaultCenturyStart;

}

/**

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

}

/**

@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

};

// 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,

};

// 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,

};

/**

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