dateparser.java

已经移植好的java虚拟机

/*
 *
 * @(#)DateParser.java	1.0 99/11/15
 * Copyright (c) 1999 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 * Use is subject to license terms.
 */
package com.sun.cldc.io;

import java.util.Hashtable;

/**
 * This class implements somewhat of a subset of the J2SE Date class.
 * However, since the semantics of parse() is slightly different
 * (DateParser will not handle dates prior to 1/1/1970, amd to
 * be able to provide methods that will set timezone and DST
 * information, it is called DateParser.
 */
public class DateParser {
	protected int year;
	protected int month;
	protected int day;
	protected int hour;
	protected int minute;
	protected int second;
	protected int milli;
    protected int tzoffset;
    protected static int local_tz;

	/**
	 * Allocates a <code>DateParser</code> object and initializes it so that 
	 * it represents the instant at the start of the second specified 
	 * by the <code>year</code>, <code>month</code>, <code>date</code>, 
	 * <code>hrs</code>, <code>min</code>, and <code>sec</code> arguments, 
	 * in the local time zone. 
	 *
	 * @param   year    the year, >= 1583.
	 * @param   month   the month between 0-11.
	 * @param   date    the day of the month between 1-31.
	 * @param   hrs     the hours between 0-23.
	 * @param   min     the minutes between 0-59.
	 * @param   sec     the seconds between 0-59.
	 */
	 DateParser(int year, int month, int day, 
							  int hour, int minute, int second) {
		if (year < 1583
			|| month < 0 || month > 11
			|| day < 0 || (day > days_in_month[month] 
			&& !(month == 1 && day == 29 && year % 4 == 0))
			|| hour < 0 || hour > 23
			|| minute < 0 || minute > 59
			|| second < 0 || second > 59) {
			throw new IllegalArgumentException();
		}

		this.year = year;
		this.month = month;
		this.day = day;
		this.hour = hour;
		this.minute = minute;
		this.second = second;
		milli = 0;
	}

	/**
	 * Allocates a <code>DateParser</code> object and initializes it so that 
	 * it represents the date and time indicated by the string 
	 * <code>s</code>, which is interpreted as if by the 
	 * {@link DateParser#parse} method. 
	 *
	 * @param   s   a string representation of the date.
	 */
	DateParser(String s) {
		internalParse(s);
	}

	/** 
	 * Set the local time zone for the DateParser class.
	 * <code>tz</code> must in abbreviated format, e.g. "PST"
	 * for Pacific Standard Time.
	 */
	static void setTimeZone(String tz) {
		if (timezones.get(tz) == null) return;
		local_tz = ((Integer)timezones.get(tz)).intValue();
	}

	/**
	 * Attempts to interpret the string <tt>s</tt> as a representation 
	 * of a date and time. If the attempt is successful, the time 
	 * indicated is returned represented as teh distance, measured in 
	 * milliseconds, of that time from the epoch (00:00:00 GMT on 
	 * January 1, 1970). If the attempt fails, an 
	 * <tt>IllegalArgumentException</tt> is thrown.
	 * <p>
	 * It accepts many syntaxes; in particular, it recognizes the IETF 
	 * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also 
	 * understands the continental U.S. time-zone abbreviations, but for 
	 * general use, a time-zone offset should be used: "Sat, 12 Aug 1995 
	 * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich 
	 * meridian). If no time zone is specified, the local time zone is 
	 * assumed. GMT and UTC are considered equivalent.
	 * <p>
	 * The string <tt>s</tt> is processed from left to right, looking for 
	 * data of interest. Any material in <tt>s</tt> that is within the 
	 * ASCII parenthesis characters <tt>(</tt> and <tt>)</tt> is ignored. 
	 * Parentheses may be nested. Otherwise, the only characters permitted 
	 * within <tt>s</tt> are these ASCII characters:
	 * <blockquote><pre>
	 * abcdefghijklmnopqrstuvwxyz
	 * ABCDEFGHIJKLMNOPQRSTUVWXYZ
	 * 0123456789,+-:/</pre></blockquote>
	 * and whitespace characters.<p>
	 * A consecutive sequence of decimal digits is treated as a decimal 
	 * number:<ul>
	 * <li>If a number is preceded by <tt>+</tt> or <tt>-</tt> and a year 
	 *     has already been recognized, then the number is a time-zone 
	 *     offset. If the number is less than 24, it is an offset measured 
	 *     in hours. Otherwise, it is regarded as an offset in minutes, 
	 *     expressed in 24-hour time format without punctuation. A 
	 *     preceding <tt>-</tt> means a westward offset. Time zone offsets 
	 *     are always relative to UTC (Greenwich). Thus, for example, 
	 *     <tt>-5</tt> occurring in the string would mean "five hours west 
	 *     of Greenwich" and <tt>+0430</tt> would mean "four hours and 
	 *     thirty minutes east of Greenwich." It is permitted for the 
	 *     string to specify <tt>GMT</tt>, <tt>UT</tt>, or <tt>UTC</tt> 
	 *     redundantly-for example, <tt>GMT-5</tt> or <tt>utc+0430</tt>.
	 * <li>If a number is greater than 70, it is regarded as a year number. 
	 *     It must be followed by a space, comma, slash, or end of string. 
	 * <li>If the number is followed by a colon, it is regarded as an hour, 
	 *     unless an hour has already been recognized, in which case it is 
	 *     regarded as a minute.
	 * <li>If the number is followed by a slash, it is regarded as a month 
	 *     (it is decreased by 1 to produce a number in the range <tt>0</tt> 
	 *     to <tt>11</tt>), unless a month has already been recognized, in 
	 *     which case it is regarded as a day of the month.
	 * <li>If the number is followed by whitespace, a comma, a hyphen, or 
	 *     end of string, then if an hour has been recognized but not a 
	 *     minute, it is regarded as a minute; otherwise, if a minute has 
	 *     been recognized but not a second, it is regarded as a second; 
	 *     otherwise, it is regarded as a day of the month. </ul><p>
	 * A consecutive sequence of letters is regarded as a word and treated 
	 * as follows:<ul>
	 * <li>A word that matches <tt>AM</tt>, ignoring case, is ignored (but 
	 *     the parse fails if an hour has not been recognized or is less 
	 *     than <tt>1</tt> or greater than <tt>12</tt>).
	 * <li>A word that matches <tt>PM</tt>, ignoring case, adds <tt>12</tt> 
	 *     to the hour (but the parse fails if an hour has not been 
	 *     recognized or is less than <tt>1</tt> or greater than <tt>12</tt>).
	 * <li>Any word that matches any prefix of <tt>SUNDAY, MONDAY, TUESDAY, 
	 *     WEDNESDAY, THURSDAY, FRIDAY</tt>, or <tt>SATURDAY</tt>, ignoring 
	 *     case, is ignored. For example, <tt>sat, Friday, TUE</tt>, and 
	 *     <tt>Thurs</tt> are ignored.
	 * <li>Otherwise, any word that matches any prefix of <tt>JANUARY, 
	 *     FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, 
	 *     OCTOBER, NOVEMBER</tt>, or <tt>DECEMBER</tt>, ignoring case, and 
	 *     considering them in the order given here, is recognized as
	 *     specifying a month and is converted to a number (<tt>0</tt> to 
	 *     <tt>11</tt>). For example, <tt>aug, Sept, april</tt>, and 
	 *     <tt>NOV</tt> are recognized as months. So is <tt>Ma</tt>, which 
	 *     is recognized as <tt>MARCH</tt>, not <tt>MAY</tt>.
	 * <li>Any word that matches <tt>GMT, UT</tt>, or <tt>UTC</tt>, ignoring 
	 *     case, is treated as referring to UTC. 
	 * <li>Any word that matches <tt>EST, CST, MST</tt>, or <tt>PST</tt>, 
	 *     ignoring case, is recognized as referring to the time zone in 
	 *     North America that is five, six, seven, or eight hours west of 
	 *     Greenwich, respectively. Any word that matches <tt>EDT, CDT, 
	 *     MDT</tt>, or <tt>PDT</tt>, ignoring case, is recognized as 
	 *     referring to the same time zone, respectively, during daylight 
	 *     saving time.</ul><p>
	 * Once the entire string s has been scanned, it is converted to a time 
	 * result in one of two ways. If a time zone or time-zone offset has been 
	 * recognized, then the year, month, day of month, hour, minute, and 
	 * second are interpreted in UTC and then the time-zone offset is 
	 * applied. Otherwise, the year, month, day of month, hour, minute, and 
	 * second are interpreted in the local time zone.
	 *
	 * @param   s   a string to be parsed as a date.
	 * @return  the distance in milliseconds from January 1, 1970, 00:00:00 GMT
	 *          represented by the string argument. Note that this method will
	 *          throw an <code>IllegalArgumentException</code> if the year 
	 *          indicated in <code>s</code> is less than 1583.
	 */
	public static long parse(String s) {
		return (new DateParser(s)).getTime();
	}

	/** Return the year represented by this date. */
	int getYear() {
		return year;
	}

	/** Return the month represented by this date. */
	int getMonth() {
		return month;
	}

	/** Return the day of the month represented by this date. */
	int getDay() {
		return day;
	}

	/** Return the hour represented by this date. */
	int getHour() {
		return hour;
	}

	/** Return the minute represented by this date. */
	int getMinute() {
		return minute;
	}

	/** Return the second represented by this date. */
	int getSecond() {
		return second;
	}

	/** Return the number of milliseconds since 1/1/1970 represented by this date. */
	long getTime() {
		long julianDay = computeJulianDay(year, month, day);
		long millis = julianDayToMillis(julianDay);

		int millisInDay = 0;
		millisInDay += hour;
		millisInDay *= 60;
		millisInDay += minute; // now have minutes
		millisInDay *= 60;
		millisInDay += second; // now have seconds
		millisInDay *= 1000;
		millisInDay += milli; // now have millis

		return millis + millisInDay - tzoffset;
	}


	private final long computeJulianDay(int year, int month, int day) {