OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Makefile.am: Added locale files from Classpath.

Browse Source 
* Makefile.am: Added locale files from Classpath.
	* Makefile.in: Rebuilt.
	* gnu/java/locale/Calendar.java: New file.
	* gnu/java/locale/Calendar_de.java: New file.
	* gnu/java/locale/Calendar_en.java: New file.
	* gnu/java/locale/Calendar_nl.java: New file.
	* java/lang/ClassNotFoundException.java: Replaced with Classpath file.
	* java/math/BigDecimal.java (intVal): Renamed from 'num' for
	serialization compatibility.
	(scale): Made private.
	(serialVersionUID): New field.
	* java/math/BigInteger.java (ival): Made transient.
	(words): Made transient.
	(bitCount): New serialization field.
	(bitLength): Ditto.
	(firstNonzeroByteNum): Ditto.
	(lowestSetBit): Ditto.
	(magnitude): Ditto.
	(signum): Ditto.
	(serialVersionUID): New field.
	(readObject): New method.
	(writeObject): New method.
	* java/util/BitSet.java (serialVersionUID): New field.
	* java/util/Calendar.java: Replaced with Classpath file.
	* java/util/GregorianCalendar.java (GregorianCalendar): Pass result
	of getDefault() for TimeZone or Locale instead of passing nulls.
	* java/util/Locale.java (serialVersionUID): New field.
	(writeObject): New method.
	(readObject): New method.
	* java/util/SimpleTimeZone.java: Replaced with Classpath file.

Serialization mods.

From-SVN: r37080
This commit is contained in:
Warren Levy 2000-10-27 10:33:46 +00:00 committed by Warren Levy
parent c11a03240f
commit df98a50bb0
15 changed files with 2277 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
libjava/ChangeLog
View File

@ -1,3 +1,36 @@
2000-10-27 Warren Levy <warrenl@cygnus.com>
* Makefile.am: Added locale files from Classpath.
* Makefile.in: Rebuilt.
* gnu/java/locale/Calendar.java: New file.
* gnu/java/locale/Calendar_de.java: New file.
* gnu/java/locale/Calendar_en.java: New file.
* gnu/java/locale/Calendar_nl.java: New file.
* java/lang/ClassNotFoundException.java: Replaced with Classpath file.
* java/math/BigDecimal.java (intVal): Renamed from 'num' for
serialization compatibility.
(scale): Made private.
(serialVersionUID): New field.
* java/math/BigInteger.java (ival): Made transient.
(words): Made transient.
(bitCount): New serialization field.
(bitLength): Ditto.
(firstNonzeroByteNum): Ditto.
(lowestSetBit): Ditto.
(magnitude): Ditto.
(signum): Ditto.
(serialVersionUID): New field.
(readObject): New method.
(writeObject): New method.
* java/util/BitSet.java (serialVersionUID): New field.
* java/util/Calendar.java: Replaced with Classpath file.
* java/util/GregorianCalendar.java (GregorianCalendar): Pass result
of getDefault() for TimeZone or Locale instead of passing nulls.
* java/util/Locale.java (serialVersionUID): New field.
(writeObject): New method.
(readObject): New method.
* java/util/SimpleTimeZone.java: Replaced with Classpath file.
2000-10-25 Bryce McKinlay <bryce@albatross.co.nz>
* Makefile.am (GCJCOMPILE): Pass --tag=GCJ to libtool.

4
libjava/Makefile.am
View File

@ -998,6 +998,10 @@ gnu/java/io/ObjectIdentityWrapper.java \
gnu/java/lang/ArrayHelper.java \
gnu/java/lang/ClassHelper.java \
gnu/java/lang/reflect/TypeSignature.java \
gnu/java/locale/Calendar.java \
gnu/java/locale/Calendar_de.java \
gnu/java/locale/Calendar_en.java \
gnu/java/locale/Calendar_nl.java \
gnu/java/security/provider/Gnu.java \
gnu/java/security/provider/SHA.java \
gnu/java/security/provider/SHA1PRNG.java \

6
libjava/Makefile.in
View File

@ -742,6 +742,10 @@ gnu/java/io/ObjectIdentityWrapper.java \
gnu/java/lang/ArrayHelper.java \
gnu/java/lang/ClassHelper.java \
gnu/java/lang/reflect/TypeSignature.java \
gnu/java/locale/Calendar.java \
gnu/java/locale/Calendar_de.java \
gnu/java/locale/Calendar_en.java \
gnu/java/locale/Calendar_nl.java \
gnu/java/security/provider/Gnu.java \
gnu/java/security/provider/SHA.java \
gnu/java/security/provider/SHA1PRNG.java \
@ -1256,6 +1260,8 @@ DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
.deps/gnu/java/io/ObjectIdentityWrapper.P \
.deps/gnu/java/lang/ArrayHelper.P .deps/gnu/java/lang/ClassHelper.P \
.deps/gnu/java/lang/reflect/TypeSignature.P \
.deps/gnu/java/locale/Calendar.P .deps/gnu/java/locale/Calendar_de.P \
.deps/gnu/java/locale/Calendar_en.P .deps/gnu/java/locale/Calendar_nl.P \
.deps/gnu/java/security/provider/Gnu.P \
.deps/gnu/java/security/provider/SHA.P \
.deps/gnu/java/security/provider/SHA1PRNG.P .deps/interpret.P \

112
libjava/gnu/java/locale/Calendar.java Normal file
View File

@ -0,0 +1,112 @@
/* Calendar.java -- Default Calendar locale data
Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.locale;
import java.util.ListResourceBundle;
import java.util.Locale;
import java.util.Date;
/**
* This class contains locale data for java.util.Calendar.<br>
*
* If you localize this to another language only set fields, that
* you change. See Calendar_de for an example. Also add your
* locale to this list of availableLocales below in this(!) file.
*
* @author Jochen Hoenicke
*/
public class Calendar extends ListResourceBundle
{
/**
* The locales for which Calendar is localized.
*/
private static final Locale[] availableLocales = {
Locale.GERMAN, Locale.ENGLISH, new Locale("nl", "")
};
/**
* This is the default calendar class, that is returned on
* java.util.Calendar.getInstance().
* @see java.util.Calendar#getInstance()
*/
private static final String calendarClass = "java.util.GregorianCalendar";
/**
* This is used by java.util.Calendar.
* @see java.util.Calendar#getFirstDayOfWeek()
*/
private static final Integer firstDayOfWeek
= new Integer(java.util.Calendar.SUNDAY);
/**
* This is used by java.util.Calendar.
* @see java.util.Calendar#getMinimalDaysInFirstWeek()
*/
private static final Integer minimalDaysInFirstWeek = new Integer(1);
/**
* The point at which the Gregorian calendar rules were used.
* The default for most catholic
* countries is midnight (UTC) on October 5, 1582 (Julian),
* or October 15, 1582 (Gregorian).
* @see java.util.GregorianCalendar#getGregorianCutOver
*/
/* If you change this date be aware, that this formular does only
* work for months from MARCH to DECEMBER and doesn't work in
* leap years (look in java.util.GregorianCalendar.getDayOfYear for
* more info).
*/
private static final Date gregorianCutOver = new Date
((24*60*60*1000L) *
(((1582*(365*4+1))/4 +
(java.util.Calendar.OCTOBER*(31+30+31+30+31) - 9) / 5 + 5) -
((1970*(365*4+1))/4 + 1 - 13)));
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
{ "availableLocales", availableLocales },
{ "calendarClass", calendarClass },
{ "firstDayOfWeek", firstDayOfWeek },
{ "minimalDaysInFirstWeek", minimalDaysInFirstWeek },
{ "gregorianCutOver", gregorianCutOver }
};
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents()
{
return(contents);
}
}

60
libjava/gnu/java/locale/Calendar_de.java Normal file
View File

@ -0,0 +1,60 @@
/* Calendar_de.java -- German calendar locale data
Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.locale;
import java.util.ListResourceBundle;
import java.util.Calendar;
/**
* This class contains locale data for java.util.Calendar specific for
* german language.
* @author Jochen Hoenicke
*/
public class Calendar_de extends ListResourceBundle
{
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
{ "firstDayOfWeek", new Integer(Calendar.MONDAY) },
{ "minimalDaysInFirstWeek", new Integer(4) },
};
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents()
{
return contents;
}
}

59
libjava/gnu/java/locale/Calendar_en.java Normal file
View File

@ -0,0 +1,59 @@
/* Calendar_en.java -- English calendar locale data
Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.locale;
import java.util.ListResourceBundle;
import java.util.Calendar;
/**
* This class contains locale data for java.util.Calendar specific for
* english language.
* @author Jochen Hoenicke
*/
public class Calendar_en extends ListResourceBundle
{
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
/* Use default values. */
};
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents()
{
return contents;
}
}

63
libjava/gnu/java/locale/Calendar_nl.java Normal file
View File

@ -0,0 +1,63 @@
/* Calendar_nl.java -- Dutch calendar locale data
Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package gnu.java.locale;
import java.util.ListResourceBundle;
import java.util.Calendar;
/**
* This class contains locale data for java.util.Calendar specific for
* dutch language.
* @author Mark Wielaard
*/
public class Calendar_nl extends ListResourceBundle
{
/**
* This is the object array used to hold the keys and values
* for this bundle
*/
private static final Object[][] contents =
{
{ "firstDayOfWeek", new Integer(Calendar.MONDAY) },
/* XXX - I guess the default for gregorianCutover
* is also true for the Netherlands. But is it?
*/
};
/**
* This method returns the object array of key, value pairs containing
* the data for this bundle.
*
* @return The key, value information.
*/
public Object[][] getContents()
{
return contents;
}
}

191
libjava/java/lang/ClassNotFoundException.java
View File

@ -1,61 +1,164 @@
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
/* ClassNotFoundException.java -- exception thrown when attempting to load
a class when no definition for the class can be found.
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.lang;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 18, 1998.
* Exceptions may be thrown by one part of a Java program and caught
* by another in order to deal with exceptional conditions. This
* exception can by thrown by specific methods of <code>ClassLoader</code>
* and <code>Class</code> when attempting to load a class when no definition
* for the specified class can be found.
*
* @since JDK 1.0
*
* @author Brian Jones
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
public class ClassNotFoundException extends Exception
{
// TODO12:
// Throwable ex;
static final long serialVersionUID = 9176873029745254542L;
private Throwable ex = null;
/**
* Create an exception without a message.
*/
public ClassNotFoundException()
{
super();
}
{
super();
}
// TODO12:
// public ClassNotFoundException(String msg, Throwable ex)
// {
// FIXME: Set 'ex' here.
// }
/**
* Create an exception with a message.
*/
public ClassNotFoundException(String s)
{
super(s);
}
public ClassNotFoundException(String msg)
{
super(msg);
}
/**
* Create an exception with a message and include the exception
* which occurred while loading the class.
*
* @param ex the exception which occurred while loading the class
*
* @since JDK 1.2
*/
public ClassNotFoundException(String s, Throwable ex)
{
super(s);
this.ex = ex;
}
// TODO12:
// public Throwable getException()
// {
// }
/**
* Returns the exception which occurred while loading the class,
* otherwise returns null.
*
* @since JDK 1.2
*/
public Throwable getException()
{
return ex;
}
// TBD: if this needs to be implemented
// public void printStackTrace()
// {
// }
/**
* Print a stack trace of the exception that occurred.
*/
public void printStackTrace()
{
if (ex == null)
{
super.printStackTrace();
}
else
{
ex.printStackTrace();
}
}
// TBD: if this needs to be implemented
// public void printStackTrace(PrintStream ps)
// {
// }
/**
* Print a stack trace of the exception that occurred to
* the specified <code>PrintStream</code>.
*/
public void printStackTrace(PrintStream ps)
{
if (ex == null)
{
super.printStackTrace(ps);
}
else
{
ex.printStackTrace(ps);
}
}
// TBD: if this needs to be implemented
// public void printStackTrace(PrintWriter pw)
// {
// }
/**
* Print a stack trace of the exception that occurred to
* the specified <code>PrintWriter</code>.
*/
public void printStackTrace(PrintWriter pw)
{
if (ex == null)
{
super.printStackTrace(pw);
}
else
{
ex.printStackTrace(pw);
}
}
/**
* Serialize the object in a manner binary compatible with the JDK 1.2
*/
private void writeObject(java.io.ObjectOutputStream s)
throws IOException
{
ObjectOutputStream.PutField oFields;
oFields = s.putFields();
oFields.put("ex", this.ex);
s.writeFields();
}
/**
* Deserialize the object in a manner binary compatible with the JDK 1.2
*/
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
ObjectInputStream.GetField oFields;
oFields = s.readFields();
ex = (Throwable)oFields.get("ex", (Throwable)null);
}
}

44
libjava/java/math/BigDecimal.java
View File

@ -29,8 +29,9 @@ package java.math;
import java.math.BigInteger;
public class BigDecimal extends Number implements Comparable {
BigInteger num;
int scale;
private BigInteger intVal;
private int scale;
private static final long serialVersionUID = 6108874887143696463L;
private final static BigDecimal ZERO =
new BigDecimal (BigInteger.valueOf (0), 0);
@ -56,7 +57,7 @@ public class BigDecimal extends Number implements Comparable {
{
if (scale < 0)
throw new NumberFormatException ("scale of " + scale + " is < 0");
this.num = num;
this.intVal = num;
this.scale = scale;
}
@ -68,7 +69,7 @@ public class BigDecimal extends Number implements Comparable {
public BigDecimal (String num) throws NumberFormatException
{
int point = num.indexOf('.');
this.num = new BigInteger (point == -1 ? num :
this.intVal = new BigInteger (point == -1 ? num :
num.substring (0, point) +
num.substring (point + 1));
scale = num.length() - (point == -1 ? num.length () : point + 1);
@ -99,8 +100,8 @@ public class BigDecimal extends Number implements Comparable {
// For addition, need to line up decimals. Note that the movePointRight
// method cannot be used for this as it might return a BigDecimal with
// scale == 0 instead of the scale we need.
BigInteger op1 = num;
BigInteger op2 = val.num;
BigInteger op1 = intVal;
BigInteger op2 = val.intVal;
if (scale < val.scale)
op1 = op1.multiply (BigInteger.valueOf (10).pow (val.scale - scale));
else if (scale > val.scale)
@ -116,7 +117,7 @@ public class BigDecimal extends Number implements Comparable {
public BigDecimal multiply (BigDecimal val)
{
return new BigDecimal (num.multiply (val.num), scale + val.scale);
return new BigDecimal (intVal.multiply (val.intVal), scale + val.scale);
}
public BigDecimal divide (BigDecimal val, int roundingMode)
@ -135,13 +136,13 @@ public class BigDecimal extends Number implements Comparable {
if (scale < 0)
throw new ArithmeticException ("scale is negative: " + scale);
if (num.signum () == 0) // handle special case of 0.0/0.0
if (intVal.signum () == 0) // handle special case of 0.0/0.0
return ZERO;
BigInteger dividend = num.multiply (BigInteger.valueOf (10).pow
BigInteger dividend = intVal.multiply (BigInteger.valueOf (10).pow
(newScale + 1 - (scale - val.scale)));
BigInteger parts[] = dividend.divideAndRemainder (val.num);
BigInteger parts[] = dividend.divideAndRemainder (val.intVal);
// System.out.println("int: " + parts[0]);
// System.out.println("rem: " + parts[1]);
@ -194,12 +195,12 @@ public class BigDecimal extends Number implements Comparable {
public int compareTo (BigDecimal val)
{
if (scale == val.scale)
return num.compareTo (val.num);
return intVal.compareTo (val.intVal);
BigInteger thisParts[] =
num.divideAndRemainder (BigInteger.valueOf (10).pow (scale));
intVal.divideAndRemainder (BigInteger.valueOf (10).pow (scale));
BigInteger valParts[] =
val.num.divideAndRemainder (BigInteger.valueOf (10).pow (val.scale));
val.intVal.divideAndRemainder (BigInteger.valueOf (10).pow (val.scale));
int compare;
if ((compare = thisParts[0].compareTo (valParts[0])) != 0)
@ -263,7 +264,7 @@ public class BigDecimal extends Number implements Comparable {
public BigDecimal movePointLeft (int n)
{
return (n < 0) ? movePointRight (-n) : new BigDecimal (num, scale + n);
return (n < 0) ? movePointRight (-n) : new BigDecimal (intVal, scale + n);
}
public BigDecimal movePointRight (int n)
@ -272,15 +273,15 @@ public class BigDecimal extends Number implements Comparable {
return movePointLeft (-n);
if (scale >= n)
return new BigDecimal (num, scale - n);
return new BigDecimal (intVal, scale - n);
return new BigDecimal (num.multiply
return new BigDecimal (intVal.multiply
(BigInteger.valueOf (10).pow (n - scale)), 0);
}
public int signum ()
{
return num.signum ();
return intVal.signum ();
}
public int scale ()
@ -290,17 +291,17 @@ public class BigDecimal extends Number implements Comparable {
public BigDecimal abs ()
{
return new BigDecimal (num.abs (), scale);
return new BigDecimal (intVal.abs (), scale);
}
public BigDecimal negate ()
{
return new BigDecimal (num.negate (), scale);
return new BigDecimal (intVal.negate (), scale);
}
public String toString ()
{
String bigStr = num.toString();
String bigStr = intVal.toString();
if (scale == 0)
return bigStr;
@ -322,7 +323,8 @@ public class BigDecimal extends Number implements Comparable {
public BigInteger toBigInteger ()
{
return scale == 0 ? num : num.divide (BigInteger.valueOf (10).pow (scale));
return scale == 0 ? intVal :
intVal.divide (BigInteger.valueOf (10).pow (scale));
}

34
libjava/java/math/BigInteger.java
View File

@ -11,6 +11,9 @@ details. */
package java.math;
import gnu.gcj.math.*;
import java.util.Random;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
/**
* @author Warren Levy <warrenl@cygnus.com>
@ -35,8 +38,17 @@ public class BigInteger extends Number implements Comparable
* If words == null, the ival is the value of this BigInteger.
* Otherwise, the first ival elements of words make the value
* of this BigInteger, stored in little-endian order, 2's-complement form. */
private int ival;
private int[] words;
transient private int ival;
transient private int[] words;
// Serialization fields.
private int bitCount = -1;
private int bitLength = -1;
private int firstNonzeroByteNum = -2;
private int lowestSetBit = -2;
private byte[] magnitude;
private int signum;
private static final long serialVersionUID = -8287574255936472291L;
/** We pre-allocate integers in the range minFixNum..maxFixNum. */
@ -2201,4 +2213,22 @@ public class BigInteger extends Number implements Comparable
}
return isNegative() ? x_len * 32 - i : i;
}
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
words = byteArrayToIntArray(magnitude, signum < 0 ? -1 : 0);
BigInteger result = make(words, words.length);
this.ival = result.ival;
this.words = result.words;
}
private void writeObject(ObjectOutputStream s)
throws IOException, ClassNotFoundException
{
signum = signum();
magnitude = toByteArray();
s.defaultWriteObject();
}
}

1
libjava/java/util/BitSet.java
View File

@ -174,4 +174,5 @@ public final class BitSet implements Cloneable, Serializable
// The actual bits.
private long[] bits;
private static final long serialVersionUID = 7997698588986878753L;
}

1164
libjava/java/util/Calendar.java
View File

File diff suppressed because it is too large Load Diff

8
libjava/java/util/GregorianCalendar.java
View File

@ -1,4 +1,4 @@
/* Copyright (C) 1998, 1999 Free Software Foundation
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
This file is part of libgcj.
@ -93,17 +93,17 @@ public class GregorianCalendar extends Calendar {
public GregorianCalendar ()
{
this(null, null);
this(TimeZone.getDefault (), Locale.getDefault ());
}
public GregorianCalendar (TimeZone zone)
{
this (zone, null);
this (zone, Locale.getDefault ());
}
public GregorianCalendar (Locale locale)
{
this (null, locale);
this (TimeZone.getDefault (), locale);
}
public GregorianCalendar (TimeZone zone, Locale locale)

25
libjava/java/util/Locale.java
View File

@ -26,6 +26,7 @@ public final class Locale implements java.io.Serializable, Cloneable
private String language;
private String variant;
private static Locale defaultLocale;
private static final long serialVersionUID = 9149081749638150636L;
// These are as specified in the JDK 1.2 AP documentation
@ -145,4 +146,28 @@ public final class Locale implements java.io.Serializable, Cloneable
}
return result.toString();
}
/**
* @serialdata According to jdk1.2 the hashcode should always be
* written as -1;
*/
private void writeObject(java.io.ObjectOutputStream output)
throws java.io.IOException
{
int tmpHashcode = hashcode;
hashcode = -1;
output.defaultWriteObject();
hashcode = tmpHashcode;
}
/**
* @serialdata According to jdk1.2 the hashCode is always invalid
* and must be recomputed.
*/
private void readObject(java.io.ObjectInputStream input)
throws java.io.IOException, ClassNotFoundException
{
input.defaultReadObject();
hashcode = language.hashCode() ^ country.hashCode() ^ variant.hashCode();
}
}

926
libjava/java/util/SimpleTimeZone.java
View File

@ -1,208 +1,830 @@
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
/* java.util.SimpleTimeZone
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of libgcj.
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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.util;
import java.text.DateFormatSymbols;
/**
* @author Per Bothner <bothner@cygnus.com>
* @date October 24, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3.
* Status: Does not know how to figure out if daylight savings time
* is in effect; hence only correct for zones without DST.
* No known spec for hashCode.
*/
* This class represents a simple time zone offset and handles
* daylight savings. It can only handle one daylight savings rule, so
* it can't represent historical changes.
*
* 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. It can only handle daylight savings for years
* lying in the AD era.
*
* @see Calendar
* @see GregorianCalender
* @author Jochen Hoenicke */
public class SimpleTimeZone extends TimeZone
{
// The fields are as specified in Sun's "Serialized Form"
// in the JDK 1.2 beta 4 API specification.
/**
* The raw time zone offset in milliseconds to GMT, ignoring
* daylight savings.
* @serial
*/
private int rawOffset;
int dstSavings = 60 * 60 * 1000;
/**
* True, if this timezone uses daylight savings, false otherwise.
* @serial
*/
private boolean useDaylight;
int rawOffset;
/**
* 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.
* @serial
* @since JDK1.1.4
*/
private int dstSavings = 60 * 60 * 1000;
// int serialVersionOnStream;
/**
* The first year, in which daylight savings rules applies.
* @serial
*/
private int startYear;
int startDay;
int startDayOfWeek;
int startMode; /// Seems to be JDK 1.2 only.
private static final int DOM_MODE = 1;
private static final int DOW_IN_MONTH_MODE = 2;
private static final int DOW_GE_DOM_MODE = 3;
private static final int DOW_LE_DOM_MODE = 4;
/**
* The mode of the start rule. This takes one of the following values:
* <dl>
* <dt>DOM_MODE (1)</dt>
* <dd> startDay contains the day in month of the start date,
* startDayOfWeek is unused. </dd>
* <dt>DOW_IN_MONTH_MODE (2)</dt>
* <dd> The startDay gives the day of week in month, and
* startDayOfWeek the day of week. For example startDay=2 and
* startDayOfWeek=Calender.SUNDAY specifies that the change is on
* the second sunday in that month. You must make sure, that this
* day always exists (ie. don't specify the 5th sunday).
* </dd>
* <dt>DOW_GE_DOM_MODE (3)</dt>
* <dd> The start is on the first startDayOfWeek on or after
* startDay. For example startDay=13 and
* startDayOfWeek=Calendar.FRIDAY specifies that the daylight
* savings start on the first FRIDAY on or after the 13th of that
* Month. Make sure that the change is always in the given month, or
* the result is undefined.
* </dd>
* <dt>DOW_LE_DOM_MONTH (4)</dt>
* <dd> The start is on the first startDayOfWeek on or before the
* startDay. Make sure that the change is always in the given
* month, or the result is undefined.
</dd>
* </dl>
* @serial */
private int startMode;
int startMonth;
/**
* The month in which daylight savings start. This is one of the
* constants Calendar.JANUARY, ..., Calendar.DECEMBER.
* @serial
*/
private int startMonth;
int startTime;
/**
* This variable can have different meanings. See startMode for details
* @see #startMode;
* @serial
*/
private int startDay;
/**
* This variable specifies the day of week the change takes place. If
* startMode == DOM_MODE, this is undefined.
* @serial
* @see #startMode;
*/
private int startDayOfWeek;
/**
* This variable specifies the time of change to daylight savings.
* This time is given in milliseconds after midnight local
* standard time.
* @serial
*/
private int startTime;
/**
* The month in which daylight savings ends. This is one of the
* constants Calendar.JANUARY, ..., Calendar.DECEMBER.
* @serial
*/
private int endMonth;
int startYear;
/**
* This variable gives the mode for the end of daylight savings rule.
* It can take the same values as startMode.
* @serial
* @see #startMode
*/
private int endMode;
int endDay;
/**
* This variable can have different meanings. See startMode for details
* @serial
* @see #startMode;
*/
private int endDay;
/**
* This variable specifies the day of week the change takes place. If
* endMode == DOM_MODE, this is undefined.
* @serial
* @see #startMode;
*/
private int endDayOfWeek;
/**
* This variable specifies the time of change back to standard time.
* This time is given in milliseconds after midnight local
* standard time.
* @serial
*/
private int endTime;
int endDayOfWeek;
/**
* This variable points to a deprecated array from JDK 1.1. It is
* ignored in JDK 1.2 but streamed out for compatibility with JDK 1.1.
* The array contains the lengths of the months in the year and is
* assigned from a private static final field to avoid allocating
* the array for every instance of the object.
* Note that static final fields are not serialized.
* @serial
*/
private byte[] monthLength = monthArr;
private static final byte[] monthArr =
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int endMode; // Seems to be JDK 1.2 only.
/**
* The version of the serialized data on the stream.
* <dl>
* <dt>0 or not present on stream</dt>
* <dd> JDK 1.1.3 or earlier, only provides this fields:
* rawOffset, startDay, startDayOfWeek, startMonth, startTime,
* startYear, endDay, endDayOfWeek, endMonth, endTime
* </dd>
* <dd> JDK 1.1.4 or later. This includes three new fields, namely
* startMode, endMode and dstSavings. And there is a optional section
* as described in writeObject.
* </dd>
*
* XXX - JDK 1.2 Beta 4 docu states 1.1.4, but my 1.1.5 has the old
* version.
*
* When streaming out this class it is always written in the latest
* version.
* @serial
* @since JDK1.1.4
*/
private int serialVersionOnStream = 1;
int endMonth;
private static final long serialVersionUID = -403250971215465050L;
int endTime;
// byte[] monthLength;
boolean useDaylight;
public SimpleTimeZone (int rawOffset, String ID)
/**
* Create a <code>SimpleTimeZone</code> with the given time offset
* from GMT and without daylight savings.
* @param rawOffset the time offset from GMT in milliseconds.
* @param id The identifier of this time zone.
*/
public SimpleTimeZone(int rawOffset, String id)
{
this.rawOffset = rawOffset;
setID(id);
useDaylight = false;
startYear = 0;
}
/**
* Create a <code>SimpleTimeZone</code> with the given time offset
* from GMT and with daylight savings. The start/end parameters
* can have different meaning (replace WEEKDAY with a real day of
* week). Only the first two meanings were supported by earlier
* versions of jdk.
*
* <dl>
* <dt><code>day &gt; 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
* <dd>The start/end of daylight savings is on the <code>day</code>-th
* <code>WEEKDAY</code> in the given month. </dd>
* <dt><code>day &lt; 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
* <dd>The start/end of daylight savings is on the <code>-day</code>-th
* <code>WEEKDAY</code> counted from the <i>end</i> of the month. </dd>
* <dt><code>day &gt; 0, dayOfWeek = 0</code></dt>
* <dd>The start/end of daylight is on the <code>day</code>-th day of
* the month. </dd>
* <dt><code>day &gt; 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
* <dd>The start/end of daylight is on the first WEEKDAY on or after
* the <code>day</code>-th day of the month. You must make sure that
* this day lies in the same month. </dd>
* <dt><code>day &lt; 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
* <dd>The start/end of daylight is on the first WEEKDAY on or
* <i>before</i> the <code>-day</code>-th day of the month. You
* must make sure that this day lies in the same month. </dd>
* </dl>
*
* If you give a non existing month, a day that is zero, or too big,
* or a dayOfWeek that is too big, the result is undefined.
*
* The start rule must have a different month than the end rule.
* This restriction shouldn't hurt for all possible time zones.
*
* @param rawOffset The time offset from GMT in milliseconds.
* @param id The identifier of this time zone.
* @param startMonth The start month of daylight savings; use the
* constants in Calendar.
* @param startday A day in month or a day of week number, as
* described above.
* @param startDayOfWeek The start rule day of week; see above.
* @param startTime A time in millis in standard time.
* @param endMonth The end month of daylight savings; use the
* constants in Calendar.
* @param endday A day in month or a day of week number, as
* described above.
* @param endDayOfWeek The end rule day of week; see above.
* @param endTime A time in millis in standard time. */
public SimpleTimeZone(int rawOffset, String id,
int startMonth, int startDayOfWeekInMonth,
int startDayOfWeek, int startTime,
int endMonth, int endDayOfWeekInMonth,
int endDayOfWeek, int endTime)
{
this.rawOffset = rawOffset;
setID(id);
useDaylight = true;
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 constructs a new SimpleTimeZone that supports a daylight savings
* rule. The parameter are the same as for the constructor above, except
* there is the additional dstSavaings parameter.
*
* @param dstSavings the amount of savings for daylight savings
* time in milliseconds. This must be positive.
*/
public SimpleTimeZone(int rawOffset, String id,
int startMonth, int startDayOfWeekInMonth,
int startDayOfWeek, int startTime,
int endMonth, int endDayOfWeekInMonth,
int endDayOfWeek, int endTime, int dstSavings)
{
this(rawOffset, id,
startMonth, startDayOfWeekInMonth, startDayOfWeek, startTime,
endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
this.dstSavings = dstSavings;
}
/**
* Sets the first year, where daylight savings applies. The daylight
* savings rule never apply for years in the BC era. Note that this
* is gregorian calendar specific.
* @param year the start year.
*/
public void setStartYear(int year)
{
startYear = year;
useDaylight = true;
}
/**
* Checks if the month, day, dayOfWeek arguments are in range and
* returns the mode of the rule.
* @param month the month parameter as in the constructor
* @param day the day parameter as in the constructor
* @param dayOfWeek the day of week parameter as in the constructor
* @return the mode of this rule see startMode.
* @exception IllegalArgumentException if parameters are out of range.
* @see #SimpleTimeZone(int, String, int, int, int, int, int, int, int, int)
* @see #startMode
*/
private int checkRule(int month, int day, int dayOfWeek)
{
int daysInMonth = getDaysInMonth(month, 1);
if (dayOfWeek == 0)
{
if (day <= 0 || day > daysInMonth)
throw new IllegalArgumentException("day out of range");
return DOM_MODE;
}
else if (dayOfWeek > 0)
{
if (Math.abs(day) > (daysInMonth + 6) / 7)
throw new IllegalArgumentException("dayOfWeekInMonth out of range");
if (dayOfWeek > Calendar.SATURDAY)
throw new IllegalArgumentException("dayOfWeek out of range");
return DOW_IN_MONTH_MODE;
}
else
{
if (day == 0 || Math.abs(day) > daysInMonth)
throw new IllegalArgumentException("day out of range");
if (dayOfWeek < -Calendar.SATURDAY)
throw new IllegalArgumentException("dayOfWeek out of range");
if (day < 0)
return DOW_LE_DOM_MODE;
else
return DOW_GE_DOM_MODE;
}
}
/**
* Sets the daylight savings start rule. You must also set the
* end rule with <code>setEndRule</code> or the result of
* getOffset is undefined. For the parameters see the ten-argument
* constructor above.
*
* @param month The month where daylight savings start, zero
* based. You should use the constants in Calendar.
* @param day A day of month or day of week in month.
* @param dayOfWeek The day of week where daylight savings start.
* @param time The time in milliseconds standard time where daylight
* savings start.
* @see SimpleTimeZone */
public void setStartRule(int month, int day, int dayOfWeek, int time)
{
this.startMode = checkRule(month, day, dayOfWeek);
this.startMonth = month;
// FIXME: XXX: JDK 1.2 allows negative values and has 2 new variations
// of this method.
this.startDay = Math.abs(day);
this.startDayOfWeek = Math.abs(dayOfWeek);
this.startTime = time;
useDaylight = true;
}
/**
* Sets the daylight savings end rule. You must also set the
* start rule with <code>setStartRule</code> or the result of
* getOffset is undefined. For the parameters see the ten-argument
* constructor above.
*
* @param rawOffset The time offset from GMT.
* @param id The identifier of this time zone.
* @param Month The end month of daylight savings.
* @param day A day in month, or a day of week in month.
* @param DayOfWeek A day of week, when daylight savings ends.
* @param Time A time in millis in standard time.
* @see #setStartRule */
public void setEndRule(int month, int day, int dayOfWeek, int time)
{
this.endMode = checkRule(month, day, dayOfWeek);
this.endMonth = month;
// FIXME: XXX: JDK 1.2 allows negative values and has 2 new variations
// of this method.
this.endDay = Math.abs(day);
this.endDayOfWeek = Math.abs(dayOfWeek);
this.endTime = time;
useDaylight = true;
}
/**
* 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.
*
* In the standard JDK the results given by this method may result in
* inaccurate results at the end of February or the beginning of March.
* To avoid this, you should use Calendar instead:
* <pre>
* offset = cal.get(Calendar.ZONE_OFFSET) + cal.get(Calendar.DST_OFFSET);
* </pre>
* You could also use in
*
* This version doesn't suffer this inaccuracy.
*
* @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 be matching the
* other fields.
* @param millis the millis in the day (in local standard time)
* @return the time zone offset in milliseconds. */
public int getOffset(int era, int year, int month,
int day, int dayOfWeek, int millis)
{
// This method is called by Calendar, so we mustn't use that class.
int daylightSavings = 0;
if (useDaylight && era == GregorianCalendar.AD && year >= startYear)
{
// 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,
endMode, endMonth,
endDay, endDayOfWeek, endTime);
if (startMonth < endMonth)
{
// use daylight savings, if the date is after the start of
// savings, and before the end of savings.
daylightSavings = afterStart && beforeEnd ? dstSavings : 0;
}
else
{
// use daylight savings, if the date is before the end of
// savings, or after the start of savings.
daylightSavings = beforeEnd || afterStart ? dstSavings : 0;
}
}
return rawOffset + daylightSavings;
}
/**
* 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)
{
setID(ID);
this.rawOffset = rawOffset;
}
public SimpleTimeZone (int rawOffset, String ID,
int startMonth, int startDay,
int startDayOfWeek, int startTime,
int endMonth, int endDay,
int endDayOfWeek, int endTime)
/**
* 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.
* @since JDK1.1.4?
*/
public int getDSTSavings()
{
this(rawOffset, ID);
setStartRule (startMonth, startDay, startDayOfWeek, startTime);
setEndRule (endMonth, endDay, endDayOfWeek, endTime);
return dstSavings;
}
public int getRawOffset() { return rawOffset; }
public void setRawOffset (int offsetMillis) { rawOffset = offsetMillis; }
public int getOffset (int era, int year, int month, int day,
int dayOfWeek, int millis)
/**
* Returns if this time zone uses daylight savings time.
* @return true, if we use daylight savings time, false otherwise.
*/
public boolean useDaylightTime()
{
int offset = getRawOffset();
if (useDaylight)
return useDaylight;
}
/**
* Returns the number of days in the given month. It does always
* use the Gregorian leap year rule.
* @param month The month, zero based; use one of the Calendar constants.
* @param year The year.
*/
private int getDaysInMonth(int month, int year)
{
// Most of this is copied from GregorianCalendar.getActualMaximum()
if (month == Calendar.FEBRUARY)
{
if (startYear != 0
&& (year < startYear || era == GregorianCalendar.BC))
return offset;
boolean midYearSummer = startMonth < endMonth;
if (midYearSummer ? (month < startMonth || month > endMonth)
: (month < startMonth && month > endMonth))
return offset; // Definitely not DST.
if (midYearSummer ? (month > startMonth && month < endMonth)
: (month > startMonth || month < endMonth))
return offset + dstSavings; // Definitely DST.
// Now it gets more complicated. Bail for now.
throw new Error("not implemented - SimpleTimeZone.getOffset");
return ((year & 3) == 0 && (year % 100 != 0 || year % 400 == 0))
? 29 : 28;
}
return offset;
else if (month < Calendar.AUGUST)
return 31 - (month & 1);
else
return 30 + (month & 1);
}
public boolean useDaylightTime() { return useDaylight; }
/**
* Checks if the date given in calXXXX, is before the change between
* dst and standard time.
* @param calYear the year of the date to check (for leap day cheking).
* @param calMonth the month of the date to check.
* @param calDay the day of month of the date to check.
* @param calDayOfWeek the day of week of the date to check.
* @param calMillis the millis of day of the date to check (standard time).
* @param mode the change mode; same semantic as startMode.
* @param month the change month; same semantic as startMonth.
* @param day the change day; same semantic as startDay.
* @param dayOfWeek the change day of week;
* @param millis the change time in millis since midnight standard time.
* same semantic as startDayOfWeek.
* @return true, if cal is before the change, false if cal is on
* or after the change.
*/
private boolean isBefore(int calYear,
int calMonth, int calDayOfMonth, int calDayOfWeek,
int calMillis, int mode, int month,
int day, int dayOfWeek, int millis)
{
// This method is called by Calendar, so we mustn't use that class.
// We have to do all calculations by hand.
// check the months:
// XXX - this is not correct:
// for the DOW_GE_DOM and DOW_LE_DOM modes the change date may
// be in a different month.
if (calMonth != month)
return calMonth < month;
// check the day:
switch (mode)
{
case DOM_MODE:
if (calDayOfMonth != day)
return calDayOfMonth < day;
break;
case DOW_IN_MONTH_MODE:
{
// This computes the day of month of the day of type
// "dayOfWeek" that lies in the same (sunday based) week as cal.
calDayOfMonth += (dayOfWeek - calDayOfWeek);
// Now we convert it to 7 based number (to get a one based offset
// after dividing by 7). If we count from the end of the
// month, we get want a -7 based number counting the days from
// the end:
if (day < 0)
calDayOfMonth -= getDaysInMonth(calMonth, calYear) + 7;
else
calDayOfMonth += 6;
// day > 0 day < 0
// S M T W T F S S M T W T F S
// 7 8 9 10 11 12 -36-35-34-33-32-31
// 13 14 15 16 17 18 19 -30-29-28-27-26-25-24
// 20 21 22 23 24 25 26 -23-22-21-20-19-18-17
// 27 28 29 30 31 32 33 -16-15-14-13-12-11-10
// 34 35 36 -9 -8 -7
// Now we calculate the day of week in month:
int week = calDayOfMonth / 7;
// day > 0 day < 0
// S M T W T F S S M T W T F S
// 1 1 1 1 1 1 -5 -5 -4 -4 -4 -4
// 1 2 2 2 2 2 2 -4 -4 -4 -3 -3 -3 -3
// 2 3 3 3 3 3 3 -3 -3 -3 -2 -2 -2 -2
// 3 4 4 4 4 4 4 -2 -2 -2 -1 -1 -1 -1
// 4 5 5 -1 -1 -1
if (week != day)
return week < day;
if (calDayOfWeek != dayOfWeek)
return calDayOfWeek < dayOfWeek;
// daylight savings starts/ends on the given day.
break;
}
case DOW_LE_DOM_MODE:
// The greatest sunday before or equal December, 12
// is the same as smallest sunday after or equal December, 6.
day -= 6;
case DOW_GE_DOM_MODE:
// Calculate the day of month of the day of type
// "dayOfWeek" that lies before (or on) the given date.
calDayOfMonth -= (calDayOfWeek < dayOfWeek ? 7 : 0)
+ calDayOfWeek - dayOfWeek;
if (calDayOfMonth < day)
return true;
if (calDayOfWeek != dayOfWeek || calDayOfMonth >= day + 7)
return false;
// now we have the same day
break;
}
// the millis decides:
return (calMillis < millis);
}
/**
* 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)
{
if (! useDaylight)
Calendar cal = Calendar.getInstance(this);
cal.setTime(date);
return (cal.get(Calendar.DST_OFFSET) != 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()
{
return rawOffset ^
(useDaylight ?
startMonth ^ startDay ^ startDayOfWeek ^ startTime
^ endMonth ^ endDay ^ endDayOfWeek ^ endTime : 0);
}
public synchronized boolean equals(Object o)
{
if (this == o)
return true;
if (!(o instanceof SimpleTimeZone))
return false;
throw new Error("not implemented - SimpleTimeZone.inDaylightTime");
SimpleTimeZone zone = (SimpleTimeZone) o;
if (zone.hashCode() != hashCode()
|| !getID().equals(zone.getID())
|| rawOffset != zone.rawOffset || useDaylight != zone.useDaylight)
return false;
if (!useDaylight)
return true;
return (startYear == zone.startYear
&& startMonth == zone.startMonth
&& startDay == zone.startDay
&& startDayOfWeek == zone.startDayOfWeek
&& startTime == zone.startTime
&& endMonth == zone.endMonth
&& endDay == zone.endDay
&& endDayOfWeek == zone.endDayOfWeek
&& endTime == zone.endTime);
}
public int getDSTSavings () { return dstSavings; }
public void setDSTSavings (int millisSavedDuringDST)
{ dstSavings = millisSavedDuringDST; }
public void setStartRule (int month, int dayOfWeekInMonth,
int dayOfWeek, int time)
{
this.startMonth = month;
this.startDay = dayOfWeekInMonth;
this.startDayOfWeek = dayOfWeek;
this.startTime = time;
this.useDaylight = true;
}
public void setEndRule (int month, int dayOfWeekInMonth,
int dayOfWeek, int time)
{
this.endMonth = month;
this.endDay = dayOfWeekInMonth;
this.endDayOfWeek = dayOfWeek;
this.endTime = time;
this.useDaylight = true;
}
public void setStartYear (int year)
{
this.startYear = startYear;
}
public boolean hasSameRules (TimeZone other)
/**
* 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 SimpleTimeZone,
* 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 other)
{
if (this == other)
return true;
if (! (other instanceof SimpleTimeZone))
if (!(other instanceof SimpleTimeZone))
return false;
SimpleTimeZone o = (SimpleTimeZone) other;
if (rawOffset != o.rawOffset)
SimpleTimeZone zone = (SimpleTimeZone) other;
if (zone.hashCode() != hashCode()
|| rawOffset != zone.rawOffset || useDaylight != zone.useDaylight)
return false;
if (useDaylight != o.useDaylight)
return false;
if (! useDaylight)
if (!useDaylight)
return true;
return startDay == o.startDay
&& startDayOfWeek == o.startDayOfWeek
&& startMonth == o.startMonth
&& startTime == o.startTime
&& endDay == o.endDay
&& endDayOfWeek == o.endDayOfWeek
&& endMonth == o.endMonth
&& endTime == o.endTime
&& startYear == o.startYear
&& startMode == o.startMode
&& endMode == o.endMode;
return (startYear == zone.startYear
&& startMonth == zone.startMonth
&& startDay == zone.startDay
&& startDayOfWeek == zone.startDayOfWeek
&& startTime == zone.startTime
&& endMonth == zone.endMonth
&& endDay == zone.endDay
&& endDayOfWeek == zone.endDayOfWeek && endTime == zone.endTime);
}
public boolean equals (Object obj)
/**
* Returns a string representation of this SimpleTimeZone object.
* @return a string representation of this SimpleTimeZone object.
*/
public String toString()
{
if (! (obj instanceof SimpleTimeZone))
return false;
SimpleTimeZone other = (SimpleTimeZone) obj;
return getID() == other.getID() && hasSameRules(other);
// the test for useDaylight is an incompatibility to jdk1.2, but
// I think this shouldn't hurt.
return getClass().getName() + "["
+ "id=" + getID()
+ ",offset=" + rawOffset
+ ",dstSavings=" + dstSavings
+ ",useDaylight=" + useDaylight
+ (useDaylight ?
",startYear=" + startYear
+ ",startMode=" + startMode
+ ",startMonth=" + startMonth
+ ",startDay=" + startDay
+ ",startDayOfWeek=" + startDayOfWeek
+ ",startTime=" + startTime
+ ",endMode=" + endMode
+ ",endMonth=" + endMonth
+ ",endDay=" + endDay
+ ",endDayOfWeek=" + endDayOfWeek
+ ",endTime=" + endTime : "") + "]";
}
public Object clone ()
/**
* Reads a serialized simple time zone from stream.
* @see #writeObject
*/
private void readObject(java.io.ObjectInputStream input)
throws java.io.IOException, ClassNotFoundException
{
// We know the superclass just call's Object's generic cloner.
return super.clone ();
input.defaultReadObject();
if (serialVersionOnStream == 0)
{
// initialize the new fields to default values.
dstSavings = 60 * 60 * 1000;
endMode = DOW_IN_MONTH_MODE;
startMode = DOW_IN_MONTH_MODE;
serialVersionOnStream = 1;
}
else
{
int length = input.readInt();
byte[]byteArray = new byte[length];
input.read(byteArray, 0, length);
if (length >= 4)
{
// Lets hope that Sun does extensions to the serialized
// form in a sane manner.
startDay = byteArray[0];
startDayOfWeek = byteArray[1];
endDay = byteArray[2];
endDayOfWeek = byteArray[3];
}
}
}
public String toString ()
/**
* Serializes this object to a stream. @serialdata The object is
* first written in the old JDK 1.1 format, so that it can be read
* by by the old classes. This means, that the
* <code>start/endDay(OfWeek)</code>-Fields are written in the
* DOW_IN_MONTH_MODE rule, since this was the only supported rule
* in 1.1.
*
* In the optional section, we write first the length of an byte
* array as int and afterwards the byte array itself. The byte
* array contains in this release four elements, namely the real
* startDay, startDayOfWeek endDay, endDayOfWeek in that Order.
* These fields are needed, because for compatibility reasons only
* approximative values are written to the required section, as
* described above.
*/
private void writeObject(java.io.ObjectOutputStream output)
throws java.io.IOException
{
// The docs don't say much about how we might implement this.
// We choose a debugging implementation.
return ("dstSavings " + dstSavings
+ "; rawOffset " + rawOffset
+ "; startDay " + startDay
+ "; startDayOfWeek " + startDayOfWeek
+ "; startMode " + startMode
+ "; startMonth " + startMonth
+ "; startTime " + startTime
+ "; startYear " + startYear
+ "; endDay " + endDay
+ "; endDayOfWeek " + endDayOfWeek
+ "; endMode " + endMode
+ "; endMonth " + endMonth
+ "; endTime " + endTime
+ "; useDaylight " + useDaylight);
}
byte[] byteArray = new byte[]
{
(byte) startDay, (byte) startDayOfWeek,
(byte) endDay, (byte) endDayOfWeek};
public int hashCode ()
{
// FIXME - this does not folow any spec (since none is public)!
int hash = rawOffset;
if (useDaylight)
hash += dstSavings + startYear + startMode + endMode
+ startDay + startDayOfWeek + startMonth + startTime
+ endDay + endDayOfWeek + endMonth + endTime;
return hash;
/* calculate the approximation for JDK 1.1 */
switch (startMode)
{
case DOM_MODE:
startDayOfWeek = Calendar.SUNDAY; // random day of week
// fall through
case DOW_GE_DOM_MODE:
case DOW_LE_DOM_MODE:
startDay = (startDay + 6) / 7;
}
switch (endMode)
{
case DOM_MODE:
endDayOfWeek = Calendar.SUNDAY;
// fall through
case DOW_GE_DOM_MODE:
case DOW_LE_DOM_MODE:
endDay = (endDay + 6) / 7;
}
// the required part:
output.defaultWriteObject();
// the optional part:
output.writeInt(byteArray.length);
output.write(byteArray, 0, byteArray.length);
}
}