diff options
Diffstat (limited to 'libjava/java/text/SimpleDateFormat.java')
| -rw-r--r-- | libjava/java/text/SimpleDateFormat.java | 906 |
1 files changed, 638 insertions, 268 deletions
diff --git a/libjava/java/text/SimpleDateFormat.java b/libjava/java/text/SimpleDateFormat.java index 35083eb887e..190b4d624f4 100644 --- a/libjava/java/text/SimpleDateFormat.java +++ b/libjava/java/text/SimpleDateFormat.java @@ -1,6 +1,6 @@ /* SimpleDateFormat.java -- A class for parsing/formating simple date constructs - Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004 + Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -46,6 +46,7 @@ import gnu.java.text.FormatCharacterIterator; import gnu.java.text.StringFormatBuffer; import java.io.IOException; +import java.io.InvalidObjectException; import java.io.ObjectInputStream; import java.util.ArrayList; import java.util.Calendar; @@ -53,8 +54,9 @@ import java.util.Date; import java.util.GregorianCalendar; import java.util.Iterator; import java.util.Locale; -import java.util.SimpleTimeZone; import java.util.TimeZone; +import java.util.regex.Matcher; +import java.util.regex.Pattern; /** * SimpleDateFormat provides convenient methods for parsing and formatting @@ -62,34 +64,190 @@ import java.util.TimeZone; */ public class SimpleDateFormat extends DateFormat { - /** A pair class used by SimpleDateFormat as a compiled representation - * of a format string. + /** + * This class is used by <code>SimpleDateFormat</code> as a + * compiled representation of a format string. The field + * ID, size, and character used are stored for each sequence + * of pattern characters. */ - private class FieldSizePair + private class CompiledField { - public int field; - public int size; + /** + * The ID of the field within the local pattern characters, + */ + private int field; + + /** + * The size of the character sequence. + */ + private int size; + + /** + * The character used. + */ + private char character; - /** Constructs a pair with the given field and size values */ - public FieldSizePair(int f, int s) { + /** + * Constructs a compiled field using the + * the given field ID, size and character + * values. + * + * @param f the field ID. + * @param s the size of the field. + * @param c the character used. + */ + public CompiledField(int f, int s, char c) + { field = f; size = s; + character = c; + } + + /** + * Retrieves the ID of the field relative to + * the local pattern characters. + */ + public int getField() + { + return field; + } + + /** + * Retrieves the size of the character sequence. + */ + public int getSize() + { + return size; + } + + /** + * Retrieves the character used in the sequence. + */ + public char getCharacter() + { + return character; + } + + /** + * Returns a <code>String</code> representation + * of the compiled field, primarily for debugging + * purposes. + * + * @return a <code>String</code> representation. + */ + public String toString() + { + StringBuffer builder; + + builder = new StringBuffer(getClass().getName()); + builder.append("[field="); + builder.append(field); + builder.append(", size="); + builder.append(size); + builder.append(", character="); + builder.append(character); + builder.append("]"); + + return builder.toString(); } } + /** + * A list of <code>CompiledField</code>s, + * representing the compiled version of the pattern. + * + * @see CompiledField + * @serial Ignored. + */ private transient ArrayList tokens; - private DateFormatSymbols formatData; // formatData + + /** + * The localised data used in formatting, + * such as the day and month names in the local + * language, and the localized pattern characters. + * + * @see DateFormatSymbols + * @serial The localisation data. May not be null. + */ + private DateFormatSymbols formatData; + + /** + * The date representing the start of the century + * used for interpreting two digit years. For + * example, 24/10/2004 would cause two digit + * years to be interpreted as representing + * the years between 2004 and 2104. + * + * @see get2DigitYearStart() + * @see set2DigitYearStart(java.util.Date) + * @see Date + * @serial The start date of the century for parsing two digit years. + * May not be null. + */ private Date defaultCenturyStart; + + /** + * The year at which interpretation of two + * digit years starts. + * + * @see get2DigitYearStart() + * @see set2DigitYearStart(java.util.Date) + * @serial Ignored. + */ private transient int defaultCentury; + + /** + * The non-localized pattern string. This + * only ever contains the pattern characters + * stored in standardChars. Localized patterns + * are translated to this form. + * + * @see applyPattern(String) + * @see applyLocalizedPattern(String) + * @see toPattern() + * @see toLocalizedPattern() + * @serial The non-localized pattern string. May not be null. + */ private String pattern; + + /** + * The version of serialized data used by this class. + * Version 0 only includes the pattern and formatting + * data. Version 1 adds the start date for interpreting + * two digit years. + * + * @serial This specifies the version of the data being serialized. + * Version 0 (or no version) specifies just <code>pattern</code> + * and <code>formatData</code>. Version 1 adds + * the <code>defaultCenturyStart</code>. This implementation + * always writes out version 1 data. + */ private int serialVersionOnStream = 1; // 0 indicates JDK1.1.3 or earlier + + /** + * For compatability. + */ private static final long serialVersionUID = 4774881970558875024L; - // This string is specified in the JCL. We set it here rather than - // do a DateFormatSymbols(Locale.US).getLocalPatternChars() since - // someone could theoretically change those values (though unlikely). - private static final String standardChars = "GyMdkHmsSEDFwWahKzZ"; + // This string is specified in the root of the CLDR. We set it here + // rather than doing a DateFormatSymbols(Locale.US).getLocalPatternChars() + // since someone could theoretically change those values (though unlikely). + private static final String standardChars = "GyMdkHmsSEDFwWahKzYeugAZ"; + /** + * Reads the serialized version of this object. + * If the serialized data is only version 0, + * then the date for the start of the century + * for interpreting two digit years is computed. + * The pattern is parsed and compiled following the process + * of reading in the serialized data. + * + * @param stream the object stream to read the data from. + * @throws IOException if an I/O error occurs. + * @throws ClassNotFoundException if the class of the serialized data + * could not be found. + * @throws InvalidObjectException if the pattern is invalid. + */ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { @@ -105,9 +263,25 @@ public class SimpleDateFormat extends DateFormat // Set up items normally taken care of by the constructor. tokens = new ArrayList(); - compileFormat(pattern); + try + { + compileFormat(pattern); + } + catch (IllegalArgumentException e) + { + throw new InvalidObjectException("The stream pattern was invalid."); + } } + /** + * Compiles the supplied non-localized pattern into a form + * from which formatting and parsing can be performed. + * This also detects errors in the pattern, which will + * be raised on later use of the compiled data. + * + * @param pattern the non-localized pattern to compile. + * @throws IllegalArgumentException if the pattern is invalid. + */ private void compileFormat(String pattern) { // Any alphabetical characters are treated as pattern characters @@ -116,24 +290,25 @@ public class SimpleDateFormat extends DateFormat char thisChar; int pos; int field; - FieldSizePair current = null; + CompiledField current = null; for (int i=0; i<pattern.length(); i++) { thisChar = pattern.charAt(i); - field = formatData.getLocalPatternChars().indexOf(thisChar); + field = standardChars.indexOf(thisChar); if (field == -1) { current = null; if ((thisChar >= 'A' && thisChar <= 'Z') || (thisChar >= 'a' && thisChar <= 'z')) { - // Not a valid letter - tokens.add(new FieldSizePair(-1,0)); + // Not a valid letter + throw new IllegalArgumentException("Invalid letter " + thisChar + + "encountered at character " + i + + "."); } else if (thisChar == '\'') { // Quoted text section; skip to next single quote pos = pattern.indexOf('\'',i+1); if (pos == -1) { - // This ought to be an exception, but spec does not - // let us throw one. - tokens.add(new FieldSizePair(-1,0)); + throw new IllegalArgumentException("Quotes starting at character " + + i + " not closed."); } if ((pos+1 < pattern.length()) && (pattern.charAt(pos+1) == '\'')) { tokens.add(pattern.substring(i+1,pos+1)); @@ -150,20 +325,38 @@ public class SimpleDateFormat extends DateFormat if ((current != null) && (field == current.field)) { current.size++; } else { - current = new FieldSizePair(field,1); + current = new CompiledField(field,1,thisChar); tokens.add(current); } } } } + /** + * Returns a string representation of this + * class. + * + * @return a string representation of the <code>SimpleDateFormat</code> + * instance. + */ public String toString() { - StringBuffer output = new StringBuffer(); - Iterator i = tokens.iterator(); - while (i.hasNext()) { - output.append(i.next().toString()); - } + StringBuffer output = new StringBuffer(getClass().getName()); + output.append("[tokens="); + output.append(tokens); + output.append(", formatData="); + output.append(formatData); + output.append(", defaultCenturyStart="); + output.append(defaultCenturyStart); + output.append(", defaultCentury="); + output.append(defaultCentury); + output.append(", pattern="); + output.append(pattern); + output.append(", serialVersionOnStream="); + output.append(serialVersionOnStream); + output.append(", standardChars="); + output.append(standardChars); + output.append("]"); return output.toString(); } @@ -194,8 +387,12 @@ public class SimpleDateFormat extends DateFormat } /** - * Creates a date formatter using the specified pattern, with the default - * DateFormatSymbols for the default locale. + * Creates a date formatter using the specified non-localized pattern, + * with the default DateFormatSymbols for the default locale. + * + * @param pattern the pattern to use. + * @throws NullPointerException if the pattern is null. + * @throws IllegalArgumentException if the pattern is invalid. */ public SimpleDateFormat(String pattern) { @@ -203,8 +400,13 @@ public class SimpleDateFormat extends DateFormat } /** - * Creates a date formatter using the specified pattern, with the default - * DateFormatSymbols for the given locale. + * Creates a date formatter using the specified non-localized pattern, + * with the default DateFormatSymbols for the given locale. + * + * @param pattern the non-localized pattern to use. + * @param locale the locale to use for the formatting symbols. + * @throws NullPointerException if the pattern is null. + * @throws IllegalArgumentException if the pattern is invalid. */ public SimpleDateFormat(String pattern, Locale locale) { @@ -222,8 +424,14 @@ public class SimpleDateFormat extends DateFormat } /** - * Creates a date formatter using the specified pattern. The - * specified DateFormatSymbols will be used when formatting. + * Creates a date formatter using the specified non-localized + * pattern. The specified DateFormatSymbols will be used when + * formatting. + * + * @param pattern the non-localized pattern to use. + * @param formatData the formatting symbols to use. + * @throws NullPointerException if the pattern or formatData is null. + * @throws IllegalArgumentException if the pattern is invalid. */ public SimpleDateFormat(String pattern, DateFormatSymbols formatData) { @@ -231,6 +439,8 @@ public class SimpleDateFormat extends DateFormat calendar = new GregorianCalendar(); computeCenturyStart (); tokens = new ArrayList(); + if (formatData == null) + throw new NullPointerException("formatData"); this.formatData = formatData; compileFormat(pattern); this.pattern = pattern; @@ -240,9 +450,6 @@ public class SimpleDateFormat extends DateFormat numberFormat.setMaximumFractionDigits (0); } - // What is the difference between localized and unlocalized? The - // docs don't say. - /** * This method returns a string with the formatting pattern being used * by this object. This string is unlocalized. @@ -263,7 +470,7 @@ public class SimpleDateFormat extends DateFormat public String toLocalizedPattern() { String localChars = formatData.getLocalPatternChars(); - return applyLocalizedPattern (pattern, standardChars, localChars); + return translateLocalizedPattern(pattern, standardChars, localChars); } /** @@ -271,6 +478,8 @@ public class SimpleDateFormat extends DateFormat * object. This string is not localized. * * @param pattern The new format pattern. + * @throws NullPointerException if the pattern is null. + * @throws IllegalArgumentException if the pattern is invalid. */ public void applyPattern(String pattern) { @@ -284,16 +493,34 @@ public class SimpleDateFormat extends DateFormat * object. This string is localized. * * @param pattern The new format pattern. + * @throws NullPointerException if the pattern is null. + * @throws IllegalArgumentException if the pattern is invalid. */ public void applyLocalizedPattern(String pattern) { String localChars = formatData.getLocalPatternChars(); - pattern = applyLocalizedPattern (pattern, localChars, standardChars); + pattern = translateLocalizedPattern(pattern, localChars, standardChars); applyPattern(pattern); } - private String applyLocalizedPattern(String pattern, - String oldChars, String newChars) + /** + * Translates either from or to a localized variant of the pattern + * string. For example, in the German locale, 't' (for 'tag') is + * used instead of 'd' (for 'date'). This method translates + * a localized pattern (such as 'ttt') to a non-localized pattern + * (such as 'ddd'), or vice versa. Non-localized patterns use + * a standard set of characters, which match those of the U.S. English + * locale. + * + * @param pattern the pattern to translate. + * @param oldChars the old set of characters (used in the pattern). + * @param newChars the new set of characters (which will be used in the + * pattern). + * @return a version of the pattern using the characters in + * <code>newChars</code>. + */ + private String translateLocalizedPattern(String pattern, + String oldChars, String newChars) { int len = pattern.length(); StringBuffer buf = new StringBuffer(len); @@ -341,14 +568,14 @@ public class SimpleDateFormat extends DateFormat } /** - * This method returns the format symbol information used for parsing - * and formatting dates. + * This method returns a copy of the format symbol information used + * for parsing and formatting dates. * - * @return The date format symbols. + * @return a copy of the date format symbols. */ public DateFormatSymbols getDateFormatSymbols() { - return formatData; + return (DateFormatSymbols) formatData.clone(); } /** @@ -356,9 +583,15 @@ public class SimpleDateFormat extends DateFormat * and formatting dates. * * @param formatData The date format symbols. + * @throws NullPointerException if <code>formatData</code> is null. */ public void setDateFormatSymbols(DateFormatSymbols formatData) { + if (formatData == null) + { + throw new + NullPointerException("The supplied format data was null."); + } this.formatData = formatData; } @@ -431,12 +664,12 @@ public class SimpleDateFormat extends DateFormat while (iter.hasNext()) { Object o = iter.next(); - if (o instanceof FieldSizePair) + if (o instanceof CompiledField) { - FieldSizePair p = (FieldSizePair) o; + CompiledField cf = (CompiledField) o; int beginIndex = buffer.length(); - switch (p.field) + switch (cf.getField()) { case ERA_FIELD: buffer.append (formatData.eras[calendar.get (Calendar.ERA)], DateFormat.Field.ERA); @@ -445,75 +678,75 @@ public class SimpleDateFormat extends DateFormat // If we have two digits, then we truncate. Otherwise, we // use the size of the pattern, and zero pad. buffer.setDefaultAttribute (DateFormat.Field.YEAR); - if (p.size == 2) + if (cf.getSize() == 2) { temp = String.valueOf (calendar.get (Calendar.YEAR)); buffer.append (temp.substring (temp.length() - 2)); } else - withLeadingZeros (calendar.get (Calendar.YEAR), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.YEAR), cf.getSize(), buffer); break; case MONTH_FIELD: buffer.setDefaultAttribute (DateFormat.Field.MONTH); - if (p.size < 3) - withLeadingZeros (calendar.get (Calendar.MONTH) + 1, p.size, buffer); - else if (p.size < 4) + if (cf.getSize() < 3) + withLeadingZeros (calendar.get (Calendar.MONTH) + 1, cf.getSize(), buffer); + else if (cf.getSize() < 4) buffer.append (formatData.shortMonths[calendar.get (Calendar.MONTH)]); else buffer.append (formatData.months[calendar.get (Calendar.MONTH)]); break; case DATE_FIELD: buffer.setDefaultAttribute (DateFormat.Field.DAY_OF_MONTH); - withLeadingZeros (calendar.get (Calendar.DATE), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.DATE), cf.getSize(), buffer); break; case HOUR_OF_DAY1_FIELD: // 1-24 buffer.setDefaultAttribute(DateFormat.Field.HOUR_OF_DAY1); withLeadingZeros ( ((calendar.get (Calendar.HOUR_OF_DAY) + 23) % 24) + 1, - p.size, buffer); + cf.getSize(), buffer); break; case HOUR_OF_DAY0_FIELD: // 0-23 buffer.setDefaultAttribute (DateFormat.Field.HOUR_OF_DAY0); - withLeadingZeros (calendar.get (Calendar.HOUR_OF_DAY), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.HOUR_OF_DAY), cf.getSize(), buffer); break; case MINUTE_FIELD: buffer.setDefaultAttribute (DateFormat.Field.MINUTE); withLeadingZeros (calendar.get (Calendar.MINUTE), - p.size, buffer); + cf.getSize(), buffer); break; case SECOND_FIELD: buffer.setDefaultAttribute (DateFormat.Field.SECOND); withLeadingZeros(calendar.get (Calendar.SECOND), - p.size, buffer); + cf.getSize(), buffer); break; case MILLISECOND_FIELD: buffer.setDefaultAttribute (DateFormat.Field.MILLISECOND); - withLeadingZeros (calendar.get (Calendar.MILLISECOND), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.MILLISECOND), cf.getSize(), buffer); break; case DAY_OF_WEEK_FIELD: buffer.setDefaultAttribute (DateFormat.Field.DAY_OF_WEEK); - if (p.size < 4) + if (cf.getSize() < 4) buffer.append (formatData.shortWeekdays[calendar.get (Calendar.DAY_OF_WEEK)]); else buffer.append (formatData.weekdays[calendar.get (Calendar.DAY_OF_WEEK)]); break; case DAY_OF_YEAR_FIELD: buffer.setDefaultAttribute (DateFormat.Field.DAY_OF_YEAR); - withLeadingZeros (calendar.get (Calendar.DAY_OF_YEAR), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.DAY_OF_YEAR), cf.getSize(), buffer); break; case DAY_OF_WEEK_IN_MONTH_FIELD: buffer.setDefaultAttribute (DateFormat.Field.DAY_OF_WEEK_IN_MONTH); withLeadingZeros (calendar.get (Calendar.DAY_OF_WEEK_IN_MONTH), - p.size, buffer); + cf.getSize(), buffer); break; case WEEK_OF_YEAR_FIELD: buffer.setDefaultAttribute (DateFormat.Field.WEEK_OF_YEAR); withLeadingZeros (calendar.get (Calendar.WEEK_OF_YEAR), - p.size, buffer); + cf.getSize(), buffer); break; case WEEK_OF_MONTH_FIELD: buffer.setDefaultAttribute (DateFormat.Field.WEEK_OF_MONTH); withLeadingZeros (calendar.get (Calendar.WEEK_OF_MONTH), - p.size, buffer); + cf.getSize(), buffer); break; case AM_PM_FIELD: buffer.setDefaultAttribute (DateFormat.Field.AM_PM); @@ -521,25 +754,39 @@ public class SimpleDateFormat extends DateFormat break; case HOUR1_FIELD: // 1-12 buffer.setDefaultAttribute (DateFormat.Field.HOUR1); - withLeadingZeros (((calendar.get (Calendar.HOUR) + 11) % 12) + 1, p.size, buffer); + withLeadingZeros (((calendar.get (Calendar.HOUR) + 11) % 12) + 1, + cf.getSize(), buffer); break; case HOUR0_FIELD: // 0-11 buffer.setDefaultAttribute (DateFormat.Field.HOUR0); - withLeadingZeros (calendar.get (Calendar.HOUR), p.size, buffer); + withLeadingZeros (calendar.get (Calendar.HOUR), cf.getSize(), buffer); break; case TIMEZONE_FIELD: buffer.setDefaultAttribute (DateFormat.Field.TIME_ZONE); TimeZone zone = calendar.getTimeZone(); boolean isDST = calendar.get (Calendar.DST_OFFSET) != 0; // FIXME: XXX: This should be a localized time zone. - String zoneID = zone.getDisplayName (isDST, p.size > 3 ? TimeZone.LONG : TimeZone.SHORT); + String zoneID = zone.getDisplayName + (isDST, cf.getSize() > 3 ? TimeZone.LONG : TimeZone.SHORT); buffer.append (zoneID); break; + case RFC822_TIMEZONE_FIELD: + buffer.setDefaultAttribute(DateFormat.Field.RFC822_TIME_ZONE); + int pureMinutes = (calendar.get(Calendar.ZONE_OFFSET) + + calendar.get(Calendar.DST_OFFSET)) / (1000 * 60); + String sign = (pureMinutes < 0) ? "-" : "+"; + int hours = pureMinutes / 60; + int minutes = pureMinutes % 60; + buffer.append(sign); + withLeadingZeros(hours, 2, buffer); + withLeadingZeros(minutes, 2, buffer); + break; default: - throw new IllegalArgumentException ("Illegal pattern character " + p.field); + throw new IllegalArgumentException ("Illegal pattern character " + + cf.getCharacter()); } if (pos != null && (buffer.getDefaultAttribute() == pos.getFieldAttribute() - || p.field == pos.getField())) + || cf.getField() == pos.getField())) { pos.setBeginIndex(beginIndex); pos.setEndIndex(buffer.length()); @@ -614,232 +861,277 @@ public class SimpleDateFormat extends DateFormat boolean saw_timezone = false; int quote_start = -1; boolean is2DigitYear = false; - for (; fmt_index < fmt_max; ++fmt_index) + try { - char ch = pattern.charAt(fmt_index); - if (ch == '\'') + for (; fmt_index < fmt_max; ++fmt_index) { - int index = pos.getIndex(); - if (fmt_index < fmt_max - 1 - && pattern.charAt(fmt_index + 1) == '\'') + char ch = pattern.charAt(fmt_index); + if (ch == '\'') + { + int index = pos.getIndex(); + if (fmt_index < fmt_max - 1 + && pattern.charAt(fmt_index + 1) == '\'') + { + if (! expect (dateStr, pos, ch)) + return null; + ++fmt_index; + } + else + quote_start = quote_start < 0 ? fmt_index : -1; + continue; + } + + if (quote_start != -1 + || ((ch < 'a' || ch > 'z') + && (ch < 'A' || ch > 'Z'))) { if (! expect (dateStr, pos, ch)) return null; - ++fmt_index; + continue; } - else - quote_start = quote_start < 0 ? fmt_index : -1; - continue; - } - - if (quote_start != -1 - || ((ch < 'a' || ch > 'z') - && (ch < 'A' || ch > 'Z'))) - { - if (! expect (dateStr, pos, ch)) - return null; - continue; - } - - // We've arrived at a potential pattern character in the - // pattern. - int first = fmt_index; - while (++fmt_index < fmt_max && pattern.charAt(fmt_index) == ch) - ; - int fmt_count = fmt_index - first; - - // We might need to limit the number of digits to parse in - // some cases. We look to the next pattern character to - // decide. - boolean limit_digits = false; - if (fmt_index < fmt_max - && standardChars.indexOf(pattern.charAt(fmt_index)) >= 0) - limit_digits = true; - --fmt_index; - - // We can handle most fields automatically: most either are - // numeric or are looked up in a string vector. In some cases - // we need an offset. When numeric, `offset' is added to the - // resulting value. When doing a string lookup, offset is the - // initial index into the string array. - int calendar_field; - boolean is_numeric = true; - String[] match = null; - int offset = 0; - boolean maybe2DigitYear = false; - switch (ch) - { - case 'd': - calendar_field = Calendar.DATE; - break; - case 'D': - calendar_field = Calendar.DAY_OF_YEAR; - break; - case 'F': - calendar_field = Calendar.DAY_OF_WEEK_IN_MONTH; - break; - case 'E': - is_numeric = false; - offset = 1; - calendar_field = Calendar.DAY_OF_WEEK; - match = (fmt_count <= 3 - ? formatData.getShortWeekdays() - : formatData.getWeekdays()); - break; - case 'w': - calendar_field = Calendar.WEEK_OF_YEAR; - break; - case 'W': - calendar_field = Calendar.WEEK_OF_MONTH; - break; - case 'M': - calendar_field = Calendar.MONTH; - if (fmt_count <= 2) - offset = -1; - else + + // We've arrived at a potential pattern character in the + // pattern. + int fmt_count = 1; + while (++fmt_index < fmt_max && pattern.charAt(fmt_index) == ch) { - is_numeric = false; - match = (fmt_count <= 3 - ? formatData.getShortMonths() - : formatData.getMonths()); + ++fmt_count; } - break; - case 'y': - calendar_field = Calendar.YEAR; - if (fmt_count <= 2) - maybe2DigitYear = true; - break; - case 'K': - calendar_field = Calendar.HOUR; - break; - case 'h': - calendar_field = Calendar.HOUR; - break; - case 'H': - calendar_field = Calendar.HOUR_OF_DAY; - break; - case 'k': - calendar_field = Calendar.HOUR_OF_DAY; - break; - case 'm': - calendar_field = Calendar.MINUTE; - break; - case 's': - calendar_field = Calendar.SECOND; - break; - case 'S': - calendar_field = Calendar.MILLISECOND; - break; - case 'a': - is_numeric = false; - calendar_field = Calendar.AM_PM; - match = formatData.getAmPmStrings(); - break; - case 'z': - // We need a special case for the timezone, because it - // uses a different data structure than the other cases. - is_numeric = false; - calendar_field = Calendar.DST_OFFSET; - String[][] zoneStrings = formatData.getZoneStrings(); - int zoneCount = zoneStrings.length; - int index = pos.getIndex(); - boolean found_zone = false; - for (int j = 0; j < zoneCount; j++) + + // We might need to limit the number of digits to parse in + // some cases. We look to the next pattern character to + // decide. + boolean limit_digits = false; + if (fmt_index < fmt_max + && standardChars.indexOf(pattern.charAt(fmt_index)) >= 0) + limit_digits = true; + --fmt_index; + + // We can handle most fields automatically: most either are + // numeric or are looked up in a string vector. In some cases + // we need an offset. When numeric, `offset' is added to the + // resulting value. When doing a string lookup, offset is the + // initial index into the string array. + int calendar_field; + boolean is_numeric = true; + int offset = 0; + boolean maybe2DigitYear = false; + boolean oneBasedHour = false; + boolean oneBasedHourOfDay = false; + Integer simpleOffset; + String[] set1 = null; + String[] set2 = null; + switch (ch) { - String[] strings = zoneStrings[j]; - int k; - for (k = 1; k < strings.length; ++k) + case 'd': + calendar_field = Calendar.DATE; + break; + case 'D': + calendar_field = Calendar.DAY_OF_YEAR; + break; + case 'F': + calendar_field = Calendar.DAY_OF_WEEK_IN_MONTH; + break; + case 'E': + is_numeric = false; + offset = 1; + calendar_field = Calendar.DAY_OF_WEEK; + set1 = formatData.getWeekdays(); + set2 = formatData.getShortWeekdays(); + break; + case 'w': + calendar_field = Calendar.WEEK_OF_YEAR; + break; + case 'W': + calendar_field = Calendar.WEEK_OF_MONTH; + break; + case 'M': + calendar_field = Calendar.MONTH; + if (fmt_count <= 2) + offset = -1; + else { - if (dateStr.startsWith(strings[k], index)) - break; + is_numeric = false; + set1 = formatData.getMonths(); + set2 = formatData.getShortMonths(); } - if (k != strings.length) + break; + case 'y': + calendar_field = Calendar.YEAR; + if (fmt_count <= 2) + maybe2DigitYear = true; + break; + case 'K': + calendar_field = Calendar.HOUR; + break; + case 'h': + calendar_field = Calendar.HOUR; + oneBasedHour = true; + break; + case 'H': + calendar_field = Calendar.HOUR_OF_DAY; + break; + case 'k': + calendar_field = Calendar.HOUR_OF_DAY; + oneBasedHourOfDay = true; + break; + case 'm': + calendar_field = Calendar.MINUTE; + break; + case 's': + calendar_field = Calendar.SECOND; + break; + case 'S': + calendar_field = Calendar.MILLISECOND; + break; + case 'a': + is_numeric = false; + calendar_field = Calendar.AM_PM; + set1 = formatData.getAmPmStrings(); + break; + case 'z': + case 'Z': + // We need a special case for the timezone, because it + // uses a different data structure than the other cases. + is_numeric = false; + calendar_field = Calendar.ZONE_OFFSET; + String[][] zoneStrings = formatData.getZoneStrings(); + int zoneCount = zoneStrings.length; + int index = pos.getIndex(); + boolean found_zone = false; + simpleOffset = computeOffset(dateStr.substring(index)); + if (simpleOffset != null) { found_zone = true; saw_timezone = true; - TimeZone tz = TimeZone.getTimeZone (strings[0]); - calendar.set (Calendar.ZONE_OFFSET, tz.getRawOffset ()); - offset = 0; - if (k > 2 && tz instanceof SimpleTimeZone) + calendar.set(Calendar.DST_OFFSET, 0); + offset = simpleOffset.intValue(); + } + else + { + for (int j = 0; j < zoneCount; j++) { - SimpleTimeZone stz = (SimpleTimeZone) tz; - offset = stz.getDSTSavings (); + String[] strings = zoneStrings[j]; + int k; + for (k = 0; k < strings.length; ++k) + { + if (dateStr.startsWith(strings[k], index)) + break; + } + if (k != strings.length) + { + found_zone = true; + saw_timezone = true; + TimeZone tz = TimeZone.getTimeZone (strings[0]); + // Check if it's a DST zone or ordinary + if(k == 3 || k == 4) + calendar.set (Calendar.DST_OFFSET, tz.getDSTSavings()); + else + calendar.set (Calendar.DST_OFFSET, 0); + offset = tz.getRawOffset (); + pos.setIndex(index + strings[k].length()); + break; + } } - pos.setIndex(index + strings[k].length()); - break; } - } - if (! found_zone) - { + if (! found_zone) + { + pos.setErrorIndex(pos.getIndex()); + return null; + } + break; + default: pos.setErrorIndex(pos.getIndex()); return null; } - break; - default: - pos.setErrorIndex(pos.getIndex()); - return null; - } - - // Compute the value we should assign to the field. - int value; - int index = -1; - if (is_numeric) - { - numberFormat.setMinimumIntegerDigits(fmt_count); - if (limit_digits) - numberFormat.setMaximumIntegerDigits(fmt_count); - if (maybe2DigitYear) - index = pos.getIndex(); - Number n = numberFormat.parse(dateStr, pos); - if (pos == null || ! (n instanceof Long)) - return null; - value = n.intValue() + offset; - } - else if (match != null) - { - index = pos.getIndex(); - int i; - for (i = offset; i < match.length; ++i) + + // Compute the value we should assign to the field. + int value; + int index = -1; + if (is_numeric) { - if (dateStr.startsWith(match[i], index)) - break; + numberFormat.setMinimumIntegerDigits(fmt_count); + if (limit_digits) + numberFormat.setMaximumIntegerDigits(fmt_count); + if (maybe2DigitYear) + index = pos.getIndex(); + Number n = numberFormat.parse(dateStr, pos); + if (pos == null || ! (n instanceof Long)) + return null; + value = n.intValue() + offset; } - if (i == match.length) + else if (set1 != null) { - pos.setErrorIndex(index); - return null; + index = pos.getIndex(); + int i; + boolean found = false; + for (i = offset; i < set1.length; ++i) + { + if (set1[i] != null) + if (dateStr.toUpperCase().startsWith(set1[i].toUpperCase(), + index)) + { + found = true; + pos.setIndex(index + set1[i].length()); + break; + } + } + if (!found && set2 != null) + { + for (i = offset; i < set2.length; ++i) + { + if (set2[i] != null) + if (dateStr.toUpperCase().startsWith(set2[i].toUpperCase(), + index)) + { + found = true; + pos.setIndex(index + set2[i].length()); + break; + } + } + } + if (!found) + { + pos.setErrorIndex(index); + return null; + } + value = i; } - pos.setIndex(index + match[i].length()); - value = i; - } - else - value = offset; + else + value = offset; - if (maybe2DigitYear) - { - // Parse into default century if the numeric year string has - // exactly 2 digits. - int digit_count = pos.getIndex() - index; - if (digit_count == 2) - is2DigitYear = true; - } + if (maybe2DigitYear) + { + // Parse into default century if the numeric year string has + // exactly 2 digits. + int digit_count = pos.getIndex() - index; + if (digit_count == 2) + { + is2DigitYear = true; + value += defaultCentury; + } + } + + // Calendar uses 0-based hours. + // I.e. 00:00 AM is midnight, not 12 AM or 24:00 + if (oneBasedHour && value == 12) + value = 0; - // Assign the value and move on. - calendar.set(calendar_field, value); - } + if (oneBasedHourOfDay && value == 24) + value = 0; + + // Assign the value and move on. + calendar.set(calendar_field, value); + } - if (is2DigitYear) - { - // Apply the 80-20 heuristic to dermine the full year based on - // defaultCenturyStart. - int year = defaultCentury + calendar.get(Calendar.YEAR); - calendar.set(Calendar.YEAR, year); - if (calendar.getTime().compareTo(defaultCenturyStart) < 0) - calendar.set(Calendar.YEAR, year + 100); - } - - try - { + if (is2DigitYear) + { + // Apply the 80-20 heuristic to dermine the full year based on + // defaultCenturyStart. + int year = calendar.get(Calendar.YEAR); + if (calendar.getTime().compareTo(defaultCenturyStart) < 0) + calendar.set(Calendar.YEAR, year + 100); + } if (! saw_timezone) { // Use the real rules to determine whether or not this @@ -854,6 +1146,69 @@ public class SimpleDateFormat extends DateFormat pos.setErrorIndex(pos.getIndex()); return null; } + } + + /** + * <p> + * Computes the time zone offset in milliseconds + * relative to GMT, based on the supplied + * <code>String</code> representation. + * </p> + * <p> + * The supplied <code>String</code> must be a three + * or four digit signed number, with an optional 'GMT' + * prefix. The first one or two digits represents the hours, + * while the last two represent the minutes. The + * two sets of digits can optionally be separated by + * ':'. The mandatory sign prefix (either '+' or '-') + * indicates the direction of the offset from GMT. + * </p> + * <p> + * For example, 'GMT+0200' specifies 2 hours after + * GMT, while '-05:00' specifies 5 hours prior to + * GMT. The special case of 'GMT' alone can be used + * to represent the offset, 0. + * </p> + * <p> + * If the <code>String</code> can not be parsed, + * the result will be null. The resulting offset + * is wrapped in an <code>Integer</code> object, in + * order to allow such failure to be represented. + * </p> + * + * @param zoneString a string in the form + * (GMT)? sign hours : minutes + * where sign = '+' or '-', hours + * is a one or two digits representing + * a number between 0 and 23, and + * minutes is two digits representing + * a number between 0 and 59. + * @return the parsed offset, or null if parsing + * failed. + */ + private Integer computeOffset(String zoneString) + { + Pattern pattern = + Pattern.compile("(GMT)?([+-])([012])?([0-9]):?([0-9]{2})"); + Matcher matcher = pattern.matcher(zoneString); + if (matcher.matches()) + { + int sign = matcher.group(2).equals("+") ? 1 : -1; + int hour = (Integer.parseInt(matcher.group(3)) * 10) + + Integer.parseInt(matcher.group(4)); + int minutes = Integer.parseInt(matcher.group(5)); + + if (hour > 23) + return null; + + int offset = sign * ((hour * 60) + minutes) * 60000; + return new Integer(offset); + } + else if (zoneString.startsWith("GMT")) + { + return new Integer(0); + } + return null; } // Compute the start of the current century as defined by @@ -864,4 +1219,19 @@ public class SimpleDateFormat extends DateFormat calendar.set(Calendar.YEAR, year - 80); set2DigitYearStart(calendar.getTime()); } + + /** + * Returns a copy of this instance of + * <code>SimpleDateFormat</code>. The copy contains + * clones of the formatting symbols and the 2-digit + * year century start date. + */ + public Object clone() + { + SimpleDateFormat clone = (SimpleDateFormat) super.clone(); + clone.setDateFormatSymbols((DateFormatSymbols) formatData.clone()); + clone.set2DigitYearStart((Date) defaultCenturyStart.clone()); + return clone; + } + } |