PushbackReader.java: Merged with Classpath.

	* 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.

From-SVN: r37512

6 files changed, 1742 insertions, 811 deletions

diff --git a/libjava/java/io/PushbackReader.java b/libjava/java/io/PushbackReader.java
index 1a7523d..be8dba4 100644
--- a/libjava/java/io/PushbackReader.java
+++ b/libjava/java/io/PushbackReader.java
@@ -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
+ */
+
+/**
+  * This is the default buffer size
+  */
+private static final int DEFAULT_BUFFER_SIZE = 1;
+
+/*************************************************************************/
+
+/*
+ * Instance 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 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
  */
- 
-public class PushbackReader extends FilterReader
+
+/**
+  * 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)
+{
+  this(in, DEFAULT_BUFFER_SIZE);
+}
+
+/*************************************************************************/
+
+/**
+  * 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
 {
-  /* Internal buffer array for data. */
-  private char[] buf;
-
-  /* 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)
+  synchronized (lock)
     {
       buf = null;
       super.close();
     }
-  }
+}
+
+/*************************************************************************/
+
+/**
+  * 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);
 
-  public boolean markSupported()
-  {
-    return false;
-  }
+      return(chars_discarded + chars_skipped);
+    } // synchronized
+}
+
+/*************************************************************************/
 
-  public int read() throws IOException
-  {
-    synchronized (lock)
+/**
+  * 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();
+	throw new IOException("stream closed");
+      if (pos == 0)
+	throw new IOException("Pushback buffer is full");
 
-      if (buf.length - pos > 0)
-        return true;
-
-      return super.ready();
-    }
-  }
+      --pos;
+      buf[pos] = (char)(b & 0xFFFF);
+    } // synchronized
+}
 
-  public void unread(int b) throws IOException
-  {
-    synchronized (lock)
-    {
-      if (buf == null || pos <= 0)
-        throw new IOException();
+/*************************************************************************/
 
-      buf[--pos] = (char) b;
-    }
-  }
+/**
+  * 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);
+}
 
-  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
diff --git a/libjava/java/lang/Character.java b/libjava/java/lang/Character.java
index 2695b04..cdb3957 100644
--- a/libjava/java/lang/Character.java
+++ b/libjava/java/lang/Character.java
@@ -284,4 +284,208 @@ public final class Character implements Serializable, Comparable
 
   // 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
+    };
+  }
 }
diff --git a/libjava/java/lang/Double.java b/libjava/java/lang/Double.java
index 10e9093..8de429e 100644
--- a/libjava/java/lang/Double.java
+++ b/libjava/java/lang/Double.java
@@ -18,7 +18,7 @@ package java.lang;
  * 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 final class Double extends Number
   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);
+  }
+}
diff --git a/libjava/java/lang/Float.java b/libjava/java/lang/Float.java
index b5939de..5733752 100644
--- a/libjava/java/lang/Float.java
+++ b/libjava/java/lang/Float.java
@@ -18,7 +18,7 @@ package java.lang;
  * 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 final class Float extends Number
 
   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);
+  }
+}
diff --git a/libjava/java/lang/Math.java b/libjava/java/lang/Math.java
index 0b9ae21..8e33112 100644
--- a/libjava/java/lang/Math.java
+++ b/libjava/java/lang/Math.java
@@ -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.
 
@@ -110,6 +110,16 @@ public final class Math
 
   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 ()
   {
diff --git a/libjava/java/util/Arrays.java b/libjava/java/util/Arrays.java
index fc51d38..b97f457 100644
--- a/libjava/java/util/Arrays.java
+++ b/libjava/java/util/Arrays.java
@@ -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 @@ 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
@@ -36,17 +36,20 @@ package java.util;
  * 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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    *
    * @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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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;
     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 @@ public class Arrays {
    *
    * @param a the array to sort
    */
-  public static void sort(char[] a) {
+  public static void sort(char[]a)
+  {
     qsort(a, 0, a.length);
   }
 
-  private static int cmp(char i, char j) {
-    return i-j;
+  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 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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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;
     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 @@ public class Arrays {
    *
    * @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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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;
     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 @@ public class Arrays {
    *
    * @param a the array to sort
    */
-  public static void sort(float[] a) {
+  public static void sort(float[]a)
+  {
     qsort(a, 0, a.length);
   }
 
-  private static float cmp(float i, float j) {
-    return i-j;
+  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 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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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 @@ public class Arrays {
    *
    * @param a the array to sort
    */
-  public static void sort(int[] a) {
+  public static void sort(int[]a)
+  {
     qsort(a, 0, a.length);
   }
 
-  private static long cmp(int i, int j) {
-    return (long)i-(long)j;
+  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 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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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 @@ public class Arrays {
    *
    * @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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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 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 @@ public class Arrays {
    *
    * @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;
-    }
-
-    int pm = n/2;       // small arrays, middle element
-    if (n > 7) {
-      int pl = start;
-      int pn = start + n-1;
+    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 > 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;
     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 @@ public class Arrays {
    * 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 @@ public class Arrays {
 	    // 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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    *   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 @@ public class Arrays {
    * @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 @@ public class Arrays {
    * 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 @@ public class Arrays {
 
     private Object[] a;
   }
-    
 }