mirror of
https://gcc.gnu.org/git/gcc.git
synced 2024-11-28 06:14:10 +08:00
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
This commit is contained in:
Tom Tromey
parent
dd3b81b421
commit
98182da528
@ -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.
|
||||
*/
|
||||
/* 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 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
|
||||
{
|
||||
/* Internal buffer array for data. */
|
||||
private char[] buf;
|
||||
|
||||
/* The current position in the buffer. */
|
||||
private int pos;
|
||||
/*************************************************************************/
|
||||
|
||||
public PushbackReader(Reader in)
|
||||
{
|
||||
this(in, 1);
|
||||
}
|
||||
/*
|
||||
* Class Variables
|
||||
*/
|
||||
|
||||
public PushbackReader(Reader in, int size)
|
||||
{
|
||||
super(in);
|
||||
if (size < 0)
|
||||
throw new IllegalArgumentException();
|
||||
buf = new char[size];
|
||||
pos = buf.length;
|
||||
}
|
||||
/**
|
||||
* This is the default buffer size
|
||||
*/
|
||||
private static final int DEFAULT_BUFFER_SIZE = 1;
|
||||
|
||||
public void close() throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* Instance Variables
|
||||
*/
|
||||
|
||||
/**
|
||||
* This is the buffer that is used to store the pushed back data
|
||||
*/
|
||||
private char[] buf;
|
||||
|
||||
/**
|
||||
* This is the position in the buffer from which the next char will be
|
||||
* read. Bytes are stored in reverse order in the buffer, starting from
|
||||
* <code>buf[buf.length - 1]</code> to <code>buf[0]</code>. Thus when
|
||||
* <code>pos</code> is 0 the buffer is full and <code>buf.length</code> when
|
||||
* it is empty
|
||||
*/
|
||||
private int pos;
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* Constructors
|
||||
*/
|
||||
|
||||
/**
|
||||
* This method initializes a <code>PushbackReader</code> to read from the
|
||||
* specified subordinate <code>Reader</code> with a default pushback buffer
|
||||
* size of 1.
|
||||
*
|
||||
* @code in The subordinate stream to read from
|
||||
*/
|
||||
public
|
||||
PushbackReader(Reader in)
|
||||
{
|
||||
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
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
buf = null;
|
||||
super.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public boolean markSupported()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/*************************************************************************/
|
||||
|
||||
public int read() throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
/**
|
||||
* This method throws an exception when called since this class does
|
||||
* not support mark/reset.
|
||||
*
|
||||
* @param read_limit Not used.
|
||||
*
|
||||
* @exception IOException Always thrown to indicate mark/reset not supported.
|
||||
*/
|
||||
public void
|
||||
mark(int read_limit) throws IOException
|
||||
{
|
||||
throw new IOException("mark not supported in this class");
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method returns <code>false</code> to indicate that it does not support
|
||||
* mark/reset functionality.
|
||||
*
|
||||
* @return This method returns <code>false</code> to indicate that this class does not support mark/reset functionality
|
||||
*
|
||||
*/
|
||||
public boolean
|
||||
markSupported()
|
||||
{
|
||||
return(false);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method always throws an IOException in this class because
|
||||
* mark/reset functionality is not supported.
|
||||
*
|
||||
* @exception IOException Always thrown for this class
|
||||
*/
|
||||
public void
|
||||
reset() throws IOException
|
||||
{
|
||||
throw new IOException("reset not supported in this class");
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method determines whether or not this stream is ready to be read.
|
||||
* If it returns <code>false</code> to indicate that the stream is not
|
||||
* ready, any attempt to read from the stream could (but is not
|
||||
* guaranteed to) block.
|
||||
* <p>
|
||||
* This stream is ready to read if there are either chars waiting to be
|
||||
* read in the pushback buffer or if the underlying stream is ready to
|
||||
* be read.
|
||||
*
|
||||
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public boolean
|
||||
ready() throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
if (buf == null)
|
||||
throw new IOException();
|
||||
throw new IOException ("stream closed");
|
||||
|
||||
if (pos < buf.length)
|
||||
return ((int) buf[pos++]) & 0xFFFF;
|
||||
|
||||
return super.read();
|
||||
if (((buf.length - pos) > 0) || super.ready())
|
||||
return(true);
|
||||
else
|
||||
return(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int read(char[] b, int off, int len) throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
/*************************************************************************/
|
||||
|
||||
// Don't delete this method just because the spec says it shouldn't be there!
|
||||
// See the CVS log for details.
|
||||
/**
|
||||
* This method skips the specified number of chars in the stream. It
|
||||
* returns the actual number of chars skipped, which may be less than the
|
||||
* requested amount.
|
||||
* <p>
|
||||
* This method first discards chars from the buffer, then calls the
|
||||
* <code>skip</code> method on the underlying <code>Reader</code> to
|
||||
* skip additional chars if necessary.
|
||||
*
|
||||
* @param num_chars The requested number of chars to skip
|
||||
*
|
||||
* @return The actual number of chars skipped.
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public long
|
||||
skip(long num_chars) throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
if (num_chars <= 0)
|
||||
return(0);
|
||||
|
||||
if ((buf.length - pos) >= num_chars)
|
||||
{
|
||||
pos += num_chars;
|
||||
return(num_chars);
|
||||
}
|
||||
|
||||
int chars_discarded = buf.length - pos;
|
||||
pos = buf.length;
|
||||
|
||||
long chars_skipped = in.skip(num_chars - chars_discarded);
|
||||
|
||||
return(chars_discarded + chars_skipped);
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method reads an unsigned char from the input stream and returns it
|
||||
* as an int in the range of 0-65535. This method also will return -1 if
|
||||
* the end of the stream has been reached. The char returned will be read
|
||||
* from the pushback buffer, unless the buffer is empty, in which case
|
||||
* the char will be read from the underlying stream.
|
||||
* <p>
|
||||
* This method will block until the char can be read.
|
||||
*
|
||||
* @return The char read or -1 if end of stream
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public int
|
||||
read() throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
if (buf == null)
|
||||
throw new IOException();
|
||||
throw new IOException("stream closed");
|
||||
|
||||
if (off < 0 || len < 0 || off + len > b.length)
|
||||
if (pos == buf.length)
|
||||
return(super.read());
|
||||
|
||||
++pos;
|
||||
return((buf[pos - 1] & 0xFFFF));
|
||||
}
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* 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("stream closed");
|
||||
|
||||
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;
|
||||
--pos;
|
||||
buf[pos] = (char)(b & 0xFFFF);
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
return super.ready();
|
||||
}
|
||||
}
|
||||
/*************************************************************************/
|
||||
|
||||
public void unread(int b) throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
/**
|
||||
* 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);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* 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 <= 0)
|
||||
throw new IOException();
|
||||
|
||||
buf[--pos] = (char) b;
|
||||
}
|
||||
}
|
||||
|
||||
public void unread(char[] b) throws IOException
|
||||
{
|
||||
unread(b, 0, b.length);
|
||||
}
|
||||
|
||||
public void unread(char[] b, int off, int len) throws IOException
|
||||
{
|
||||
synchronized (lock)
|
||||
{
|
||||
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
|
||||
|
||||
@ -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
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -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 ()
|
||||
{
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
48
libjava/scripts/blocks.pl
Normal file
48
libjava/scripts/blocks.pl
Normal file
@ -0,0 +1,48 @@
|
||||
#! /usr/bin/perl
|
||||
|
||||
if ($ARGV[0] eq '')
|
||||
{
|
||||
$file = 'Blocks.txt';
|
||||
if (! -f $file)
|
||||
{
|
||||
# Too painful to figure out how to get Perl to do it.
|
||||
# FIXME.
|
||||
system 'wget -o .wget-log http://www.isi.edu/in-notes/iana/unidata/Blocks.txt';
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
$file = $ARGV[0];
|
||||
}
|
||||
|
||||
open (INPUT, "< $file") || die "couldn't open $file: $!";
|
||||
|
||||
@array = ();
|
||||
while (<INPUT>)
|
||||
{
|
||||
next if /^#/;
|
||||
chop;
|
||||
|
||||
($start, $to, $text) = split (/; /);
|
||||
($symbol = $text) =~ tr/a-z/A-Z/;
|
||||
$symbol =~ s/[- ]/_/g;
|
||||
|
||||
# Special case for one of the SPECIALS.
|
||||
next if $start eq 'FEFF';
|
||||
|
||||
printf " public static final UnicodeBlock %s = new UnicodeBlock (\"%s\", '\\u%s', '\\u%s');\n",
|
||||
$symbol, $text, $start, $to;
|
||||
|
||||
push (@array, $symbol);
|
||||
}
|
||||
|
||||
printf " private static final UnicodeBlock[] blocks = {\n";
|
||||
foreach (@array)
|
||||
{
|
||||
printf " %s", $_;
|
||||
printf "," unless $_ eq 'SPECIALS';
|
||||
printf "\n";
|
||||
}
|
||||
printf " };\n";
|
||||
|
||||
close (INPUT);
|
||||
Loading…
Reference in New Issue
Block a user