This commit was manufactured by cvs2svn to create tagapple/gcc-5208

'apple-gcc-5208'.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/tags/apple-gcc-5208@101526 138bc75d-0d04-0410-961f-82ee72b054a4

18 files changed, 1032 insertions, 453 deletions

diff --git a/libjava/java/text/BreakIterator.java b/libjava/java/text/BreakIterator.java
index a79db8c5f23..7fbc16b5849 100644
--- a/libjava/java/text/BreakIterator.java
+++ b/libjava/java/text/BreakIterator.java
@@ -1,5 +1,5 @@
 /* BreakIterator.java -- Breaks text into elements
-   Copyright (C) 1998, 1999, 2001, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -53,7 +53,7 @@ import java.util.ResourceBundle;
  * class will be valid upon creation.  That is, their methods will
  * not cause exceptions if called before you call setText().
  *
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @date March 19, 1999
  */
diff --git a/libjava/java/text/ChoiceFormat.java b/libjava/java/text/ChoiceFormat.java
index ff3c9f667d9..3c390278b88 100644
--- a/libjava/java/text/ChoiceFormat.java
+++ b/libjava/java/text/ChoiceFormat.java
@@ -1,5 +1,5 @@
 /* ChoiceFormat.java -- Format over a range of numbers
-   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005
    Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
@@ -71,7 +71,7 @@ formats = { "file", "files" }</pre>
  * array must be sorted in ascending order and the format string array
  * must be the same length as the terminator array.
  *
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @date March 9, 1999
  */
diff --git a/libjava/java/text/CollationElementIterator.java b/libjava/java/text/CollationElementIterator.java
index 91f341f55b2..481b286c479 100644
--- a/libjava/java/text/CollationElementIterator.java
+++ b/libjava/java/text/CollationElementIterator.java
@@ -53,9 +53,9 @@ import java.util.ArrayList;
  * <code>getCollationElementIterator</code> method on 
  * <code>RuleBasedCollator</code>.
  *
- * @author Aaron M. Renn <arenn@urbanophile.com>
- * @author Tom Tromey <tromey@cygnus.com>
- * @author Guilhem Lavaux <guilhem.lavaux@free.fr>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Tom Tromey (tromey@cygnus.com)
+ * @author Guilhem Lavaux (guilhem.lavaux@free.fr)
  */
 public final class CollationElementIterator
 {
@@ -369,8 +369,9 @@ public final class CollationElementIterator
 		    idx_idx += idxToMove;
 		    idxToMove = 0;
 		  }
-	      } else
-		idx_idx += prefix.key.length();
+	      }
+	    else
+	      idx_idx += prefix.key.length();
 	  }
       }
     
diff --git a/libjava/java/text/CollationKey.java b/libjava/java/text/CollationKey.java
index 4e6aca2635d..1fa380f3595 100644
--- a/libjava/java/text/CollationKey.java
+++ b/libjava/java/text/CollationKey.java
@@ -1,5 +1,5 @@
 /* CollationKey.java -- Precomputed collation value
-   Copyright (C) 1998, 1999, 2000, 2003  Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2003, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -59,8 +59,8 @@ package java.text;
  * <code>CollationKey</code> is created by calling the
  * <code>getCollationKey</code> method on an instance of <code>Collator</code>.
  *
- * @author Aaron M. Renn <arenn@urbanophile.com>
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Tom Tromey (tromey@cygnus.com)
  * @date March 25, 1999
  */
 public final class CollationKey implements Comparable
diff --git a/libjava/java/text/Collator.java b/libjava/java/text/Collator.java
index 6464d137041..4e634e1c137 100644
--- a/libjava/java/text/Collator.java
+++ b/libjava/java/text/Collator.java
@@ -1,5 +1,5 @@
 /* Collator.java -- Perform locale dependent String comparisons.
-   Copyright (C) 1998, 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -64,7 +64,7 @@ import java.util.ResourceBundle;
  * are described in detail in the documentation for the methods and values
  * that are related to them.
  *
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @date March 18, 1999
  */
diff --git a/libjava/java/text/DateFormat.java b/libjava/java/text/DateFormat.java
index 6fe4461b030..1571672dc43 100644
--- a/libjava/java/text/DateFormat.java
+++ b/libjava/java/text/DateFormat.java
@@ -1,5 +1,5 @@
 /* DateFormat.java -- Class for formatting/parsing date/times
-   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.
@@ -48,7 +48,7 @@ import java.util.ResourceBundle;
 import java.util.TimeZone;
 
 /**
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  * @date October 25, 1998.
  */
 /* Written using "Java Class Libraries", 2nd edition, plus online
@@ -70,29 +70,221 @@ public abstract class DateFormat extends Format implements Cloneable
 
   /* These constants need to have these exact values.  They
    * correspond to index positions within the localPatternChars
-   * string for a given locale.  For example, the US locale uses
-   * the string "GyMdkHmsSEDFwWahKz", where 'G' is the character
-   * for era, 'y' for year, and so on down to 'z' for time zone.
+   * string for a given locale.  Each locale may specify its
+   * own character for a particular field, but the position
+   * of these characters must correspond to an appropriate field
+   * number (as listed below), in order for their meaning to
+   * be determined.  For example, the US locale uses
+   * the string "GyMdkHmsSEDFwWahKzYeugAZ", where 'G' is the character
+   * for era, 'y' for year, and so on down to 'Z' for time zone.
    */
+  /**
+   * Represents the position of the era
+   * pattern character in the array of
+   * localized pattern characters. 
+   * For example, 'AD' is an era used
+   * in the Gregorian calendar system.
+   * In the U.S. locale, this is 'G'.
+   */  
   public static final int ERA_FIELD = 0;
+  /**
+   * Represents the position of the year
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'y'.
+   */
   public static final int YEAR_FIELD = 1;
+  /**
+   * Represents the position of the month
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'M'.
+   */
   public static final int MONTH_FIELD = 2;
+  /**
+   * Represents the position of the date
+   * or day of the month pattern character
+   * in the array of localized pattern
+   * characters.  In the U.S. locale,
+   * this is 'd'.
+   */
   public static final int DATE_FIELD = 3;
+  /**
+   * Represents the position of the 24
+   * hour pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'k'.
+   * This field numbers hours from 1 to 24.
+   */
   public static final int HOUR_OF_DAY1_FIELD = 4;
+  /**
+   * Represents the position of the 24
+   * hour pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'H'.
+   * This field numbers hours from 0 to 23.
+   */
   public static final int HOUR_OF_DAY0_FIELD = 5;
+  /**
+   * Represents the position of the minute
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'm'.
+   */
   public static final int MINUTE_FIELD = 6;
+  /**
+   * Represents the position of the second
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 's'.
+   */
   public static final int SECOND_FIELD = 7;
+  /**
+   * Represents the position of the millisecond
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'S'.
+   */
   public static final int MILLISECOND_FIELD = 8;
+  /**
+   * Represents the position of the day of the
+   * week pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'E'.
+   */
   public static final int DAY_OF_WEEK_FIELD = 9;
+  /**
+   * Represents the position of the day of the
+   * year pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'D'.
+   */
   public static final int DAY_OF_YEAR_FIELD = 10;
+  /**
+   * Represents the position of the day of the
+   * week in the month pattern character in the
+   * array of localized pattern characters.
+   * In the U.S. locale, this is 'F'.
+   */
   public static final int DAY_OF_WEEK_IN_MONTH_FIELD = 11;
+  /**
+   * Represents the position of the week of the
+   * year pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'w'.
+   */
   public static final int WEEK_OF_YEAR_FIELD = 12;
+  /**
+   * Represents the position of the week of the
+   * month pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'W'.
+   */
   public static final int WEEK_OF_MONTH_FIELD = 13;
+  /**
+   * Represents the position of the am/pm
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'a'.
+   */
   public static final int AM_PM_FIELD = 14;
+  /**
+   * Represents the position of the 12 
+   * hour pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'h'.
+   * This field numbers hours from 1 to 12.
+   */
   public static final int HOUR1_FIELD = 15;
+  /**
+   * Represents the position of the 12 
+   * hour pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'K'.
+   * This field numbers hours from 0 to 11.
+   */
   public static final int HOUR0_FIELD = 16;
+  /**
+   * Represents the position of the generic
+   * timezone pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'z'.
+   */
   public static final int TIMEZONE_FIELD = 17;
-
+  /**
+   * Represents the position of the ISO year
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'Y'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  This value may
+   * differ from the normal year value.
+   */
+  public static final int ISO_YEAR_FIELD = 18;
+  /**
+   * Represents the position of the localized
+   * day of the week pattern character in the
+   * array of localized pattern characters.
+   * In the U.S. locale, this is 'e'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  This value only
+   * differs from the day of the week with
+   * numeric formatting, in which case the
+   * locale's first day of the week is used.
+   */
+  public static final int LOCALIZED_DAY_OF_WEEK_FIELD = 19;
+  /**
+   * Represents the position of the extended year
+   * pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'u'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  This value modifies
+   * the year value, so as to incorporate the era.
+   * For example, in the Gregorian calendar system,
+   * the extended year is negative instead of being
+   * marked as BC.
+   */
+  public static final int EXTENDED_YEAR_FIELD = 20;
+  /**
+   * Represents the position of the modified Julian
+   * day pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'g'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  This value differs
+   * from the standard Julian day in that days
+   * are marked from midnight onwards rather than
+   * noon, and the local time zone affects the value.
+   * In simple terms, it can be thought of as all
+   * the date fields represented as a single number.
+   */
+  public static final int MODIFIED_JULIAN_DAY_FIELD = 21;
+  /**
+   * Represents the position of the millisecond
+   * in the day pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'A'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  This value represents
+   * all the time fields (excluding the time zone)
+   * numerically, giving the number of milliseconds
+   * into the day (e.g. 10 in the morning would
+   * be 10 * 60 * 60 * 1000).  Any daylight savings
+   * offset also affects this value.
+   */
+  public static final int MILLISECOND_IN_DAY_FIELD = 22;
+  /**
+   * Represents the position of the RFC822
+   * timezone pattern character in the array of
+   * localized pattern characters.
+   * In the U.S. locale, this is 'Z'.
+   * This is a GNU extension in accordance with
+   * the CLDR data used.  The value is the offset
+   * of the current time from GMT e.g. -0500 would
+   * be five hours prior to GMT.
+   */
+  public static final int RFC822_TIMEZONE_FIELD = 23;
 
   public static class Field extends Format.Field
   {
@@ -136,14 +328,28 @@ public abstract class DateFormat extends Format implements Cloneable
 	= new Field("hour0", Calendar.HOUR);
     public static final DateFormat.Field TIME_ZONE
 	= new Field("timezone", Calendar.ZONE_OFFSET);
- 
+    public static final DateFormat.Field ISO_YEAR
+	= new Field("iso year", Calendar.YEAR);
+    public static final DateFormat.Field LOCALIZED_DAY_OF_WEEK
+	= new Field("localized day of week", Calendar.DAY_OF_WEEK);
+    public static final DateFormat.Field EXTENDED_YEAR
+      = new Field("extended year", Calendar.YEAR);
+    public static final DateFormat.Field MODIFIED_JULIAN_DAY
+	= new Field("julian day", -1);
+    public static final DateFormat.Field MILLISECOND_IN_DAY
+	= new Field("millisecond in day", -1);
+    public static final DateFormat.Field RFC822_TIME_ZONE
+	= new Field("rfc822 timezone", Calendar.ZONE_OFFSET);
+
     static final DateFormat.Field[] allFields =
     {
       ERA, YEAR, MONTH, DAY_OF_MONTH, HOUR_OF_DAY1,
       HOUR_OF_DAY0, MINUTE, SECOND, MILLISECOND,
       DAY_OF_WEEK, DAY_OF_YEAR, DAY_OF_WEEK_IN_MONTH,
       WEEK_OF_YEAR, WEEK_OF_MONTH, AM_PM, HOUR1, HOUR0,
-      TIME_ZONE
+      TIME_ZONE, ISO_YEAR, LOCALIZED_DAY_OF_WEEK,
+      EXTENDED_YEAR, MODIFIED_JULIAN_DAY, MILLISECOND_IN_DAY,
+      RFC822_TIME_ZONE
     };
 
     // For deserialization
@@ -288,7 +494,7 @@ public abstract class DateFormat extends Format implements Cloneable
    * This method returns a list of available locales supported by this
    * class.
    */
-  public static Locale[] getAvailableLocales ()
+  public static Locale[] getAvailableLocales()
   {
     // FIXME
     Locale[] l = new Locale[1];
diff --git a/libjava/java/text/DateFormatSymbols.java b/libjava/java/text/DateFormatSymbols.java
index b9b71ba36a7..9555cfb67bc 100644
--- a/libjava/java/text/DateFormatSymbols.java
+++ b/libjava/java/text/DateFormatSymbols.java
@@ -1,5 +1,5 @@
 /* DateFormatSymbols.java -- Format over a range of numbers
-   Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -45,7 +45,7 @@ import java.util.ResourceBundle;
 /**
  * This class acts as container for locale specific date/time formatting
  * information such as the days of the week and the months of the year.
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  * @date October 24, 1998.
  */
 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3.
diff --git a/libjava/java/text/DecimalFormat.java b/libjava/java/text/DecimalFormat.java
index 8b2c25cd3c3..a085875a1ae 100644
--- a/libjava/java/text/DecimalFormat.java
+++ b/libjava/java/text/DecimalFormat.java
@@ -49,7 +49,8 @@ import java.util.HashMap;
 import java.util.Locale;
 
 /**
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  * @date March 4, 1999
  */
 /* Written using "Java Class Libraries", 2nd edition, plus online
diff --git a/libjava/java/text/DecimalFormatSymbols.java b/libjava/java/text/DecimalFormatSymbols.java
index 7a4e56e9a42..72a132e002a 100644
--- a/libjava/java/text/DecimalFormatSymbols.java
+++ b/libjava/java/text/DecimalFormatSymbols.java
@@ -52,7 +52,7 @@ import java.util.ResourceBundle;
  * normally handled automatically, but an application can override
  * values as desired using this class.
  *
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @date February 24, 1999
  */
diff --git a/libjava/java/text/FieldPosition.java b/libjava/java/text/FieldPosition.java
index 47cf7a146f4..6dd3a626705 100644
--- a/libjava/java/text/FieldPosition.java
+++ b/libjava/java/text/FieldPosition.java
@@ -1,5 +1,5 @@
 /* FieldPosition.java -- Keeps track of field positions while formatting
-   Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -45,7 +45,7 @@ package java.text;
  * typically define constant values for the field identifiers.
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  */
 public class FieldPosition
 {
diff --git a/libjava/java/text/Format.java b/libjava/java/text/Format.java
index 2c75578243c..970c7ce631f 100644
--- a/libjava/java/text/Format.java
+++ b/libjava/java/text/Format.java
@@ -1,5 +1,5 @@
 /* Format.java -- Abstract superclass for formatting/parsing strings.
-   Copyright (C) 1998, 1999, 2000, 2001, 2003  Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -57,7 +57,7 @@ import java.io.Serializable;
  * available locales in the current runtime environment.
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  */
 public abstract class Format implements Serializable, Cloneable
 {
diff --git a/libjava/java/text/MessageFormat.java b/libjava/java/text/MessageFormat.java
index 6a031bc7254..6c1b0508bda 100644
--- a/libjava/java/text/MessageFormat.java
+++ b/libjava/java/text/MessageFormat.java
@@ -46,107 +46,107 @@ import java.util.HashMap;
 import java.util.Locale;
 import java.util.Vector;
 
-/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @author Jorge Aliss <jaliss@hotmail.com>
- * @date March 3, 1999
- */
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 from http://www.javasoft.com.
- * Status:  Believed complete and correct to 1.2, except serialization.
- *          and parsing.
- */
-final class MessageFormatElement
+public class MessageFormat extends Format
 {
-  // Argument number.
-  int argNumber;
-  // Formatter to be used.  This is the format set by setFormat.
-  Format setFormat;
-  // Formatter to be used based on the type.
-  Format format;
-
-  // Argument will be checked to make sure it is an instance of this
-  // class.
-  Class formatClass;
-
-  // Formatter type.
-  String type;
-  // Formatter style.
-  String style;
-
-  // Text to follow this element.
-  String trailer;
-
-  // Recompute the locale-based formatter.
-  void setLocale (Locale loc)
+  /**
+   * @author Tom Tromey (tromey@cygnus.com)
+   * @author Jorge Aliss (jaliss@hotmail.com)
+   * @date March 3, 1999
+   */
+  /* Written using "Java Class Libraries", 2nd edition, plus online
+   * API docs for JDK 1.2 from http://www.javasoft.com.
+   * Status:  Believed complete and correct to 1.2, except serialization.
+   *          and parsing.
+   */
+  private static final class MessageFormatElement
   {
-    if (type == null)
-      ;
-    else if (type.equals("number"))
-      {
-	formatClass = java.lang.Number.class;
-
-	if (style == null)
-	  format = NumberFormat.getInstance(loc);
-	else if (style.equals("currency"))
-	  format = NumberFormat.getCurrencyInstance(loc);
-	else if (style.equals("percent"))
-	  format = NumberFormat.getPercentInstance(loc);
-	else if (style.equals("integer"))
-	  {
-	    NumberFormat nf = NumberFormat.getNumberInstance(loc);
-	    nf.setMaximumFractionDigits(0);
-	    nf.setGroupingUsed(false);
-	    format = nf;
-	  }
-	else
-	  {
-	    format = NumberFormat.getNumberInstance(loc);
-	    DecimalFormat df = (DecimalFormat) format;
-	    df.applyPattern(style);
-	  }
-      }
-    else if (type.equals("time") || type.equals("date"))
-      {
-	formatClass = java.util.Date.class;
-
-	int val = DateFormat.DEFAULT;
-	if (style == null)
-	  ;
-	else if (style.equals("short"))
-	  val = DateFormat.SHORT;
-	else if (style.equals("medium"))
-	  val = DateFormat.MEDIUM;
-	else if (style.equals("long"))
-	  val = DateFormat.LONG;
-	else if (style.equals("full"))
-	  val = DateFormat.FULL;
-
-	if (type.equals("time"))
-	  format = DateFormat.getTimeInstance(val, loc);
-	else
-	  format = DateFormat.getDateInstance(val, loc);
-
-	if (style != null && val == DateFormat.DEFAULT)
-	  {
-	    SimpleDateFormat sdf = (SimpleDateFormat) format;
-	    sdf.applyPattern(style);
-	  }
-      }
-    else if (type.equals("choice"))
-      {
-	formatClass = java.lang.Number.class;
-
-	if (style == null)
-	  throw new
-	    IllegalArgumentException ("style required for choice format");
-	format = new ChoiceFormat (style);
-      }
+    // Argument number.
+    int argNumber;
+    // Formatter to be used.  This is the format set by setFormat.
+    Format setFormat;
+    // Formatter to be used based on the type.
+    Format format;
+
+    // Argument will be checked to make sure it is an instance of this
+    // class.
+    Class formatClass;
+
+    // Formatter type.
+    String type;
+    // Formatter style.
+    String style;
+
+    // Text to follow this element.
+    String trailer;
+
+    // Recompute the locale-based formatter.
+    void setLocale (Locale loc)
+    {
+      if (type == null)
+        ;
+      else if (type.equals("number"))
+        {
+	  formatClass = java.lang.Number.class;
+
+	  if (style == null)
+	    format = NumberFormat.getInstance(loc);
+	  else if (style.equals("currency"))
+	    format = NumberFormat.getCurrencyInstance(loc);
+	  else if (style.equals("percent"))
+	    format = NumberFormat.getPercentInstance(loc);
+	  else if (style.equals("integer"))
+	    {
+	      NumberFormat nf = NumberFormat.getNumberInstance(loc);
+	      nf.setMaximumFractionDigits(0);
+	      nf.setGroupingUsed(false);
+	      format = nf;
+	    }
+	  else
+	    {
+	      format = NumberFormat.getNumberInstance(loc);
+	      DecimalFormat df = (DecimalFormat) format;
+	      df.applyPattern(style);
+	    }
+        }
+      else if (type.equals("time") || type.equals("date"))
+        {
+	  formatClass = java.util.Date.class;
+
+	  int val = DateFormat.DEFAULT;
+	  if (style == null)
+	    ;
+	  else if (style.equals("short"))
+	    val = DateFormat.SHORT;
+	  else if (style.equals("medium"))
+	    val = DateFormat.MEDIUM;
+	  else if (style.equals("long"))
+	    val = DateFormat.LONG;
+	  else if (style.equals("full"))
+	    val = DateFormat.FULL;
+
+	  if (type.equals("time"))
+	    format = DateFormat.getTimeInstance(val, loc);
+	  else
+	    format = DateFormat.getDateInstance(val, loc);
+
+	  if (style != null && val == DateFormat.DEFAULT)
+	    {
+	      SimpleDateFormat sdf = (SimpleDateFormat) format;
+	      sdf.applyPattern(style);
+	    }
+        }
+      else if (type.equals("choice"))
+        {
+	  formatClass = java.lang.Number.class;
+
+	  if (style == null)
+	    throw new
+	      IllegalArgumentException ("style required for choice format");
+	  format = new ChoiceFormat (style);
+        }
+    }
   }
-}
 
-public class MessageFormat extends Format
-{
   private static final long serialVersionUID = 6479157306784022952L;
 
   public static class Field extends Format.Field
diff --git a/libjava/java/text/NumberFormat.java b/libjava/java/text/NumberFormat.java
index 368292686bc..4fc98b15c54 100644
--- a/libjava/java/text/NumberFormat.java
+++ b/libjava/java/text/NumberFormat.java
@@ -59,7 +59,7 @@ import java.util.ResourceBundle;
  * static factory methods in this class such as 
  * <code>getCurrencyInstance</code>.
  * 
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @date March 4, 1999
  */
diff --git a/libjava/java/text/ParseException.java b/libjava/java/text/ParseException.java
index 20e828e18a7..13229c8c89a 100644
--- a/libjava/java/text/ParseException.java
+++ b/libjava/java/text/ParseException.java
@@ -1,5 +1,5 @@
 /* ParseException.java -- an error occurred while parsing
-   Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2002, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -42,7 +42,7 @@ package java.text;
  * This exception is thrown when an unexpected error occurs during parsing.
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  * @see Format
  * @see FieldPosition
  * @status updated to 1.4
diff --git a/libjava/java/text/ParsePosition.java b/libjava/java/text/ParsePosition.java
index c6dffed8f59..91fa44fccf4 100644
--- a/libjava/java/text/ParsePosition.java
+++ b/libjava/java/text/ParsePosition.java
@@ -1,5 +1,5 @@
 /* ParsePosition.java -- Keep track of position while parsing.
-   Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -43,7 +43,7 @@ package java.text;
  * operations.
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
- * @author Per Bothner <bothner@cygnus.com>
+ * @author Per Bothner (bothner@cygnus.com)
  */
 public class ParsePosition
 {
diff --git a/libjava/java/text/RuleBasedCollator.java b/libjava/java/text/RuleBasedCollator.java
index c2cff5a0c8c..afb766ff8ae 100644
--- a/libjava/java/text/RuleBasedCollator.java
+++ b/libjava/java/text/RuleBasedCollator.java
@@ -1,5 +1,5 @@
 /* RuleBasedCollator.java -- Concrete Collator Class
-   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004  Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -435,56 +435,57 @@ main_parse_loop:
 	    continue;
 	  }
 
-	switch (c) {
-	case '!':
-	  throw new ParseException
-	    ("Modifier '!' is not yet supported by Classpath", i+base_offset);
-	case '<':
-	  type = CollationSorter.GREATERP;
-	  break;
-	case ';':
-	  type = CollationSorter.GREATERS;
-	  break;
-	case ',':
-	  type = CollationSorter.GREATERT;
-	  break;
-	case '=':
-	  type = CollationSorter.EQUAL;
-	  break;
-	case '\'':
-	  eatingChars = !eatingChars;
-	  doubleQuote = true;
-	  break;
-	case '@':
-	  if (ignoreChars)
-	    throw new ParseException
-	      ("comparison list has not yet been started. You may only use"
-	       + "(<,;=&)", i+base_offset);
-	  // Inverse the order of secondaries from now on.
-	  nextIsModifier = true;
-	  type = CollationSorter.INVERSE_SECONDARY;
-	  break;
-	case '&':
-	  type = CollationSorter.RESET;
-	  if (stop_on_reset)
-	    break main_parse_loop;
-	  break;
-	default:
-	  if (operator < 0)
-	    throw new ParseException
-	      ("operator missing at " + (i+base_offset), i+base_offset);
-	  if (!eatingChars &&
-	      ((c >= 0x21 && c <= 0x2F) 
-	       || (c >= 0x3A && c <= 0x40)
-	       || (c >= 0x5B && c <= 0x60)
-	       || (c >= 0x7B && c <= 0x7E)))
+	switch (c)
+	  {
+	  case '!':
 	    throw new ParseException
-	      ("unquoted punctuation character '"+c+"'", i+base_offset);
-
-	  //type = ignoreChars ? CollationSorter.IGNORE : -1;
-	  sb.append(c);
-	  break;
-	}
+	      ("Modifier '!' is not yet supported by Classpath", i + base_offset);
+	  case '<':
+	    type = CollationSorter.GREATERP;
+	    break;
+	  case ';':
+	    type = CollationSorter.GREATERS;
+	    break;
+	  case ',':
+	    type = CollationSorter.GREATERT;
+	    break;
+	  case '=':
+	    type = CollationSorter.EQUAL;
+	    break;
+	  case '\'':
+	    eatingChars = !eatingChars;
+	    doubleQuote = true;
+	    break;
+	  case '@':
+	    if (ignoreChars)
+	      throw new ParseException
+		("comparison list has not yet been started. You may only use"
+		 + "(<,;=&)", i + base_offset);
+	    // Inverse the order of secondaries from now on.
+	    nextIsModifier = true;
+	    type = CollationSorter.INVERSE_SECONDARY;
+	    break;
+	  case '&':
+	    type = CollationSorter.RESET;
+	    if (stop_on_reset)
+	      break main_parse_loop;
+	    break;
+	  default:
+	    if (operator < 0)
+	      throw new ParseException
+		("operator missing at " + (i + base_offset), i + base_offset);
+	    if (! eatingChars
+		&& ((c >= 0x21 && c <= 0x2F) 
+		    || (c >= 0x3A && c <= 0x40)
+		    || (c >= 0x5B && c <= 0x60)
+		    || (c >= 0x7B && c <= 0x7E)))
+	      throw new ParseException
+		("unquoted punctuation character '" + c + "'", i + base_offset);
+
+	    //type = ignoreChars ? CollationSorter.IGNORE : -1;
+	    sb.append(c);
+	    break;
+	  }
 
 	if (type  < 0)
 	  continue;
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;
+  }
+
 }
diff --git a/libjava/java/text/StringCharacterIterator.java b/libjava/java/text/StringCharacterIterator.java
index 44bac6b74a3..82df7c44992 100644
--- a/libjava/java/text/StringCharacterIterator.java
+++ b/libjava/java/text/StringCharacterIterator.java
@@ -1,5 +1,5 @@
 /* StringCharacterIterator.java -- Iterate over a character range in a string
-   Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2001, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -46,7 +46,7 @@ package java.text;
  * the index to be set. 
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
- * @author Tom Tromey <tromey@cygnus.com>
+ * @author Tom Tromey (tromey@cygnus.com)
  */
 public final class StringCharacterIterator implements CharacterIterator
 {