pjs/grendel/calypso/util/NetworkDate.java

1075 строки
37 KiB
Java
Исходник Обычный вид История

1998-09-09 04:52:38 +04:00
/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil -*-
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is the Grendel mail/news client.
*
* The Initial Developer of the Original Code is Netscape Communications
* Corporation. Portions created by Netscape are Copyright (C) 1997
* Netscape Communications Corporation. All Rights Reserved.
*
* Created: Jamie Zawinski <jwz@netscape.com>, 3 Aug 1995.
* Ported from C on 19 Aug 1997.
*
* Contributors: Edwin Woudt <edwin@woudt.nl>
1998-09-09 04:52:38 +04:00
*/
package calypso.util;
import java.util.Date;
import java.util.TimeZone;
import calypso.util.ByteBuf;
/** Parses a date out of a string of bytes. Call it like this:
<P><UL>
<TT>ByteBuf bytes = </TT>...<TT> ;</TT><BR>
<TT>Date date = NetworkDate.parseDate(bytes);</TT>
</UL>
<P> Note that it operates on bytes, not chars, since network
dates are always ASCII.
<P> Why would you want to use this instead of
<TT>java.text.DateFormat.parse()</TT>? Because this algorithm has been
tested in the field against real-world message headers for several
years (the C code hadn't changed substantively since Netscape 2.0.)
(There had been DST-related problems, but the tokenizer/parser was
always sound.)
@see Date
@see Calendar
@see java.text.DateFormat
*/
public class NetworkDate {
private NetworkDate() { }
static private final int UNKNOWN = 0; // random unknown token
static private final int SUN = 101; // days of the week
static private final int MON = 102;
static private final int TUE = 103;
static private final int WED = 104;
static private final int THU = 105;
static private final int FRI = 107;
static private final int SAT = 108;
static private final int JAN = 201; // months
static private final int FEB = 202;
static private final int MAR = 203;
static private final int APR = 204;
static private final int MAY = 205;
static private final int JUN = 206;
static private final int JUL = 207;
static private final int AUG = 208;
static private final int SEP = 209;
static private final int OCT = 210;
static private final int NOV = 211;
static private final int DEC = 212;
static private final int PST = 301; // a smattering of timezones
static private final int PDT = 302;
static private final int MST = 303;
static private final int MDT = 304;
static private final int CST = 305;
static private final int CDT = 306;
static private final int EST = 307;
static private final int EDT = 308;
static private final int AST = 309;
static private final int NST = 310;
static private final int GMT = 311;
static private final int BST = 312;
static private final int MET = 313;
static private final int EET = 314;
static private final int JST = 315;
/** This parses a time/date string into a Time object.
If it can't be parsed, -1 is returned.
<P>Many formats are handled, including:
<P><UL>
<LI> <TT> 14 Apr 89 03:20:12 </TT>
<LI> <TT> 14 Apr 89 03:20 GMT </TT>
<LI> <TT> Fri, 17 Mar 89 4:01:33 </TT>
<LI> <TT> Fri, 17 Mar 89 4:01 GMT </TT>
<LI> <TT> Mon Jan 16 16:12 PDT 1989 </TT>
<LI> <TT> Mon Jan 16 16:12 +0130 1989 </TT>
<LI> <TT> 6 May 1992 16:41-JST (Wednesday) </TT>
<LI> <TT> 22-AUG-1993 10:59:12.82 </TT>
<LI> <TT> 22-AUG-1993 10:59pm </TT>
<LI> <TT> 22-AUG-1993 12:59am </TT>
<LI> <TT> 22-AUG-1993 12:59 PM </TT>
<LI> <TT> Friday, August 04, 1995 3:54 PM </TT>
<LI> <TT> 06/21/95 04:24:34 PM </TT>
<LI> <TT> 20/06/95 21:07 </TT>
<LI> <TT> 95-06-08 19:32:48 EDT </TT>
</UL>
<P> But note that <TT>6/5/95</TT> is ambiguous, since it's not obvious
which is the day and which is the month. (<TT>6/13/95</TT> is not
ambiguous, however.)
@param buf The bytes to parse. This assumes the input to be
a sequence of 8-bit ASCII characters. High-bit
characters are handled; 16-bit Unicode characters
are not.
@param default_to_gmt If the input string doesn't contain a description
of the timezone, then this argument determines whether the string is
interpreted relative to the local time zone (false) or to GMT (true).
The correct value to pass in for this argument depends on what standard
specified the time string which you are parsing; for RFC822 dates, this
argument should be true.
@return Microseconds since Jan 1, 1900, GMT.
You can pass this to <TT>new&nbsp;Date(long)</TT>.
Returns -1 if the string is unparsable
(no other negative value will ever be returned;
dates before the Epoch are not handled.)
*/
public static long parseLong(ByteBuf buf, boolean default_to_gmt) {
return parseLong(buf.toBytes(), 0, buf.length(), default_to_gmt);
}
/** The same, but takes a byte array and a region within it, instead
of a ByteBuf. */
public static long parseLong(byte string[], int start, int end,
boolean default_to_gmt) {
int dotw = UNKNOWN;
int month = UNKNOWN;
int zone = UNKNOWN;
int zone_offset = -1;
int date = -1;
int year = -1;
int hour = -1;
int min = -1;
int sec = -1;
int i = start;
while (i < end) {
byte c = string[i];
byte c2 = ((i+1 < end) ? string[i+1] : 0);
byte c3 = ((i+2 < end) ? string[i+2] : 0);
switch (c) {
case (byte)'a': case (byte)'A':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'p' || c2 == 'P') &&
(c3 == 'r' || c3 == 'R'))
month = APR;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 's') &&
(c3 == 't' || c3 == 'T'))
zone = AST;
else if (month == UNKNOWN &&
(c2 == 'u' || c2 == 'U') &&
(c3 == 'g' || c3 == 'G'))
month = AUG;
break;
case (byte)'b': case (byte)'B':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = BST;
break;
case (byte)'c': case (byte)'C':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 'd' || c2 == 'D') &&
(c3 == 't' || c3 == 'T'))
zone = CDT;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = CST;
break;
case (byte)'d': case (byte)'D':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 'c' || c3 == 'C'))
month = DEC;
break;
case (byte)'e': case (byte)'E':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 'd' || c2 == 'D') &&
(c3 == 't' || c3 == 'T'))
zone = EDT;
else if (zone == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 't' || c3 == 'T'))
zone = EET;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = EST;
break;
case (byte)'f': case (byte)'F':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 'b' || c3 == 'B'))
month = FEB;
else if (dotw == UNKNOWN &&
(c2 == 'r' || c2 == 'R') &&
(c3 == 'i' || c3 == 'I'))
dotw = FRI;
break;
case (byte)'g': case (byte)'G':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 'm' || c2 == 'M') &&
(c3 == 't' || c3 == 'T'))
zone = GMT;
break;
case (byte)'j': case (byte)'J':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'a' || c2 == 'A') &&
(c3 == 'n' || c3 == 'N'))
month = JAN;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = JST;
else if (month == UNKNOWN &&
(c2 == 'u' || c2 == 'U') &&
(c3 == 'l' || c3 == 'L'))
month = JUL;
else if (month == UNKNOWN &&
(c2 == 'u' || c2 == 'U') &&
(c3 == 'n' || c3 == 'N'))
month = JUN;
break;
case (byte)'m': case (byte)'M':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'a' || c2 == 'A') &&
(c3 == 'r' || c3 == 'R'))
month = MAR;
else if (month == UNKNOWN &&
(c2 == 'a' || c2 == 'A') &&
(c3 == 'y' || c3 == 'Y'))
month = MAY;
else if (zone == UNKNOWN &&
(c2 == 'd' || c2 == 'D') &&
(c3 == 't' || c3 == 'T'))
zone = MDT;
else if (zone == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 't' || c3 == 'T'))
zone = MET;
else if (dotw == UNKNOWN &&
(c2 == 'o' || c2 == 'O') &&
(c3 == 'n' || c3 == 'N'))
dotw = MON;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = MST;
break;
case (byte)'n': case (byte)'N':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'o' || c2 == 'O') &&
(c3 == 'v' || c3 == 'V'))
month = NOV;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = NST;
break;
case (byte)'o': case (byte)'O':
1998-09-09 04:52:38 +04:00
if (month == UNKNOWN &&
(c2 == 'c' || c2 == 'C') &&
(c3 == 't' || c3 == 'T'))
month = OCT;
break;
case (byte)'p': case (byte)'P':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 'd' || c2 == 'D') &&
(c3 == 't' || c3 == 'T'))
zone = PDT;
else if (zone == UNKNOWN &&
(c2 == 's' || c2 == 'S') &&
(c3 == 't' || c3 == 'T'))
zone = PST;
break;
case (byte)'s': case (byte)'S':
1998-09-09 04:52:38 +04:00
if (dotw == UNKNOWN &&
(c2 == 'a' || c2 == 'A') &&
(c3 == 't' || c3 == 'T'))
dotw = SAT;
else if (month == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 'p' || c3 == 'P'))
month = SEP;
else if (dotw == UNKNOWN &&
(c2 == 'u' || c2 == 'U') &&
(c3 == 'n' || c3 == 'N'))
dotw = SUN;
break;
case (byte)'t': case (byte)'T':
1998-09-09 04:52:38 +04:00
if (dotw == UNKNOWN &&
(c2 == 'h' || c2 == 'H') &&
(c3 == 'u' || c3 == 'U'))
dotw = THU;
else if (dotw == UNKNOWN &&
(c2 == 'u' || c2 == 'U') &&
(c3 == 'e' || c3 == 'E'))
dotw = TUE;
break;
case (byte)'u': case (byte)'U':
1998-09-09 04:52:38 +04:00
if (zone == UNKNOWN &&
(c2 == 't' || c2 == 'T') &&
!(c3 >= 'A' && c3 <= 'Z') &&
!(c3 >= 'a' && c3 <= 'z'))
// UT is the same as GMT but UTx is not.
zone = GMT;
break;
case (byte)'w': case (byte)'W':
1998-09-09 04:52:38 +04:00
if (dotw == UNKNOWN &&
(c2 == 'e' || c2 == 'E') &&
(c3 == 'd' || c3 == 'D'))
dotw = WED;
break;
// parsing timezone offsets
case (byte)'+': case (byte)'-': {
1998-09-09 04:52:38 +04:00
if (zone_offset >= 0) {
// already got one...
i++;
break;
}
if (zone != UNKNOWN && zone != GMT) {
// GMT+0300 is legal, but PST+0300 is not.
i++;
break;
}
int sign = ((c == '+') ? 1 : -1);
i++; /* move over sign */
int token_start = i;
int token_end;
for (token_end = token_start; token_end < end; token_end++) {
c = string[token_end];
if (c < '0' || c > '9')
break;
}
if ((token_end - token_start) == 4)
// GMT+0000: offset in HHMM
zone_offset = (((((string[token_start]-'0') * 10) +
(string[token_start+1]-'0'))
* 60) +
(((string[token_start+2]-'0') * 10) +
(string[token_start+3]-'0')));
else if ((token_end - token_start) == 2)
// GMT+00: offset in hours
zone_offset = (((string[token_start]-'0') * 10) +
(string[token_start+1]-'0')) * 60;
else if ((token_end - token_start) == 1)
// GMT+0: offset in hours
zone_offset = (string[token_start]-'0') * 60;
else
/* three digits, or more than 4: unrecognised. */
break;
zone_offset *= sign;
zone = GMT;
break;
}
// parsing numeric tokens
case (byte)'0': case (byte)'1': case (byte)'2': case (byte)'3':
case (byte)'4': case (byte)'5': case (byte)'6': case (byte)'7':
case (byte)'8': case (byte)'9': {
1998-09-09 04:52:38 +04:00
int tmp_hour = -1;
int tmp_min = -1;
int tmp_sec = -1;
int token_start = i;
int token_end;
// move token_end to the first non-digit, or end of string.
for (token_end = token_start; token_end < end; token_end++) {
c = string[token_end];
if (c < '0' || c > '9')
break;
}
if (token_end < end && c == ':') {
// If there's a colon, this is an hour/minute specification.
// If we've already set hour or min, ignore this one.
if (hour > 0 && min > 0)
break;
// We have seen "[0-9]+:", so this is probably HH:MM[:SS]
if ((token_end - token_start) == 2)
// two digits then a colon -- it is the hour.
tmp_hour = ((string[token_start]-'0') * 10 +
(string[token_start+1]-'0'));
else if ((token_end - token_start) == 1)
// one digit then a colon -- it is the hour.
tmp_hour = (string[token_start]-'0');
else
break;
// Got the hour; move over the colon, and parse the minutes.
// move token_start just past the colon.
token_start = token_end+1;
if (token_start >= end)
break;
// move token_end to the first non-digit, or end of string.
for(token_end = token_start; token_end < end; token_end++) {
c = string[token_end];
if (c < '0' || c > '9')
break;
}
if ((token_end - token_start) == 2)
// two digits followed by a colon or EOS -- it is the minutes.
tmp_min = ((string[token_start]-'0') * 10 +
(string[token_start+1]-'0'));
else if ((token_end - token_start) == 1)
// one digit followed by a colon or EOS -- it is the minutes.
tmp_min = (string[token_start]-'0');
else
break;
// Got the hour and minutes; move over the colon, and try to
// parse the seconds.
token_start = token_end;
if (token_end < end && string[token_end] == ':') {
// move token_start just past the colon.
token_start++;
// move token_end to the first non-digit, or end of string.
for(token_end = token_start; token_end < end; token_end++) {
c = string[token_end];
if (c < '0' || c > '9')
break;
}
if ((token_end - token_start) == 2)
// two digits followed by EOT -- it is the seconds.
tmp_sec = ((string[token_start]-'0') * 10 +
(string[token_start+1]-'0'));
else if ((token_end - token_start) == 1)
// one digit followed by EOT -- it is the seconds.
tmp_sec = (string[token_start]-'0');
}
// If we made it here, we've parsed hour and min,
// and possibly sec, so it worked as a unit.
// skip over whitespace and see if there's an AM or PM
// directly following the time.
if (token_end < end && tmp_hour <= 12) {
for(; token_start < end; token_start++) {
c = string[token_start];
if (c < '0' || c > '9')
break;
}
while (token_start < end &&
string[token_start] <= ' ')
token_start++;
if (token_start+1 < end) {
if ((string[token_start] == 'p' ||
string[token_start] == 'P') &&
(string[token_start+1] == 'm' ||
string[token_start+1] == 'M'))
// 10:05pm == 22:05, and 12:05pm == 12:05
tmp_hour = (tmp_hour == 12 ? 12 : tmp_hour + 12);
else if (tmp_hour == 12 &&
(string[token_start] == 'a' ||
string[token_start] == 'A') &&
(string[token_start+1] == 'm' ||
string[token_start+1] == 'M'))
// 12:05am == 00:05
tmp_hour = 0;
}
}
// if we made it all the way to here, we can keep these values.
// (We might have bugged out after parsing hour and before
// parsing min, and it would be bad to take one and not the
// other.)
hour = tmp_hour;
min = tmp_min;
sec = tmp_sec;
i = token_end-1;
break;
}
else if (token_end+1 < end &&
(c == '/' || c == '-') &&
(string[token_end+1] >= '0' &&
string[token_end+1] <= '9')) {
// Perhaps this is 6/16/95, 16/6/95, 6-16-95, or 16-6-95
// or even 95-06-05...
// #### But it doesn't handle 1995-06-22.
//
int n1, n2, n3;
if (month != UNKNOWN)
// if we saw a month name, this can't be.
break;
token_start = i;
// get the first one or two digits
n1 = (string[token_start] - '0');
token_start++;
if (token_start+1 < end &&
string[token_start] >= '0' &&
string[token_start] <= '9') {
n1 = (n1*10) + (string[token_start] - '0');
token_start++;
}
// demand that the next char be / or -.
if (token_start >= end-1 ||
(string[token_start] != '/' &&
string[token_start] != '-'))
break;
token_start++;
// demand that the next char be a digit.
if (string[token_start] < '0' ||
string[token_start] > '9')
break;
// get the second group of one or two digits
n2 = (string[token_start] - '0');
token_start++;
if (token_start+1 < end &&
string[token_start] >= '0' &&
string[token_start] <= '9') {
n2 = (n2*10) + (string[token_start] - '0');
token_start++;
}
// demand that the next char be / or -.
if (token_start >= end-1 ||
(string[token_start] != '/' &&
string[token_start] != '-'))
break;
token_start++;
// demand that the next char be a digit.
if (string[token_start] < '0' ||
string[token_start] > '9')
break;
// get the third group of one, two, or four digits
n3 = (string[token_start] - '0');
token_start++;
if (token_start+1 <= end &&
string[token_start] >= '0' &&
string[token_start] <= '9') {
// digit two
n3 = (n3*10) + (string[token_start] - '0');
token_start++;
// digit three
if (token_start+1 < end &&
string[token_start] >= '0' &&
string[token_start] <= '9') {
// if we have digit three but not digit four, give up on it:
// there are no three-digit-numbers in this context.
if (token_start+2 > end ||
(string[token_start+1] < '0' &&
string[token_start+1] > '9'))
break;
n3 = (n3*10) + (string[token_start++] - '0');
n3 = (n3*10) + (string[token_start++] - '0');
}
}
// if the digits are followed by an alphanumeric, give up on it.
if (token_start < end &&
((string[token_start] >= '0' &&
string[token_start] <= '9') ||
(string[token_start] >= 'a' &&
string[token_start] <= 'z') ||
(string[token_start] >= 'A' &&
string[token_start] <= 'Z')))
break;
// At this point, we've parsed three 1-2 digit numbers, with / or -
// between them. Now decide what the hell they are (DD/MM/YY or
// MM/DD/YY or YY/MM/DD.)
if (n1 > 70) { // must be YY/MM/DD
if (n2 > 12) break;
if (n3 > 31) break;
year = n1;
if (year < 1900) year += 1900;
month = (n2 + JAN - 1);
date = n3;
i = token_start;
break;
}
if (n3 < 70 || // before epoch - can't represent it.
(n1 > 12 && n2 > 12)) { // illegal
i = token_start;
break;
}
if (n3 < 1900) n3 += 1900;
if (n1 > 12) { // must be DD/MM/YY
date = n1;
month = (n2 + JAN - 1);
year = n3;
} else { // assume MM/DD/YY
// #### In the ambiguous case, should we consult the locale to
// find out the local default?
month = (n1 + JAN - 1);
date = n2;
year = n3;
}
i = token_start;
}
else if (token_end+1 < end &&
(string[token_end] >= 'A' ||
string[token_end] <= 'Z') &&
(string[token_end+1] >= 'a' &&
string[token_end+1] <= 'z')) {
// Digits followed by non-punctuation - what's that?
}
else if ((token_end - token_start) == 4) {
// four digits in a row must be a year.
if (year < 0)
year = ((string[i]-'0') * 1000 +
(string[i+1]-'0') * 100 +
(string[i+2]-'0') * 10 +
(string[i+3]-'0'));
}
else if ((token_end - token_start) == 2) {
// two digits in a row might be a date, or a year
int n = ((string[i]-'0') * 10 +
(string[i+1]-'0'));
// If we don't have a date (day of the month) and we see a number
// less than 32, then assume that is the date.
//
// Otherwise, if we have a date and not a year, assume this is the
// year. If it is less than 70, then assume it refers to the 21st
// century. If it is two digits (>= 70), assume it refers to the
// 20th century. Otherwise, assume it refers to an unambiguous year.
//
// The world will surely end soon.
//
if (date < 0 && n < 32)
date = n;
else if (year < 0) {
if (n < 70)
year = 2000 + n;
else if (n < 100)
year = 1900 + n;
else
year = n;
}
}
else if ((token_end - token_start) == 1) {
// one digit all alone -- it must be a date.
if (date < 0)
date = string[i]-'0';
}
else {
// else, three or more than four digits - what's that?
break;
}
}
} // closes switch
// Skip to the end of this token, whether we parsed it or not.
// Tokens are delimited by whitespace, or ,;-/
// But explicitly not :+-.
for (; i < end; i++) {
c = string[i];
if (c <= ' ' || c == ',' || c == ';' || c == '-' || c == '+' ||
c == '/' || c == '(' || c == ')' || c == '[' || c == ']')
break;
}
boolean done = false;
while (!done) {
done = true;
// skip over uninteresting chars before the next token.
for (; i < end; i++) {
c = string[i];
if (! (c <= ' ' || c == ',' || c == ';' || c == '/' ||
c == '(' || c == ')' || c == '[' || c == ']'))
break;
}
// "-" is ignored at the beginning of a token if we have not yet
// parsed a year, or if the character after the dash is not a digit.
if (i < end &&
c == '-' &&
(year < 0 ||
string[i+1] < '0' ||
string[i+1] > '9')) {
i++;
done = false;
}
}
}
// done parsing string -- turn symbolic zones into numeric offsets.
if (zone != UNKNOWN && zone_offset == -1) {
switch (zone) {
case PST: zone_offset = -8 * 60; break;
case PDT: zone_offset = -7 * 60; break;
case MST: zone_offset = -7 * 60; break;
case MDT: zone_offset = -6 * 60; break;
case CST: zone_offset = -6 * 60; break;
case CDT: zone_offset = -5 * 60; break;
case EST: zone_offset = -5 * 60; break;
case EDT: zone_offset = -4 * 60; break;
case AST: zone_offset = -4 * 60; break;
case NST: zone_offset = -3 * 60 - 30; break;
case GMT: zone_offset = 0 * 60; break;
case BST: zone_offset = 1 * 60; break;
case MET: zone_offset = 1 * 60; break;
case EET: zone_offset = 2 * 60; break;
case JST: zone_offset = 9 * 60; break;
}
}
// If we didn't find a year, month, or day-of-the-month, we can't
// possibly parse this, so just give up. (In fact, in the Unix C version
// of this code, I'd seen mktime() do something random -- it always
// returned "Tue Feb 5 06:28:16 2036", which is no doubt a
// numerologically significant date...
//
if (month == UNKNOWN || date == -1 || year == -1)
return -1;
if (zone_offset == -1) {
if (default_to_gmt)
zone_offset = 0;
else
zone_offset = localZoneOffset();
}
return UTC((year - 1900),
(month - JAN),
date,
(hour == -1 ? 0 : hour),
(min == -1 ? 0 : min) - zone_offset,
(sec == -1 ? 0 : sec));
}
/** The same, but assumes GMT is the default timezone. */
public static long parseLong(ByteBuf string) {
return parseLong(string, true);
}
/** Like parseLong(), but returns a new Date object instead. */
public static Date parseDate(ByteBuf string, boolean default_to_gmt) {
long date = parseLong(string, default_to_gmt);
if (date == -1) return null;
return new Date(date);
}
/** The same, but assumes GMT is the default timezone. */
public static Date parseDate(ByteBuf string) {
return parseDate(string, true);
}
/** Composes the given date into a number suitable for passing to
<TT>new&nbsp;Date(n)</TT>. This is the number of milliseconds
past the Epoch.
*/
public static long UTC(int year, int month, int date,
int hour, int min, int sec) {
long day = (date
+ monthOffset[month]
+ ((((year & 3) != 0)
|| ((year % 100 == 0) && ((year + 300) % 400 != 0))
|| (month < 2))
? -1 : 0) /* convert day-of-month to 0 based range,
* except following February in a leap year,
* in which case we skip the conversion to
* account for the extra day in February */
+ ((year - 70) * 365L) // days per year
+ ((year - 69) / 4) // plus leap days
- ((year - 1) / 100) // no leap on century years
+ ((year + 299) / 400)); // except %400 years
return (1000 *
((sec + (60 * (min + (60 * hour))))
+ (60 * 60 * 24) * day));
}
static private final short monthOffset[] = {
0, // 31 January
31, // 28 February
59, // 31 March
90, // 30 April
120, // 31 May
151, // 30 June
181, // 31 July
212, // 31 August
243, // 30 September
273, // 31 October
304, // 30 November
334 // 31 December
// 365
};
static private int localZoneOffset() {
TimeZone z = TimeZone.getDefault();
int off = z.getRawOffset() / (1000 * 60);
if (z.inDaylightTime(new Date())) // Consing!!
off += 60;
return off;
}
/*
private static void debug_print(int dotw, int month, int zone, int offset,
int date, int year, int hour, int min,
int sec) {
System.out.println("dotw = " + debug_token_to_string(dotw)
+ " (" + dotw + ")");
System.out.println("date = " + date);
System.out.println("month = " + debug_token_to_string(month)
+ " (" + month + ")");
System.out.println("year = " + year);
System.out.println("hour = " + hour);
System.out.println("min = " + min);
System.out.println("sec = " + sec);
System.out.println("zone = " + debug_token_to_string(zone)
+ " (" + zone + ")");
System.out.println("off = " + offset);
System.out.println("");
}
private static String debug_token_to_string(int t) {
switch (t) {
case UNKNOWN: return "UNKNOWN"; case SUN: return "SUN";
case MON: return "MON"; case TUE: return "TUE"; case WED: return "WED";
case THU: return "THU"; case FRI: return "FRI"; case SAT: return "SAT";
case JAN: return "JAN"; case FEB: return "FEB"; case MAR: return "MAR";
case APR: return "APR"; case MAY: return "MAY"; case JUN: return "JUN";
case JUL: return "JUL"; case AUG: return "AUG"; case SEP: return "SEP";
case OCT: return "OCT"; case NOV: return "NOV"; case DEC: return "DEC";
case PST: return "PST"; case PDT: return "PDT"; case MST: return "MST";
case MDT: return "MDT"; case CST: return "CST"; case CDT: return "CDT";
case EST: return "EST"; case EDT: return "EDT"; case AST: return "AST";
case NST: return "NST"; case GMT: return "GMT"; case BST: return "BST";
case MET: return "MET"; case EET: return "EET"; case JST: return "JST";
default: return "???";
}
}
*/
}
/*
We only handle a few time zones, but in case someone is feeling ambitious,
here are a bunch of other timezone names and numbers.
It's generally frowned upon to put timezone names in date headers instead
of GMT offsets, so the small set of zone names that we already handle is
probably sufficient.
---------------------------------------------------------------------
I lifted this list of time zone abbreviations out of a UNIX computers
setup file (specifically, from an AT&T StarServer running UNIX System V
Release 4, in the /usr/lib/local/TZ directory).
The list is by no means complete or comprehensive, as much of it comes
out of scripts designed to adjust the time on computers when Daylight
Savings Time (DST) rolls around. Also, I would consider it at least a
little suspect. First, because it was compiled by Americans, and you know
how us Americans are with geography :). Second, the data looks to be a
little old, circa 1991 (note the reference to the "Soviet Union").
The first column is an approximate name for the time zone described, the
second column gives the time relative to GMT, the third column takes a
stab at listing the country that the time zone is in, and the final
column gives one or more abbreviations that apply to that time zone (note
that abbreviations that end with "DST" or with "S" as the middle letter
indicate Daylight Savings Time is in effect).
I've also tried to roughly divide the listings into geographical
groupings.
Hope this helps,
Raymond McCauley
Texas A&M University
scooter@tamu.edu
<List follows...>
=================
Europe
Great Britain 0:00 GB-Eire GMT, BST
Western European nations +0:00 W-Eur WET, WET DST
Iceland +0:00 - WET
Middle European nations +1:00 M-Eur MET, MET DST
Poland +1:00 W-Eur MET, MET DST
Eastern European nations +2:00 E-Eur EET, EET DST
Turkey +3:00 Turkey EET, EET DST
Warsaw Pact/Soviet Union +3:00 M-Eur ????
North America
Canada/Newfoundland -3:30 Canada NST, NDT
Canada/Atlantic -4:00 Canada AST, ADT
Canada/Eastern -5:00 Canada EST, EDT
Canada/Central -6:00 Canada CST, CDT
Canada/East-Saskatchewan -6:00 Canada CST
Canada/Mountain -7:00 Canada MST, MDT
Canada/Pacific -8:00 Canada PST, PDT
Canada/Yukon -9:00 Canada YST, YDT
US/Eastern -5:00 US EST, EDT
US/Central -6:00 US CST, CDT
US/Mountain -7:00 US MST, MDT
US/Pacific -8:00 US PST, PDT
US/Yukon -9:00 US YST, YDT
US/Hawaii -10:00 US HST, PST, PDT, PPET
Mexico/BajaNorte -8:00 Mexico PST, PDT
Mexico/BajaSur -7:00 Mexico MST
Mexico/General -6:00 Mexico CST
South America
Brazil/East -3:00 Brazil EST, EDT
Brazil/West -4:00 Brazil WST, WDT
Brazil/Acre -5:00 Brazil AST, ADT
Brazil/DeNoronha -2:00 Brazil FST, FDT
Chile/Continental -4:00 Chile CST, CDT
Chile/EasterIsland -6:00 Chile EST, EDT
Asia
People's Repub. of China +8:00 PRC CST, CDT
(Yes, they really have only one time zone.)
Republic of Korea +9:00 ROK KST, KDT
Japan +9:00 Japan JST
Singapore +8:00 Singapore SST
Hongkong +8:00 U.K. HKT
ROC +8:00 - CST
Middle East
Israel +3:00 Israel IST, IDT
(This was the only listing I found)
Australia
Australia/Tasmania +10:00 Oz EST
Australia/Queensland +10:00 Oz EST
Australia/North +9:30 Oz CST
Australia/West +8:00 Oz WST
Australia/South +9:30 Oz CST
Hour TZN DZN Zone Example
0 GMT Greenwich Mean Time GMT0
0 UTC Universal Coordinated Time UTC0
2 FST FDT Fernando De Noronha Std FST2FDT
3 BST Brazil Standard Time BST3
3 EST EDT Eastern Standard (Brazil) EST3EDT
3 GST Greenland Standard Time GST3
3:30 NST NDT Newfoundland Standard Time NST3:30NDT
4 AST ADT Atlantic Standard Time AST4ADT
4 WST WDT Western Standard (Brazil) WST4WDT
5 EST EDT Eastern Standard Time EST5EDT
5 CST CDT Chile Standard Time CST5CDT
Hour TZN DZN Zone Example
5 AST ADT Acre Standard Time AST5ADT
5 CST CDT Cuba Standard Time CST5CDT
6 CST CDT Central Standard Time CST6CDT
6 EST EDT Easter Island Standard EST6EDT
7 MST MDT Mountain Standard Time MST7MDT
8 PST PDT Pacific Standard Time PST8PDT
9 AKS AKD Alaska Standard Time AKS9AKD
9 YST YDT Yukon Standard Time YST9YST
10 HST HDT Hawaii Standard Time HST10HDT
11 SST Somoa Standard Time SST11
-12 NZS NZD New Zealand Standard Time NZS-12NZD
-10 GST Guam Standard Time GST-10
-10 EAS EAD Eastern Australian Standard EAS-10EAD
-9:30 CAS CAD Central Australian Standard CAS-9:30CAD
-9 JST Japan Standard Time JST-9
-9 KST KDT Korean Standard Time KST-9KDT
-8 CCT China Coast Time CCT-8
-8 HKT Hong Kong Time HKT-8
-8 SST Singapore Standard Time SST-8
-8 WAS WAD Western Australian Standard WAS-8WAD
-7:30 JT Java Standard Time JST-7:30
-7 NST North Sumatra Time NST-7
-5:30 IST Indian Standard Time IST-5:30
-3:30 IST IDT Iran Standard Time IST-3:30IDT
-3 MSK MSD Moscow Winter Time MSK-3MSD
-2 EET Eastern Europe Time EET-2
-2 IST IDT Israel Standard Time IST-2IDT
-1 MEZ MES Middle European Time MEZ-1MES
-1 SWT SST Swedish Winter Time SWT-1SST
-1 FWT FST French Winter Time FWT-1FST
-1 CET CES Central European Time CET-1CES
-1 WAT West African Time WAT-1
*/