mirror of git://gcc.gnu.org/git/gcc.git
1161 lines
41 KiB
Java
1161 lines
41 KiB
Java
/* 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;
|
|
}
|
|
}
|