/* java.util.Date   Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.This file is part of GNU Classpath.GNU Classpath is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe 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, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception statement from your version. */package java.util;/** * This class represents a specific time in milliseconds since the epoch. * The epoch is 1970, January 1 00:00:00.0000 UTC.   * * Date is intended to reflect universal time coordinate (UTC), but doesn't * handle the leap seconds. * * Prior to jdk 1.1 this class was the sole Time class and had also  * calendar functionality.  But this can't be localized, so a new Calendar * class was created, that you should use instead.  The functions which * get or return a year, month, day etc. are all deprecated and shouldn't be * used.  Use Calendar instead. *  * @see Calendar * @see GregorianCalendar * @see java.text.DateFormat * @author Jochen Hoenicke * @author Per Bothner <bothner@cygnus.com> */public class Date implements Cloneable, Comparable, java.io.Serializable{  /**   * This is the serialization UID for this class   */  private static final long serialVersionUID = 7523967970034938905L;  /**   * The time in milliseconds since the epoch.   */  private transient long time;  /**   * Creates a new Date Object representing the current time.   */  public Date()  {    time = System.currentTimeMillis();  }  /**   * Creates a new Date Object representing the given time.   * @param time the time in milliseconds since the epoch.   */  public Date(long time)  {    this.time = time;  }  /**   * Creates a new Date Object representing the given time.   * @deprecated use <code>new GregorianCalendar(year+1900, month,   * day)</code> instead.     */  public Date(int year, int month, int day)  {    time = new GregorianCalendar(year + 1900, month, day).getTimeInMillis();  }  /**   * Creates a new Date Object representing the given time.   * @deprecated use <code>new GregorianCalendar(year+1900, month,   * day, hour, min)</code> instead.     */  public Date(int year, int month, int day, int hour, int min)  {    time =      new GregorianCalendar(year + 1900, month, day, hour,			    min).getTimeInMillis();  }  /**   * Creates a new Date Object representing the given time.   * @deprecated use <code>new GregorianCalendar(year+1900, month,   * day)</code> instead.     */  public Date(int year, int month, int day, int hour, int min, int sec)  {    time =      new GregorianCalendar(year + 1900, month, day, hour, min,			    sec).getTimeInMillis();  }  /**   * Creates a new Date from the given string representation.  This   * does the same as <code>new Date(Date.parse(s))</code>   * @see #parse   * @deprecated use <code>java.text.DateFormat.parse(s)</code> instead.     */  public Date(String s)  {    time = parse(s);  }  public Object clone()  {    try      {	return super.clone();      }    catch (CloneNotSupportedException ex)      {	return null;      }  }  /**   * @deprecated Use Calendar with a UTC TimeZone instead.   * @return the time in millis since the epoch.   */  public static long UTC(int year, int month, int date,			 int hrs, int min, int sec)  {    GregorianCalendar cal =      new GregorianCalendar(year + 1900, month, date, hrs, min, sec);    cal.set(Calendar.ZONE_OFFSET, 0);    cal.set(Calendar.DST_OFFSET, 0);    return cal.getTimeInMillis();  }  /**   * Gets the time represented by this Object   * @return the time in milliseconds since the epoch.   */  public long getTime()  {    return time;  }  /**   * @deprecated use   * Calendar.get(Calendar.ZONE_OFFSET)+Calendar.get(Calendar.DST_OFFSET)   * instead.   * @return The time zone offset in minutes of the local time zone   * relative to UTC.  The time represented by this object is used to   * determine if we should use daylight savings.   */  public int getTimezoneOffset()  {    Calendar cal = Calendar.getInstance();    cal.setTimeInMillis(time);    return (cal.get(Calendar.ZONE_OFFSET)	    + cal.get(Calendar.DST_OFFSET)) / (60 * 1000);  }  /**   * Sets the time which this Object should represented.   * @param time the time in milliseconds since the epoch.  */  public void setTime(long time)  {    this.time = time;  }  /**   * Tests if this date is after the specified date.   * @param when the other date   * @return true, if the date represented by this Object is   * strictly later than the time represented by when.     */  public boolean after(Date when)  {    return time > when.time;  }  /**   * Tests if this date is before the specified date.   * @param when the other date   * @return true, if the date represented by when is strictly later   * than the time represented by this object.   */  public boolean before(Date when)  {    return time < when.time;  }  /**   * Compares two dates for equality.   * @param obj the object to compare.   * @return true, if obj is a Date object and the date represented   * by obj is exactly the same as the time represented by this   * object.     */  public boolean equals(Object obj)  {    return (obj instanceof Date && time == ((Date) obj).time);  }  /**   * Compares two dates.   * @param when the other date.   * @return 0, if the date represented   * by obj is exactly the same as the time represented by this   * object, a negative if this Date is before the other Date, and   * a positive value otherwise.     */  public int compareTo(Date when)  {    return (time < when.time) ? -1 : (time == when.time) ? 0 : 1;  }  /**   * Compares this Date to another.  This behaves like   * <code>compareTo(Date)</code>, but it may throw a   * <code>ClassCastException</code>   * @param obj the other date.   * @return 0, if the date represented   * by obj is exactly the same as the time represented by this   * object, a negative if this Date is before the other Date, and   * a positive value otherwise.     * @exception ClassCastException if obj is not of type Date.   */  public int compareTo(Object obj)  {    return compareTo((Date) obj);  }  public int hashCode()  {    return (int) time ^ (int) (time >>> 32);  }  private static final String[] weekNames = { "Sun", "Mon", "Tue", "Wed",					      "Thu", "Fri", "Sat" };  private static final String[] monthNames = { "Jan", "Feb", "Mar", "Apr",					       "May", "Jun", "Jul", "Aug",					       "Sep", "Oct", "Nov", "Dec" };  public String toString()  {    Calendar cal = Calendar.getInstance();    cal.setTimeInMillis(time);    String day = "0" + cal.get(Calendar.DATE);    String hour = "0" + cal.get(Calendar.HOUR_OF_DAY);    String min = "0" + cal.get(Calendar.MINUTE);    String sec = "0" + cal.get(Calendar.SECOND);    String year = "000" + cal.get(Calendar.YEAR);    return weekNames[cal.get(Calendar.DAY_OF_WEEK) - 1] + " "      + monthNames[cal.get(Calendar.MONTH)] + " "      + day.substring(day.length() - 2) + " "      + hour.substring(hour.length() - 2) + ":"      + min.substring(min.length() - 2) + ":"      + sec.substring(sec.length() - 2) + " "      +      cal.getTimeZone().getDisplayName(cal.getTimeZone().inDaylightTime(this),				       TimeZone.SHORT) + " " +      year.substring(year.length() - 4);  }  /** Format this object in a locale-specific way.   * @deprecated Use DateFormat.format(Date)   */  public String toLocaleString()  {    return java.text.DateFormat.getInstance().format(this);  }  /** Format this object in a standard format in the GMT timezone.   * @deprecated Use DateFormat.format(Date) with a GMT TimeZone.   */  public String toGMTString()  {    java.text.DateFormat format = java.text.DateFormat.getInstance();    format.setTimeZone(TimeZone.getTimeZone("GMT"));    return format.format(this);  }  private static int parseTz(String tok, char sign)    throws IllegalArgumentException  {    int num;    try      {	// parseInt doesn't handle '+' so strip off sign.	num = Integer.parseInt(tok.substring(1));      }    catch (NumberFormatException ex)      {	throw new IllegalArgumentException(tok);      }    // Convert hours to minutes.    if (num < 24)      num *= 60;    else      num = (num / 100) * 60 + num % 100;    return sign == '-' ? -num : num;  }  private static int parseMonth(String tok)  {    // Initialize strings for month names.    // We could possibly use the fields of DateFormatSymbols but that is    // localized and thus might not match the English words specified.    String months[] = { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY",			"JUNE", "JULY", "AUGUST", "SEPTEMBER", "OCTOBER",			"NOVEMBER", "DECEMBER" };    int i;    for (i = 0; i < 12; i++)      if (months[i].startsWith(tok))        return i;    // Return -1 if not found.    return -1;  }  private static boolean parseDayOfWeek(String tok)  {    // Initialize strings for days of the week names.    // We could possibly use the fields of DateFormatSymbols but that is    // localized and thus might not match the English words specified.    String daysOfWeek[] = { "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",			    "THURSDAY", "FRIDAY", "SATURDAY" };    int i;    for (i = 0; i < 7; i++)      if (daysOfWeek[i].startsWith(tok))        return true;    return false;  }  /** Parse a String and return the time it represents.   * @param s The String to parse.   * @deprecated Use DateFormat.parse(String)   */  public static long parse(String string)  {    // Initialize date/time fields before parsing begins.    int year = -1;    int month = -1;    int day = -1;    int hour = -1;    int minute = -1;    int second = -1;    int timezone = 0;    boolean localTimezone = true;    // Trim out any nested stuff in parentheses now to make parsing easier.    StringBuffer buf = new StringBuffer();    int parenNesting = 0;    int len = string.length();    for (int i = 0;  i < len;  i++)      {	char ch = string.charAt(i);