This is the mail archive of the
java-patches@sources.redhat.com
mailing list for the Java project.
Patch: Java 2 compatibility
- To: Java Patch List <java-patches at sourceware dot cygnus dot com>
- Subject: Patch: Java 2 compatibility
- From: Tom Tromey <tromey at cygnus dot com>
- Date: 16 Nov 2000 21:56:49 -0700
- Reply-To: tromey at cygnus dot com
I'm checking this in.
It adds some missing Java 2 methods, merges java.io.PushbackReader
with Classpath, and re-merges java.util.Arrays.
2000-11-16 Tom Tromey <tromey@cygnus.com>
* java/io/PushbackReader.java: Merged with Classpath.
* java/util/Arrays.java: Updated from Classpath.
* scripts/blocks.pl: New file.
* java/lang/Character.java (Subset): New class.
(UnicodeBlock): New class.
* java/lang/Math.java (toDegrees, toRadians): New methods.
* java/lang/Float.java: Implement Comparable.
(compareTo): New methods.
* java/lang/Double.java: Implement Comparable.
(compareTo): New methods.
Tom
Index: java/util/Arrays.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/util/Arrays.java,v
retrieving revision 1.1
diff -u -r1.1 Arrays.java
--- Arrays.java 2000/05/19 17:55:33 1.1
+++ Arrays.java 2000/11/17 04:48:13
@@ -1,5 +1,5 @@
/* Arrays.java -- Utility class with methods to operate on arrays
- Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -7,7 +7,7 @@
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
@@ -36,17 +36,20 @@
* arrays, and a method to provide a List "view" of an array to facilitate
* using arrays with Collection-based APIs.
*/
-public class Arrays {
-
+public class Arrays
+{
/**
* This class is non-instantiable.
*/
- private Arrays() {
+ private Arrays()
+ {
}
- private static Comparator defaultComparator = new Comparator() {
- public int compare(Object o1, Object o2) {
- return ((Comparable)o1).compareTo(o2);
+ private static Comparator defaultComparator = new Comparator()
+ {
+ public int compare(Object o1, Object o2)
+ {
+ return ((Comparable) o1).compareTo(o2);
}
};
@@ -64,21 +67,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(byte[] a, byte key) {
+ public static int binarySearch(byte[]a, byte key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final byte d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final byte d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -96,21 +107,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(char[] a, char key) {
+ public static int binarySearch(char[]a, char key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final char d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final char d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -128,21 +147,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(double[] a, double key) {
+ public static int binarySearch(double[]a, double key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final double d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final double d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -160,21 +187,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(float[] a, float key) {
+ public static int binarySearch(float[]a, float key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final float d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final float d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -192,21 +227,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(int[] a, int key) {
+ public static int binarySearch(int[]a, int key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final int d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final int d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -224,21 +267,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(long[] a, long key) {
+ public static int binarySearch(long[]a, long key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final long d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final long d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -256,21 +307,29 @@
* found, where n is the index of the first value higher than key or
* a.length if there is no such value.
*/
- public static int binarySearch(short[] a, short key) {
+ public static int binarySearch(short[]a, short key)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final short d = a[mid];
- if (d == key) {
- return mid;
- } else if (d > key) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final short d = a[mid];
+ if (d == key)
+ {
+ return mid;
+ }
+ else if (d > key)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -279,21 +338,29 @@
* @exception NullPointerException if the specified comparator is null.
* @exception ClassCastException if the objects are not comparable by c.
*/
- private static int objectSearch(Object[] a, Object key, final Comparator c) {
+ private static int objectSearch(Object[]a, Object key, final Comparator c)
+ {
int low = 0;
int hi = a.length - 1;
int mid = 0;
- while (low <= hi) {
- mid = (low + hi) >> 1;
- final int d = c.compare(key, a[mid]);
- if (d == 0) {
- return mid;
- } else if (d < 0) {
- hi = mid - 1;
- } else {
- low = ++mid; // This gets the insertion point right on the last loop
+ while (low <= hi)
+ {
+ mid = (low + hi) >> 1;
+ final int d = c.compare(key, a[mid]);
+ if (d == 0)
+ {
+ return mid;
+ }
+ else if (d < 0)
+ {
+ hi = mid - 1;
+ }
+ else
+ {
+ // This gets the insertion point right on the last loop
+ low = ++mid;
+ }
}
- }
return -mid - 1;
}
@@ -316,7 +383,8 @@
* elements of a
* @exception NullPointerException if a null element has compareTo called
*/
- public static int binarySearch(Object[] a, Object key) {
+ public static int binarySearch(Object[]a, Object key)
+ {
return objectSearch(a, key, defaultComparator);
}
@@ -339,7 +407,8 @@
* @exception ClassCastException if key could not be compared with one of the
* elements of a
*/
- public static int binarySearch(Object[] a, Object key, Comparator c) {
+ public static int binarySearch(Object[]a, Object key, Comparator c)
+ {
return objectSearch(a, key, c);
}
@@ -351,28 +420,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(byte[] a1, byte[] a2) {
-
+ public static boolean equals(byte[]a1, byte[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -385,28 +461,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(char[] a1, char[] a2) {
-
+ public static boolean equals(char[]a1, char[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -419,28 +502,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(double[] a1, double[] a2) {
-
+ public static boolean equals(double[]a1, double[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -453,28 +543,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(float[] a1, float[] a2) {
-
+ public static boolean equals(float[]a1, float[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -487,28 +584,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(long[] a1, long[] a2) {
-
+ public static boolean equals(long[]a1, long[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -521,28 +625,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(short[] a1, short[] a2) {
-
+ public static boolean equals(short[]a1, short[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -555,28 +666,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(boolean[] a1, boolean[] a2) {
-
+ public static boolean equals(boolean[]a1, boolean[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -589,28 +707,35 @@
* @returns true if a1 and a2 are both null, or if a2 is of the same length
* as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
*/
- public static boolean equals(int[] a1, int[] a2) {
-
+ public static boolean equals(int[]a1, int[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (a1[i] != a2[i]) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (a1[i] != a2[i])
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -624,28 +749,35 @@
* as a2, and for each 0 <= i < a.length, a1[i] == null ? a2[i] == null :
* a1[i].equals(a2[i]).
*/
- public static boolean equals(Object[] a1, Object[] a2) {
-
+ public static boolean equals(Object[]a1, Object[]a2)
+ {
// Quick test which saves comparing elements of the same array, and also
// catches the case that both are null.
- if (a1 == a2) {
- return true;
- }
- try {
-
- // If they're the same length, test each element
- if (a1.length == a2.length) {
- for (int i = 0; i < a1.length; i++) {
- if (!(a1[i] == null ? a2[i] == null : a1[i].equals(a2[i]))) {
- return false;
- }
- }
- return true;
+ if (a1 == a2)
+ {
+ return true;
}
+
+ try
+ {
+ // If they're the same length, test each element
+ if (a1.length == a2.length)
+ {
+ for (int i = 0; i < a1.length; i++)
+ {
+ if (!(a1[i] == null ? a2[i] == null : a1[i].equals(a2[i])))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
- // If a1 == null or a2 == null but not both then we will get a NullPointer
- } catch (NullPointerException e) {
- }
+ // If a1 == null or a2 == null but not both then we will get a NullPointer
+ }
+ catch (NullPointerException e)
+ {
+ }
return false;
}
@@ -656,7 +788,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(boolean[] a, boolean val) {
+ public static void fill(boolean[]a, boolean val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -671,11 +804,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(boolean[] a, int fromIndex, int toIndex,
- boolean val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(boolean[]a, int fromIndex, int toIndex, boolean val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -684,7 +818,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(byte[] a, byte val) {
+ public static void fill(byte[]a, byte val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -699,10 +834,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(byte[]a, int fromIndex, int toIndex, byte val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -711,7 +848,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(char[] a, char val) {
+ public static void fill(char[]a, char val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -726,10 +864,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(char[] a, int fromIndex, int toIndex, char val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(char[]a, int fromIndex, int toIndex, char val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -738,7 +878,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(double[] a, double val) {
+ public static void fill(double[]a, double val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -753,10 +894,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(double[] a, int fromIndex, int toIndex, double val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(double[]a, int fromIndex, int toIndex, double val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -765,7 +908,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(float[] a, float val) {
+ public static void fill(float[]a, float val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -780,10 +924,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(float[] a, int fromIndex, int toIndex, float val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(float[]a, int fromIndex, int toIndex, float val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -792,7 +938,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(int[] a, int val) {
+ public static void fill(int[]a, int val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -807,10 +954,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(int[] a, int fromIndex, int toIndex, int val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(int[]a, int fromIndex, int toIndex, int val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -819,7 +968,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(long[] a, long val) {
+ public static void fill(long[]a, long val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -834,10 +984,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(long[] a, int fromIndex, int toIndex, long val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(long[]a, int fromIndex, int toIndex, long val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -846,7 +998,8 @@
* @param a the array to fill
* @param val the value to fill it with
*/
- public static void fill(short[] a, short val) {
+ public static void fill(short[]a, short val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -861,10 +1014,12 @@
* @param toIndex the index to fill to, exclusive
* @param val the value to fill with
*/
- public static void fill(short[] a, int fromIndex, int toIndex, short val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(short[]a, int fromIndex, int toIndex, short val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
/**
@@ -875,7 +1030,8 @@
* @exception ClassCastException if val is not an instance of the element
* type of a.
*/
- public static void fill(Object[] a, Object val) {
+ public static void fill(Object[]a, Object val)
+ {
// This implementation is slightly inefficient timewise, but the extra
// effort over inlining it is O(1) and small, and I refuse to repeat code
// if it can be helped.
@@ -892,10 +1048,12 @@
* @exception ClassCastException if val is not an instance of the element
* type of a.
*/
- public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
- for (int i = fromIndex; i < toIndex; i++) {
- a[i] = val;
- }
+ public static void fill(Object[]a, int fromIndex, int toIndex, Object val)
+ {
+ for (int i = fromIndex; i < toIndex; i++)
+ {
+ a[i] = val;
+ }
}
// Thanks to Paul Fisher <rao@gnu.org> for finding this quicksort algorithm
@@ -911,79 +1069,110 @@
*
* @param a the array to sort
*/
- public static void sort(byte[] a) {
+ public static void sort(byte[]a)
+ {
qsort(a, 0, a.length);
}
- private static short cmp(byte i, byte j) {
- return (short)(i-j);
+ public static void sort(byte[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
}
- private static int med3(int a, int b, int c, byte[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static short cmp(byte i, byte j)
+ {
+ return (short) (i - j);
+ }
+
+ private static int med3(int a, int b, int c, byte[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
-
- private static void swap(int i, int j, byte[] a) {
+
+ private static void swap(int i, int j, byte[]a)
+ {
byte c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(byte[] a, int start, int n) {
+ private static void qsort(byte[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
+
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
short r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, byte[] a) {
+ private static void vecswap(int i, int j, int n, byte[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -998,79 +1187,110 @@
*
* @param a the array to sort
*/
- public static void sort(char[] a) {
+ public static void sort(char[]a)
+ {
qsort(a, 0, a.length);
}
+
+ public static void sort(char[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
+ }
- private static int cmp(char i, char j) {
- return i-j;
+ private static int cmp(char i, char j)
+ {
+ return i - j;
}
- private static int med3(int a, int b, int c, char[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static int med3(int a, int b, int c, char[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
-
- private static void swap(int i, int j, char[] a) {
+
+ private static void swap(int i, int j, char[]a)
+ {
char c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(char[] a, int start, int n) {
+ private static void qsort(char[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
+
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
int r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, char[] a) {
+ private static void vecswap(int i, int j, int n, char[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1086,79 +1306,110 @@
*
* @param a the array to sort
*/
- public static void sort(double[] a) {
+ public static void sort(double[]a)
+ {
qsort(a, 0, a.length);
}
- private static double cmp(double i, double j) {
- return i-j;
+ public static void sort(double[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
}
- private static int med3(int a, int b, int c, double[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static double cmp(double i, double j)
+ {
+ return i - j;
+ }
+
+ private static int med3(int a, int b, int c, double[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
-
- private static void swap(int i, int j, double[] a) {
+
+ private static void swap(int i, int j, double[]a)
+ {
double c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(double[] a, int start, int n) {
+ private static void qsort(double[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
+
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
double r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, double[] a) {
+ private static void vecswap(int i, int j, int n, double[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1174,79 +1425,110 @@
*
* @param a the array to sort
*/
- public static void sort(float[] a) {
+ public static void sort(float[]a)
+ {
qsort(a, 0, a.length);
}
+
+ public static void sort(float[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
+ }
- private static float cmp(float i, float j) {
- return i-j;
+ private static float cmp(float i, float j)
+ {
+ return i - j;
}
- private static int med3(int a, int b, int c, float[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static int med3(int a, int b, int c, float[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
- private static void swap(int i, int j, float[] a) {
+ private static void swap(int i, int j, float[]a)
+ {
float c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(float[] a, int start, int n) {
+ private static void qsort(float[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
+
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
float r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, float[] a) {
+ private static void vecswap(int i, int j, int n, float[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1261,79 +1543,110 @@
*
* @param a the array to sort
*/
- public static void sort(int[] a) {
+ public static void sort(int[]a)
+ {
qsort(a, 0, a.length);
}
+
+ public static void sort(int[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
+ }
- private static long cmp(int i, int j) {
- return (long)i-(long)j;
+ private static long cmp(int i, int j)
+ {
+ return (long) i - (long) j;
}
- private static int med3(int a, int b, int c, int[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static int med3(int a, int b, int c, int[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
-
- private static void swap(int i, int j, int[] a) {
+
+ private static void swap(int i, int j, int[]a)
+ {
int c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(int[] a, int start, int n) {
+ private static void qsort(int[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
+
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
long r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, int[] a) {
+ private static void vecswap(int i, int j, int n, int[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1348,80 +1661,110 @@
*
* @param a the array to sort
*/
- public static void sort(long[] a) {
+ public static void sort(long[]a)
+ {
qsort(a, 0, a.length);
}
+ public static void sort(long[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
+ }
+
// The "cmp" method has been removed from here and replaced with direct
// compares in situ, to avoid problems with overflow if the difference
// between two numbers is bigger than a long will hold.
// One particular change as a result is the use of r1 and r2 in qsort
- private static int med3(int a, int b, int c, long[] d) {
- return d[a] < d[b] ?
+ private static int med3(int a, int b, int c, long[]d)
+ {
+ return d[a] < d[b] ?
(d[b] < d[c] ? b : d[a] < d[c] ? c : a)
- : (d[b] > d[c] ? b : d[a] > d[c] ? c : a);
+ : (d[b] > d[c] ? b : d[a] > d[c] ? c : a);
}
-
- private static void swap(int i, int j, long[] a) {
+
+ private static void swap(int i, int j, long[]a)
+ {
long c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(long[] a, int start, int n) {
+ private static void qsort(long[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && a[j-1] > a[j]; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && a[j - 1] > a[j]; j--)
+ swap(j, j - 1, a);
+ return;
+ }
+
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
long r1, r2;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r1 = a[pb]) <= (r2 = a[pv])) {
- if (r1 == r2) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r1 = a[pc]) >= (r2 = a[pv])) {
- if (r1 == r2) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r1 = a[pb]) <= (r2 = a[pv]))
+ {
+ if (r1 == r2)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r1 = a[pc]) >= (r2 = a[pv]))
+ {
+ if (r1 == r2)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, long[] a) {
+ private static void vecswap(int i, int j, int n, long[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1436,79 +1779,110 @@
*
* @param a the array to sort
*/
- public static void sort(short[] a) {
+ public static void sort(short[]a)
+ {
qsort(a, 0, a.length);
}
- private static int cmp(short i, short j) {
- return i-j;
+ public static void sort(short[] a, int fromIndex, int toIndex)
+ {
+ qsort(a, fromIndex, toIndex);
}
- private static int med3(int a, int b, int c, short[] d) {
- return cmp(d[a], d[b]) < 0 ?
+ private static int cmp(short i, short j)
+ {
+ return i - j;
+ }
+
+ private static int med3(int a, int b, int c, short[]d)
+ {
+ return cmp(d[a], d[b]) < 0 ?
(cmp(d[b], d[c]) < 0 ? b : cmp(d[a], d[c]) < 0 ? c : a)
- : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
+ : (cmp(d[b], d[c]) > 0 ? b : cmp(d[a], d[c]) > 0 ? c : a);
}
-
- private static void swap(int i, int j, short[] a) {
+
+ private static void swap(int i, int j, short[]a)
+ {
short c = a[i];
a[i] = a[j];
a[j] = c;
}
- private static void qsort(short[] a, int start, int n) {
+ private static void qsort(short[]a, int start, int n)
+ {
// use an insertion sort on small arrays
- if (n < 7) {
- for (int i = start + 1; i < start + n; i++)
- for (int j = i; j > 0 && cmp(a[j-1], a[j]) > 0; j--)
- swap(j, j-1, a);
- return;
- }
+ if (n < 7)
+ {
+ for (int i = start + 1; i < start + n; i++)
+ for (int j = i; j > 0 && cmp(a[j - 1], a[j]) > 0; j--)
+ swap(j, j - 1, a);
+ return;
+ }
+
+ int pm = n / 2; // small arrays, middle element
+ if (n > 7)
+ {
+ int pl = start;
+ int pn = start + n - 1;
- int pm = n/2; // small arrays, middle element
- if (n > 7) {
- int pl = start;
- int pn = start + n-1;
-
- if (n > 40) { // big arrays, pseudomedian of 9
- int s = n/8;
- pl = med3(pl, pl+s, pl+2*s, a);
- pm = med3(pm-s, pm, pm+s, a);
- pn = med3(pn-2*s, pn-s, pn, a);
+ if (n > 40)
+ { // big arrays, pseudomedian of 9
+ int s = n / 8;
+ pl = med3(pl, pl + s, pl + 2 * s, a);
+ pm = med3(pm - s, pm, pm + s, a);
+ pn = med3(pn - 2 * s, pn - s, pn, a);
+ }
+ pm = med3(pl, pm, pn, a); // mid-size, med of 3
}
- pm = med3(pl, pm, pn, a); // mid-size, med of 3
- }
int pa, pb, pc, pd, pv;
int r;
- pv = start; swap(pv, pm, a);
+ pv = start;
+ swap(pv, pm, a);
pa = pb = start;
- pc = pd = start + n-1;
-
- for (;;) {
- while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0) {
- if (r == 0) { swap(pa, pb, a); pa++; }
- pb++;
- }
- while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0) {
- if (r == 0) { swap(pc, pd, a); pd--; }
- pc--;
- }
- if (pb > pc) break;
- swap(pb, pc, a);
- pb++;
- pc--;
- }
+ pc = pd = start + n - 1;
+
+ for (;;)
+ {
+ while (pb <= pc && (r = cmp(a[pb], a[pv])) <= 0)
+ {
+ if (r == 0)
+ {
+ swap(pa, pb, a);
+ pa++;
+ }
+ pb++;
+ }
+ while (pc >= pb && (r = cmp(a[pc], a[pv])) >= 0)
+ {
+ if (r == 0)
+ {
+ swap(pc, pd, a);
+ pd--;
+ }
+ pc--;
+ }
+ if (pb > pc)
+ break;
+ swap(pb, pc, a);
+ pb++;
+ pc--;
+ }
int pn = start + n;
int s;
- s = Math.min(pa-start, pb-pa); vecswap(start, pb-s, s, a);
- s = Math.min(pd-pc, pn-pd-1); vecswap(pb, pn-s, s, a);
- if ((s = pb-pa) > 1) qsort(a, start, s);
- if ((s = pd-pc) > 1) qsort(a, pn-s, s);
+ s = Math.min(pa - start, pb - pa);
+ vecswap(start, pb - s, s, a);
+ s = Math.min(pd - pc, pn - pd - 1);
+ vecswap(pb, pn - s, s, a);
+ if ((s = pb - pa) > 1)
+ qsort(a, start, s);
+ if ((s = pd - pc) > 1)
+ qsort(a, pn - s, s);
}
- private static void vecswap(int i, int j, int n, short[] a) {
+ private static void vecswap(int i, int j, int n, short[]a)
+ {
for (; n > 0; i++, j++, n--)
swap(i, j, a);
}
@@ -1520,45 +1894,45 @@
* than I can, and if I try it will make it more confusing for the
* JIT.
*/
- private static void mergeSort(Object[] a, int from, int to, Comparator c)
+ private static void mergeSort(Object[]a, int from, int to, Comparator c)
{
// First presort the array in chunks of length 6 with insertion sort.
// mergesort would give too much overhead for this length.
for (int chunk = from; chunk < to; chunk += 6)
{
- int end = Math.min(chunk+6, to);
+ int end = Math.min(chunk + 6, to);
for (int i = chunk + 1; i < end; i++)
{
- if (c.compare(a[i-1], a[i]) > 0)
+ if (c.compare(a[i - 1], a[i]) > 0)
{
// not already sorted
- int j=i;
+ int j = i;
Object elem = a[j];
- do
+ do
{
- a[j] = a[j-1];
+ a[j] = a[j - 1];
j--;
- }
- while (j>chunk && c.compare(a[j-1], elem) > 0);
+ }
+ while (j > chunk && c.compare(a[j - 1], elem) > 0);
a[j] = elem;
}
}
}
-
+
int len = to - from;
// If length is smaller or equal 6 we are done.
if (len <= 6)
return;
- Object[] src = a;
- Object[] dest = new Object[len];
- Object[] t = null; // t is used for swapping src and dest
+ Object[]src = a;
+ Object[]dest = new Object[len];
+ Object[]t = null; // t is used for swapping src and dest
// The difference of the fromIndex of the src and dest array.
int srcDestDiff = -from;
// The merges are done in this loop
- for (int size = 6; size < len; size <<= 1)
+ for (int size = 6; size < len; size <<= 1)
{
for (int start = from; start < to; start += size << 1)
{
@@ -1566,48 +1940,55 @@
// end the start of the next sublist (or end of array).
int mid = start + size;
int end = Math.min(to, mid + size);
-
+
// The second list is empty or the elements are already in
// order - no need to merge
- if (mid >= end || c.compare(src[mid - 1], src[mid]) <= 0) {
- System.arraycopy(src, start,
- dest, start + srcDestDiff, end - start);
-
- // The two halves just need swapping - no need to merge
- } else if (c.compare(src[start], src[end - 1]) > 0) {
- System.arraycopy(src, start,
- dest, end - size + srcDestDiff, size);
- System.arraycopy(src, mid,
- dest, start + srcDestDiff, end - mid);
-
- } else {
- // Declare a lot of variables to save repeating
- // calculations. Hopefully a decent JIT will put these
- // in registers and make this fast
- int p1 = start;
- int p2 = mid;
- int i = start + srcDestDiff;
-
- // The main merge loop; terminates as soon as either
- // half is ended
- while (p1 < mid && p2 < end)
- {
- dest[i++] =
- src[c.compare(src[p1], src[p2]) <= 0 ? p1++ : p2++];
- }
-
- // Finish up by copying the remainder of whichever half
- // wasn't finished.
- if (p1 < mid)
- System.arraycopy(src, p1, dest, i, mid - p1);
- else
- System.arraycopy(src, p2, dest, i, end - p2);
- }
+ if (mid >= end || c.compare(src[mid - 1], src[mid]) <= 0)
+ {
+ System.arraycopy(src, start,
+ dest, start + srcDestDiff, end - start);
+
+ // The two halves just need swapping - no need to merge
+ }
+ else if (c.compare(src[start], src[end - 1]) > 0)
+ {
+ System.arraycopy(src, start,
+ dest, end - size + srcDestDiff, size);
+ System.arraycopy(src, mid,
+ dest, start + srcDestDiff, end - mid);
+
+ }
+ else
+ {
+ // Declare a lot of variables to save repeating
+ // calculations. Hopefully a decent JIT will put these
+ // in registers and make this fast
+ int p1 = start;
+ int p2 = mid;
+ int i = start + srcDestDiff;
+
+ // The main merge loop; terminates as soon as either
+ // half is ended
+ while (p1 < mid && p2 < end)
+ {
+ dest[i++] =
+ src[c.compare(src[p1], src[p2]) <= 0 ? p1++ : p2++];
+ }
+
+ // Finish up by copying the remainder of whichever half
+ // wasn't finished.
+ if (p1 < mid)
+ System.arraycopy(src, p1, dest, i, mid - p1);
+ else
+ System.arraycopy(src, p2, dest, i, end - p2);
+ }
}
// swap src and dest ready for the next merge
- t = src; src = dest; dest = t;
+ t = src;
+ src = dest;
+ dest = t;
from += srcDestDiff;
- to += srcDestDiff;
+ to += srcDestDiff;
srcDestDiff = -srcDestDiff;
}
@@ -1635,7 +2016,8 @@
* @exception NullPointerException if an element is null (since
* null.compareTo cannot work)
*/
- public static void sort(Object[] a) {
+ public static void sort(Object[]a)
+ {
mergeSort(a, 0, a.length, defaultComparator);
}
@@ -1652,7 +2034,8 @@
* @exception ClassCastException if any two elements are not mutually
* comparable by the Comparator provided
*/
- public static void sort(Object[] a, Comparator c) {
+ public static void sort(Object[]a, Comparator c)
+ {
mergeSort(a, 0, a.length, c);
}
@@ -1673,11 +2056,11 @@
* are not in range.
* @exception IllegalArgumentException if fromIndex > toIndex
*/
- public static void sort(Object[] a, int fromIndex,
- int toIndex) {
+ public static void sort(Object[]a, int fromIndex, int toIndex)
+ {
if (fromIndex > toIndex)
- throw new IllegalArgumentException("fromIndex "+fromIndex
- +" > toIndex "+toIndex);
+ throw new IllegalArgumentException("fromIndex " + fromIndex
+ + " > toIndex " + toIndex);
mergeSort(a, fromIndex, toIndex, defaultComparator);
}
@@ -1699,11 +2082,11 @@
* are not in range.
* @exception IllegalArgumentException if fromIndex > toIndex
*/
- public static void sort(Object[] a, int fromIndex,
- int toIndex, Comparator c) {
+ public static void sort(Object[]a, int fromIndex, int toIndex, Comparator c)
+ {
if (fromIndex > toIndex)
- throw new IllegalArgumentException("fromIndex "+fromIndex
- +" > toIndex "+toIndex);
+ throw new IllegalArgumentException("fromIndex " + fromIndex
+ + " > toIndex " + toIndex);
mergeSort(a, fromIndex, toIndex, c);
}
@@ -1715,13 +2098,14 @@
* @param a the array to return a view of
* @returns a fixed-size list, changes to which "write through" to the array
*/
- public static List asList(final Object[] a) {
-
- if (a == null) {
- throw new NullPointerException();
- }
+ public static List asList(final Object[]a)
+ {
+ if (a == null)
+ {
+ throw new NullPointerException();
+ }
- return new ListImpl( a );
+ return new ListImpl(a);
}
@@ -1731,21 +2115,25 @@
* Note: When Sun fully specify serialized forms, this class will have to
* be renamed.
*/
- private static class ListImpl extends AbstractList {
-
- ListImpl(Object[] a) {
+ private static class ListImpl extends AbstractList
+ {
+ ListImpl(Object[]a)
+ {
this.a = a;
}
- public Object get(int index) {
+ public Object get(int index)
+ {
return a[index];
}
- public int size() {
+ public int size()
+ {
return a.length;
}
- public Object set(int index, Object element) {
+ public Object set(int index, Object element)
+ {
Object old = a[index];
a[index] = element;
return old;
@@ -1753,5 +2141,4 @@
private Object[] a;
}
-
}
Index: scripts/blocks.pl
===================================================================
RCS file: blocks.pl
diff -N blocks.pl
--- /dev/null Tue May 5 13:32:27 1998
+++ blocks.pl Thu Nov 16 20:48:13 2000
@@ -0,0 +1,48 @@
+#! /usr/bin/perl
+
+if ($ARGV[0] eq '')
+{
+ $file = 'Blocks.txt';
+ if (! -f $file)
+ {
+ # Too painful to figure out how to get Perl to do it.
+ # FIXME.
+ system 'wget -o .wget-log http://www.isi.edu/in-notes/iana/unidata/Blocks.txt';
+ }
+}
+else
+{
+ $file = $ARGV[0];
+}
+
+open (INPUT, "< $file") || die "couldn't open $file: $!";
+
+@array = ();
+while (<INPUT>)
+{
+ next if /^#/;
+ chop;
+
+ ($start, $to, $text) = split (/; /);
+ ($symbol = $text) =~ tr/a-z/A-Z/;
+ $symbol =~ s/[- ]/_/g;
+
+ # Special case for one of the SPECIALS.
+ next if $start eq 'FEFF';
+
+ printf " public static final UnicodeBlock %s = new UnicodeBlock (\"%s\", '\\u%s', '\\u%s');\n",
+ $symbol, $text, $start, $to;
+
+ push (@array, $symbol);
+}
+
+printf " private static final UnicodeBlock[] blocks = {\n";
+foreach (@array)
+{
+ printf " %s", $_;
+ printf "," unless $_ eq 'SPECIALS';
+ printf "\n";
+}
+printf " };\n";
+
+close (INPUT);
Index: java/io/PushbackReader.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/io/PushbackReader.java,v
retrieving revision 1.4
diff -u -r1.4 PushbackReader.java
--- PushbackReader.java 2000/06/27 21:27:50 1.4
+++ PushbackReader.java 2000/11/17 04:48:13
@@ -1,140 +1,429 @@
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* PushbackReader.java -- An character stream that can unread chars
+ Copyright (C) 1998, 2000 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.io;
/**
- * @author Warren Levy <warrenl@cygnus.com>
- * @date October 16, 1998.
+ * This subclass of <code>FilterReader</code> provides the ability to
+ * unread data from a stream. It maintains an internal buffer of unread
+ * data that is supplied to the next read operation. This is conceptually
+ * similar to mark/reset functionality, except that in this case the
+ * position to reset the stream to does not need to be known in advance.
+ * <p>
+ * The default pushback buffer size one char, but this can be overridden
+ * by the creator of the stream.
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Warren Levy <warrenl@cygnus.com>
+ */
+public class PushbackReader extends FilterReader
+{
+
+/*************************************************************************/
+
+/*
+ * Class Variables
*/
-/* 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.
+
+/**
+ * This is the default buffer size
+ */
+private static final int DEFAULT_BUFFER_SIZE = 1;
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
*/
-
-public class PushbackReader extends FilterReader
+
+/**
+ * This is the buffer that is used to store the pushed back data
+ */
+private char[] buf;
+
+/**
+ * This is the position in the buffer from which the next char will be
+ * read. Bytes are stored in reverse order in the buffer, starting from
+ * <code>buf[buf.length - 1]</code> to <code>buf[0]</code>. Thus when
+ * <code>pos</code> is 0 the buffer is full and <code>buf.length</code> when
+ * it is empty
+ */
+private int pos;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+/**
+ * This method initializes a <code>PushbackReader</code> to read from the
+ * specified subordinate <code>Reader</code> with a default pushback buffer
+ * size of 1.
+ *
+ * @code in The subordinate stream to read from
+ */
+public
+PushbackReader(Reader in)
{
- /* Internal buffer array for data. */
- private char[] buf;
+ this(in, DEFAULT_BUFFER_SIZE);
+}
- /* The current position in the buffer. */
- private int pos;
+/*************************************************************************/
- public PushbackReader(Reader in)
- {
- this(in, 1);
- }
-
- public PushbackReader(Reader in, int size)
- {
- super(in);
- if (size < 0)
- throw new IllegalArgumentException();
- buf = new char[size];
- pos = buf.length;
- }
-
- public void close() throws IOException
- {
- synchronized (lock)
+/**
+ * This method initializes a <code>PushbackReader</code> to read from the
+ * specified subordinate <code>Reader</code> with the specified buffer
+ * size
+ *
+ * @param in The subordinate <code>Reader</code> to read from
+ * @param bufsize The pushback buffer size to use
+ */
+public
+PushbackReader(Reader in, int bufsize)
+{
+ super(in);
+
+ if (bufsize < 0)
+ throw new IllegalArgumentException("buffer size must be positive");
+
+ buf = new char[bufsize];
+ pos = bufsize;
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+/**
+ * This method closes the stream and frees any associated resources.
+ *
+ * @exception IOException If an error occurs.
+ */
+public void
+close() throws IOException
+{
+ synchronized (lock)
{
buf = null;
super.close();
}
- }
+}
+
+/*************************************************************************/
- public boolean markSupported()
- {
- return false;
- }
-
- public int read() throws IOException
- {
- synchronized (lock)
+/**
+ * This method throws an exception when called since this class does
+ * not support mark/reset.
+ *
+ * @param read_limit Not used.
+ *
+ * @exception IOException Always thrown to indicate mark/reset not supported.
+ */
+public void
+mark(int read_limit) throws IOException
+{
+ throw new IOException("mark not supported in this class");
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns <code>false</code> to indicate that it does not support
+ * mark/reset functionality.
+ *
+ * @return This method returns <code>false</code> to indicate that this class does not support mark/reset functionality
+ *
+ */
+public boolean
+markSupported()
+{
+ return(false);
+}
+
+/*************************************************************************/
+
+/**
+ * This method always throws an IOException in this class because
+ * mark/reset functionality is not supported.
+ *
+ * @exception IOException Always thrown for this class
+ */
+public void
+reset() throws IOException
+{
+ throw new IOException("reset not supported in this class");
+}
+
+/*************************************************************************/
+
+/**
+ * This method determines whether or not this stream is ready to be read.
+ * If it returns <code>false</code> to indicate that the stream is not
+ * ready, any attempt to read from the stream could (but is not
+ * guaranteed to) block.
+ * <p>
+ * This stream is ready to read if there are either chars waiting to be
+ * read in the pushback buffer or if the underlying stream is ready to
+ * be read.
+ *
+ * @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
+ *
+ * @exception IOException If an error occurs
+ */
+public boolean
+ready() throws IOException
+{
+ synchronized (lock)
+ {
+ if (buf == null)
+ throw new IOException ("stream closed");
+
+ if (((buf.length - pos) > 0) || super.ready())
+ return(true);
+ else
+ return(false);
+ }
+}
+
+/*************************************************************************/
+
+// Don't delete this method just because the spec says it shouldn't be there!
+// See the CVS log for details.
+/**
+ * This method skips the specified number of chars in the stream. It
+ * returns the actual number of chars skipped, which may be less than the
+ * requested amount.
+ * <p>
+ * This method first discards chars from the buffer, then calls the
+ * <code>skip</code> method on the underlying <code>Reader</code> to
+ * skip additional chars if necessary.
+ *
+ * @param num_chars The requested number of chars to skip
+ *
+ * @return The actual number of chars skipped.
+ *
+ * @exception IOException If an error occurs
+ */
+public long
+skip(long num_chars) throws IOException
+{
+ synchronized (lock)
+ {
+ if (num_chars <= 0)
+ return(0);
+
+ if ((buf.length - pos) >= num_chars)
+ {
+ pos += num_chars;
+ return(num_chars);
+ }
+
+ int chars_discarded = buf.length - pos;
+ pos = buf.length;
+
+ long chars_skipped = in.skip(num_chars - chars_discarded);
+
+ return(chars_discarded + chars_skipped);
+ } // synchronized
+}
+
+/*************************************************************************/
+
+/**
+ * This method reads an unsigned char from the input stream and returns it
+ * as an int in the range of 0-65535. This method also will return -1 if
+ * the end of the stream has been reached. The char returned will be read
+ * from the pushback buffer, unless the buffer is empty, in which case
+ * the char will be read from the underlying stream.
+ * <p>
+ * This method will block until the char can be read.
+ *
+ * @return The char read or -1 if end of stream
+ *
+ * @exception IOException If an error occurs
+ */
+public int
+read() throws IOException
+{
+ synchronized (lock)
{
if (buf == null)
- throw new IOException();
+ throw new IOException("stream closed");
- if (pos < buf.length)
- return ((int) buf[pos++]) & 0xFFFF;
+ if (pos == buf.length)
+ return(super.read());
- return super.read();
+ ++pos;
+ return((buf[pos - 1] & 0xFFFF));
}
- }
+}
+
+/*************************************************************************/
- public int read(char[] b, int off, int len) throws IOException
- {
- synchronized (lock)
+/**
+ * This method read chars from a stream and stores them into a caller
+ * supplied buffer. It starts storing the data at index <code>offset</code> into
+ * the buffer and attempts to read <code>len</code> chars. This method can
+ * return before reading the number of chars requested. The actual number
+ * of chars read is returned as an int. A -1 is returned to indicate the
+ * end of the stream.
+ * <p>
+ * This method will block until some data can be read.
+ * <p>
+ * This method first reads chars from the pushback buffer in order to
+ * satisfy the read request. If the pushback buffer cannot provide all
+ * of the chars requested, the remaining chars are read from the
+ * underlying stream.
+ *
+ * @param buf The array into which the chars read should be stored
+ * @param offset The offset into the array to start storing chars
+ * @param len The requested number of chars to read
+ *
+ * @return The actual number of chars read, or -1 if end of stream.
+ *
+ * @exception IOException If an error occurs.
+ */
+public synchronized int
+read(char[] b, int offset, int len) throws IOException
+{
+ synchronized (lock)
{
if (buf == null)
- throw new IOException();
+ throw new IOException("stream closed");
- if (off < 0 || len < 0 || off + len > b.length)
+ if (offset < 0 || len < 0 || offset + len > b.length)
throw new ArrayIndexOutOfBoundsException();
int numBytes = Math.min(buf.length - pos, len);
if (numBytes > 0)
{
- System.arraycopy (buf, pos, b, off, numBytes);
+ System.arraycopy (buf, pos, b, offset, numBytes);
pos += numBytes;
return numBytes;
}
- return super.read(b, off, len);
+ return super.read(b, offset, len);
}
- }
+}
+
+/*************************************************************************/
- public boolean ready() throws IOException
- {
- synchronized (lock)
+/**
+ * This method pushes a single char of data into the pushback buffer.
+ * The char pushed back is the one that will be returned as the first char
+ * of the next read.
+ * <p>
+ * If the pushback buffer is full, this method throws an exception.
+ * <p>
+ * The argument to this method is an <code>int</code>. Only the low eight bits
+ * of this value are pushed back.
+ *
+ * @param b The char to be pushed back, passed as an int
+ *
+ * @exception IOException If the pushback buffer is full.
+ */
+public void
+unread(int b) throws IOException
+{
+ synchronized (lock)
{
if (buf == null)
- throw new IOException();
-
- if (buf.length - pos > 0)
- return true;
+ throw new IOException("stream closed");
+ if (pos == 0)
+ throw new IOException("Pushback buffer is full");
+
+ --pos;
+ buf[pos] = (char)(b & 0xFFFF);
+ } // synchronized
+}
- return super.ready();
- }
- }
+/*************************************************************************/
- public void unread(int b) throws IOException
- {
- synchronized (lock)
- {
- if (buf == null || pos <= 0)
- throw new IOException();
+/**
+ * This method pushes all of the chars in the passed char array into
+ * the pushback buffer. These chars are pushed in reverse order so that
+ * the next char read from the stream after this operation will be
+ * <code>buf[0]</code> followed by <code>buf[1]</code>, etc.
+ * <p>
+ * If the pushback buffer cannot hold all of the requested chars, an
+ * exception is thrown.
+ *
+ * @param buf The char array to be pushed back
+ *
+ * @exception IOException If the pushback buffer is full
+ */
+public synchronized void
+unread(char[] buf) throws IOException
+{
+ unread(buf, 0, buf.length);
+}
- buf[--pos] = (char) b;
- }
- }
+/*************************************************************************/
- public void unread(char[] b) throws IOException
- {
- unread(b, 0, b.length);
- }
-
- public void unread(char[] b, int off, int len) throws IOException
- {
- synchronized (lock)
+/**
+ * This method pushed back chars from the passed in array into the pushback
+ * buffer. The chars from <code>buf[offset]</code> to <cdoe>buf[offset + len]</code>
+ * are pushed in reverse order so that the next char read from the stream
+ * after this operation will be <code>buf[offset]</code> followed by
+ * <code>buf[offset + 1]</code>, etc.
+ * <p>
+ * If the pushback buffer cannot hold all of the requested chars, an
+ * exception is thrown.
+ *
+ * @param buf The char array to be pushed back
+ * @param offset The index into the array where the chars to be push start
+ * @param len The number of chars to be pushed.
+ *
+ * @exception IOException If the pushback buffer is full
+ */
+public synchronized void
+unread(char[] b, int offset, int len) throws IOException
+{
+ synchronized (lock)
{
- if (buf == null || pos < len)
- throw new IOException();
+ if (buf == null)
+ throw new IOException("stream closed");
+ if (pos < len)
+ throw new IOException("Pushback buffer is full");
// Note the order that these chars are being added is the opposite
// of what would be done if they were added to the buffer one at a time.
// See the Java Class Libraries book p. 1397.
- System.arraycopy(b, off, buf, pos - len, len);
+ System.arraycopy(b, offset, buf, pos - len, len);
// Don't put this into the arraycopy above, an exception might be thrown
// and in that case we don't want to modify pos.
pos -= len;
}
- }
}
+
+} // class PushbackReader
Index: java/lang/Character.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/Character.java,v
retrieving revision 1.4
diff -u -r1.4 Character.java
--- Character.java 2000/09/08 19:37:08 1.4
+++ Character.java 2000/11/17 04:48:16
@@ -284,4 +284,208 @@
// Private data.
private char value;
+
+ public static class Subset
+ {
+ protected Subset (String name)
+ {
+ this.name = name;
+ }
+
+ public final boolean equals (Object obj)
+ {
+ return obj == this;
+ }
+
+ public final int hashCode ()
+ {
+ return super.hashCode ();
+ }
+
+ public final String toString ()
+ {
+ return name;
+ }
+
+ // Name of this subset.
+ private String name;
+ }
+
+ public static final class UnicodeBlock extends Subset
+ {
+ private UnicodeBlock (String name, char start, char end)
+ {
+ super (name);
+ this.start = start;
+ this.end = end;
+ }
+
+ public static UnicodeBlock of (char c)
+ {
+ // A special case we need.
+ if (c == '\uFEFF')
+ return SPECIALS;
+
+ // Do a binary search to find the correct subset.
+ int hi = blocks.length;
+ int lo = 0;
+ while (hi > lo)
+ {
+ int mid = (hi + lo) / 2;
+ UnicodeBlock ub = blocks[mid];
+ if (c < ub.start)
+ hi = mid;
+ else if (c > ub.end)
+ lo = mid;
+ else
+ return ub;
+ }
+
+ return null;
+ }
+
+ // Start and end characters.
+ private char start, end;
+
+ // Everything from here to the end of UnicodeBlock is
+ // automatically generated by the blocks.pl script.
+ public static final UnicodeBlock BASIC_LATIN = new UnicodeBlock ("Basic Latin", '\u0000', '\u007F');
+ public static final UnicodeBlock LATIN_1_SUPPLEMENT = new UnicodeBlock ("Latin-1 Supplement", '\u0080', '\u00FF');
+ public static final UnicodeBlock LATIN_EXTENDED_A = new UnicodeBlock ("Latin Extended-A", '\u0100', '\u017F');
+ public static final UnicodeBlock LATIN_EXTENDED_B = new UnicodeBlock ("Latin Extended-B", '\u0180', '\u024F');
+ public static final UnicodeBlock IPA_EXTENSIONS = new UnicodeBlock ("IPA Extensions", '\u0250', '\u02AF');
+ public static final UnicodeBlock SPACING_MODIFIER_LETTERS = new UnicodeBlock ("Spacing Modifier Letters", '\u02B0', '\u02FF');
+ public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS = new UnicodeBlock ("Combining Diacritical Marks", '\u0300', '\u036F');
+ public static final UnicodeBlock GREEK = new UnicodeBlock ("Greek", '\u0370', '\u03FF');
+ public static final UnicodeBlock CYRILLIC = new UnicodeBlock ("Cyrillic", '\u0400', '\u04FF');
+ public static final UnicodeBlock ARMENIAN = new UnicodeBlock ("Armenian", '\u0530', '\u058F');
+ public static final UnicodeBlock HEBREW = new UnicodeBlock ("Hebrew", '\u0590', '\u05FF');
+ public static final UnicodeBlock ARABIC = new UnicodeBlock ("Arabic", '\u0600', '\u06FF');
+ public static final UnicodeBlock DEVANAGARI = new UnicodeBlock ("Devanagari", '\u0900', '\u097F');
+ public static final UnicodeBlock BENGALI = new UnicodeBlock ("Bengali", '\u0980', '\u09FF');
+ public static final UnicodeBlock GURMUKHI = new UnicodeBlock ("Gurmukhi", '\u0A00', '\u0A7F');
+ public static final UnicodeBlock GUJARATI = new UnicodeBlock ("Gujarati", '\u0A80', '\u0AFF');
+ public static final UnicodeBlock ORIYA = new UnicodeBlock ("Oriya", '\u0B00', '\u0B7F');
+ public static final UnicodeBlock TAMIL = new UnicodeBlock ("Tamil", '\u0B80', '\u0BFF');
+ public static final UnicodeBlock TELUGU = new UnicodeBlock ("Telugu", '\u0C00', '\u0C7F');
+ public static final UnicodeBlock KANNADA = new UnicodeBlock ("Kannada", '\u0C80', '\u0CFF');
+ public static final UnicodeBlock MALAYALAM = new UnicodeBlock ("Malayalam", '\u0D00', '\u0D7F');
+ public static final UnicodeBlock THAI = new UnicodeBlock ("Thai", '\u0E00', '\u0E7F');
+ public static final UnicodeBlock LAO = new UnicodeBlock ("Lao", '\u0E80', '\u0EFF');
+ public static final UnicodeBlock TIBETAN = new UnicodeBlock ("Tibetan", '\u0F00', '\u0FBF');
+ public static final UnicodeBlock GEORGIAN = new UnicodeBlock ("Georgian", '\u10A0', '\u10FF');
+ public static final UnicodeBlock HANGUL_JAMO = new UnicodeBlock ("Hangul Jamo", '\u1100', '\u11FF');
+ public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL = new UnicodeBlock ("Latin Extended Additional", '\u1E00', '\u1EFF');
+ public static final UnicodeBlock GREEK_EXTENDED = new UnicodeBlock ("Greek Extended", '\u1F00', '\u1FFF');
+ public static final UnicodeBlock GENERAL_PUNCTUATION = new UnicodeBlock ("General Punctuation", '\u2000', '\u206F');
+ public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS = new UnicodeBlock ("Superscripts and Subscripts", '\u2070', '\u209F');
+ public static final UnicodeBlock CURRENCY_SYMBOLS = new UnicodeBlock ("Currency Symbols", '\u20A0', '\u20CF');
+ public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS = new UnicodeBlock ("Combining Marks for Symbols", '\u20D0', '\u20FF');
+ public static final UnicodeBlock LETTERLIKE_SYMBOLS = new UnicodeBlock ("Letterlike Symbols", '\u2100', '\u214F');
+ public static final UnicodeBlock NUMBER_FORMS = new UnicodeBlock ("Number Forms", '\u2150', '\u218F');
+ public static final UnicodeBlock ARROWS = new UnicodeBlock ("Arrows", '\u2190', '\u21FF');
+ public static final UnicodeBlock MATHEMATICAL_OPERATORS = new UnicodeBlock ("Mathematical Operators", '\u2200', '\u22FF');
+ public static final UnicodeBlock MISCELLANEOUS_TECHNICAL = new UnicodeBlock ("Miscellaneous Technical", '\u2300', '\u23FF');
+ public static final UnicodeBlock CONTROL_PICTURES = new UnicodeBlock ("Control Pictures", '\u2400', '\u243F');
+ public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION = new UnicodeBlock ("Optical Character Recognition", '\u2440', '\u245F');
+ public static final UnicodeBlock ENCLOSED_ALPHANUMERICS = new UnicodeBlock ("Enclosed Alphanumerics", '\u2460', '\u24FF');
+ public static final UnicodeBlock BOX_DRAWING = new UnicodeBlock ("Box Drawing", '\u2500', '\u257F');
+ public static final UnicodeBlock BLOCK_ELEMENTS = new UnicodeBlock ("Block Elements", '\u2580', '\u259F');
+ public static final UnicodeBlock GEOMETRIC_SHAPES = new UnicodeBlock ("Geometric Shapes", '\u25A0', '\u25FF');
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS = new UnicodeBlock ("Miscellaneous Symbols", '\u2600', '\u26FF');
+ public static final UnicodeBlock DINGBATS = new UnicodeBlock ("Dingbats", '\u2700', '\u27BF');
+ public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION = new UnicodeBlock ("CJK Symbols and Punctuation", '\u3000', '\u303F');
+ public static final UnicodeBlock HIRAGANA = new UnicodeBlock ("Hiragana", '\u3040', '\u309F');
+ public static final UnicodeBlock KATAKANA = new UnicodeBlock ("Katakana", '\u30A0', '\u30FF');
+ public static final UnicodeBlock BOPOMOFO = new UnicodeBlock ("Bopomofo", '\u3100', '\u312F');
+ public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO = new UnicodeBlock ("Hangul Compatibility Jamo", '\u3130', '\u318F');
+ public static final UnicodeBlock KANBUN = new UnicodeBlock ("Kanbun", '\u3190', '\u319F');
+ public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS = new UnicodeBlock ("Enclosed CJK Letters and Months", '\u3200', '\u32FF');
+ public static final UnicodeBlock CJK_COMPATIBILITY = new UnicodeBlock ("CJK Compatibility", '\u3300', '\u33FF');
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS = new UnicodeBlock ("CJK Unified Ideographs", '\u4E00', '\u9FFF');
+ public static final UnicodeBlock HANGUL_SYLLABLES = new UnicodeBlock ("Hangul Syllables", '\uAC00', '\uD7A3');
+ public static final UnicodeBlock HIGH_SURROGATES = new UnicodeBlock ("High Surrogates", '\uD800', '\uDB7F');
+ public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES = new UnicodeBlock ("High Private Use Surrogates", '\uDB80', '\uDBFF');
+ public static final UnicodeBlock LOW_SURROGATES = new UnicodeBlock ("Low Surrogates", '\uDC00', '\uDFFF');
+ public static final UnicodeBlock PRIVATE_USE = new UnicodeBlock ("Private Use", '\uE000', '\uF8FF');
+ public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS = new UnicodeBlock ("CJK Compatibility Ideographs", '\uF900', '\uFAFF');
+ public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS = new UnicodeBlock ("Alphabetic Presentation Forms", '\uFB00', '\uFB4F');
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A = new UnicodeBlock ("Arabic Presentation Forms-A", '\uFB50', '\uFDFF');
+ public static final UnicodeBlock COMBINING_HALF_MARKS = new UnicodeBlock ("Combining Half Marks", '\uFE20', '\uFE2F');
+ public static final UnicodeBlock CJK_COMPATIBILITY_FORMS = new UnicodeBlock ("CJK Compatibility Forms", '\uFE30', '\uFE4F');
+ public static final UnicodeBlock SMALL_FORM_VARIANTS = new UnicodeBlock ("Small Form Variants", '\uFE50', '\uFE6F');
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B = new UnicodeBlock ("Arabic Presentation Forms-B", '\uFE70', '\uFEFE');
+ public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS = new UnicodeBlock ("Halfwidth and Fullwidth Forms", '\uFF00', '\uFFEF');
+ public static final UnicodeBlock SPECIALS = new UnicodeBlock ("Specials", '\uFFF0', '\uFFFD');
+ private static final UnicodeBlock[] blocks = {
+ BASIC_LATIN,
+ LATIN_1_SUPPLEMENT,
+ LATIN_EXTENDED_A,
+ LATIN_EXTENDED_B,
+ IPA_EXTENSIONS,
+ SPACING_MODIFIER_LETTERS,
+ COMBINING_DIACRITICAL_MARKS,
+ GREEK,
+ CYRILLIC,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ DEVANAGARI,
+ BENGALI,
+ GURMUKHI,
+ GUJARATI,
+ ORIYA,
+ TAMIL,
+ TELUGU,
+ KANNADA,
+ MALAYALAM,
+ THAI,
+ LAO,
+ TIBETAN,
+ GEORGIAN,
+ HANGUL_JAMO,
+ LATIN_EXTENDED_ADDITIONAL,
+ GREEK_EXTENDED,
+ GENERAL_PUNCTUATION,
+ SUPERSCRIPTS_AND_SUBSCRIPTS,
+ CURRENCY_SYMBOLS,
+ COMBINING_MARKS_FOR_SYMBOLS,
+ LETTERLIKE_SYMBOLS,
+ NUMBER_FORMS,
+ ARROWS,
+ MATHEMATICAL_OPERATORS,
+ MISCELLANEOUS_TECHNICAL,
+ CONTROL_PICTURES,
+ OPTICAL_CHARACTER_RECOGNITION,
+ ENCLOSED_ALPHANUMERICS,
+ BOX_DRAWING,
+ BLOCK_ELEMENTS,
+ GEOMETRIC_SHAPES,
+ MISCELLANEOUS_SYMBOLS,
+ DINGBATS,
+ CJK_SYMBOLS_AND_PUNCTUATION,
+ HIRAGANA,
+ KATAKANA,
+ BOPOMOFO,
+ HANGUL_COMPATIBILITY_JAMO,
+ KANBUN,
+ ENCLOSED_CJK_LETTERS_AND_MONTHS,
+ CJK_COMPATIBILITY,
+ CJK_UNIFIED_IDEOGRAPHS,
+ HANGUL_SYLLABLES,
+ HIGH_SURROGATES,
+ HIGH_PRIVATE_USE_SURROGATES,
+ LOW_SURROGATES,
+ PRIVATE_USE,
+ CJK_COMPATIBILITY_IDEOGRAPHS,
+ ALPHABETIC_PRESENTATION_FORMS,
+ ARABIC_PRESENTATION_FORMS_A,
+ COMBINING_HALF_MARKS,
+ CJK_COMPATIBILITY_FORMS,
+ SMALL_FORM_VARIANTS,
+ ARABIC_PRESENTATION_FORMS_B,
+ HALFWIDTH_AND_FULLWIDTH_FORMS,
+ SPECIALS
+ };
+ }
}
Index: java/lang/Double.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/Double.java,v
retrieving revision 1.6
diff -u -r1.6 Double.java
--- Double.java 2000/09/08 19:37:08 1.6
+++ Double.java 2000/11/17 04:48:16
@@ -18,7 +18,7 @@
* Status: Believed complete and correct.
*/
-public final class Double extends Number
+public final class Double extends Number implements Comparable
{
public static final double MIN_VALUE = 5e-324;
public static final double MAX_VALUE = 1.7976931348623157e+308;
@@ -147,5 +147,26 @@
public static native long doubleToLongBits (double value);
public static native double longBitsToDouble (long bits);
-}
+ public int compareTo (Double d)
+ {
+ double v = d.value;
+ if (isNaN (value))
+ return isNaN (v) ? 1 : 0;
+ else if (isNaN (v))
+ return -1;
+ else if (value == 0.0 && v == -0.0)
+ return 1;
+ else if (value == -0.0 && v == 0.0)
+ return -1;
+ else if (value == v)
+ return 0;
+
+ return value > v ? 1 : -1;
+ }
+
+ public int compareTo (Object o)
+ {
+ return compareTo ((Double) o);
+ }
+}
Index: java/lang/Float.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/Float.java,v
retrieving revision 1.4
diff -u -r1.4 Float.java
--- Float.java 2000/09/08 19:37:08 1.4
+++ Float.java 2000/11/17 04:48:16
@@ -18,7 +18,7 @@
* Status: Believed complete and correct.
*/
-public final class Float extends Number
+public final class Float extends Number implements Comparable
{
public static final float MAX_VALUE = 3.4028235e+38f;
public static final float MIN_VALUE = 1.4e-45f;
@@ -147,5 +147,25 @@
public static native float intBitsToFloat (int bits);
-}
+ public int compareTo (Float d)
+ {
+ float v = d.value;
+ if (isNaN (value))
+ return isNaN (v) ? 1 : 0;
+ else if (isNaN (v))
+ return -1;
+ else if (value == 0.0 && v == -0.0)
+ return 1;
+ else if (value == -0.0 && v == 0.0)
+ return -1;
+ else if (value == v)
+ return 0;
+
+ return value > v ? 1 : -1;
+ }
+ public int compareTo (Object o)
+ {
+ return compareTo ((Float) o);
+ }
+}
Index: java/lang/Math.java
===================================================================
RCS file: /cvs/java/libgcj/libjava/java/lang/Math.java,v
retrieving revision 1.3
diff -u -r1.3 Math.java
--- Math.java 2000/03/07 19:55:26 1.3
+++ Math.java 2000/11/17 04:48:16
@@ -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.
@@ -109,6 +109,16 @@
public static native float max (float a, float b);
public static native double max (double a, double b);
+
+ public static double toDegrees (double radians)
+ {
+ return radians * 180 / PI;
+ }
+
+ public static double toRadians (double degrees)
+ {
+ return degrees * PI / 180;
+ }
// Don't allow objects to be made.
private Math ()