2007-02-24 Jakub Jelinek <jakub@redhat.com>

libjava/classpath/
	* java/util/TimeZone.java (getDefaultDisplayName): Don't
	check if TimeZone is instanceof SimpleTimeZone.

2007-02-22  Jakub Jelinek  <jakub@redhat.com>

libjava/
	* java/util/VMTimeZone.java (getDefaultTimeZoneId): To read
	/etc/localtime, use ZoneInfo.readTZFile instead of
	VMTimeZone.readtzFile.  Get better timezone name for /etc/localtime,
	either if it is a symlink or through /etc/sysconfig/clock.
	(readSysconfigClockFile): New static method.
	(readtzFile): Removed.
	* java/lang/System.java: Add gnu.java.util.zoneinfo.dir to comments.
	* posix.cc (_Jv_platform_initProperties): Set
	gnu.java.util.zoneinfo.dir.
	* sources.am (gnu_java_util_source_files): Add
	classpath/gnu/java/util/ZoneInfo.java.
	* Makefile.in: Regenerated.
libjava/classpath/
	* java/util/Date.java (parse): Properly parse 09:01:02 as
	hours/minutes/seconds, not as hours/minutes/year.
	* java/util/SimpleTimeZone.java (SimpleTimeZone): Simplify
	{start,end}TimeMode constructor by calling shorter constructor,
	set {start,end}TimeMode fields after it returns.
	(setStartRule): Don't adjust startTime into WALL_TIME.  Set
	startTimeMode to WALL_TIME.
	(endStartRule): Similarly.
	(getOffset): Handle properly millis + dstOffset overflowing into the
	next day.  Adjust startTime resp. endTime based on startTimeMode
	resp. endTimeMode.
	* java/util/TimeZone.java (zoneinfo_dir, availableIDs, aliases0): New
	static fields.
	(timezones): Remove synchronized keyword.  Set zoneinfo_dir.
	If non-null, set up aliases0 and don't put anything into
	timezones0.
	(defaultZone): Call getTimeZone instead of timezones().get.
	(getDefaultTimeZone): Fix parsing of EST5 or EST5EDT6.  Use
	getTimeZoneInternal instead of timezones().get.
	(parseTime): Parse correctly hour:minute.
	(getTimeZoneInternal): New private method.
	(getTimeZone): Do the custom ID checking first, canonicalize
	ID for custom IDs as required by documentation.  Call
	getTimeZoneInternal to handle the rest.
	(getAvailableIDs(int)): Add locking.  Handle zoneinfo_dir != null.
	(getAvailableIDs(File,String,ArrayList)): New private method.
	(getAvailableIDs()): Add locking.  Handle zoneinfo_dir != null.
	* gnu/java/util/ZoneInfo.java: New file.

2007-02-14  Jakub Jelinek  <jakub@redhat.com>
	Andrew Haley  <aph@redhat.com>

libjava/classpath/
	* java/util/TimeZone.java (getDateParams): Negate dayOfWeek.

2007-02-09  Jakub Jelinek  <jakub@redhat.com>

libjava/
	* java/util/VMTimeZone.java: Rewrite to handle both the old
	'TZif\0' format and the new one.
libjava/classpath/
	* java/util/TimeZone.java: Handle default (one hour) daylight
	savings.

	* scripts/timezones.pl: Parse each file in 2 passes, in one parse
	just Rule lines, in the other everything else.  Pass 0 instead of
	$savings as second argument to parseRule when parsing the start
	rule.
	* java/util/TimeZone.java (timezones): Regenerate from tzdata2007a.


git-svn-id: https://gcc.gnu.org/svn/gcc/branches/redhat/fc5-4_1-branch@127091 138bc75d-0d04-0410-961f-82ee72b054a4

12 files changed, 1844 insertions, 397 deletions

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 716ad555374..20d777f0de6 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,25 @@
+2007-02-22  Jakub Jelinek  <jakub@redhat.com>
+
+	PR libgcj/17002
+	PR classpath/28550
+	* java/util/VMTimeZone.java (getDefaultTimeZoneId): To read
+	/etc/localtime, use ZoneInfo.readTZFile instead of
+	VMTimeZone.readtzFile.  Get better timezone name for /etc/localtime,
+	either if it is a symlink or through /etc/sysconfig/clock.
+	(readSysconfigClockFile): New static method.
+	(readtzFile): Removed.
+	* java/lang/System.java: Add gnu.java.util.zoneinfo.dir to comments.
+	* posix.cc (_Jv_platform_initProperties): Set
+	gnu.java.util.zoneinfo.dir.
+	* sources.am (gnu_java_util_source_files): Add
+	classpath/gnu/java/util/ZoneInfo.java.
+	* Makefile.in: Regenerated.
+
+2007-02-09  Jakub Jelinek  <jakub@redhat.com>
+
+	* java/util/VMTimeZone.java: Rewrite to handle both the old
+	'TZif\0' format and the new one.
+
 2006-07-13  Anthony Green  <green@redhat.com>
 
 	* java/io/natFilePosix.cc (performSetLastModified): Return true on
diff --git a/libjava/Makefile.in b/libjava/Makefile.in
index 872c21fe5fb..fa9538da2e0 100644
--- a/libjava/Makefile.in
+++ b/libjava/Makefile.in
@@ -1892,7 +1892,8 @@ classpath/gnu/java/text/WordBreakIterator.java
 gnu_java_text_header_files = $(patsubst classpath/%,%,$(patsubst %.java,%.h,$(gnu_java_text_source_files)))
 gnu_java_util_source_files = \
 classpath/gnu/java/util/DoubleEnumeration.java \
-classpath/gnu/java/util/EmptyEnumeration.java
+classpath/gnu/java/util/EmptyEnumeration.java \
+classpath/gnu/java/util/ZoneInfo.java
 
 gnu_java_util_header_files = $(patsubst classpath/%,%,$(patsubst %.java,%.h,$(gnu_java_util_source_files)))
 gnu_java_util_prefs_source_files = \
diff --git a/libjava/classpath/ChangeLog b/libjava/classpath/ChangeLog
index 2f9eddd2735..4a58ff37b70 100644
--- a/libjava/classpath/ChangeLog
+++ b/libjava/classpath/ChangeLog
@@ -1,3 +1,58 @@
+2007-02-24  Jakub Jelinek  <jakub@redhat.com>
+
+	* java/util/TimeZone.java (getDefaultDisplayName): Don't
+	check if TimeZone is instanceof SimpleTimeZone.
+
+2007-02-22  Jakub Jelinek  <jakub@redhat.com>
+
+	PR libgcj/17002
+	PR classpath/28550
+	* java/util/Date.java (parse): Properly parse 09:01:02 as
+	hours/minutes/seconds, not as hours/minutes/year.
+	* java/util/SimpleTimeZone.java (SimpleTimeZone): Simplify
+	{start,end}TimeMode constructor by calling shorter constructor,
+	set {start,end}TimeMode fields after it returns.
+	(setStartRule): Don't adjust startTime into WALL_TIME.  Set
+	startTimeMode to WALL_TIME.
+	(endStartRule): Similarly.
+	(getOffset): Handle properly millis + dstOffset overflowing into the
+	next day.  Adjust startTime resp. endTime based on startTimeMode
+	resp. endTimeMode.
+	* java/util/TimeZone.java (zoneinfo_dir, availableIDs, aliases0): New
+	static fields.
+	(timezones): Remove synchronized keyword.  Set zoneinfo_dir.
+	If non-null, set up aliases0 and don't put anything into
+	timezones0.
+	(defaultZone): Call getTimeZone instead of timezones().get.
+	(getDefaultTimeZone): Fix parsing of EST5 or EST5EDT6.  Use
+	getTimeZoneInternal instead of timezones().get.
+	(parseTime): Parse correctly hour:minute.
+	(getTimeZoneInternal): New private method.
+	(getTimeZone): Do the custom ID checking first, canonicalize
+	ID for custom IDs as required by documentation.  Call
+	getTimeZoneInternal to handle the rest.
+	(getAvailableIDs(int)): Add locking.  Handle zoneinfo_dir != null.
+	(getAvailableIDs(File,String,ArrayList)): New private method.
+	(getAvailableIDs()): Add locking.  Handle zoneinfo_dir != null.
+	* gnu/java/util/ZoneInfo.java: New file.
+
+2007-02-14  Jakub Jelinek  <jakub@redhat.com>
+	Andrew Haley  <aph@redhat.com>
+
+	* java/util/TimeZone.java (getDateParams): Negate dayOfWeek.
+
+2007-02-09  Jakub Jelinek  <jakub@redhat.com>
+
+	* java/util/TimeZone.java: Handle default (one hour) daylight
+	savings.
+
+	PR 23566
+	* scripts/timezones.pl: Parse each file in 2 passes, in one parse
+	just Rule lines, in the other everything else.  Pass 0 instead of
+	$savings as second argument to parseRule when parsing the start
+	rule.
+	* java/util/TimeZone.java (timezones): Regenerate from tzdata2007a.
+
 2006-07-04  Peter O'Gorman  <peter@pogma.com>
 
 	* ltconfig: chmod 644 before ranlib during install.
diff --git a/libjava/classpath/gnu/java/util/ZoneInfo.java b/libjava/classpath/gnu/java/util/ZoneInfo.java
index 2146a321f40..a243193a97d 100644
--- a/libjava/classpath/gnu/java/util/ZoneInfo.java
+++ b/libjava/classpath/gnu/java/util/ZoneInfo.java
@@ -1158,3 +1158,1163 @@ public class ZoneInfo extends TimeZone
     return millis;
   }
 }
+/* gnu.java.util.ZoneInfo
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.util;
+
+import java.io.BufferedInputStream;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.SimpleTimeZone;
+import java.util.TimeZone;
+
+/**
+ * This class represents more advanced variant of java.util.SimpleTimeZone.
+ * It can handle zic(8) compiled transition dates plus uses a SimpleTimeZone
+ * for years beyond last precomputed transition.  Before first precomputed
+ * transition it assumes no daylight saving was in effect.
+ * Timezones that never used daylight saving time should use just
+ * SimpleTimeZone instead of this class.
+ *
+ * This object is tightly bound to the Gregorian calendar.  It assumes
+ * a regular seven days week, and the month lengths are that of the
+ * Gregorian Calendar.
+ *
+ * @see Calendar
+ * @see GregorianCalendar
+ * @see SimpleTimeZone
+ * @author Jakub Jelinek
+ */
+public class ZoneInfo extends TimeZone
+{
+  private static final int SECS_SHIFT = 22;
+  private static final long OFFSET_MASK = (1 << 21) - 1;
+  private static final int OFFSET_SHIFT = 64 - 21;
+  private static final long IS_DST = 1 << 21;
+
+  /**
+   * The raw time zone offset in milliseconds to GMT, ignoring
+   * daylight savings.
+   * @serial
+   */
+  private int rawOffset;
+
+  /**
+   * Cached DST savings for the last transition rule.
+   */
+  private int dstSavings;
+
+  /**
+   * Cached flag whether last transition rule uses DST saving.
+   */
+  private boolean useDaylight;
+
+  /**
+   * Array of encoded transitions.
+   * Transition time in UTC seconds since epoch is in the most
+   * significant 64 - SECS_SHIFT bits, then one bit flag
+   * whether DST is active and the least significant bits
+   * containing offset relative to rawOffset.  Both the DST
+   * flag and relative offset apply to time before the transition
+   * and after or equal to previous transition if any.
+   * The array must be sorted.
+   */
+  private long[] transitions;
+
+  /**
+   * SimpleTimeZone rule which applies on or after the latest
+   * transition.  If the DST changes are not expresible as a
+   * SimpleTimeZone rule, then the rule should just contain
+   * the standard time and no DST time.
+   */
+  private SimpleTimeZone lastRule;
+
+  /**
+   * Cached GMT SimpleTimeZone object for internal use in
+   * getOffset method.
+   */
+  private static SimpleTimeZone gmtZone = null;
+
+  static final long serialVersionUID = -3740626706860383657L;
+
+  /**
+   * Create a <code>ZoneInfo</code> with the given time offset
+   * from GMT and with daylight savings.
+   *
+   * @param rawOffset The time offset from GMT in milliseconds.
+   * @param id  The identifier of this time zone.
+   * @param transitions  Array of transition times in UTC seconds since
+   * Epoch in topmost 42 bits, below that 1 boolean bit whether the time
+   * before that transition used daylight saving and in bottommost 21
+   * bits relative daylight saving offset against rawOffset in seconds
+   * that applies before this transition.
+   * @param endRule SimpleTimeZone class describing the daylight saving
+   * rules after the last transition.
+   */
+  public ZoneInfo(int rawOffset, String id, long[] transitions,
+		  SimpleTimeZone lastRule)
+  {
+    if (transitions == null || transitions.length < 1)
+      throw new IllegalArgumentException("transitions must not be null");
+    if (lastRule == null)
+      throw new IllegalArgumentException("lastRule must not be null");
+    this.rawOffset = rawOffset;
+    this.transitions = transitions;
+    this.lastRule = lastRule;
+    setID(id);
+    computeDSTSavings();
+  }
+
+  /**
+   * Gets the time zone offset, for current date, modified in case of
+   * daylight savings.  This is the offset to add to UTC to get the local
+   * time.
+   *
+   * The day must be a positive number and dayOfWeek must be a positive value
+   * from Calendar.  dayOfWeek is redundant, but must match the other values
+   * or an inaccurate result may be returned.
+   *
+   * @param era the era of the given date
+   * @param year the year of the given date
+   * @param month the month of the given date, 0 for January.
+   * @param day the day of month
+   * @param dayOfWeek the day of week; this must match the other fields.
+   * @param millis the millis in the day (in local standard time)
+   * @return the time zone offset in milliseconds.
+   * @throws IllegalArgumentException if arguments are incorrect.
+   */
+  public int getOffset(int era, int year, int month, int day, int dayOfWeek,
+		       int millis)
+  {
+    if (gmtZone == null)
+      gmtZone = new SimpleTimeZone(0, "GMT");
+
+    if (dayOfWeek < Calendar.SUNDAY || dayOfWeek > Calendar.SATURDAY)
+      throw new IllegalArgumentException("dayOfWeek out of range");
+    if (month < Calendar.JANUARY || month > Calendar.DECEMBER)
+      throw new IllegalArgumentException("month out of range:" + month);
+
+    if (era != GregorianCalendar.AD)
+      return (int) (((transitions[0] << OFFSET_SHIFT) >> OFFSET_SHIFT) * 1000);
+
+    GregorianCalendar cal = new GregorianCalendar((TimeZone) gmtZone);
+    cal.set(year, month, day, 0, 0, 0);
+    if (cal.get(Calendar.DAY_OF_MONTH) != day)
+      throw new IllegalArgumentException("day out of range");
+
+    return getOffset(cal.getTimeInMillis() - rawOffset + millis);
+  }
+
+  private long findTransition(long secs)
+  {
+    if (secs < (transitions[0] >> SECS_SHIFT))
+      return transitions[0];
+
+    if (secs >= (transitions[transitions.length-1] >> SECS_SHIFT))
+      return Long.MAX_VALUE;
+
+    long val = (secs + 1) << SECS_SHIFT;
+    int lo = 1;
+    int hi = transitions.length;
+    int mid = 1;
+    while (lo < hi)
+      {
+	mid = (lo + hi) / 2;
+	// secs < (transitions[mid-1] >> SECS_SHIFT)
+	if (val <= transitions[mid-1])
+	  hi = mid;
+	// secs >= (transitions[mid] >> SECS_SHIFT)
+	else if (val > transitions[mid])
+	  lo = mid + 1;
+	else
+	  break;
+      }
+    return transitions[mid];
+  }
+
+  /**
+   * Get the time zone offset for the specified date, modified in case of
+   * daylight savings.  This is the offset to add to UTC to get the local
+   * time.
+   * @param date the date represented in millisecends
+   * since January 1, 1970 00:00:00 GMT.
+   */
+  public int getOffset(long date)
+  {
+    long d = (date >= 0 ? date / 1000 : (date + 1) / 1000 - 1);
+    long transition = findTransition(d);
+
+    // For times on or after last transition use lastRule.
+    if (transition == Long.MAX_VALUE)
+      return lastRule.getOffset(date);
+
+    return (int) (((transition << OFFSET_SHIFT) >> OFFSET_SHIFT) * 1000);
+  }
+
+  /**
+   * Returns the time zone offset to GMT in milliseconds, ignoring
+   * day light savings.
+   * @return the time zone offset.
+   */
+  public int getRawOffset()
+  {
+    return rawOffset;
+  }
+
+  /**
+   * Sets the standard time zone offset to GMT.
+   * @param rawOffset The time offset from GMT in milliseconds.
+   */
+  public void setRawOffset(int rawOffset)
+  {
+    this.rawOffset = rawOffset;
+    lastRule.setRawOffset(rawOffset);
+  }
+
+  private void computeDSTSavings()
+  {
+    if (lastRule.useDaylightTime())
+      {
+	dstSavings = lastRule.getDSTSavings();
+	useDaylight = true;
+      }
+    else
+      {
+	dstSavings = 0;
+	useDaylight = false;
+	// lastRule might say no DST is in effect simply because
+	// the DST rules are too complex for SimpleTimeZone, say
+	// for Asia/Jerusalem.
+	// Look at the last DST offset if it is newer than current time.
+	long currentSecs = System.currentTimeMillis() / 1000;
+	int i;
+	for (i = transitions.length - 1;
+	     i >= 0 && currentSecs < (transitions[i] >> SECS_SHIFT);
+	     i--)
+	  if ((transitions[i] & IS_DST) != 0)
+	    {
+	      dstSavings = (int) (((transitions[i] << OFFSET_SHIFT)
+				   >> OFFSET_SHIFT) * 1000)
+			   - rawOffset;
+	      useDaylight = true;
+	      break;
+	    }
+      }
+  }
+
+  /**
+   * Gets the daylight savings offset.  This is a positive offset in
+   * milliseconds with respect to standard time.  Typically this
+   * is one hour, but for some time zones this may be half an our.
+   * @return the daylight savings offset in milliseconds.
+   */
+  public int getDSTSavings()
+  {
+    return dstSavings;
+  }
+
+  /**
+   * Returns if this time zone uses daylight savings time.
+   * @return true, if we use daylight savings time, false otherwise.
+   */
+  public boolean useDaylightTime()
+  {
+    return useDaylight;
+  }
+
+  /**
+   * Determines if the given date is in daylight savings time.
+   * @return true, if it is in daylight savings time, false otherwise.
+   */
+  public boolean inDaylightTime(Date date)
+  {
+    long d = date.getTime();
+    d = (d >= 0 ? d / 1000 : (d + 1) / 1000 - 1);
+    long transition = findTransition(d);
+
+    // For times on or after last transition use lastRule.
+    if (transition == Long.MAX_VALUE)
+      return lastRule.inDaylightTime(date);
+
+    return (transition & IS_DST) != 0;
+  }
+
+  /**
+   * Generates the hashCode for the SimpleDateFormat object.  It is
+   * the rawOffset, possibly, if useDaylightSavings is true, xored
+   * with startYear, startMonth, startDayOfWeekInMonth, ..., endTime.
+   */
+  public synchronized int hashCode()
+  {
+    int hash = lastRule.hashCode();
+    // FIXME - hash transitions?
+    return hash;
+  }
+
+  public synchronized boolean equals(Object o)
+  {
+    if (! hasSameRules((TimeZone) o))
+      return false;
+
+    ZoneInfo zone = (ZoneInfo) o;
+    return getID().equals(zone.getID());
+  }
+
+  /**
+   * Test if the other time zone uses the same rule and only
+   * possibly differs in ID.  This implementation for this particular
+   * class will return true if the other object is a ZoneInfo,
+   * the raw offsets and useDaylight are identical and if useDaylight
+   * is true, also the start and end datas are identical.
+   * @return true if this zone uses the same rule.
+   */
+  public boolean hasSameRules(TimeZone o)
+  {
+    if (this == o)
+      return true;
+    if (! (o instanceof ZoneInfo))
+      return false;
+    ZoneInfo zone = (ZoneInfo) o;
+    if (zone.hashCode() != hashCode() || rawOffset != zone.rawOffset)
+      return false;
+    if (! lastRule.equals(zone.lastRule))
+      return false;
+    // FIXME - compare transitions?
+    return true;
+  }
+
+  /**
+   * Returns a string representation of this ZoneInfo object.
+   * @return a string representation of this ZoneInfo object.
+   */
+  public String toString()
+  {
+    return getClass().getName() + "[" + "id=" + getID() + ",offset="
+	   + rawOffset + ",transitions=" + transitions.length
+	   + ",useDaylight=" + useDaylight
+	   + (useDaylight ? (",dstSavings=" + dstSavings) : "")
+	   + ",lastRule=" + lastRule.toString() + "]";
+  }
+
+  /**
+   * Reads zic(8) compiled timezone data file from file
+   * and returns a TimeZone class describing it, either
+   * SimpleTimeZone or ZoneInfo depending on whether
+   * it can be described by SimpleTimeZone rule or not.
+   */
+  public static TimeZone readTZFile(String id, String file)
+  {
+    DataInputStream dis = null;
+    try
+      {
+	FileInputStream fis = new FileInputStream(file);
+	BufferedInputStream bis = new BufferedInputStream(fis);
+	dis = new DataInputStream(bis);
+
+	// Make sure we are reading a tzfile.
+	byte[] tzif = new byte[5];
+	dis.readFully(tzif);
+	int tzif2 = 4;
+	if (tzif[0] == 'T' && tzif[1] == 'Z'
+	    && tzif[2] == 'i' && tzif[3] == 'f')
+	  {
+	    if (tzif[4] >= '2')
+	      tzif2 = 8;
+	    // Reserved bytes
+	    skipFully(dis, 16 - 1);
+	  }
+	else
+	  // Darwin has tzdata files that don't start with the TZif marker
+	  skipFully(dis, 16 - 5);
+
+	int ttisgmtcnt = dis.readInt();
+	int ttisstdcnt = dis.readInt();
+	int leapcnt = dis.readInt();
+	int timecnt = dis.readInt();
+	int typecnt = dis.readInt();
+	int charcnt = dis.readInt();
+	if (tzif2 == 8)
+	  {
+	    skipFully(dis, timecnt * (4 + 1) + typecnt * (4 + 1 + 1) + charcnt
+			   + leapcnt * (4 + 4) + ttisgmtcnt + ttisstdcnt);
+
+	    dis.readFully(tzif);
+	    if (tzif[0] != 'T' || tzif[1] != 'Z' || tzif[2] != 'i'
+		|| tzif[3] != 'f' || tzif[4] < '2')
+	      return null;
+
+	    // Reserved bytes
+	    skipFully(dis, 16 - 1);
+	    ttisgmtcnt = dis.readInt();
+	    ttisstdcnt = dis.readInt();
+	    leapcnt = dis.readInt();
+	    timecnt = dis.readInt();
+	    typecnt = dis.readInt();
+	    charcnt = dis.readInt();
+	  }
+
+	// Sanity checks
+	if (typecnt <= 0 || timecnt < 0 || charcnt < 0
+	    || leapcnt < 0 || ttisgmtcnt < 0 || ttisstdcnt < 0
+	    || ttisgmtcnt > typecnt || ttisstdcnt > typecnt)
+	  return null;
+
+	// Transition times
+	long[] times = new long[timecnt];
+	for (int i = 0; i < timecnt; i++)
+	  if (tzif2 == 8)
+	    times[i] = dis.readLong();
+	  else
+	    times[i] = (long) dis.readInt();
+
+	// Transition types
+	int[] types = new int[timecnt];
+	for (int i = 0; i < timecnt; i++)
+	  {
+	    types[i] = dis.readByte();
+	    if (types[i] < 0)
+	      types[i] += 256;
+	    if (types[i] >= typecnt)
+	      return null;
+	  }
+
+	// Types
+	int[] offsets = new int[typecnt];
+	int[] typeflags = new int[typecnt];
+	for (int i = 0; i < typecnt; i++)
+	  {
+	    offsets[i] = dis.readInt();
+	    if (offsets[i] >= IS_DST / 2 || offsets[i] <= -IS_DST / 2)
+	      return null;
+	    int dst = dis.readByte();
+	    int abbrind = dis.readByte();
+	    if (abbrind < 0)
+	      abbrind += 256;
+	    if (abbrind >= charcnt)
+	      return null;
+	    typeflags[i] = (dst != 0 ? (1 << 8) : 0) + abbrind;
+	  }
+
+	// Abbrev names
+	byte[] names = new byte[charcnt];
+	dis.readFully(names);
+
+	// Leap transitions, for now ignore
+	skipFully(dis, leapcnt * (tzif2 + 4) + ttisstdcnt + ttisgmtcnt);
+
+	// tzIf2 format has optional POSIX TZ env string
+	String tzstr = null;
+	if (tzif2 == 8 && dis.readByte() == '\n')
+	  {
+	    tzstr = dis.readLine();
+	    if (tzstr.length() <= 0)
+	      tzstr = null;
+	  }
+
+	// Get std/dst_offset and dst/non-dst time zone names.
+	int std_ind = -1;
+	int dst_ind = -1;
+	if (timecnt == 0)
+	  std_ind = 0;
+	else
+	  for (int i = timecnt - 1; i >= 0; i--)
+	    {
+	      if (std_ind == -1 && (typeflags[types[i]] & (1 << 8)) == 0)
+		std_ind = types[i];
+	      else if (dst_ind == -1 && (typeflags[types[i]] & (1 << 8)) != 0)
+		dst_ind = types[i];
+	      if (dst_ind != -1 && std_ind != -1)
+		break;
+	    }
+
+	if (std_ind == -1)
+	  return null;
+
+	int j = typeflags[std_ind] & 255;
+	while (j < charcnt && names[j] != 0)
+	  j++;
+	String std_zonename = new String(names, typeflags[std_ind] & 255,
+					 j - (typeflags[std_ind] & 255),
+					 "ASCII");
+
+	String dst_zonename = "";
+	if (dst_ind != -1)
+	  {
+	    j = typeflags[dst_ind] & 255;
+	    while (j < charcnt && names[j] != 0)
+	      j++;
+	    dst_zonename = new String(names, typeflags[dst_ind] & 255,
+				      j - (typeflags[dst_ind] & 255), "ASCII");
+	  }
+
+	// Only use gmt offset when necessary.
+	// Also special case GMT+/- timezones.
+	String std_offset_string = "";
+	String dst_offset_string = "";
+	if (tzstr == null
+	    && (dst_ind != -1
+		|| (offsets[std_ind] != 0
+		    && !std_zonename.startsWith("GMT+")
+		    && !std_zonename.startsWith("GMT-"))))
+	  {
+	    std_offset_string = Integer.toString(-offsets[std_ind] / 3600);
+	    int seconds = -offsets[std_ind] % 3600;
+	    if (seconds != 0)
+	      {
+		if (seconds < 0)
+		  seconds *= -1;
+		if (seconds < 600)
+		  std_offset_string += ":0" + Integer.toString(seconds / 60);
+		else
+		  std_offset_string += ":" + Integer.toString(seconds / 60);
+		seconds = seconds % 60;
+		if (seconds >= 10)
+		  std_offset_string += ":" + Integer.toString(seconds);
+		else if (seconds > 0)
+		  std_offset_string += ":0" + Integer.toString(seconds);
+	      }
+
+	    if (dst_ind != -1 && offsets[dst_ind] != offsets[std_ind] + 3600)
+	      {
+		dst_offset_string = Integer.toString(-offsets[dst_ind] / 3600);
+		seconds = -offsets[dst_ind] % 3600;
+		if (seconds != 0)
+		  {
+		    if (seconds < 0)
+		      seconds *= -1;
+		    if (seconds < 600)
+		      dst_offset_string
+			+= ":0" + Integer.toString(seconds / 60);
+		    else
+		      dst_offset_string
+			+= ":" + Integer.toString(seconds / 60);
+		    seconds = seconds % 60;
+		    if (seconds >= 10)
+		      dst_offset_string += ":" + Integer.toString(seconds);
+		    else if (seconds > 0)
+		      dst_offset_string += ":0" + Integer.toString(seconds);
+		  }
+	      }
+	  }
+
+	/*
+	 * If no tzIf2 POSIX TZ string is available and the timezone
+	 * uses DST, try to guess the last rule by trying to make
+	 * sense from transitions at 5 years in the future and onwards.
+	 * tzdata actually uses only 3 forms of rules:
+	 * fixed date within a month, e.g. change on April, 5th
+	 * 1st weekday on or after Nth: change on Sun>=15 in April
+	 * last weekday in a month: change on lastSun in April
+	 */
+	String[] change_spec = { null, null };
+	if (tzstr == null && dst_ind != -1 && timecnt > 10)
+	  {
+	    long nowPlus5y = System.currentTimeMillis() / 1000
+			     + 5 * 365 * 86400;
+	    int first;
+
+	    for (first = timecnt - 1; first >= 0; first--)
+	      if (times[first] < nowPlus5y
+		  || (types[first] != std_ind && types[first] != dst_ind)
+		  || types[first] != types[timecnt - 2 + ((first ^ timecnt) & 1)])
+		break;
+	    first++;
+
+	    if (timecnt - first >= 10 && types[timecnt - 1] != types[timecnt - 2])
+	      {
+		GregorianCalendar cal
+		  = new GregorianCalendar(new SimpleTimeZone(0, "GMT"));
+
+		int[] values = new int[2 * 11];
+		int i;
+		for (i = timecnt - 1; i >= first; i--)
+		  {
+		    int base = (i % 2) * 11;
+		    int offset = offsets[types[i > first ? i - 1 : i + 1]];
+		    cal.setTimeInMillis((times[i] + offset) * 1000);
+		    if (i >= timecnt - 2)
+		      {
+			values[base + 0] = cal.get(Calendar.YEAR);
+			values[base + 1] = cal.get(Calendar.MONTH);
+			values[base + 2] = cal.get(Calendar.DAY_OF_MONTH);
+			values[base + 3]
+			  = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
+			values[base + 4] = cal.get(Calendar.DAY_OF_WEEK);
+			values[base + 5] = cal.get(Calendar.HOUR_OF_DAY);
+			values[base + 6] = cal.get(Calendar.MINUTE);
+			values[base + 7] = cal.get(Calendar.SECOND);
+			values[base + 8] = values[base + 2]; // Range start
+			values[base + 9] = values[base + 2]; // Range end
+			values[base + 10] = 0; // Determined type
+		      }
+		    else
+		      {
+			int year = cal.get(Calendar.YEAR);
+			int month = cal.get(Calendar.MONTH);
+			int day_of_month = cal.get(Calendar.DAY_OF_MONTH);
+			int month_days
+			  = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
+			int day_of_week = cal.get(Calendar.DAY_OF_WEEK);
+			int hour = cal.get(Calendar.HOUR_OF_DAY);
+			int minute = cal.get(Calendar.MINUTE);
+			int second = cal.get(Calendar.SECOND);
+			if (year != values[base + 0] - 1
+			    || month != values[base + 1]
+			    || hour != values[base + 5]
+			    || minute != values[base + 6]
+			    || second != values[base + 7])
+			  break;
+			if (day_of_week == values[base + 4])
+			  {
+			    // Either a Sun>=8 or lastSun rule.
+			    if (day_of_month < values[base + 8])
+			      values[base + 8] = day_of_month;
+			    if (day_of_month > values[base + 9])
+			      values[base + 9] = day_of_month;
+			    if (values[base + 10] < 0)
+			      break;
+			    if (values[base + 10] == 0)
+			      {
+				values[base + 10] = 1;
+				// If day of month > 28, this is
+				// certainly lastSun rule.
+				if (values[base + 2] > 28)
+				  values[base + 2] = 3;
+				// If day of month isn't in the last
+				// week, it can't be lastSun rule.
+				else if (values[base + 2]
+					 <= values[base + 3] - 7)
+				  values[base + 3] = 2;
+			      }
+			    if (values[base + 10] == 1)
+			      {
+				// If day of month is > 28, this is
+				// certainly lastSun rule.
+				if (day_of_month > 28)
+				  values[base + 10] = 3;
+				// If day of month isn't in the last
+				// week, it can't be lastSun rule.
+				else if (day_of_month <= month_days - 7)
+				  values[base + 10] = 2;
+			      }
+			    else if ((values[base + 10] == 2
+				      && day_of_month > 28)
+				     || (values[base + 10] == 3
+					 && day_of_month <= month_days - 7))
+			      break;
+			  }
+			else
+			  {
+			    // Must be fixed day in month rule.
+			    if (day_of_month != values[base + 2]
+				|| values[base + 10] > 0)
+			      break;
+			    values[base + 4] = day_of_week;
+			    values[base + 10] = -1;
+			  }
+			values[base + 0] -= 1;
+		      }
+		  }
+
+		if (i < first)
+		  {
+		    for (i = 0; i < 2; i++)
+		      {
+			int base = 11 * i;
+			if (values[base + 10] == 0)
+			  continue;
+			if (values[base + 10] == -1)
+			  {
+			    int[] dayCount
+			      = { 0, 31, 59, 90, 120, 151,
+				  181, 212, 243, 273, 304, 334 };
+			    int d = dayCount[values[base + 1]
+					     - Calendar.JANUARY];
+			    d += values[base + 2];
+			    change_spec[i] = ",J" + Integer.toString(d);
+			  }
+			else if (values[base + 10] == 2)
+			  {
+			    // If we haven't seen all days of the week,
+			    // we can't be sure what the rule really is.
+			    if (values[base + 8] + 6 != values[base + 9])
+			      continue;
+
+			    int d;
+			    d = values[base + 1] - Calendar.JANUARY + 1;
+			    // E.g. Sun >= 5 is not representable in POSIX
+			    // TZ env string, use ",Am.n.d" extension
+			    // where m is month 1 .. 12, n is the date on
+			    // or after which it happens and d is day
+			    // of the week, 0 .. 6.  So Sun >= 5 in April
+			    // is ",A4.5.0".
+			    if ((values[base + 8] % 7) == 1)
+			      {
+				change_spec[i] = ",M" + Integer.toString(d);
+				d = (values[base + 8] + 6) / 7;
+			      }
+			    else
+			      {
+				change_spec[i] = ",A" + Integer.toString(d);
+				d = values[base + 8];
+			      }
+			    change_spec[i] += "." + Integer.toString(d);
+			    d = values[base + 4] - Calendar.SUNDAY;
+			    change_spec[i] += "." + Integer.toString(d);
+			  }
+			else
+			  {
+			    // If we don't know whether this is lastSun or
+			    // Sun >= 22 rule.  That can be either because
+			    // there was insufficient number of
+			    // transitions, or February, where it is quite
+			    // probable we haven't seen any 29th dates.
+			    // For February, assume lastSun rule, otherwise
+			    // punt.
+			    if (values[base + 10] == 1
+				&& values[base + 1] != Calendar.FEBRUARY)
+			      continue;
+
+			    int d;
+			    d = values[base + 1] - Calendar.JANUARY + 1;
+			    change_spec[i] = ",M" + Integer.toString(d);
+			    d = values[base + 4] - Calendar.SUNDAY;
+			    change_spec[i] += ".5." + Integer.toString(d);
+			  }
+
+			// Don't add time specification if time is
+			// 02:00:00.
+			if (values[base + 5] != 2
+			    || values[base + 6] != 0
+			    || values[base + 7] != 0)
+			  {
+			    int d = values[base + 5];
+			    change_spec[i] += "/" + Integer.toString(d);
+			    if (values[base + 6] != 0 || values[base + 7] != 0)
+			      {
+				d = values[base + 6];
+				if (d < 10)
+				  change_spec[i]
+				    += ":0" + Integer.toString(d);
+				else
+				  change_spec[i] += ":" + Integer.toString(d);
+				d = values[base + 7];
+				if (d >= 10)
+				   change_spec[i]
+				     += ":" + Integer.toString(d);
+				else if (d > 0)
+				  change_spec[i]
+				    += ":0" + Integer.toString(d);
+			      }
+			  }
+		      }
+		    if (types[(timecnt - 1) & -2] == std_ind)
+		      {
+			String tmp = change_spec[0];
+			change_spec[0] = change_spec[1];
+			change_spec[1] = tmp;
+		      }
+		  }
+	      }
+	  }
+
+	if (tzstr == null)
+	  {
+	    tzstr = std_zonename + std_offset_string;
+	    if (change_spec[0] != null && change_spec[1] != null)
+	      tzstr += dst_zonename + dst_offset_string
+		       + change_spec[0] + change_spec[1];
+	  }
+
+	if (timecnt == 0)
+	  return new SimpleTimeZone(offsets[std_ind] * 1000,
+				    id != null ? id : tzstr);
+
+	SimpleTimeZone endRule = createLastRule(tzstr);
+	if (endRule == null)
+	  return null;
+
+	/* Finally adjust the times array into the form the constructor
+	 * expects.  times[0] is special, the offset and DST flag there
+	 * are for all times before that transition.  Use the first non-DST
+	 * type.  For all other transitions, the data file has the type
+	 * (<offset, isdst, zonename>) for the time interval starting
+	 */
+	for (int i = 0; i < typecnt; i++)
+	  if ((typeflags[i] & (1 << 8)) == 0)
+	    {
+	      times[0] = (times[0] << SECS_SHIFT) | (offsets[i] & OFFSET_MASK);
+	      break;
+	    }
+
+	for (int i = 1; i < timecnt; i++)
+	  times[i] = (times[i] << SECS_SHIFT)
+		     | (offsets[types[i - 1]] & OFFSET_MASK)
+		     | ((typeflags[types[i - 1]] & (1 << 8)) != 0 ? IS_DST : 0);
+
+	return new ZoneInfo(offsets[std_ind] * 1000, id != null ? id : tzstr,
+			    times, endRule);
+      }
+    catch (IOException ioe)
+      {
+	// Parse error, not a proper tzfile.
+	return null;
+      }
+    finally
+      {
+	try
+	  {
+	    if (dis != null)
+	      dis.close();
+	  }
+	catch(IOException ioe)
+	  {
+	    // Error while close, nothing we can do.
+	  }
+      }
+  }
+
+  /**
+   * Skips the requested number of bytes in the given InputStream.
+   * Throws EOFException if not enough bytes could be skipped.
+   * Negative numbers of bytes to skip are ignored.
+   */
+  private static void skipFully(InputStream is, long l) throws IOException
+  {
+    while (l > 0)
+      {
+	long k = is.skip(l);
+	if (k <= 0)
+	  throw new EOFException();
+	l -= k;
+      }
+  }
+
+  /**
+   * Create a SimpleTimeZone from a POSIX TZ environment string,
+   * see http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html
+   * for details.
+   * It supports also an extension, where Am.n.d rule (m 1 .. 12, n 1 .. 25, d
+   * 0 .. 6) describes day of week d on or after nth day of month m.
+   * Say A4.5.0 is Sun>=5 in April.
+   */
+  private static SimpleTimeZone createLastRule(String tzstr)
+  {
+    String stdName = null;
+    int stdOffs;
+    int dstOffs;
+    try
+      {
+	int idLength = tzstr.length();
+
+	int index = 0;
+	int prevIndex;
+	char c;
+
+	// get std
+	do
+	  c = tzstr.charAt(index);
+	while (c != '+' && c != '-' && c != ',' && c != ':'
+	       && ! Character.isDigit(c) && c != '\0' && ++index < idLength);
+
+	if (index >= idLength)
+	  return new SimpleTimeZone(0, tzstr);
+
+	stdName = tzstr.substring(0, index);
+	prevIndex = index;
+
+	// get the std offset
+	do
+	  c = tzstr.charAt(index++);
+	while ((c == '-' || c == '+' || c == ':' || Character.isDigit(c))
+	       && index < idLength);
+	if (index < idLength)
+	  index--;
+
+	{ // convert the dst string to a millis number
+	    String offset = tzstr.substring(prevIndex, index);
+	    prevIndex = index;
+
+	    if (offset.charAt(0) == '+' || offset.charAt(0) == '-')
+	      stdOffs = parseTime(offset.substring(1));
+	    else
+	      stdOffs = parseTime(offset);
+
+	    if (offset.charAt(0) == '-')
+	      stdOffs = -stdOffs;
+
+	    // TZ timezone offsets are positive when WEST of the meridian.
+	    stdOffs = -stdOffs;
+	}
+
+	// Done yet? (Format: std offset)
+	if (index >= idLength)
+	  return new SimpleTimeZone(stdOffs, stdName);
+
+	// get dst
+	do
+	  c = tzstr.charAt(index);
+	while (c != '+' && c != '-' && c != ',' && c != ':'
+	       && ! Character.isDigit(c) && c != '\0' && ++index < idLength);
+
+	// Done yet? (Format: std offset dst)
+	if (index >= idLength)
+	  return new SimpleTimeZone(stdOffs, stdName);
+
+	// get the dst offset
+	prevIndex = index;
+	do
+	  c = tzstr.charAt(index++);
+	while ((c == '-' || c == '+' || c == ':' || Character.isDigit(c))
+	       && index < idLength);
+	if (index < idLength)
+	  index--;
+
+	if (index == prevIndex && (c == ',' || c == ';'))
+	  {
+	    // Missing dst offset defaults to one hour ahead of standard
+	    // time.
+	    dstOffs = stdOffs + 60 * 60 * 1000;
+	  }
+	else
+	  { // convert the dst string to a millis number
+	    String offset = tzstr.substring(prevIndex, index);
+	    prevIndex = index;
+
+	    if (offset.charAt(0) == '+' || offset.charAt(0) == '-')
+	      dstOffs = parseTime(offset.substring(1));
+	    else
+	      dstOffs = parseTime(offset);
+
+	    if (offset.charAt(0) == '-')
+	      dstOffs = -dstOffs;
+
+	    // TZ timezone offsets are positive when WEST of the meridian.
+	    dstOffs = -dstOffs;
+	  }
+
+	// Done yet? (Format: std offset dst offset)
+	if (index >= idLength)
+	  return new SimpleTimeZone(stdOffs, stdName);
+
+	// get the DST rule
+	if (tzstr.charAt(index) == ','
+	    || tzstr.charAt(index) == ';')
+	  {
+	    index++;
+	    int offs = index;
+	    while (tzstr.charAt(index) != ','
+		   && tzstr.charAt(index) != ';')
+	      index++;
+	    String startTime = tzstr.substring(offs, index);
+	    index++;
+	    String endTime = tzstr.substring(index);
+
+	    index = startTime.indexOf('/');
+	    int startMillis;
+	    int endMillis;
+	    String startDate;
+	    String endDate;
+	    if (index != -1)
+	      {
+		startDate = startTime.substring(0, index);
+		startMillis = parseTime(startTime.substring(index + 1));
+	      }
+	    else
+	      {
+		startDate = startTime;
+		// if time isn't given, default to 2:00:00 AM.
+		startMillis = 2 * 60 * 60 * 1000;
+	      }
+	    index = endTime.indexOf('/');
+	    if (index != -1)
+	      {
+		endDate = endTime.substring(0, index);
+		endMillis = parseTime(endTime.substring(index + 1));
+	      }
+	    else
+	      {
+		endDate = endTime;
+		// if time isn't given, default to 2:00:00 AM.
+		endMillis = 2 * 60 * 60 * 1000;
+	      }
+
+	    int[] start = getDateParams(startDate);
+	    int[] end = getDateParams(endDate);
+	    return new SimpleTimeZone(stdOffs, tzstr, start[0], start[1],
+				      start[2], startMillis, end[0], end[1],
+				      end[2], endMillis, (dstOffs - stdOffs));
+	  }
+      }
+
+    catch (IndexOutOfBoundsException _)
+      {
+      }
+    catch (NumberFormatException _)
+      {
+      }
+
+    return null;
+  }
+
+  /**
+   * Parses and returns the params for a POSIX TZ date field,
+   * in the format int[]{ month, day, dayOfWeek }, following the
+   * SimpleTimeZone constructor rules.
+   */
+  private static int[] getDateParams(String date)
+  {
+    int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
+    int month;
+    int type = 0;
+
+    if (date.charAt(0) == 'M' || date.charAt(0) == 'm')
+      type = 1;
+    else if (date.charAt(0) == 'A' || date.charAt(0) == 'a')
+      type = 2;
+
+    if (type > 0)
+      {
+	int day;
+
+	// Month, week of month, day of week
+	// "Mm.w.d".  d is between 0 (Sunday) and 6.  Week w is
+	// between 1 and 5; Week 1 is the first week in which day d
+	// occurs and Week 5 specifies the last d day in the month.
+	// Month m is between 1 and 12.
+
+	// Month, day of month, day of week
+	// ZoneInfo extension, not in POSIX
+	// "Am.n.d".  d is between 0 (Sunday) and 6.  Day of month n is
+	// between 1 and 25.  Month m is between 1 and 12.
+
+	month = Integer.parseInt(date.substring(1, date.indexOf('.')));
+	int week = Integer.parseInt(date.substring(date.indexOf('.') + 1,
+						   date.lastIndexOf('.')));
+	int dayOfWeek = Integer.parseInt(date.substring(date.lastIndexOf('.')
+							+ 1));
+	dayOfWeek++; // Java day of week is one-based, Sunday is first day.
+
+	if (type == 2)
+	  {
+	    day = week;
+	    dayOfWeek = -dayOfWeek;
+	  }
+ 	else if (week == 5)
+ 	  day = -1; // last day of month is -1 in java, 5 in TZ
+ 	else
+	  {
+	    // First day of week starting on or after.  For example,
+	    // to specify the second Sunday of April, set month to
+	    // APRIL, day-of-month to 8, and day-of-week to -SUNDAY.
+	    day = (week - 1) * 7 + 1;
+	    dayOfWeek = -dayOfWeek;
+	  }
+
+	month--; // Java month is zero-based.
+	return new int[] { month, day, dayOfWeek };
+      }
+
+    // julian day, either zero-based 0<=n<=365 (incl feb 29)
+    // or one-based 1<=n<=365 (no feb 29)
+    int julianDay; // Julian day
+
+    if (date.charAt(0) != 'J' || date.charAt(0) != 'j')
+      {
+	julianDay = Integer.parseInt(date.substring(1));
+	julianDay++; // make 1-based
+	// Adjust day count to include feb 29.
+	dayCount = new int[]
+		   {
+		     0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
+		   };
+      }
+    else
+      // 1-based julian day
+      julianDay = Integer.parseInt(date);
+
+    int i = 11;
+    while (i > 0)
+      if (dayCount[i] < julianDay)
+	break;
+      else
+	i--;
+    julianDay -= dayCount[i];
+    month = i;
+    return new int[] { month, julianDay, 0 };
+  }
+
+  /**
+   * Parses a time field hh[:mm[:ss]], returning the result
+   * in milliseconds. No leading sign.
+   */
+  private static int parseTime(String time)
+  {
+    int millis = 0;
+    int i = 0;
+
+    while (i < time.length())
+      if (time.charAt(i) == ':')
+	break;
+      else
+	i++;
+    millis = 60 * 60 * 1000 * Integer.parseInt(time.substring(0, i));
+    if (i >= time.length())
+      return millis;
+
+    int iprev = ++i;
+    while (i < time.length())
+      if (time.charAt(i) == ':')
+	break;
+      else
+	i++;
+    millis += 60 * 1000 * Integer.parseInt(time.substring(iprev, i));
+    if (i >= time.length())
+      return millis;
+
+    millis += 1000 * Integer.parseInt(time.substring(++i));
+    return millis;
+  }
+}
diff --git a/libjava/classpath/java/util/Date.java b/libjava/classpath/java/util/Date.java
index aecca29b39e..6e618094a45 100644
--- a/libjava/classpath/java/util/Date.java
+++ b/libjava/classpath/java/util/Date.java
@@ -772,6 +772,7 @@ public class Date
 	  }
 	else if (firstch >= '0' && firstch <= '9')
 	  {
+	    int lastPunct = -1;
 	    while (tok != null && tok.length() > 0)
 	      {
 		int punctOffset = tok.length();
@@ -809,6 +810,13 @@ public class Date
 		    else
 		      minute = num;
 		  }
+		else if (lastPunct == ':' && hour >= 0 && (minute < 0 || second < 0))
+		  {
+		    if (minute < 0)
+		      minute = num;
+		    else
+		      second = num;
+		  }
 	        else if ((num >= 70
 			  && (punct == ' ' || punct == ','
 			      || punct == '/' || punct < 0))
@@ -846,6 +854,7 @@ public class Date
 		  tok = null;
 		else
 		  tok = tok.substring(punctOffset + 1);
+		lastPunct = punct;
 	      }
 	  }
 	else if (firstch >= 'A' && firstch <= 'Z')
diff --git a/libjava/classpath/java/util/SimpleTimeZone.java b/libjava/classpath/java/util/SimpleTimeZone.java
index 0bda44c3327..a9e328efb17 100644
--- a/libjava/classpath/java/util/SimpleTimeZone.java
+++ b/libjava/classpath/java/util/SimpleTimeZone.java
@@ -1,5 +1,6 @@
 /* java.util.SimpleTimeZone
-   Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005  Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005, 2007
+   Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -141,8 +142,8 @@ public class SimpleTimeZone extends TimeZone
 
   /**
    * This variable specifies the time of change to daylight savings.
-   * This time is given in milliseconds after midnight local
-   * standard time.
+   * This time is given in milliseconds after midnight in startTimeMode
+   * chosen time mode.
    * @serial
    */
   private int startTime;
@@ -187,8 +188,8 @@ public class SimpleTimeZone extends TimeZone
 
   /**
    * This variable specifies the time of change back to standard time.
-   * This time is given in milliseconds after midnight local
-   * standard time.
+   * This time is given in milliseconds after midnight in endTimeMode
+   * chosen time mode.
    * @serial
    */
   private int endTime;
@@ -380,24 +381,17 @@ public class SimpleTimeZone extends TimeZone
                         int endDayOfWeekInMonth, int endDayOfWeek,
                         int endTime, int endTimeMode, int dstSavings)
   {
-    this.rawOffset = rawOffset;
-    setID(id);
-    useDaylight = true;
+    this(rawOffset, id, startMonth, startDayOfWeekInMonth, startDayOfWeek,
+	 startTime, endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
 
     if (startTimeMode < WALL_TIME || startTimeMode > UTC_TIME)
       throw new IllegalArgumentException("startTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
     if (endTimeMode < WALL_TIME || endTimeMode > UTC_TIME)
       throw new IllegalArgumentException("endTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
-    this.startTimeMode = startTimeMode;
-    this.endTimeMode = endTimeMode;
-
-    setStartRule(startMonth, startDayOfWeekInMonth, startDayOfWeek, startTime);
-    setEndRule(endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
-    if (startMonth == endMonth)
-      throw new IllegalArgumentException("startMonth and endMonth must be different");
-    this.startYear = 0;
 
     this.dstSavings = dstSavings;
+    this.startTimeMode = startTimeMode;
+    this.endTimeMode = endTimeMode;
   }
 
   /**
@@ -477,12 +471,8 @@ public class SimpleTimeZone extends TimeZone
     this.startMonth = month;
     this.startDay = day;
     this.startDayOfWeek = Math.abs(dayOfWeek);
-    if (this.startTimeMode == WALL_TIME || this.startTimeMode == STANDARD_TIME)
-      this.startTime = time;
-    else
-      // Convert from UTC to STANDARD
-      this.startTime = time + this.rawOffset;
-    useDaylight = true;
+    this.startTime = time;
+    this.startTimeMode = WALL_TIME;
   }
 
   /**
@@ -513,24 +503,10 @@ public class SimpleTimeZone extends TimeZone
   public void setStartRule(int month, int day, int dayOfWeek, int time,
                            boolean after)
   {
-    // FIXME: XXX: Validate that checkRule and offset processing work with on
-    // or before mode.
-    this.startDay = after ? Math.abs(day) : -Math.abs(day);
-    this.startDayOfWeek = after ? Math.abs(dayOfWeek) : -Math.abs(dayOfWeek);
-    this.startMode = (dayOfWeek != 0)
-                     ? (after ? DOW_GE_DOM_MODE : DOW_LE_DOM_MODE)
-                     : checkRule(month, day, dayOfWeek);
-    this.startDay = Math.abs(this.startDay);
-    this.startDayOfWeek = Math.abs(this.startDayOfWeek);
-
-    this.startMonth = month;
-
-    if (this.startTimeMode == WALL_TIME || this.startTimeMode == STANDARD_TIME)
-      this.startTime = time;
+    if (after)
+      setStartRule(month, day, -dayOfWeek, time);
     else
-      // Convert from UTC to STANDARD
-      this.startTime = time + this.rawOffset;
-    useDaylight = true;
+      setStartRule(month, -day, -dayOfWeek, time);
   }
 
   /**
@@ -570,14 +546,8 @@ public class SimpleTimeZone extends TimeZone
     this.endMonth = month;
     this.endDay = day;
     this.endDayOfWeek = Math.abs(dayOfWeek);
-    if (this.endTimeMode == WALL_TIME)
-      this.endTime = time;
-    else if (this.endTimeMode == STANDARD_TIME)
-      // Convert from STANDARD to DST
-      this.endTime = time + this.dstSavings;
-    else
-      // Convert from UTC to DST
-      this.endTime = time + this.rawOffset + this.dstSavings;
+    this.endTime = time;
+    this.endTimeMode = WALL_TIME;
     useDaylight = true;
   }
 
@@ -607,27 +577,10 @@ public class SimpleTimeZone extends TimeZone
   public void setEndRule(int month, int day, int dayOfWeek, int time,
                          boolean after)
   {
-    // FIXME: XXX: Validate that checkRule and offset processing work with on
-    // or before mode.
-    this.endDay = after ? Math.abs(day) : -Math.abs(day);
-    this.endDayOfWeek = after ? Math.abs(dayOfWeek) : -Math.abs(dayOfWeek);
-    this.endMode = (dayOfWeek != 0)
-                   ? (after ? DOW_GE_DOM_MODE : DOW_LE_DOM_MODE)
-                   : checkRule(month, day, dayOfWeek);
-    this.endDay = Math.abs(this.endDay);
-    this.endDayOfWeek = Math.abs(endDayOfWeek);
-
-    this.endMonth = month;
-
-    if (this.endTimeMode == WALL_TIME)
-      this.endTime = time;
-    else if (this.endTimeMode == STANDARD_TIME)
-      // Convert from STANDARD to DST
-      this.endTime = time + this.dstSavings;
+    if (after)
+      setEndRule(month, day, -dayOfWeek, time);
     else
-      // Convert from UTC to DST
-      this.endTime = time + this.rawOffset + this.dstSavings;
-    useDaylight = true;
+      setEndRule(month, -day, -dayOfWeek, time);
   }
 
   /**
@@ -688,16 +641,37 @@ public class SimpleTimeZone extends TimeZone
     int daylightSavings = 0;
     if (useDaylight && era == GregorianCalendar.AD && year >= startYear)
       {
+	int orig_year = year;
+	int time = startTime + (startTimeMode == UTC_TIME ? rawOffset : 0);
 	// This does only work for Gregorian calendars :-(
 	// This is mainly because setStartYear doesn't take an era.
 	boolean afterStart = ! isBefore(year, month, day, dayOfWeek, millis,
 	                                startMode, startMonth, startDay,
-	                                startDayOfWeek, startTime);
-	boolean beforeEnd = isBefore(year, month, day, dayOfWeek,
-				     millis + dstSavings,
-	                             endMode, endMonth, endDay, endDayOfWeek,
-	                             endTime);
-
+					startDayOfWeek, time);
+	millis += dstSavings;
+	if (millis >= 24 * 60 * 60 * 1000)
+	  {
+	    millis -= 24 * 60 * 60 * 1000;
+	    dayOfWeek = (dayOfWeek % 7) + 1;
+	    if (++day > daysInMonth)
+	      {
+		day = 1;
+		if (month++ == Calendar.DECEMBER)
+		  {
+		    month = Calendar.JANUARY;
+		    year++;
+		  }
+	      }
+	  }
+	time = endTime + (endTimeMode == UTC_TIME ? rawOffset : 0);
+	if (endTimeMode != WALL_TIME)
+	  time += dstSavings;
+	boolean beforeEnd = isBefore(year, month, day, dayOfWeek, millis,
+				     endMode, endMonth, endDay, endDayOfWeek,
+				     time);
+
+	if (year != orig_year)
+	  afterStart = false;
 	if (startMonth < endMonth)
 	  // use daylight savings, if the date is after the start of
 	  // savings, and before the end of savings.
diff --git a/libjava/classpath/java/util/TimeZone.java b/libjava/classpath/java/util/TimeZone.java
index 95117afe4a2..786b76dbb91 100644
--- a/libjava/classpath/java/util/TimeZone.java
+++ b/libjava/classpath/java/util/TimeZone.java
@@ -39,6 +39,9 @@ exception statement from your version. */
 
 package java.util;
 
+import gnu.classpath.SystemProperties;
+import gnu.java.util.ZoneInfo;
+import java.io.File;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.text.DateFormatSymbols;
@@ -115,7 +118,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 		
 		// Fall back on GMT.
 		if (zone == null)
-		  zone = (TimeZone) timezones().get("GMT");
+		  zone = getTimeZone ("GMT");
 		
 		return zone;
 	      }
@@ -128,6 +131,22 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
   private static final long serialVersionUID = 3581463369166924961L;
 
   /**
+   * Flag whether zoneinfo data should be used,
+   * otherwise builtin timezone data will be provided.
+   */
+  private static String zoneinfo_dir;
+
+  /**
+   * Cached copy of getAvailableIDs().
+   */
+  private static String[] availableIDs = null;
+
+  /**
+   * JDK 1.1.x compatibility aliases.
+   */
+  private static HashMap aliases0;
+
+  /**
    * HashMap for timezones by ID.  
    */
   private static HashMap timezones0;
@@ -135,13 +154,55 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
    * it is not needed: 
    */
   // Package-private to avoid a trampoline.
-  static synchronized HashMap timezones()
+  static HashMap timezones()
   {
     if (timezones0 == null) 
       {
 	HashMap timezones = new HashMap();
 	timezones0 = timezones;
 
+	zoneinfo_dir = SystemProperties.getProperty("gnu.java.util.zoneinfo.dir");
+	if (zoneinfo_dir != null && !new File(zoneinfo_dir).isDirectory())
+	  zoneinfo_dir = null;
+
+	if (zoneinfo_dir != null)
+	  {
+	    aliases0 = new HashMap();
+
+	    // These deprecated aliases for JDK 1.1.x compatibility
+	    // should take precedence over data files read from
+	    // /usr/share/zoneinfo.
+	    aliases0.put("ACT", "Australia/Darwin");
+	    aliases0.put("AET", "Australia/Sydney");
+	    aliases0.put("AGT", "America/Argentina/Buenos_Aires");
+	    aliases0.put("ART", "Africa/Cairo");
+	    aliases0.put("AST", "America/Juneau");
+	    aliases0.put("BST", "Asia/Colombo");
+	    aliases0.put("CAT", "Africa/Gaborone");
+	    aliases0.put("CNT", "America/St_Johns");
+	    aliases0.put("CST", "CST6CDT");
+	    aliases0.put("CTT", "Asia/Brunei");
+	    aliases0.put("EAT", "Indian/Comoro");
+	    aliases0.put("ECT", "CET");
+	    aliases0.put("EST", "EST5EDT");
+	    aliases0.put("EST5", "EST5EDT");
+	    aliases0.put("IET", "EST5EDT");
+	    aliases0.put("IST", "Asia/Calcutta");
+	    aliases0.put("JST", "Asia/Seoul");
+	    aliases0.put("MIT", "Pacific/Niue");
+	    aliases0.put("MST", "MST7MDT");
+	    aliases0.put("MST7", "MST7MDT");
+	    aliases0.put("NET", "Indian/Mauritius");
+	    aliases0.put("NST", "Pacific/Auckland");
+	    aliases0.put("PLT", "Indian/Kerguelen");
+	    aliases0.put("PNT", "MST7MDT");
+	    aliases0.put("PRT", "America/Anguilla");
+	    aliases0.put("PST", "PST8PDT");
+	    aliases0.put("SST", "Pacific/Ponape");
+	    aliases0.put("VST", "Asia/Bangkok");
+	    return timezones;
+	  }
+
 	TimeZone tz;
 	// Automatically generated by scripts/timezones.pl
 	// XXX - Should we read this data from a file?
@@ -153,8 +214,8 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Pago_Pago", tz);
 	tz = new SimpleTimeZone
 	  (-10000 * 3600, "America/Adak",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("America/Adak", tz);
 	tz = new SimpleTimeZone(-10000 * 3600, "HST");
 	timezones0.put("HST", tz);
@@ -167,8 +228,8 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Marquesas", tz);
 	tz = new SimpleTimeZone
 	  (-9000 * 3600, "AST",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("AST", tz);
 	timezones0.put("America/Anchorage", tz);
 	timezones0.put("America/Juneau", tz);
@@ -177,55 +238,56 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	tz = new SimpleTimeZone(-9000 * 3600, "Pacific/Gambier");
 	timezones0.put("Pacific/Gambier", tz);
 	tz = new SimpleTimeZone
-	  (-8000 * 3600, "PST",
+	  (-8000 * 3600, "America/Tijuana",
 	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	timezones0.put("America/Tijuana", tz);
+	tz = new SimpleTimeZone
+	  (-8000 * 3600, "PST",
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("PST", tz);
 	timezones0.put("PST8PDT", tz);
 	timezones0.put("America/Dawson", tz);
 	timezones0.put("America/Los_Angeles", tz);
-	timezones0.put("America/Tijuana", tz);
 	timezones0.put("America/Vancouver", tz);
 	timezones0.put("America/Whitehorse", tz);
 	timezones0.put("US/Pacific-New", tz);
 	tz = new SimpleTimeZone(-8000 * 3600, "Pacific/Pitcairn");
 	timezones0.put("Pacific/Pitcairn", tz);
 	tz = new SimpleTimeZone
-	  (-7000 * 3600, "MST",
+	  (-7000 * 3600, "America/Chihuahua",
 	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	timezones0.put("America/Chihuahua", tz);
+	timezones0.put("America/Mazatlan", tz);
+	tz = new SimpleTimeZone(-7000 * 3600, "MST7");
+	timezones0.put("MST7", tz);
+	timezones0.put("PNT", tz);
+	timezones0.put("America/Dawson_Creek", tz);
+	timezones0.put("America/Hermosillo", tz);
+	timezones0.put("America/Phoenix", tz);
+	tz = new SimpleTimeZone
+	  (-7000 * 3600, "MST",
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("MST", tz);
 	timezones0.put("MST7MDT", tz);
 	timezones0.put("America/Boise", tz);
 	timezones0.put("America/Cambridge_Bay", tz);
-	timezones0.put("America/Chihuahua", tz);
 	timezones0.put("America/Denver", tz);
 	timezones0.put("America/Edmonton", tz);
 	timezones0.put("America/Inuvik", tz);
-	timezones0.put("America/Mazatlan", tz);
 	timezones0.put("America/Shiprock", tz);
 	timezones0.put("America/Yellowknife", tz);
-	tz = new SimpleTimeZone(-7000 * 3600, "MST7");
-	timezones0.put("MST7", tz);
-	timezones0.put("PNT", tz);
-	timezones0.put("America/Dawson_Creek", tz);
-	timezones0.put("America/Hermosillo", tz);
-	timezones0.put("America/Phoenix", tz);
 	tz = new SimpleTimeZone
-	  (-6000 * 3600, "CST",
+	  (-6000 * 3600, "America/Cancun",
 	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
-	timezones0.put("CST", tz);
-	timezones0.put("CST6CDT", tz);
 	timezones0.put("America/Cancun", tz);
-	timezones0.put("America/Chicago", tz);
-	timezones0.put("America/Menominee", tz);
 	timezones0.put("America/Merida", tz);
 	timezones0.put("America/Mexico_City", tz);
 	timezones0.put("America/Monterrey", tz);
-	timezones0.put("America/North_Dakota/Center", tz);
-	timezones0.put("America/Rainy_River", tz);
-	timezones0.put("America/Rankin_Inlet", tz);
 	tz = new SimpleTimeZone(-6000 * 3600, "America/Belize");
 	timezones0.put("America/Belize", tz);
 	timezones0.put("America/Costa_Rica", tz);
@@ -237,53 +299,62 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("America/Tegucigalpa", tz);
 	timezones0.put("Pacific/Galapagos", tz);
 	tz = new SimpleTimeZone
-	  (-6000 * 3600, "America/Winnipeg",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
+	  (-6000 * 3600, "CST",
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
+	timezones0.put("CST", tz);
+	timezones0.put("CST6CDT", tz);
+	timezones0.put("America/Chicago", tz);
+	timezones0.put("America/Indiana/Knox", tz);
+	timezones0.put("America/Indiana/Petersburg", tz);
+	timezones0.put("America/Indiana/Vincennes", tz);
+	timezones0.put("America/Menominee", tz);
+	timezones0.put("America/North_Dakota/Center", tz);
+	timezones0.put("America/North_Dakota/New_Salem", tz);
+	timezones0.put("America/Rainy_River", tz);
+	timezones0.put("America/Rankin_Inlet", tz);
 	timezones0.put("America/Winnipeg", tz);
 	tz = new SimpleTimeZone
 	  (-6000 * 3600, "Pacific/Easter",
-	   Calendar.OCTOBER, 2, Calendar.SATURDAY, 23000 * 3600,
+	   Calendar.OCTOBER, 2, Calendar.SATURDAY, 22000 * 3600,
 	   Calendar.MARCH, 2, Calendar.SATURDAY, 22000 * 3600);
 	timezones0.put("Pacific/Easter", tz);
-	tz = new SimpleTimeZone
-	  (-5000 * 3600, "America/Grand_Turk",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 0 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 0 * 3600);
-	timezones0.put("America/Grand_Turk", tz);
-	tz = new SimpleTimeZone
-	  (-5000 * 3600, "America/Havana",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 1000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
-	timezones0.put("America/Havana", tz);
 	tz = new SimpleTimeZone(-5000 * 3600, "EST5");
 	timezones0.put("EST5", tz);
 	timezones0.put("IET", tz);
+	timezones0.put("America/Atikokan", tz);
 	timezones0.put("America/Bogota", tz);
 	timezones0.put("America/Cayman", tz);
 	timezones0.put("America/Eirunepe", tz);
 	timezones0.put("America/Guayaquil", tz);
-	timezones0.put("America/Indiana/Indianapolis", tz);
-	timezones0.put("America/Indiana/Knox", tz);
-	timezones0.put("America/Indiana/Marengo", tz);
-	timezones0.put("America/Indiana/Vevay", tz);
-	timezones0.put("America/Indianapolis", tz);
 	timezones0.put("America/Jamaica", tz);
 	timezones0.put("America/Lima", tz);
 	timezones0.put("America/Panama", tz);
-	timezones0.put("America/Port-au-Prince", tz);
 	timezones0.put("America/Rio_Branco", tz);
 	tz = new SimpleTimeZone
+	  (-5000 * 3600, "America/Havana",
+	   Calendar.APRIL, 1, Calendar.SUNDAY, 0 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
+	timezones0.put("America/Havana", tz);
+	tz = new SimpleTimeZone
+	  (-5000 * 3600, "America/Grand_Turk",
+	   Calendar.APRIL, 1, Calendar.SUNDAY, 0 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 0 * 3600);
+	timezones0.put("America/Grand_Turk", tz);
+	timezones0.put("America/Port-au-Prince", tz);
+	tz = new SimpleTimeZone
 	  (-5000 * 3600, "EST",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("EST", tz);
 	timezones0.put("EST5EDT", tz);
 	timezones0.put("America/Detroit", tz);
+	timezones0.put("America/Indiana/Indianapolis", tz);
+	timezones0.put("America/Indiana/Marengo", tz);
+	timezones0.put("America/Indiana/Vevay", tz);
 	timezones0.put("America/Iqaluit", tz);
 	timezones0.put("America/Kentucky/Louisville", tz);
 	timezones0.put("America/Kentucky/Monticello", tz);
-	timezones0.put("America/Louisville", tz);
 	timezones0.put("America/Montreal", tz);
 	timezones0.put("America/Nassau", tz);
 	timezones0.put("America/New_York", tz);
@@ -291,12 +362,18 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("America/Pangnirtung", tz);
 	timezones0.put("America/Thunder_Bay", tz);
 	timezones0.put("America/Toronto", tz);
+	tz = new SimpleTimeZone
+	  (-4000 * 3600, "America/Asuncion",
+	   Calendar.OCTOBER, 3, Calendar.SUNDAY, 0 * 3600,
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 0 * 3600);
+	timezones0.put("America/Asuncion", tz);
 	tz = new SimpleTimeZone(-4000 * 3600, "PRT");
 	timezones0.put("PRT", tz);
 	timezones0.put("America/Anguilla", tz);
 	timezones0.put("America/Antigua", tz);
 	timezones0.put("America/Aruba", tz);
 	timezones0.put("America/Barbados", tz);
+	timezones0.put("America/Blanc-Sablon", tz);
 	timezones0.put("America/Boa_Vista", tz);
 	timezones0.put("America/Caracas", tz);
 	timezones0.put("America/Curacao", tz);
@@ -318,38 +395,30 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("America/St_Vincent", tz);
 	timezones0.put("America/Tortola", tz);
 	tz = new SimpleTimeZone
-	  (-4000 * 3600, "America/Asuncion",
-	   Calendar.OCTOBER, 3, Calendar.SUNDAY, 0 * 3600,
-	   Calendar.MARCH, 2, Calendar.SUNDAY, 0 * 3600);
-	timezones0.put("America/Asuncion", tz);
-	tz = new SimpleTimeZone
 	  (-4000 * 3600, "America/Campo_Grande",
-	   Calendar.OCTOBER, 3, Calendar.SUNDAY, 0 * 3600,
-	   Calendar.FEBRUARY, 3, Calendar.SUNDAY, 0 * 3600);
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 0 * 3600,
+	   Calendar.FEBRUARY, -1, Calendar.SUNDAY, 0 * 3600);
 	timezones0.put("America/Campo_Grande", tz);
 	timezones0.put("America/Cuiaba", tz);
 	tz = new SimpleTimeZone
 	  (-4000 * 3600, "America/Goose_Bay",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 60000,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 60000);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 60000,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 60000);
 	timezones0.put("America/Goose_Bay", tz);
 	tz = new SimpleTimeZone
-	  (-4000 * 3600, "America/Santiago",
-	   Calendar.OCTOBER, 9, -Calendar.SUNDAY, 1000 * 3600,
-	   Calendar.MARCH, 9, -Calendar.SUNDAY, 0 * 3600);
-	timezones0.put("America/Santiago", tz);
-	tz = new SimpleTimeZone
 	  (-4000 * 3600, "America/Glace_Bay",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("America/Glace_Bay", tz);
 	timezones0.put("America/Halifax", tz);
+	timezones0.put("America/Moncton", tz);
 	timezones0.put("America/Thule", tz);
 	timezones0.put("Atlantic/Bermuda", tz);
 	tz = new SimpleTimeZone
-	  (-4000 * 3600, "Antarctica/Palmer",
+	  (-4000 * 3600, "America/Santiago",
 	   Calendar.OCTOBER, 9, -Calendar.SUNDAY, 0 * 3600,
 	   Calendar.MARCH, 9, -Calendar.SUNDAY, 0 * 3600);
+	timezones0.put("America/Santiago", tz);
 	timezones0.put("Antarctica/Palmer", tz);
 	tz = new SimpleTimeZone
 	  (-4000 * 3600, "Atlantic/Stanley",
@@ -358,31 +427,35 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Atlantic/Stanley", tz);
 	tz = new SimpleTimeZone
 	  (-3500 * 3600, "CNT",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 60000,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 60000);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 60000,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 60000);
 	timezones0.put("CNT", tz);
 	timezones0.put("America/St_Johns", tz);
 	tz = new SimpleTimeZone
 	  (-3000 * 3600, "America/Godthab",
-	   Calendar.MARCH, 30, -Calendar.SATURDAY, 23000 * 3600,
+	   Calendar.MARCH, 30, -Calendar.SATURDAY, 22000 * 3600,
 	   Calendar.OCTOBER, 30, -Calendar.SATURDAY, 23000 * 3600);
 	timezones0.put("America/Godthab", tz);
 	tz = new SimpleTimeZone
 	  (-3000 * 3600, "America/Miquelon",
-	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("America/Miquelon", tz);
 	tz = new SimpleTimeZone
+	  (-3000 * 3600, "America/Montevideo",
+	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600);
+	timezones0.put("America/Montevideo", tz);
+	tz = new SimpleTimeZone
 	  (-3000 * 3600, "America/Sao_Paulo",
-	   Calendar.OCTOBER, 3, Calendar.SUNDAY, 0 * 3600,
-	   Calendar.FEBRUARY, 3, Calendar.SUNDAY, 0 * 3600);
+	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 0 * 3600,
+	   Calendar.FEBRUARY, -1, Calendar.SUNDAY, 0 * 3600);
 	timezones0.put("America/Sao_Paulo", tz);
 	tz = new SimpleTimeZone(-3000 * 3600, "AGT");
 	timezones0.put("AGT", tz);
 	timezones0.put("America/Araguaina", tz);
 	timezones0.put("America/Argentina/Buenos_Aires", tz);
 	timezones0.put("America/Argentina/Catamarca", tz);
-	timezones0.put("America/Argentina/ComodRivadavia", tz);
 	timezones0.put("America/Argentina/Cordoba", tz);
 	timezones0.put("America/Argentina/Jujuy", tz);
 	timezones0.put("America/Argentina/La_Rioja", tz);
@@ -396,7 +469,6 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("America/Cayenne", tz);
 	timezones0.put("America/Fortaleza", tz);
 	timezones0.put("America/Maceio", tz);
-	timezones0.put("America/Montevideo", tz);
 	timezones0.put("America/Paramaribo", tz);
 	timezones0.put("America/Recife", tz);
 	timezones0.put("Antarctica/Rothera", tz);
@@ -405,7 +477,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Atlantic/South_Georgia", tz);
 	tz = new SimpleTimeZone
 	  (-1000 * 3600, "America/Scoresbysund",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 1000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 0 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
 	timezones0.put("America/Scoresbysund", tz);
 	timezones0.put("Atlantic/Azores", tz);
@@ -429,22 +501,23 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Africa/Nouakchott", tz);
 	timezones0.put("Africa/Ouagadougou", tz);
 	timezones0.put("Africa/Sao_Tome", tz);
-	timezones0.put("Africa/Timbuktu", tz);
 	timezones0.put("America/Danmarkshavn", tz);
 	timezones0.put("Atlantic/Reykjavik", tz);
 	timezones0.put("Atlantic/St_Helena", tz);
-	timezones0.put("Europe/Belfast", tz);
-	timezones0.put("Europe/Dublin", tz);
-	timezones0.put("Europe/London", tz);
 	tz = new SimpleTimeZone
 	  (0 * 3600, "WET",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 1000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
 	timezones0.put("WET", tz);
 	timezones0.put("Atlantic/Canary", tz);
-	timezones0.put("Atlantic/Faeroe", tz);
+	timezones0.put("Atlantic/Faroe", tz);
 	timezones0.put("Atlantic/Madeira", tz);
+	timezones0.put("Europe/Dublin", tz);
+	timezones0.put("Europe/Guernsey", tz);
+	timezones0.put("Europe/Isle_of_Man", tz);
+	timezones0.put("Europe/Jersey", tz);
 	timezones0.put("Europe/Lisbon", tz);
+	timezones0.put("Europe/London", tz);
 	tz = new SimpleTimeZone(1000 * 3600, "Africa/Algiers");
 	timezones0.put("Africa/Algiers", tz);
 	timezones0.put("Africa/Bangui", tz);
@@ -458,7 +531,6 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Africa/Ndjamena", tz);
 	timezones0.put("Africa/Niamey", tz);
 	timezones0.put("Africa/Porto-Novo", tz);
-	timezones0.put("Africa/Tunis", tz);
 	tz = new SimpleTimeZone
 	  (1000 * 3600, "Africa/Windhoek",
 	   Calendar.SEPTEMBER, 1, Calendar.SUNDAY, 2000 * 3600,
@@ -466,12 +538,13 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Africa/Windhoek", tz);
 	tz = new SimpleTimeZone
 	  (1000 * 3600, "CET",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("CET", tz);
 	timezones0.put("ECT", tz);
 	timezones0.put("MET", tz);
 	timezones0.put("Africa/Ceuta", tz);
+	timezones0.put("Africa/Tunis", tz);
 	timezones0.put("Arctic/Longyearbyen", tz);
 	timezones0.put("Atlantic/Jan_Mayen", tz);
 	timezones0.put("Europe/Amsterdam", tz);
@@ -490,6 +563,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Europe/Monaco", tz);
 	timezones0.put("Europe/Oslo", tz);
 	timezones0.put("Europe/Paris", tz);
+	timezones0.put("Europe/Podgorica", tz);
 	timezones0.put("Europe/Prague", tz);
 	timezones0.put("Europe/Rome", tz);
 	timezones0.put("Europe/San_Marino", tz);
@@ -505,7 +579,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Europe/Zurich", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "ART",
-	   Calendar.APRIL, -1, Calendar.FRIDAY, 1000 * 3600,
+	   Calendar.APRIL, -1, Calendar.FRIDAY, 0 * 3600,
 	   Calendar.SEPTEMBER, -1, Calendar.THURSDAY, 24000 * 3600);
 	timezones0.put("ART", tz);
 	timezones0.put("Africa/Cairo", tz);
@@ -526,8 +600,8 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Asia/Jerusalem", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "Asia/Amman",
-	   Calendar.MARCH, -1, Calendar.THURSDAY, 1000 * 3600,
-	   Calendar.SEPTEMBER, -1, Calendar.THURSDAY, 1000 * 3600);
+	   Calendar.MARCH, -1, Calendar.THURSDAY, 0 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.FRIDAY, 1000 * 3600);
 	timezones0.put("Asia/Amman", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "Asia/Beirut",
@@ -541,12 +615,12 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Asia/Damascus", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "Asia/Gaza",
-	   Calendar.APRIL, 3, Calendar.FRIDAY, 0 * 3600,
+	   Calendar.APRIL, 1, 0, 0 * 3600,
 	   Calendar.OCTOBER, 3, Calendar.FRIDAY, 0 * 3600);
 	timezones0.put("Asia/Gaza", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "EET",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 4000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 4000 * 3600);
 	timezones0.put("EET", tz);
 	timezones0.put("Asia/Istanbul", tz);
@@ -568,25 +642,25 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Europe/Zaporozhye", tz);
 	tz = new SimpleTimeZone
 	  (2000 * 3600, "Europe/Kaliningrad",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Europe/Kaliningrad", tz);
 	timezones0.put("Europe/Minsk", tz);
 	tz = new SimpleTimeZone
 	  (3000 * 3600, "Asia/Baghdad",
-	   Calendar.APRIL, 1, 0, 4000 * 3600,
+	   Calendar.APRIL, 1, 0, 3000 * 3600,
 	   Calendar.OCTOBER, 1, 0, 4000 * 3600);
 	timezones0.put("Asia/Baghdad", tz);
 	tz = new SimpleTimeZone
-	  (3000 * 3600, "Asia/Tbilisi",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	  (3000 * 3600, "Europe/Moscow",
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
-	timezones0.put("Asia/Tbilisi", tz);
 	timezones0.put("Europe/Moscow", tz);
+	timezones0.put("Europe/Volgograd", tz);
 	tz = new SimpleTimeZone(3000 * 3600, "EAT");
 	timezones0.put("EAT", tz);
 	timezones0.put("Africa/Addis_Ababa", tz);
-	timezones0.put("Africa/Asmera", tz);
+	timezones0.put("Africa/Asmara", tz);
 	timezones0.put("Africa/Dar_es_Salaam", tz);
 	timezones0.put("Africa/Djibouti", tz);
 	timezones0.put("Africa/Kampala", tz);
@@ -606,64 +680,61 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Asia/Tehran", tz);
 	tz = new SimpleTimeZone
 	  (4000 * 3600, "Asia/Baku",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 1000 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 4000 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 5000 * 3600);
 	timezones0.put("Asia/Baku", tz);
 	tz = new SimpleTimeZone
 	  (4000 * 3600, "Asia/Yerevan",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Yerevan", tz);
 	timezones0.put("Europe/Samara", tz);
 	tz = new SimpleTimeZone(4000 * 3600, "NET");
 	timezones0.put("NET", tz);
-	timezones0.put("Asia/Aqtau", tz);
 	timezones0.put("Asia/Dubai", tz);
 	timezones0.put("Asia/Muscat", tz);
-	timezones0.put("Asia/Oral", tz);
+	timezones0.put("Asia/Tbilisi", tz);
 	timezones0.put("Indian/Mahe", tz);
 	timezones0.put("Indian/Mauritius", tz);
 	timezones0.put("Indian/Reunion", tz);
 	tz = new SimpleTimeZone(4500 * 3600, "Asia/Kabul");
 	timezones0.put("Asia/Kabul", tz);
 	tz = new SimpleTimeZone
-	  (5000 * 3600, "Asia/Bishkek",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 2500 * 3600,
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2500 * 3600);
-	timezones0.put("Asia/Bishkek", tz);
-	tz = new SimpleTimeZone
 	  (5000 * 3600, "Asia/Yekaterinburg",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Yekaterinburg", tz);
 	tz = new SimpleTimeZone(5000 * 3600, "PLT");
 	timezones0.put("PLT", tz);
+	timezones0.put("Asia/Aqtau", tz);
 	timezones0.put("Asia/Aqtobe", tz);
 	timezones0.put("Asia/Ashgabat", tz);
 	timezones0.put("Asia/Dushanbe", tz);
 	timezones0.put("Asia/Karachi", tz);
+	timezones0.put("Asia/Oral", tz);
 	timezones0.put("Asia/Samarkand", tz);
 	timezones0.put("Asia/Tashkent", tz);
 	timezones0.put("Indian/Kerguelen", tz);
 	timezones0.put("Indian/Maldives", tz);
-	tz = new SimpleTimeZone(5500 * 3600, "IST");
+	tz = new SimpleTimeZone(5500 * 3600, "BST");
+	timezones0.put("BST", tz);
 	timezones0.put("IST", tz);
 	timezones0.put("Asia/Calcutta", tz);
+	timezones0.put("Asia/Colombo", tz);
 	tz = new SimpleTimeZone(5750 * 3600, "Asia/Katmandu");
 	timezones0.put("Asia/Katmandu", tz);
-	tz = new SimpleTimeZone(6000 * 3600, "BST");
-	timezones0.put("BST", tz);
+	tz = new SimpleTimeZone(6000 * 3600, "Antarctica/Mawson");
 	timezones0.put("Antarctica/Mawson", tz);
 	timezones0.put("Antarctica/Vostok", tz);
 	timezones0.put("Asia/Almaty", tz);
-	timezones0.put("Asia/Colombo", tz);
+	timezones0.put("Asia/Bishkek", tz);
 	timezones0.put("Asia/Dhaka", tz);
 	timezones0.put("Asia/Qyzylorda", tz);
 	timezones0.put("Asia/Thimphu", tz);
 	timezones0.put("Indian/Chagos", tz);
 	tz = new SimpleTimeZone
 	  (6000 * 3600, "Asia/Novosibirsk",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Novosibirsk", tz);
 	timezones0.put("Asia/Omsk", tz);
@@ -687,7 +758,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Asia/Hovd", tz);
 	tz = new SimpleTimeZone
 	  (7000 * 3600, "Asia/Krasnoyarsk",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Krasnoyarsk", tz);
 	tz = new SimpleTimeZone(8000 * 3600, "CTT");
@@ -710,7 +781,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Australia/Perth", tz);
 	tz = new SimpleTimeZone
 	  (8000 * 3600, "Asia/Irkutsk",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Irkutsk", tz);
 	tz = new SimpleTimeZone
@@ -718,6 +789,8 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	   Calendar.MARCH, -1, Calendar.SATURDAY, 2000 * 3600,
 	   Calendar.SEPTEMBER, -1, Calendar.SATURDAY, 2000 * 3600);
 	timezones0.put("Asia/Ulaanbaatar", tz);
+	tz = new SimpleTimeZone(8750 * 3600, "Australia/Eucla");
+	timezones0.put("Australia/Eucla", tz);
 	tz = new SimpleTimeZone
 	  (9000 * 3600, "Asia/Choibalsan",
 	   Calendar.MARCH, -1, Calendar.SATURDAY, 2000 * 3600,
@@ -733,12 +806,12 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Palau", tz);
 	tz = new SimpleTimeZone
 	  (9000 * 3600, "Asia/Yakutsk",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Yakutsk", tz);
 	tz = new SimpleTimeZone
 	  (9500 * 3600, "Australia/Adelaide",
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Australia/Adelaide", tz);
 	timezones0.put("Australia/Broken_Hill", tz);
@@ -753,21 +826,21 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Port_Moresby", tz);
 	timezones0.put("Pacific/Saipan", tz);
 	timezones0.put("Pacific/Truk", tz);
-	timezones0.put("Pacific/Yap", tz);
 	tz = new SimpleTimeZone
 	  (10000 * 3600, "Asia/Sakhalin",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Sakhalin", tz);
 	timezones0.put("Asia/Vladivostok", tz);
 	tz = new SimpleTimeZone
-	  (10000 * 3600, "Australia/Hobart",
-	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 3000 * 3600,
+	  (10000 * 3600, "Australia/Currie",
+	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
+	timezones0.put("Australia/Currie", tz);
 	timezones0.put("Australia/Hobart", tz);
 	tz = new SimpleTimeZone
 	  (10000 * 3600, "AET",
-	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("AET", tz);
 	timezones0.put("Australia/Melbourne", tz);
@@ -779,7 +852,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Australia/Lord_Howe", tz);
 	tz = new SimpleTimeZone
 	  (11000 * 3600, "Asia/Magadan",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Magadan", tz);
 	tz = new SimpleTimeZone(11000 * 3600, "SST");
@@ -793,7 +866,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Norfolk", tz);
 	tz = new SimpleTimeZone
 	  (12000 * 3600, "NST",
-	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.MARCH, 3, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("NST", tz);
 	timezones0.put("Antarctica/McMurdo", tz);
@@ -801,7 +874,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Auckland", tz);
 	tz = new SimpleTimeZone
 	  (12000 * 3600, "Asia/Anadyr",
-	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
+	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
 	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
 	timezones0.put("Asia/Anadyr", tz);
 	timezones0.put("Asia/Kamchatka", tz);
@@ -816,7 +889,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	timezones0.put("Pacific/Wallis", tz);
 	tz = new SimpleTimeZone
 	  (12750 * 3600, "Pacific/Chatham",
-	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 3750 * 3600,
+	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2750 * 3600,
 	   Calendar.MARCH, 3, Calendar.SUNDAY, 3750 * 3600);
 	timezones0.put("Pacific/Chatham", tz);
 	tz = new SimpleTimeZone(13000 * 3600, "Pacific/Enderbury");
@@ -875,7 +948,6 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
   static TimeZone getDefaultTimeZone(String sysTimeZoneId)
   {
     String stdName = null;
-    String dstName;
     int stdOffs;
     int dstOffs;
     try
@@ -888,14 +960,14 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 
 	// get std
 	do
-	  c = sysTimeZoneId.charAt(index++);
+	  c = sysTimeZoneId.charAt(index);
 	while (c != '+' && c != '-' && c != ',' && c != ':'
-	       && ! Character.isDigit(c) && c != '\0' && index < idLength);
+	       && ! Character.isDigit(c) && c != '\0' && ++index < idLength);
 
 	if (index >= idLength)
-	  return (TimeZone)timezones().get(sysTimeZoneId);
+	  return getTimeZoneInternal(sysTimeZoneId);
 
-	stdName = sysTimeZoneId.substring(0, --index);
+	stdName = sysTimeZoneId.substring(0, index);
 	prevIndex = index;
 
 	// get the std offset
@@ -926,7 +998,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	if (index >= idLength)
 	  {
 	    // Do we have an existing timezone with that name and offset?
-	    TimeZone tz = (TimeZone) timezones().get(stdName);
+	    TimeZone tz = getTimeZoneInternal(stdName);
 	    if (tz != null)
 	      if (tz.getRawOffset() == stdOffs)
 		return tz;
@@ -937,16 +1009,16 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 
 	// get dst
 	do
-	  c = sysTimeZoneId.charAt(index++);
+	  c = sysTimeZoneId.charAt(index);
 	while (c != '+' && c != '-' && c != ',' && c != ':'
-	       && ! Character.isDigit(c) && c != '\0' && index < idLength);
+	       && ! Character.isDigit(c) && c != '\0' && ++index < idLength);
 
 	// Done yet? (Format: std offset dst)
 	if (index >= idLength)
 	  {
 	    // Do we have an existing timezone with that name and offset 
 	    // which has DST?
-	    TimeZone tz = (TimeZone) timezones().get(stdName);
+	    TimeZone tz = getTimeZoneInternal(stdName);
 	    if (tz != null)
 	      if (tz.getRawOffset() == stdOffs && tz.useDaylightTime())
 		return tz;
@@ -956,7 +1028,6 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	  }
 
 	// get the dst offset
-	dstName = sysTimeZoneId.substring(prevIndex, --index);
 	prevIndex = index;
 	do
 	  c = sysTimeZoneId.charAt(index++);
@@ -965,7 +1036,14 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	if (index < idLength)
 	  index--;
 
-	{ // convert the dst string to a millis number
+	if (index == prevIndex && (c == ',' || c == ';'))
+	  {
+	    // Missing dst offset defaults to one hour ahead of standard
+	    // time.  
+	    dstOffs = stdOffs + 60 * 60 * 1000;
+	  }
+	else
+	  { // convert the dst string to a millis number
 	    String offset = sysTimeZoneId.substring(prevIndex, index);
 	    prevIndex = index;
 
@@ -979,14 +1057,14 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 
 	    // TZ timezone offsets are positive when WEST of the meridian.
 	    dstOffs = -dstOffs;
-	}
+	  }
 
 	// Done yet? (Format: std offset dst offset)
 	// FIXME: We don't support DST without a rule given. Should we?
 	if (index >= idLength)
 	  {
 	    // Time Zone existing with same name, dst and offsets?
-	    TimeZone tz = (TimeZone) timezones().get(stdName);
+	    TimeZone tz = getTimeZoneInternal(stdName);
 	    if (tz != null)
 	      if (tz.getRawOffset() == stdOffs && tz.useDaylightTime()
 	          && tz.getDSTSavings() == (dstOffs - stdOffs))
@@ -1071,18 +1149,30 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	int day;
 
 	// Month, week of month, day of week
+
+	// "Mm.w.d".  d is between 0 (Sunday) and 6.  Week w is
+	// between 1 and 5; Week 1 is the first week in which day d
+	// occurs and Week 5 specifies the last d day in the month.
+	// Month m is between 1 and 12.
+
 	month = Integer.parseInt(date.substring(1, date.indexOf('.')));
 	int week = Integer.parseInt(date.substring(date.indexOf('.') + 1,
 	                                           date.lastIndexOf('.')));
 	int dayOfWeek = Integer.parseInt(date.substring(date.lastIndexOf('.')
 	                                                + 1));
-	if (week == 5)
-	  day = -1; // last day of month is -1 in java, 5 in TZ
-	else
-	  // first day of week starting on or after.
-	  day = (week - 1) * 7 + 1;
-
 	dayOfWeek++; // Java day of week is one-based, Sunday is first day.
+
+ 	if (week == 5)
+ 	  day = -1; // last day of month is -1 in java, 5 in TZ
+ 	else
+	  {
+	    // First day of week starting on or after.  For example,
+	    // to specify the second Sunday of April, set month to
+	    // APRIL, day-of-month to 8, and day-of-week to -SUNDAY.
+	    day = (week - 1) * 7 + 1;
+	    dayOfWeek = -dayOfWeek;
+	  }
+
 	month--; // Java month is zero-based.
 	return new int[] { month, day, dayOfWeek };
       }
@@ -1140,10 +1230,10 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	break;
       else
 	i++;
+    millis += 60 * 1000 * Integer.parseInt(time.substring(iprev, i));
     if (i >= time.length())
       return millis;
 
-    millis += 60 * 1000 * Integer.parseInt(time.substring(iprev, i));
     millis += 1000 * Integer.parseInt(time.substring(++i));
     return millis;
   }
@@ -1312,14 +1402,7 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 
   private String getDefaultDisplayName(boolean dst)
   {
-    int offset = getRawOffset();
-    if (dst && this instanceof SimpleTimeZone)
-      {
-	// ugly, but this is a design failure of the API:
-	// getDisplayName takes a dst parameter even though
-	// TimeZone knows nothing about daylight saving offsets.
-	offset += ((SimpleTimeZone) this).getDSTSavings();
-      }
+    int offset = getRawOffset() + (dst ? getDSTSavings() : 0);
 
     StringBuffer sb = new StringBuffer(9);
     sb.append("GMT");
@@ -1375,30 +1458,67 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
    * @return The time zone for the identifier or GMT, if no such time
    * zone exists.
    */
-  // FIXME: XXX: JCL indicates this and other methods are synchronized.
-  public static TimeZone getTimeZone(String ID)
+  private static TimeZone getTimeZoneInternal(String ID)
   {
     // First check timezones hash
-    TimeZone tz = (TimeZone) timezones().get(ID);
-    if (tz != null)
+    TimeZone tz = null;
+    TimeZone tznew = null;
+    for (int pass = 0; pass < 2; pass++)
       {
-	if (tz.getID().equals(ID))
-	  return tz;
-
-	// We always return a timezone with the requested ID.
-	// This is the same behaviour as with JDK1.2.
-	tz = (TimeZone) tz.clone();
-	tz.setID(ID);
-	// We also save the alias, so that we return the same
-	// object again if getTimeZone is called with the same
-	// alias.
-	timezones().put(ID, tz);
-	return tz;
+	synchronized (TimeZone.class)
+	  {
+	    tz = (TimeZone) timezones().get(ID);
+	    if (tz != null)
+	      {
+		if (!tz.getID().equals(ID))
+		  {
+		    // We always return a timezone with the requested ID.
+		    // This is the same behaviour as with JDK1.2.
+		    tz = (TimeZone) tz.clone();
+		    tz.setID(ID);
+		    // We also save the alias, so that we return the same
+		    // object again if getTimeZone is called with the same
+		    // alias.
+		    timezones().put(ID, tz);
+		  }
+		return tz;
+	      }
+	    else if (tznew != null)
+	      {
+		timezones().put(ID, tznew);
+		return tznew;
+	      }
+	  }
+
+	if (pass == 1 || zoneinfo_dir == null)
+	  return null;
+
+	// aliases0 is never changing after first timezones(), so should
+	// be safe without synchronization.
+	String zonename = (String) aliases0.get(ID);
+	if (zonename == null)
+	  zonename = ID;
+
+	// Read the file outside of the critical section, it is expensive.
+	tznew = ZoneInfo.readTZFile (ID, zoneinfo_dir
+				     + File.separatorChar + zonename);
+	if (tznew == null)
+	  return null;
       }
 
-    // See if the ID is really a GMT offset form.
-    // Note that GMT is in the table so we know it is different.
-    if (ID.startsWith("GMT"))
+    return null;
+  }
+
+  /**
+   * Gets the TimeZone for the given ID.
+   * @param ID the time zone identifier.
+   * @return The time zone for the identifier or GMT, if no such time
+   * zone exists.
+   */
+  public static TimeZone getTimeZone(String ID)
+  {
+    // Check for custom IDs first
+    if (ID.startsWith("GMT") && ID.length() > 3)
       {
 	int pos = 3;
 	int offset_direction = 1;
@@ -1443,8 +1563,20 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 		  }
 	      }
 
-	    return new SimpleTimeZone((hour * (60 * 60 * 1000) +
-				       minute * (60 * 1000))
+	    // Custom IDs have to be normalized
+	    StringBuffer sb = new StringBuffer(9);
+	    sb.append("GMT");
+
+	    sb.append(offset_direction >= 0 ? '+' : '-');
+	    sb.append((char) ('0' + hour / 10));
+	    sb.append((char) ('0' + hour % 10));
+	    sb.append(':');
+	    sb.append((char) ('0' + minute / 10));
+	    sb.append((char) ('0' + minute % 10));
+	    ID = sb.toString();
+
+	    return new SimpleTimeZone((hour * (60 * 60 * 1000)
+				       + minute * (60 * 1000))
 				      * offset_direction, ID);
 	  }
 	catch (NumberFormatException e)
@@ -1452,8 +1584,11 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
 	  }
       }
 
-    // Finally, return GMT per spec
-    return getTimeZone("GMT");
+    TimeZone tz = getTimeZoneInternal(ID);
+    if (tz != null)
+      return tz;
+
+    return new SimpleTimeZone(0, "GMT");
   }
 
   /**
@@ -1466,37 +1601,134 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
    */
   public static String[] getAvailableIDs(int rawOffset)
   {
+    synchronized (TimeZone.class)
+      {
+	HashMap h = timezones();
+	int count = 0;
+	if (zoneinfo_dir == null)
+	  {
+	    Iterator iter = h.entrySet().iterator();
+	    while (iter.hasNext())
+	      {
+		// Don't iterate the values, since we want to count
+		// doubled values (aliases)
+		Map.Entry entry = (Map.Entry) iter.next();
+		if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
+		  count++;
+	      }
+
+	    String[] ids = new String[count];
+	    count = 0;
+	    iter = h.entrySet().iterator();
+	    while (iter.hasNext())
+	      {
+		Map.Entry entry = (Map.Entry) iter.next();
+		if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
+		  ids[count++] = (String) entry.getKey();
+	      }
+	    return ids;
+	  }
+      }
+
+    String[] s = getAvailableIDs();
     int count = 0;
-    Iterator iter = timezones().entrySet().iterator();
-    while (iter.hasNext())
+    for (int i = 0; i < s.length; i++)
       {
-	// Don't iterate the values, since we want to count 
-	// doubled values (aliases)
-	Map.Entry entry = (Map.Entry) iter.next();
-	if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
+	TimeZone t = getTimeZoneInternal(s[i]);
+	if (t == null || t.getRawOffset() != rawOffset)
+	  s[i] = null;
+	else
 	  count++;
       }
-
     String[] ids = new String[count];
     count = 0;
-    iter = timezones().entrySet().iterator();
-    while (iter.hasNext())
-      {
-	Map.Entry entry = (Map.Entry) iter.next();
-	if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
-	  ids[count++] = (String) entry.getKey();
-      }
+    for (int i = 0; i < s.length; i++)
+    if (s[i] != null)
+      ids[count++] = s[i];
+
     return ids;
   }
 
+  private static int getAvailableIDs(File d, String prefix, ArrayList list)
+    {
+      String[] files = d.list();
+      int count = files.length;
+      boolean top = prefix.length() == 0;
+      list.add (files);
+      for (int i = 0; i < files.length; i++)
+	{
+	  if (top
+	      && (files[i].equals("posix")
+		  || files[i].equals("right")
+		  || files[i].endsWith(".tab")
+		  || aliases0.get(files[i]) != null))
+	    {
+	      files[i] = null;
+	      count--;
+	      continue;
+	    }
+
+	  File f = new File(d, files[i]);
+	  if (f.isDirectory())
+	    {
+	      count += getAvailableIDs(f, prefix + files[i]
+				       + File.separatorChar, list) - 1;
+	      files[i] = null;
+	    }
+	  else
+	    files[i] = prefix + files[i];
+	}
+      return count;
+    }
+
   /**
    * Gets all available IDs.
    * @return An array of all supported IDs.
    */
   public static String[] getAvailableIDs()
   {
-    return (String[])
-      timezones().keySet().toArray(new String[timezones().size()]);
+    synchronized (TimeZone.class)
+      {
+	HashMap h = timezones();
+	if (zoneinfo_dir == null)
+	  return (String[]) h.keySet().toArray(new String[h.size()]);
+
+	if (availableIDs != null)
+	  {
+	    String[] ids = new String[availableIDs.length];
+	    for (int i = 0; i < availableIDs.length; i++)
+	      ids[i] = availableIDs[i];
+	    return ids;
+	  }
+
+	File d = new File(zoneinfo_dir);
+	ArrayList list = new ArrayList(30);
+	int count = getAvailableIDs(d, "", list) + aliases0.size();
+	availableIDs = new String[count];
+	String[] ids = new String[count];
+
+	count = 0;
+	for (int i = 0; i < list.size(); i++)
+	  {
+	    String[] s = (String[]) list.get(i);
+	    for (int j = 0; j < s.length; j++)
+	      if (s[j] != null)
+		{
+		  availableIDs[count] = s[j];
+		  ids[count++] = s[j];
+		}
+	  }
+
+	Iterator iter = aliases0.entrySet().iterator();
+	while (iter.hasNext())
+	  {
+	    Map.Entry entry = (Map.Entry) iter.next();
+	    availableIDs[count] = (String) entry.getKey();
+	    ids[count++] = (String) entry.getKey();
+	  }
+
+	return ids;
+      }
   }
 
   /**
diff --git a/libjava/classpath/scripts/timezones.pl b/libjava/classpath/scripts/timezones.pl
index 142ea4b7582..a069dedf6bd 100755
--- a/libjava/classpath/scripts/timezones.pl
+++ b/libjava/classpath/scripts/timezones.pl
@@ -213,6 +213,10 @@ foreach $file (@TIMEZONEFILES) {
 #    print STDERR "$file\n";
     open INPUT, "$TIMEZONEDIR/$file" or die "Can't open $TIMEZONEDIR/$file";
     my $in_time_zone = 0;
+    # As Zone can reference even Rule which is defined after the
+    # current line, parse the file in 2 passes.
+
+    # First pass, parse just Rule lines:
     while (<INPUT>) {
 	$_ = $1 if /^([^\#]*)\#/;
 	next if /^\s*$/;
@@ -239,6 +243,35 @@ foreach $file (@TIMEZONEFILES) {
 	    } elsif ($entries[0] eq "Zone") {
 		$in_time_zone = 1;
 		shift @entries;
+		shift @entries;
+	    } elsif (!(($entries[0] eq "Remove") || ($entries[0] eq "Link"))) {
+		die "Unknown command: $_";
+	    }
+	}
+	if ($in_time_zone) {
+	    die "early end of Zone: $_" if ($entries[0] =~ /^[A-Za-z]+/);
+	    if (@entries <= 3) {
+		$in_time_zone = 0;
+	    }
+	}
+    }
+    close INPUT;
+    open INPUT, "$TIMEZONEDIR/$file" or die "Can't open $TIMEZONEDIR/$file";
+    $in_time_zone = 0;
+
+    # Second pass, parse all but Rule lines.
+    while (<INPUT>) {
+	$_ = $1 if /^([^\#]*)\#/;
+	next if /^\s*$/;
+	my @entries = split;
+#	$, = ","; print "'$_' -> [",@entries,"]\n";
+	if (!$in_time_zone) {
+	    if ($entries[0] eq "Rule") {
+		# Do nothing, this was already handled in the
+		# first pass.
+	    } elsif ($entries[0] eq "Zone") {
+		$in_time_zone = 1;
+		shift @entries;
 		$timezonename = shift @entries;
 	    } elsif ($entries[0] eq "Remove") {
 		my $found = 0;
@@ -295,7 +328,7 @@ foreach $file (@TIMEZONEFILES) {
 			my $savings = $rule->[2];
 			my $endrule = parseRule($rawoffset, $savings, 
 						$rule->[0]);
-			my $startrule = parseRule($rawoffset, $savings, 
+			my $startrule = parseRule($rawoffset, 0, 
 						  $rule->[1]);
 			$rule = [ $endrule, $startrule, $savings ];
 #			print "start",@{$rule->[1]}, "end", @{$rule->[0]}, 
diff --git a/libjava/java/lang/System.java b/libjava/java/lang/System.java
index 005cba1397c..5d0d0c699bd 100644
--- a/libjava/java/lang/System.java
+++ b/libjava/java/lang/System.java
@@ -300,6 +300,7 @@ public final class System
    * <dt>gnu.java.io.encoding_scheme_alias.latin?</dt>       <dd>8859_?</dd>
    * <dt>gnu.java.io.encoding_scheme_alias.UTF-8</dt>        <dd>UTF8</dd>
    * <dt>gnu.java.io.encoding_scheme_alias.utf-8</dt>        <dd>UTF8</dd>
+   * <dt>gnu.java.util.zoneinfo.dir</dt>	<dd>Root of zoneinfo tree</dd>
    * </dl>
    *
    * @return the system properties, will never be null
diff --git a/libjava/java/util/VMTimeZone.java b/libjava/java/util/VMTimeZone.java
index 86b62584307..d885879886a 100644
--- a/libjava/java/util/VMTimeZone.java
+++ b/libjava/java/util/VMTimeZone.java
@@ -40,6 +40,9 @@ exception statement from your version. */
 package java.util;
 
 import gnu.classpath.Configuration;
+import gnu.classpath.SystemProperties;
+import gnu.java.util.ZoneInfo;
+import java.util.TimeZone;
 
 import java.io.*;
 
@@ -75,9 +78,10 @@ final class VMTimeZone
    * The reference implementation which is made for GNU/Posix like
    * systems calls <code>System.getenv("TZ")</code>,
    * <code>readTimeZoneFile("/etc/timezone")</code>,
-   * <code>readtzFile("/etc/localtime")</code> and finally
-   * <code>getSystemTimeZoneId()</code> till a supported TimeZone is
-   * found through <code>TimeZone.getDefaultTimeZone(String)</code>.
+   * <code>ZoneInfo.readTZFile((String)null, "/etc/localtime")</code>
+   * and finally <code>getSystemTimeZoneId()</code> till a supported
+   * TimeZone is found through
+   * <code>TimeZone.getDefaultTimeZone(String)</code>.
    * If every method fails <code>null</code> is returned (which means
    * the TimeZone code will fall back on GMT as default time zone).
    * <p>
@@ -108,9 +112,51 @@ final class VMTimeZone
     // Try to parse /etc/localtime
     if (zone == null)
       {
-	tzid = readtzFile("/etc/localtime");
-	if (tzid != null && !tzid.equals(""))
-	  zone = TimeZone.getDefaultTimeZone(tzid);
+	zone = ZoneInfo.readTZFile((String) null, "/etc/localtime");
+	if (zone != null)
+	  {
+	    // Try to find a more suitable ID for the /etc/localtime
+	    // timezone.
+	    // Sometimes /etc/localtime is a symlink to some
+	    // /usr/share/zoneinfo/ file.
+	    String id = null;
+	    try
+	      {
+		id = new File("/etc/localtime").getCanonicalPath();
+		if (id != null)
+		  {
+		    String zoneinfo_dir
+		      = SystemProperties.getProperty("gnu.java.util.zoneinfo.dir");
+		    if (zoneinfo_dir != null)
+		      zoneinfo_dir
+			= new File(zoneinfo_dir
+				   + File.separatorChar).getCanonicalPath();
+		    if (zoneinfo_dir != null && id.startsWith(zoneinfo_dir))
+		      {
+			int pos = zoneinfo_dir.length();
+			while (pos < id.length()
+			       && id.charAt(pos) == File.separatorChar)
+			  pos++;
+			if (pos < id.length())
+			  id = id.substring(pos);
+			else
+			  id = null;
+		      }
+		    else
+		      id = null;
+		  }
+	      }
+	    catch (IOException ioe)
+	      {
+		id = null;
+	      }
+
+	    if (id == null)
+	      id = readSysconfigClockFile("/etc/sysconfig/clock");
+
+	    if (id != null)
+	      zone.setID(id);
+	  }
       }
 
     // Try some system specific way
@@ -186,121 +232,46 @@ final class VMTimeZone
   }
 
   /**
-   * Tries to read a file as a "standard" tzfile and return a time
-   * zone id string as expected by <code>getDefaultTimeZone(String)</code>.
-   * If the file doesn't exist, an IOException occurs or it isn't a tzfile
-   * that can be parsed null is returned.
-   * <p>
-   * The tzfile structure (as also used by glibc) is described in the Olson
-   * tz database archive as can be found at
-   * <code>ftp://elsie.nci.nih.gov/pub/</code>.
+   * Tries to read the time zone name from a file.
+   * If the file cannot be read or an IOException occurs null is returned.
    * <p>
-   * At least the following platforms support the tzdata file format
-   * and /etc/localtime (GNU/Linux, Darwin, Solaris and FreeBSD at
-   * least). Some systems (like Darwin) don't start the file with the
-   * required magic bytes 'TZif', this implementation can handle
-   * that).
+   * The /etc/sysconfig/clock file is not standard, but a lot of systems
+   * have it. The file is included by shell scripts and the timezone
+   * name is defined in ZONE variable.
+   * This routine should grok it with or without quotes:
+   * ZONE=America/New_York
+   * or
+   * ZONE="Europe/London"
    */
-  private static String readtzFile(String file)
+  private static String readSysconfigClockFile(String file)
   {
-    File f = new File(file);
-    if (!f.exists())
-      return null;
-    
-    DataInputStream dis = null;
+    BufferedReader br = null;
     try
       {
-        FileInputStream fis = new FileInputStream(f);
-        BufferedInputStream bis = new BufferedInputStream(fis);
-        dis = new DataInputStream(bis);
-	
-        // Make sure we are reading a tzfile.
-        byte[] tzif = new byte[4];
-        dis.readFully(tzif);
-        if (tzif[0] == 'T' && tzif[1] == 'Z'
-            && tzif[2] == 'i' && tzif[3] == 'f')
-	  // Reserved bytes, ttisgmtcnt, ttisstdcnt and leapcnt
-	  skipFully(dis, 16 + 3 * 4);
-	else
-	  // Darwin has tzdata files that don't start with the TZif marker
-	  skipFully(dis, 16 + 3 * 4 - 4);
-	
-	int timecnt = dis.readInt();
-	int typecnt = dis.readInt();
-	if (typecnt > 0)
+	FileInputStream fis = new FileInputStream(file);
+	BufferedInputStream bis = new BufferedInputStream(fis);
+	br = new BufferedReader(new InputStreamReader(bis));
+
+	for (String line = br.readLine(); line != null; line = br.readLine())
 	  {
-	    int charcnt = dis.readInt();
-	    // Transition times plus indexed transition times.
-	    skipFully(dis, timecnt * (4 + 1));
-	    
-	    // Get last gmt_offset and dst/non-dst time zone names.
-	    int abbrind = -1;
-	    int dst_abbrind = -1;
-	    int gmt_offset = 0;
-	    while (typecnt-- > 0)
-	      {
-		// gmtoff
-		int offset = dis.readInt();
-		int dst = dis.readByte();
-		if (dst == 0)
-		  {
-		    abbrind = dis.readByte();
-		    gmt_offset = offset;
-		  }
-		else
-		  dst_abbrind = dis.readByte();
-	      }
-	    
-	    // gmt_offset is the offset you must add to UTC/GMT to
-	    // get the local time, we need the offset to add to
-	    // the local time to get UTC/GMT.
-	    gmt_offset *= -1;
-	    
-	    // Turn into hours if possible.
-	    if (gmt_offset % 3600 == 0)
-	      gmt_offset /= 3600;
-	    
-	    if (abbrind >= 0)
+	    line = line.trim();
+	    if (line.length() < 8 || !line.startsWith("ZONE="))
+	      continue;
+	    int posstart = 6;
+	    int posend;
+	    if (line.charAt(5) == '"')
+	      posend = line.indexOf('"', 6);
+	    else if (line.charAt(5) == '\'')
+	      posend = line.indexOf('\'', 6);
+	    else
 	      {
-		byte[] names = new byte[charcnt];
-		dis.readFully(names);
-		int j = abbrind;
-		while (j < charcnt && names[j] != 0)
-		  j++;
-		
-		String zonename = new String(names, abbrind, j - abbrind,
-					     "ASCII");
-		
-		String dst_zonename;
-		if (dst_abbrind >= 0)
-		  {
-		    j = dst_abbrind;
-		    while (j < charcnt && names[j] != 0)
-		      j++;
-		    dst_zonename = new String(names, dst_abbrind,
-					      j - dst_abbrind, "ASCII");
-		  }
-		else
-		  dst_zonename = "";
-		
-		// Only use gmt offset when necessary.
-		// Also special case GMT+/- timezones.
-		String offset_string;
-		if ("".equals(dst_zonename)
-		    && (gmt_offset == 0
-			|| zonename.startsWith("GMT+")
-			|| zonename.startsWith("GMT-")))
-		  offset_string = "";
-		else
-		  offset_string = Integer.toString(gmt_offset);
-		
-		String id = zonename + offset_string + dst_zonename;
-		
-		return id;
+		posstart = 5;
+		posend = line.length();
 	      }
+	    if (posend < 0)
+	      return null;
+	    return line.substring(posstart, posend);
 	  }
-	
-	// Something didn't match while reading the file.
 	return null;
       }
     catch (IOException ioe)
@@ -312,31 +283,15 @@ final class VMTimeZone
       {
 	try
 	  {
-	    if (dis != null)
-	      dis.close();
+	    if (br != null)
+	      br.close();
 	  }
-	catch(IOException ioe)
+	catch (IOException ioe)
 	  {
 	    // Error while close, nothing we can do.
 	  }
       }
   }
-  
-  /**
-   * Skips the requested number of bytes in the given InputStream.
-   * Throws EOFException if not enough bytes could be skipped.
-   * Negative numbers of bytes to skip are ignored.
-   */
-  private static void skipFully(InputStream is, long l) throws IOException
-  {
-    while (l > 0)
-      {
-        long k = is.skip(l);
-        if (k <= 0)
-          throw new EOFException();
-        l -= k;
-      }
-  }
 
   /**
    * Tries to get the system time zone id through native code.
diff --git a/libjava/posix.cc b/libjava/posix.cc
index 73c0f5f4329..cf19b5a4517 100644
--- a/libjava/posix.cc
+++ b/libjava/posix.cc
@@ -102,6 +102,10 @@ _Jv_platform_initProperties (java::util::Properties* newprops)
   if (! tmpdir)
     tmpdir = "/tmp";
   SET ("java.io.tmpdir", tmpdir);
+  const char *zoneinfodir = ::getenv("TZDATA");
+  if (! zoneinfodir)
+    zoneinfodir = "/usr/share/zoneinfo";
+  SET ("gnu.java.util.zoneinfo.dir", zoneinfodir);
 }
 
 static inline void
diff --git a/libjava/sources.am b/libjava/sources.am
index 9be4e994746..1ca6ae12014 100644
--- a/libjava/sources.am
+++ b/libjava/sources.am
@@ -1707,7 +1707,8 @@ gnu/java/text.list: $(gnu_java_text_source_files)
 
 gnu_java_util_source_files = \
 classpath/gnu/java/util/DoubleEnumeration.java \
-classpath/gnu/java/util/EmptyEnumeration.java
+classpath/gnu/java/util/EmptyEnumeration.java \
+classpath/gnu/java/util/ZoneInfo.java
 
 gnu_java_util_header_files = $(patsubst classpath/%,%,$(patsubst %.java,%.h,$(gnu_java_util_source_files)))