--- /dev/null
+/* FilterInputStream.java -- Base class for classes that filter input
+ Copyright (C) 1998, 1999, 2001, 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+//package java.io;
+
+/* 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 common superclass of all standard classes that filter
+ * input. It acts as a layer on top of an underlying <code>InputStream</code>
+ * and simply redirects calls made to it to the subordinate InputStream
+ * instead. Subclasses of this class perform additional filtering
+ * functions in addition to simply redirecting the call.
+ * <p>
+ * This class is not abstract. However, since it only redirects calls
+ * to a subordinate <code>InputStream</code> without adding any functionality
+ * on top of it, this class should not be used directly. Instead, various
+ * subclasses of this class should be used. This is enforced with a
+ * protected constructor. Do not try to hack around it.
+ * <p>
+ * When creating a subclass of <code>FilterInputStream</code>, override the
+ * appropriate methods to implement the desired filtering. However, note
+ * that the <code>read(byte[])</code> method does not need to be overridden
+ * as this class redirects calls to that method to
+ * <code>read(byte[], int, int)</code> instead of to the subordinate
+ * <code>InputStream read(byte[])</code> method.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Warren Levy (warrenl@cygnus.com)
+ */
+@LATTICE("IN<T")
+@METHODDEFAULT("OUT<IN,THISLOC=OUT,GLOBALLOC=OUT")
+public class FilterInputStream extends InputStream
+{
+ /**
+ * This is the subordinate <code>InputStream</code> to which method calls
+ * are redirected
+ */
+ @LOC("IN") protected InputStream in;
+
+ /**
+ * Create a <code>FilterInputStream</code> with the specified subordinate
+ * <code>InputStream</code>.
+ *
+ * @param in The subordinate <code>InputStream</code>
+ */
+ protected FilterInputStream(@LOC("IN") InputStream in)
+ {
+ this.in = in;
+ }
+
+ /**
+ * Calls the <code>in.mark(int)</code> method.
+ *
+ * @param readlimit The parameter passed to <code>in.mark(int)</code>
+ */
+ public void mark(@LOC("IN") int readlimit)
+ {
+ in.mark(readlimit);
+ }
+
+ /**
+ * Calls the <code>in.markSupported()</code> method.
+ *
+ * @return <code>true</code> if mark/reset is supported, <code>false</code>
+ * otherwise
+ */
+ @RETURNLOC("OUT")
+ public boolean markSupported()
+ {
+ return in.markSupported();
+ }
+
+ /**
+ * Calls the <code>in.reset()</code> method.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void reset() throws IOException
+ {
+ in.reset();
+ }
+
+ /**
+ * Calls the <code>in.available()</code> method.
+ *
+ * @return The value returned from <code>in.available()</code>
+ *
+ * @exception IOException If an error occurs
+ */
+ public int available() throws IOException
+ {
+ return in.available();
+ }
+
+ /**
+ * Calls the <code>in.skip(long)</code> method
+ *
+ * @param numBytes The requested number of bytes to skip.
+ *
+ * @return The value returned from <code>in.skip(long)</code>
+ *
+ * @exception IOException If an error occurs
+ */
+
+ public long skip(long numBytes) throws IOException
+ {
+ return in.skip(numBytes);
+ }
+
+ /**
+ * Calls the <code>in.read()</code> method
+ *
+ * @return The value returned from <code>in.read()</code>
+ *
+ * @exception IOException If an error occurs
+ */
+
+ @RETURNLOC("OUT")
+ public int read() throws IOException
+ {
+ return in.read();
+ }
+
+ /**
+ * Calls the <code>read(byte[], int, int)</code> overloaded method.
+ * Note that
+ * this method does not redirect its call directly to a corresponding
+ * method in <code>in</code>. This allows subclasses to override only the
+ * three argument version of <code>read</code>.
+ *
+ * @param buf The buffer to read bytes into
+ *
+ * @return The value retured from <code>in.read(byte[], int, int)</code>
+ *
+ * @exception IOException If an error occurs
+ */
+
+ public int read(byte[] buf) throws IOException
+ {
+ return read(buf, 0, buf.length);
+ }
+
+ /**
+ * Calls the <code>in.read(byte[], int, int)</code> method.
+ *
+ * @param buf The buffer to read bytes into
+ * @param offset The index into the buffer to start storing bytes
+ * @param len The maximum number of bytes to read.
+ *
+ * @return The value retured from <code>in.read(byte[], int, int)</code>
+ *
+ * @exception IOException If an error occurs
+ */
+
+ @RETURNLOC("OUT")
+ public int read(@LOC("OUT") byte[] buf, @LOC("IN") int offset, @LOC("IN") int len) throws IOException
+ {
+ return in.read(buf, offset, len);
+ }
+
+ /**
+ * This method closes the input stream by closing the input stream that
+ * this object is filtering. Future attempts to access this stream may
+ * throw an exception.
+ *
+ * @exception IOException If an error occurs
+ */
+
+ public void close() throws IOException
+ {
+ in.close();
+ }
+}
--- /dev/null
+/* InputStream.java -- Base class for input
+ Copyright (C) 1998, 1999, 2001, 2004, 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+//removed because no packages
+//package java.io;
+
+/**
+ * This abstract class forms the base of the hierarchy of classes that read
+ * input as a stream of bytes. It provides a common set of methods for
+ * reading bytes from streams. Subclasses implement and extend these
+ * methods to read bytes from a particular input source such as a file
+ * or network connection.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Warren Levy (warrenl@cygnus.com)
+ */
+@LATTICE("")
+@METHODDEFAULT("OUT<IN,THISLOC=IN,GLOBALLOC=IN")
+public abstract class InputStream
+{
+ /**
+ * Default, no-arg, public constructor
+ */
+ public InputStream()
+ {
+ }
+
+ /**
+ * This method returns the number of bytes that can be read from this
+ * stream before a read can block. A return of 0 indicates that blocking
+ * might (or might not) occur on the very next read attempt.
+ * <p>
+ * This method always returns 0 in this class
+ *
+ * @return The number of bytes that can be read before blocking could occur
+ *
+ * @exception IOException If an error occurs
+ */
+ @RETURNLOC("")
+ public int available() throws IOException
+ {
+ return 0;
+ }
+
+ /**
+ * This method closes the stream. Any futher attempts to read from the
+ * stream may generate an <code>IOException</code>
+ * <p>
+ * This method does nothing in this class, but subclasses may override
+ * this method in order to provide additional functionality.
+ *
+ * @exception IOException If an error occurs, which can only happen
+ * in a subclass
+ */
+ public void close() throws IOException
+ {
+ // Do nothing
+ }
+
+ /**
+ * This method marks a position in the input to which the stream can
+ * be "reset" by calling the <code>reset()</code> method. The
+ * parameter @code{readlimit} is the number of bytes that can be read
+ * from the stream after setting the mark before the mark becomes
+ * invalid. For example, if <code>mark()</code> is called with a
+ * read limit of 10, then when 11 bytes of data are read from the
+ * stream before the <code>reset()</code> method is called, then the
+ * mark is invalid and the stream object instance is not required to
+ * remember the mark.
+ * <p>
+ * This method does nothing in this class, but subclasses may override it
+ * to provide mark/reset functionality.
+ *
+ * @param readLimit The number of bytes that can be read before the
+ * mark becomes invalid
+ */
+ public void mark(@LOC("IN") int readLimit)
+ {
+ // Do nothing
+ }
+
+ /**
+ * This method returns a boolean that indicates whether the mark/reset
+ * methods are supported in this class. Those methods can be used to
+ * remember a specific point in the stream and reset the stream to that
+ * point.
+ * <p>
+ * This method always returns <code>false</code> in this class, but
+ * subclasses can override this method to return <code>true</code>
+ * if they support mark/reset functionality.
+ *
+ * @return <code>true</code> if mark/reset functionality is
+ * supported, <code>false</code> otherwise
+ */
+ @RETURN
+ public boolean markSupported()
+ {
+ return false;
+ }
+
+ /**
+ * This method reads an unsigned byte from the input stream and returns it
+ * as an int in the range of 0-255. This method also will return -1 if
+ * the end of the stream has been reached.
+ * <p>
+ * This method will block until the byte can be read.
+ *
+ * @return The byte read or -1 if end of stream
+ *
+ * @exception IOException If an error occurs
+ */
+ public abstract int read() throws IOException;
+
+ /**
+ * This method reads bytes from a stream and stores them into a caller
+ * supplied buffer. This method attempts to completely fill the buffer,
+ * but can return before doing so. The actual number of bytes 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 operates by calling an overloaded read method like so:
+ * <code>read(b, 0, b.length)</code>
+ *
+ * @param b The buffer into which the bytes read will be stored.
+ *
+ * @return The number of bytes read or -1 if end of stream.
+ *
+ * @exception IOException If an error occurs.
+ */
+ @RETURN
+ public int read(@LOC("IN") byte[] b) throws IOException
+ {
+ return read(b, 0, b.length);
+ }
+
+ /**
+ * This method read bytes from a stream and stores them into a
+ * caller supplied buffer. It starts storing the data at index
+ * <code>off</code> into the buffer and attempts to read
+ * <code>len</code> bytes. This method can return before reading the
+ * number of bytes requested. The actual number of bytes 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 operates by calling the single byte <code>read()</code> method
+ * in a loop until the desired number of bytes are read. The read loop
+ * stops short if the end of the stream is encountered or if an IOException
+ * is encountered on any read operation except the first. If the first
+ * attempt to read a bytes fails, the IOException is allowed to propagate
+ * upward. And subsequent IOException is caught and treated identically
+ * to an end of stream condition. Subclasses can (and should if possible)
+ * override this method to provide a more efficient implementation.
+ *
+ * @param b The array into which the bytes read should be stored
+ * @param off The offset into the array to start storing bytes
+ * @param len The requested number of bytes to read
+ *
+ * @return The actual number of bytes read, or -1 if end of stream.
+ *
+ * @exception IOException If an error occurs.
+ */
+ @LATTICE("OUT<")
+ @RETURN("")
+ public int read(byte[] b, int off, int len) throws IOException
+ {
+ if (off < 0 || len < 0 || b.length - off < len)
+ throw new IndexOutOfBoundsException();
+
+ int i, ch;
+
+ for (i = 0; i < len; ++i)
+ try
+ {
+ if ((ch = read()) < 0)
+ return i == 0 ? -1 : i; // EOF
+ b[off + i] = (byte) ch;
+ }
+ catch (IOException ex)
+ {
+ // Only reading the first byte should cause an IOException.
+ if (i == 0)
+ throw ex;
+ return i;
+ }
+
+ return i;
+ }
+
+ /**
+ * This method resets a stream to the point where the
+ * <code>mark()</code> method was called. Any bytes that were read
+ * after the mark point was set will be re-read during subsequent
+ * reads.
+ * <p>
+ * This method always throws an IOException in this class, but subclasses
+ * can override this method if they provide mark/reset functionality.
+ *
+ * @exception IOException Always thrown for this class
+ */
+ public void reset() throws IOException
+ {
+ throw new IOException("mark/reset not supported");
+ }
+
+ /**
+ * This method skips the specified number of bytes in the stream. It
+ * returns the actual number of bytes skipped, which may be less than the
+ * requested amount.
+ * <p>
+ * This method reads and discards bytes into a byte array until the
+ * specified number of bytes were skipped or until either the end of stream
+ * is reached or a read attempt returns a short count. Subclasses can
+ * override this metho to provide a more efficient implementation where
+ * one exists.
+ *
+ * @param n The requested number of bytes to skip
+ *
+ * @return The actual number of bytes skipped.
+ *
+ * @exception IOException If an error occurs
+ */
+ public long skip(long n) throws IOException
+ {
+ // Throw away n bytes by reading them into a temp byte[].
+ // Limit the temp array to 2Kb so we don't grab too much memory.
+ final int buflen = n > 2048 ? 2048 : (int) n;
+ byte[] tmpbuf = new byte[buflen];
+ final long origN = n;
+
+ while (n > 0L)
+ {
+ int numread = read(tmpbuf, 0, n > buflen ? buflen : (int) n);
+ if (numread <= 0)
+ break;
+ n -= numread;
+ }
+
+ return origN - n;
+ }
+}
--- /dev/null
+@LATTICE("B<T")
+@METHODDEFAULT("OUT<IN")
+public class Math {
+ @LOC("T") static final double PI=3.14159265358979323846;
+
+ // an alias for setPI()
+ public static double PI() {
+ double PI = 3.14159265358979323846;
+ return PI;
+ }
+
+ public static int abs(int x) {
+ return (x<0)?-x:x;
+ }
+
+ public static long abs(long x) {
+ return (x<0)?-x:x;
+ }
+
+ public static double abs(double x) {
+ return (x<0)?-x:x;
+ }
+
+ public static float abs(float x) {
+ return (x<0)?-x:x;
+ }
+
+ public static double max(double a, double b) {
+ return (a>b)?a:b;
+ }
+
+ public static float max(float a, float b) {
+ return (a>b)?a:b;
+ }
+
+ public static int max(int a, int b) {
+ return (a>b)?a:b;
+ }
+
+ public static long max(long a, long b) {
+ return (a>b)?a:b;
+ }
+
+ public static double min(double a, double b) {
+ return (a<b)?a:b;
+ }
+
+ @RETURNLOC("IN")
+ public static float min(@LOC("IN") float a, @LOC("IN") float b) {
+ return (a<b)?a:b;
+ }
+
+ @RETURNLOC("IN")
+ public static int min(@LOC("IN") int a, @LOC("IN") int b) {
+ return (a<b)?a:b;
+ }
+
+ @RETURNLOC("IN")
+ public static long min(@LOC("IN") long a, @LOC("IN") long b) {
+ return (a<b)?a:b;
+ }
+
+ /** sqrt(a^2 + b^2) without under/overflow. **/
+ public static double hypot(double a, double b) {
+ double r;
+ if (abs(a) > abs(b)) {
+ r = b/a;
+ r = abs(a)*sqrt(1+r*r);
+ } else if (b != 0) {
+ r = a/b;
+ r = abs(b)*sqrt(1+r*r);
+ } else {
+ r = 0.0;
+ }
+ return r;
+ }
+
+ public static double rint(double x) {
+ double y = ceil(x);
+ double d = y - x;
+ if( d == 0.5 ) {
+ if( ((int)y)%2 == 0 ) {
+ return y;
+ } else {
+ return y - 1.0;
+ }
+ } else if( d < 0.5 ) {
+ return y;
+ }
+ return y - 1.0;
+ }
+
+ public static native double sin(double a);
+ public static native double cos(double a);
+ public static native double asin(double a);
+ public static native double acos(double a);
+ public static native double tan(double a);
+ public static native double atan(double a);
+ public static native double atan2(double a, double b);
+ public static native double exp(double a);
+ public static native double sqrt(double a);
+ public static native double log(double a);
+ public static native double pow(double a, double b);
+
+ public static native double ceil(double a);
+ public static native double floor(double a);
+
+ public static native float sinf(float a);
+ public static native float cosf(float a);
+ public static native float expf(float a);
+ public static native float sqrtf(float a);
+ public static native float logf(float a);
+ public static native float powf(float a, float b);
+ public static native float ceilf(float a);
+ public static native float IEEEremainder(float f1, float f2);
+}
projects / IRC.git / commitdiff