+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.
+ * java/util/VMTimeZone.h: Regenerated.
+ * java/util/TimeZone.h: Regenerated.
+ * gnu/java/util/ZoneInfo.h: Generated.
+
2007-02-22 Mohan Embar <gnustuff@thisiscool.com>
* include/win32-threads.h: Added #undef OUT.
gnu_java_util_source_files = \
classpath/gnu/java/util/DoubleEnumeration.java \
classpath/gnu/java/util/EmptyEnumeration.java \
-classpath/gnu/java/util/WeakIdentityHashMap.java
+classpath/gnu/java/util/WeakIdentityHashMap.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_jar_source_files = \
+2007-02-20 Jakub Jelinek <jakub@redhat.com>
+
+ * 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-20 Matthias Klose <doko@ubuntu.com>
* doc/Makefile.am: Add rules to build and install man pages
--- /dev/null
+/* 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;
+ }
+}
}
else if (firstch >= '0' && firstch <= '9')
{
+ int lastPunct = -1;
while (tok != null && tok.length() > 0)
{
int punctOffset = tok.length();
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))
tok = null;
else
tok = tok.substring(punctOffset + 1);
+ lastPunct = punct;
}
}
else if (firstch >= 'A' && firstch <= 'Z')
/* 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.
/**
* 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;
/**
* 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;
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;
}
/**
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;
}
/**
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);
}
/**
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;
}
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);
}
/**
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.
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;
// Fall back on GMT.
if (zone == null)
- zone = (TimeZone) timezones().get("GMT");
+ zone = getTimeZone ("GMT");
return zone;
}
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;
* 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?
static TimeZone getDefaultTimeZone(String sysTimeZoneId)
{
String stdName = null;
- String dstName;
int stdOffs;
int dstOffs;
try
// 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
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;
// 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;
}
// get the dst offset
- dstName = sysTimeZoneId.substring(prevIndex, --index);
prevIndex = index;
do
c = sysTimeZoneId.charAt(index++);
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))
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;
}
* @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;
}
}
- 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)
}
}
- // Finally, return GMT per spec
- return getTimeZone("GMT");
+ TimeZone tz = getTimeZoneInternal(ID);
+ if (tz != null)
+ return tz;
+
+ return new SimpleTimeZone(0, "GMT");
}
/**
*/
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;
+ }
}
/**
--- /dev/null
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __gnu_java_util_ZoneInfo__
+#define __gnu_java_util_ZoneInfo__
+
+#pragma interface
+
+#include <java/util/TimeZone.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+ namespace gnu
+ {
+ namespace java
+ {
+ namespace util
+ {
+ class ZoneInfo;
+ }
+ }
+ }
+}
+
+class gnu::java::util::ZoneInfo : public ::java::util::TimeZone
+{
+
+public:
+ ZoneInfo(jint, ::java::lang::String *, JArray< jlong > *, ::java::util::SimpleTimeZone *);
+ virtual jint getOffset(jint, jint, jint, jint, jint, jint);
+private:
+ jlong findTransition(jlong);
+public:
+ virtual jint getOffset(jlong);
+ virtual jint getRawOffset();
+ virtual void setRawOffset(jint);
+private:
+ void computeDSTSavings();
+public:
+ virtual jint getDSTSavings();
+ virtual jboolean useDaylightTime();
+ virtual jboolean inDaylightTime(::java::util::Date *);
+ virtual jint hashCode();
+ virtual jboolean equals(::java::lang::Object *);
+ virtual jboolean hasSameRules(::java::util::TimeZone *);
+ virtual ::java::lang::String * toString();
+ static ::java::util::TimeZone * readTZFile(::java::lang::String *, ::java::lang::String *);
+private:
+ static void skipFully(::java::io::InputStream *, jlong);
+ static ::java::util::SimpleTimeZone * createLastRule(::java::lang::String *);
+ static JArray< jint > * getDateParams(::java::lang::String *);
+ static jint parseTime(::java::lang::String *);
+ static const jint SECS_SHIFT = 22;
+ static const jlong OFFSET_MASK = 2097151LL;
+ static const jint OFFSET_SHIFT = 43;
+ static const jlong IS_DST = 2097152LL;
+ jint __attribute__((aligned(__alignof__( ::java::util::TimeZone)))) rawOffset;
+ jint dstSavings;
+ jboolean useDaylight;
+ JArray< jlong > * transitions;
+ ::java::util::SimpleTimeZone * lastRule;
+ static ::java::util::SimpleTimeZone * gmtZone;
+public: // actually package-private
+ static const jlong serialVersionUID = -3740626706860383657LL;
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __gnu_java_util_ZoneInfo__
/* System.java -- useful methods to interface with the system
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GNU Classpath.
* <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
virtual jboolean useDaylightTime() = 0;
virtual jboolean inDaylightTime(::java::util::Date *) = 0;
virtual jint getDSTSavings();
+private:
+ static ::java::util::TimeZone * getTimeZoneInternal(::java::lang::String *);
+public:
static ::java::util::TimeZone * getTimeZone(::java::lang::String *);
static JArray< ::java::lang::String * > * getAvailableIDs(jint);
+private:
+ static jint getAvailableIDs(::java::io::File *, ::java::lang::String *, ::java::util::ArrayList *);
+public:
static JArray< ::java::lang::String * > * getAvailableIDs();
static ::java::util::TimeZone * getDefault();
static void setDefault(::java::util::TimeZone *);
::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) ID;
static ::java::util::TimeZone * defaultZone0;
static const jlong serialVersionUID = 3581463369166924961LL;
+ static ::java::lang::String * zoneinfo_dir;
+ static JArray< ::java::lang::String * > * availableIDs;
+ static ::java::util::HashMap * aliases0;
static ::java::util::HashMap * timezones0;
public:
static ::java::lang::Class class$;
static ::java::util::TimeZone * getDefaultTimeZoneId();
private:
static ::java::lang::String * readTimeZoneFile(::java::lang::String *);
- static ::java::lang::String * readtzFile(::java::lang::String *);
- static void skipFully(::java::io::InputStream *, jlong);
+ static ::java::lang::String * readSysconfigClockFile(::java::lang::String *);
static ::java::lang::String * getSystemTimeZoneId();
public:
static ::java::lang::Class class$;
package java.util;
import gnu.classpath.Configuration;
+import gnu.classpath.SystemProperties;
+import gnu.java.util.ZoneInfo;
import java.util.TimeZone;
-import java.util.Calendar;
-import java.util.GregorianCalendar;
import java.io.*;
* 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>
// 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
}
/**
- * 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.
+ * Tries to read the time zone name from a file.
+ * If the file cannot be read or an IOException occurs 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>.
- * <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);
+ 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);
-
- String id = null;
- 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();
- }
- if (typecnt > 0)
- {
- int seltimecnt = timecnt;
- if (seltimecnt > 16)
- seltimecnt = 16;
-
- long[] times = new long[seltimecnt];
- int[] types = new int[seltimecnt];
-
- // Transition times
- skipFully(dis, (timecnt - seltimecnt) * tzif2);
-
- for (int i = 0; i < seltimecnt; i++)
- if (tzif2 == 8)
- times[i] = dis.readLong();
- else
- times[i] = (long) dis.readInt();
-
- // Transition types
- skipFully(dis, timecnt - seltimecnt);
- for (int i = 0; i < seltimecnt; i++)
- {
- types[i] = dis.readByte();
- if (types[i] < 0)
- types[i] += 256;
- }
-
- // Get std/dst_offset and dst/non-dst time zone names.
- int std_abbrind = -1;
- int dst_abbrind = -1;
- int std_offset = 0;
- int dst_offset = 0;
- int std_ind = -1;
- int dst_ind = -1;
-
- int alternation = 0;
- if (seltimecnt >= 4 && types[0] != types[1]
- && types[0] < typecnt && types[1] < typecnt)
- {
- // Verify only two types are involved
- // in the transitions and they alternate.
- alternation = 1;
- for (int i = 2; i < seltimecnt; i++)
- if (types[i] != types[i % 2])
- alternation = 0;
- }
-
- // If a timezone previously used DST, but no longer does
- // (or no longer will in the near future, say 5 years),
- // then always pick only the std zone type corresponding
- // to latest applicable transition.
- if (seltimecnt > 0
- && times[seltimecnt - 1]
- < System.currentTimeMillis() / 1000 + 5 * 365 * 86400)
- alternation = -1;
-
- for (int i = 0; i < typecnt; i++)
- {
- // gmtoff
- int offset = dis.readInt();
- int dst = dis.readByte();
- int abbrind = dis.readByte();
- if (dst == 0)
- {
- if (alternation == 0
- || (alternation == 1
- && (i == types[0] || i == types[1]))
- || (alternation == -1 && i == types[seltimecnt - 1]))
- {
- std_abbrind = abbrind;
- std_offset = offset * -1;
- std_ind = i;
- }
- }
- else if (alternation >= 0)
- {
- if (alternation == 0 || i == types[0] || i == types[1])
- {
- dst_abbrind = abbrind;
- dst_offset = offset * -1;
- dst_ind = i;
- }
- }
- }
-
- if (std_abbrind >= 0)
- {
- byte[] names = new byte[charcnt];
- dis.readFully(names);
- int j = std_abbrind;
- while (j < charcnt && names[j] != 0)
- j++;
-
- String zonename = new String(names, std_abbrind,
- j - std_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 = "";
+ br = new BufferedReader(new InputStreamReader(bis));
- String[] change_spec = { null, null };
- if (dst_abbrind >= 0 && alternation > 0)
- {
- // Guess rules for the std->dst and dst->std transitions
- // from the transition times since Epoch.
- // 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
- GregorianCalendar cal
- = new GregorianCalendar (TimeZone.getTimeZone("GMT"));
-
- int[] values = new int[2 * 11];
- int i;
- for (i = seltimecnt - 1; i >= 0; i--)
- {
- int base = (i % 2) * 11;
- int offset = types[i] == dst_ind ? std_offset : dst_offset;
- cal.setTimeInMillis((times[i] - offset) * 1000);
- if (i >= seltimecnt - 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 < 0)
- {
- 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;
-
- // FIXME: Sun >= 5 is representable in
- // SimpleTimeZone, but not in POSIX TZ env
- // strings. Should we change readtzFile
- // to actually return a SimpleTimeZone
- // rather than POSIX TZ string?
- if ((values[base + 8] % 7) != 1)
- continue;
-
- int d;
- d = values[base + 1] - Calendar.JANUARY + 1;
- change_spec[i] = ",M" + Integer.toString(d);
- d = (values[base + 8] + 6) / 7;
- 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[0] == std_ind)
- {
- String tmp = change_spec[0];
- change_spec[0] = change_spec[1];
- change_spec[1] = tmp;
- }
- }
- }
-
- // Only use gmt offset when necessary.
- // Also special case GMT+/- timezones.
- String offset_string, dst_offset_string = "";
- if (dst_abbrind < 0
- && (std_offset == 0
- || zonename.startsWith("GMT+")
- || zonename.startsWith("GMT-")))
- offset_string = "";
- else
- {
- offset_string = Integer.toString(std_offset / 3600);
- int seconds = std_offset % 3600;
- if (seconds != 0)
- {
- if (seconds < 0)
- seconds *= -1;
- if (seconds < 600)
- offset_string
- += ":0" + Integer.toString(seconds / 60);
- else
- offset_string
- += ":" + Integer.toString(seconds / 60);
- seconds = seconds % 60;
- if (seconds >= 10)
- offset_string
- += ":" + Integer.toString(seconds);
- else if (seconds > 0)
- offset_string
- += ":0" + Integer.toString(seconds);
- }
- if (dst_abbrind >= 0
- && dst_offset != std_offset - 3600)
- {
- dst_offset_string
- = Integer.toString(dst_offset / 3600);
- seconds = dst_offset % 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 (dst_abbrind < 0)
- id = zonename + offset_string;
- else if (change_spec[0] != null && change_spec[1] != null)
- id = zonename + offset_string + dst_zonename
- + dst_offset_string + change_spec[0] + change_spec[1];
- }
- else if (tzif2 == 8)
- skipFully(dis, charcnt);
- }
- else if (tzif2 == 8)
- skipFully(dis, timecnt * (8 + 1) + typecnt * (4 + 1 + 1) + charcnt);
-
- if (tzif2 == 8)
+ for (String line = br.readLine(); line != null; line = br.readLine())
{
- // Skip over the rest of 64-bit data
- skipFully(dis, leapcnt * (8 + 4) + ttisgmtcnt + ttisstdcnt);
- if (dis.readByte() == '\n')
+ 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
{
- String posixtz = dis.readLine();
- if (posixtz.length() > 0)
- id = posixtz;
+ posstart = 5;
+ posend = line.length();
}
+ if (posend < 0)
+ return null;
+ return line.substring(posstart, posend);
}
-
- return id;
+ return null;
}
catch (IOException ioe)
{
{
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.
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
gnu_java_util_source_files = \
classpath/gnu/java/util/DoubleEnumeration.java \
classpath/gnu/java/util/EmptyEnumeration.java \
-classpath/gnu/java/util/WeakIdentityHashMap.java
+classpath/gnu/java/util/WeakIdentityHashMap.java \
+classpath/gnu/java/util/ZoneInfo.java
gnu_java_util_header_files = $(patsubst classpath/%,%,$(patsubst %.java,%.h,$(gnu_java_util_source_files)))
projects / platform / upstream / linaro-gcc.git / commitdiff