--- /dev/null
+/* BufferedInputStream.java -- An input stream that implements buffering
+ 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. */
+
+
+/* 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>FilterInputStream</code> buffers input from an
+ * underlying implementation to provide a possibly more efficient read
+ * mechanism. It maintains the buffer and buffer state in instance
+ * variables that are available to subclasses. The default buffer size
+ * of 2048 bytes can be overridden by the creator of the stream.
+ * <p>
+ * This class also implements mark/reset functionality. It is capable
+ * of remembering any number of input bytes, to the limits of
+ * system memory or the size of <code>Integer.MAX_VALUE</code>
+ * <p>
+ * Please note that this class does not properly handle character
+ * encodings. Consider using the <code>BufferedReader</code> class which
+ * does.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Warren Levy (warrenl@cygnus.com)
+ * @author Jeroen Frijters (jeroen@frijters.net)
+ */
+@LATTICE("BUF<C")
+@METHODDEFAULT("D<IN,D<C,THISLOC=D")
+public class BufferedInputStream extends FilterInputStream
+{
+
+ /**
+ * This is the default buffer size
+ */
+ private static final int DEFAULT_BUFFER_SIZE = 2048; // by default, it is TOP
+
+ /**
+ * The buffer used for storing data from the underlying stream.
+ */
+ @LOC("BUF") protected byte[] buf;
+
+ /**
+ * The number of valid bytes currently in the buffer. It is also the index
+ * of the buffer position one byte past the end of the valid data.
+ */
+ @LOC("C") protected int count;
+
+ /**
+ * The index of the next character that will by read from the buffer.
+ * When <code>pos == count</code>, the buffer is empty.
+ */
+ @LOC("C") protected int pos;
+
+ /**
+ * The value of <code>pos</code> when the <code>mark()</code> method was
+ * called.
+ * This is set to -1 if there is no mark set.
+ */
+ @LOC("C") protected int markpos = -1;
+
+ /**
+ * This is the maximum number of bytes than can be read after a
+ * call to <code>mark()</code> before the mark can be discarded.
+ * After this may bytes are read, the <code>reset()</code> method
+ * may not be called successfully.
+ */
+ protected int marklimit;
+
+ /**
+ * This is the initial buffer size. When the buffer is grown because
+ * of marking requirements, it will be grown by bufferSize increments.
+ * The underlying stream will be read in chunks of bufferSize.
+ */
+ private final int bufferSize;
+
+ /**
+ * This method initializes a new <code>BufferedInputStream</code> that will
+ * read from the specified subordinate stream with a default buffer size
+ * of 2048 bytes
+ *
+ * @param in The subordinate stream to read from
+ */
+ public BufferedInputStream(InputStream in)
+ {
+ this(in, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * This method initializes a new <code>BufferedInputStream</code> that will
+ * read from the specified subordinate stream with a buffer size that
+ * is specified by the caller.
+ *
+ * @param in The subordinate stream to read from
+ * @param size The buffer size to use
+ *
+ * @exception IllegalArgumentException when size is smaller then 1
+ */
+ public BufferedInputStream(InputStream in, int size)
+ {
+ super(in);
+ if (size <= 0)
+ throw new IllegalArgumentException();
+ buf = new byte[size];
+ // initialize pos & count to bufferSize, to prevent refill from
+ // allocating a new buffer (if the caller starts out by calling mark()).
+ pos = count = bufferSize = size;
+ }
+
+ /**
+ * 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>
+ * The number of available bytes will be the number of read ahead bytes
+ * stored in the internal buffer plus the number of available bytes in
+ * the underlying stream.
+ *
+ * @return The number of bytes that can be read before blocking could occur
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized int available() throws IOException
+ {
+ return count - pos + super.available();
+ }
+
+ /**
+ * This method closes the underlying input stream and frees any
+ * resources associated with it. Sets <code>buf</code> to <code>null</code>.
+ *
+ * @exception IOException If an error occurs.
+ */
+ public void close() throws IOException
+ {
+ // Free up the array memory.
+ buf = null;
+ pos = count = 0;
+ markpos = -1;
+ super.close();
+ }
+
+ /**
+ * 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</code> 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>
+ * Note that the number of bytes that can be remembered by this method
+ * can be greater than the size of the internal read buffer. It is also
+ * not dependent on the subordinate stream supporting mark/reset
+ * functionality.
+ *
+ * @param readlimit The number of bytes that can be read before the mark
+ * becomes invalid
+ */
+ public synchronized void mark(@LOC("IN") int readlimit)
+ {
+ marklimit = readlimit;
+ markpos = pos;
+ }
+
+ /**
+ * This method returns <code>true</code> to indicate that this class
+ * supports mark/reset functionality.
+ *
+ * @return <code>true</code> to indicate that mark/reset functionality is
+ * supported
+ *
+ */
+ public boolean markSupported()
+ {
+ return true;
+ }
+
+ /**
+ * 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 synchronized int read() throws IOException
+ {
+ if (pos >= count && !refill())
+ return -1; // EOF
+
+ return buf[pos++] & 0xFF;
+ }
+
+ /**
+ * This method reads 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, but it will try
+ * to read the requested number of bytes by repeatedly calling the underlying
+ * stream as long as available() for this stream continues to return a
+ * non-zero value (or until the requested number of bytes have been read).
+ * 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.
+ *
+ * @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.
+ * @exception IndexOutOfBoundsException when <code>off</code> or
+ * <code>len</code> are negative, or when <code>off + len</code>
+ * is larger then the size of <code>b</code>,
+ */
+ public synchronized int read(byte[] b, int off, int len) throws IOException
+ {
+ if (off < 0 || len < 0 || b.length - off < len)
+ throw new IndexOutOfBoundsException();
+
+ if (len == 0)
+ return 0;
+
+ if (pos >= count && !refill())
+ return -1; // No bytes were read before EOF.
+
+ int totalBytesRead = Math.min(count - pos, len);
+ System.arraycopy(buf, pos, b, off, totalBytesRead);
+ pos += totalBytesRead;
+ off += totalBytesRead;
+ len -= totalBytesRead;
+
+ while (len > 0 && super.available() > 0 && refill())
+ {
+ int remain = Math.min(count - pos, len);
+ System.arraycopy(buf, pos, b, off, remain);
+ pos += remain;
+ off += remain;
+ len -= remain;
+ totalBytesRead += remain;
+ }
+
+ return totalBytesRead;
+ }
+
+ /**
+ * 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 will throw an IOException if the number of bytes read from
+ * the stream since the call to <code>mark()</code> exceeds the mark limit
+ * passed when establishing the mark.
+ *
+ * @exception IOException If <code>mark()</code> was never called or more
+ * then <code>marklimit</code> bytes were read since the last
+ * call to <code>mark()</code>
+ */
+ public synchronized void reset() throws IOException
+ {
+ if (markpos == -1)
+ throw new IOException(buf == null ? "Stream closed." : "Invalid mark.");
+
+ pos = markpos;
+ }
+
+ /**
+ * 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.
+ *
+ * @param n The requested number of bytes to skip
+ *
+ * @return The actual number of bytes skipped.
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized long skip(long n) throws IOException
+ {
+ if (buf == null)
+ throw new IOException("Stream closed.");
+
+ final long origN = n;
+
+ while (n > 0L)
+ {
+ if (pos >= count && !refill())
+ break;
+
+ int numread = (int) Math.min((long) (count - pos), n);
+ pos += numread;
+ n -= numread;
+ }
+
+ return origN - n;
+ }
+
+ /**
+ * Called to refill the buffer (when count is equal to pos).
+ *
+ * @return <code>true</code> when at least one additional byte was read
+ * into <code>buf</code>, <code>false</code> otherwise (at EOF).
+ */
+ private boolean refill() throws IOException
+ {
+ if (buf == null)
+ throw new IOException("Stream closed.");
+
+ if (markpos == -1 || count - markpos >= marklimit)
+ {
+ markpos = -1;
+ pos = count = 0;
+ }
+ else
+ {
+ byte[] newbuf = buf;
+ if (markpos < bufferSize)
+ {
+ newbuf = new byte[count - markpos + bufferSize];
+ }
+ System.arraycopy(buf, markpos, newbuf, 0, count - markpos);
+ buf = newbuf;
+ count -= markpos;
+ pos -= markpos;
+ markpos = 0;
+ }
+
+ int numread = super.read(buf, count, bufferSize);
+
+ if (numread <= 0) // EOF
+ return false;
+
+ count += numread;
+ return true;
+ }
+}
--- /dev/null
+/* Exception.java -- generic exception thrown to indicate an exceptional
+ condition has occurred.
+ Copyright (C) 1998, 1999, 2001, 2002, 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.lang;
+
+/**
+ * The root class of all exceptions worth catching in a program. This
+ * includes the special category of <code>RuntimeException</code>, which
+ * does not need to be declared in a throws clause. Exceptions can be used
+ * to represent almost any exceptional behavior, such as programming errors,
+ * mouse movements, keyboard clicking, etc.
+ *
+ * @author Brian Jones
+ * @author Warren Levy (warrenl@cygnus.com)
+ * @author Eric Blake (ebb9@email.byu.edu)
+ * @status updated to 1.4
+ */
+public class Exception extends Throwable
+{
+ /**
+ * Compatible with JDK 1.0+.
+ */
+ private static final long serialVersionUID = -3387516993124229948L;
+
+ /**
+ * Create an exception without a message. The cause remains uninitialized.
+ *
+ * @see #initCause(Throwable)
+ */
+ public Exception()
+ {
+ }
+
+ /**
+ * Create an exception with a message. The cause remains uninitialized.
+ *
+ * @param s the message
+ * @see #initCause(Throwable)
+ */
+ public Exception(String s)
+ {
+ super(s);
+ }
+
+ /**
+ * Create an exception with a message and a cause.
+ *
+ * @param s the message string
+ * @param cause the cause of this error
+ * @since 1.4
+ */
+ public Exception(String s, Throwable cause)
+ {
+ super(s, cause);
+ }
+
+ /**
+ * Create an exception with a given cause, and a message of
+ * <code>cause == null ? null : cause.toString()</code>.
+ *
+ * @param cause the cause of this exception
+ * @since 1.4
+ */
+ public Exception(Throwable cause)
+ {
+ super(cause);
+ }
+}
--- /dev/null
+//import java.io.FileSystem;
+//import java.io.FilenameFilter;
+//import java.util.ArrayList;
+
+public class File {
+ String path;
+
+ public File(String path) {
+ this.path=path;
+ }
+
+ String getPath() {
+ return path;
+ }
+
+ long length() {
+ return nativeLength(path.getBytes());
+ }
+
+ private static native long nativeLength(byte[] pathname);
+}
--- /dev/null
+/* FilterOutputStream.java -- Parent class for output streams that filter
+ Copyright (C) 1998, 1999, 2001, 2003, 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
+ * Status: Complete to version 1.1.
+ */
+
+/**
+ * This class is the common superclass of output stream classes that
+ * filter the output they write. These classes typically transform the
+ * data in some way prior to writing it out to another underlying
+ * <code>OutputStream</code>. This class simply overrides all the
+ * methods in <code>OutputStream</code> to redirect them to the
+ * underlying stream. Subclasses provide actual filtering.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Tom Tromey (tromey@cygnus.com)
+ */
+public class FilterOutputStream extends OutputStream
+{
+ /**
+ * This is the subordinate <code>OutputStream</code> that this class
+ * redirects its method calls to.
+ */
+ protected OutputStream out;
+
+ /**
+ * This method initializes an instance of <code>FilterOutputStream</code>
+ * to write to the specified subordinate <code>OutputStream</code>.
+ *
+ * @param out The <code>OutputStream</code> to write to
+ */
+ public FilterOutputStream(OutputStream out)
+ {
+ this.out = out;
+ }
+
+ /**
+ * This method closes the underlying <code>OutputStream</code>. Any
+ * further attempts to write to this stream may throw an exception.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void close() //throws IOException
+ {
+ flush();
+ out.close();
+ }
+
+ /**
+ * This method attempt to flush all buffered output to be written to the
+ * underlying output sink.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void flush() //throws IOException
+ {
+ out.flush();
+ }
+
+ /**
+ * This method writes a single byte of output to the underlying
+ * <code>OutputStream</code>.
+ *
+ * @param b The byte to write, passed as an int.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write(int b) //throws IOException
+ {
+ out.write(b);
+ }
+
+ /**
+ * This method writes all the bytes in the specified array to the underlying
+ * <code>OutputStream</code>. It does this by calling the three parameter
+ * version of this method - <code>write(byte[], int, int)</code> in this
+ * class instead of writing to the underlying <code>OutputStream</code>
+ * directly. This allows most subclasses to avoid overriding this method.
+ *
+ * @param buf The byte array to write bytes from
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write(byte[] buf) //throws IOException
+ {
+ // Don't do checking here, per Java Lang Spec.
+ write(buf, 0, buf.length);
+ }
+
+ /**
+ * This method calls the <code>write(int)</code> method <code>len</code>
+ * times for all bytes from the array <code>buf</code> starting at index
+ * <code>offset</code>. Subclasses should overwrite this method to get a
+ * more efficient implementation.
+ *
+ * @param buf The byte array to write bytes from
+ * @param offset The index into the array to start writing bytes from
+ * @param len The number of bytes to write
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write(byte[] buf, int offset, int len) //throws IOException
+ {
+ // Don't do checking here, per Java Lang Spec.
+ for (int i=0; i < len; i++)
+ write(buf[offset + i]);
+
+ }
+
+} // class FilterOutputStream
+
--- /dev/null
+public class OutputStream {
+ public OutputStream() {
+ }
+
+ public void write(int ch) {
+ System.printString("Called unimplemented write(int)\n");
+ }
+
+ public void write(byte[] b) {
+ System.printString("Called unimplemented write(byte[])\n");
+ }
+
+ public void write(byte[] b, int off, int len) {
+ System.printString("Called unimplemented write(byte[],int,int)\n");
+ }
+
+ public void flush() {
+ }
+
+ public void close() {
+ System.printString("Called unimplemented close()\n");
+ }
+}
--- /dev/null
+/* PrintStream.java -- OutputStream for printing output
+ Copyright (C) 1998, 1999, 2001, 2003, 2004, 2005, 2006
+ 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;
+
+/*import java.util.Locale;
+import java.util.Formatter;
+
+import gnu.classpath.SystemProperties;
+*/
+/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
+ * "The Java Language Specification", ISBN 0-201-63451-1
+ * Status: Believed complete and correct to 1.3
+ */
+
+/**
+ * This class prints Java primitive values and object to a stream as
+ * text. None of the methods in this class throw an exception. However,
+ * errors can be detected by calling the <code>checkError()</code> method.
+ * Additionally, this stream can be designated as "autoflush" when
+ * created so that any writes are automatically flushed to the underlying
+ * output sink when the current line is terminated.
+ * <p>
+ * This class converts char's into byte's using the system default encoding.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ * @author Tom Tromey (tromey@cygnus.com)
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ */
+public class PrintStream extends FilterOutputStream //implements Appendable
+{
+ /* Notice the implementation is quite similar to OutputStreamWriter.
+ * This leads to some minor duplication, because neither inherits
+ * from the other, and we want to maximize performance. */
+
+ // Line separator string.
+ private static final char[] line_separator
+ = {'\n'}/*SystemProperties.getProperty("line.separator", "\n").toCharArray()*/;
+
+ /**
+ * Encoding name
+ */
+ private final String encoding;
+
+ /**
+ * This boolean indicates whether or not an error has ever occurred
+ * on this stream.
+ */
+ private boolean error_occurred = false;
+
+ /**
+ * This is <code>true</code> if auto-flush is enabled,
+ * <code>false</code> otherwise
+ */
+ private final boolean auto_flush;
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output File. Doesn't autoflush.
+ *
+ * @param file The <code>File</code> to write to.
+ * @throws FileNotFoundException if an error occurs while opening the file.
+ *
+ * @since 1.5
+ */
+ public PrintStream (File file)
+ //throws FileNotFoundException
+ {
+ this (new FileOutputStream(file), false);
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output File. Doesn't autoflush.
+ *
+ * @param file The <code>File</code> to write to.
+ * @param encoding The name of the character encoding to use for this
+ * object.
+ * @throws FileNotFoundException If an error occurs while opening the file.
+ * @throws UnsupportedEncodingException If the charset specified by
+ * <code>encoding</code> is invalid.
+ *
+ * @since 1.5
+ */
+ public PrintStream (File file, String encoding)
+ //throws FileNotFoundException,UnsupportedEncodingException
+ {
+ this (new FileOutputStream(file), false, encoding);
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output File. Doesn't autoflush.
+ *
+ * @param fileName The name of the <code>File</code> to write to.
+ * @throws FileNotFoundException if an error occurs while opening the file,
+ *
+ * @since 1.5
+ */
+ public PrintStream (String fileName)
+ //throws FileNotFoundException
+ {
+ this (new FileOutputStream(new File(fileName)), false);
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output File. Doesn't autoflush.
+ *
+ * @param fileName The name of the <code>File</code> to write to.
+ * @param encoding The name of the character encoding to use for this
+ * object.
+ * @throws FileNotFoundException if an error occurs while opening the file.
+ * @throws UnsupportedEncodingException If the charset specified by
+ * <code>encoding</code> is invalid.
+ *
+ * @since 1.5
+ */
+ public PrintStream (String fileName, String encoding)
+ //throws FileNotFoundException,UnsupportedEncodingException
+ {
+ this (new FileOutputStream(new File(fileName)), false, encoding);
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output sink. Doesn't autoflush.
+ *
+ * @param out The <code>OutputStream</code> to write to.
+ */
+ public PrintStream (OutputStream out)
+ {
+ this (out, false);
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output sink. This constructor also allows "auto-flush"
+ * functionality to be specified where the stream will be flushed after
+ * every <code>print</code> or <code>println</code> call, when the
+ * <code>write</code> methods with array arguments are called, or when a
+ * single new-line character is written.
+ * <p>
+ *
+ * @param out The <code>OutputStream</code> to write to.
+ * @param auto_flush <code>true</code> to flush the stream after every
+ * line, <code>false</code> otherwise
+ */
+ public PrintStream (OutputStream out, boolean auto_flush)
+ {
+ super (out);
+ /*String encoding;
+ try {
+ encoding = SystemProperties.getProperty("file.encoding");
+ } catch (SecurityException e){
+ encoding = "ISO8859_1";
+ } catch (IllegalArgumentException e){
+ encoding = "ISO8859_1";
+ } catch (NullPointerException e){
+ encoding = "ISO8859_1";
+ }*/
+ this.encoding = "ISO8859_1"; //encoding;
+ this.auto_flush = auto_flush;
+ }
+
+ /**
+ * This method initializes a new <code>PrintStream</code> object to write
+ * to the specified output sink. This constructor also allows "auto-flush"
+ * functionality to be specified where the stream will be flushed after
+ * every <code>print</code> or <code>println</code> call, when the
+ * <code>write</code> methods with array arguments are called, or when a
+ * single new-line character is written.
+ * <p>
+ *
+ * @param out The <code>OutputStream</code> to write to.
+ * @param auto_flush <code>true</code> to flush the stream after every
+ * line, <code>false</code> otherwise
+ * @param encoding The name of the character encoding to use for this
+ * object.
+ */
+ public PrintStream (OutputStream out, boolean auto_flush, String encoding)
+ //throws UnsupportedEncodingException
+ {
+ super (out);
+
+ new String(new byte[]{0}, encoding); // check if encoding is supported
+ this.encoding = encoding;
+ this.auto_flush = auto_flush;
+ }
+
+ /**
+ * This method checks to see if an error has occurred on this stream. Note
+ * that once an error has occurred, this method will continue to report
+ * <code>true</code> forever for this stream. Before checking for an
+ * error condition, this method flushes the stream.
+ *
+ * @return <code>true</code> if an error has occurred,
+ * <code>false</code> otherwise
+ */
+ public boolean checkError ()
+ {
+ flush ();
+ return error_occurred;
+ }
+
+ /**
+ * This method can be called by subclasses to indicate that an error
+ * has occurred and should be reported by <code>checkError</code>.
+ */
+ protected void setError ()
+ {
+ error_occurred = true;
+ }
+
+ /**
+ * This method closes this stream and all underlying streams.
+ */
+ public void close ()
+ {
+ /*try
+ {
+ flush();
+ out.close();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread().interrupt();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ /**
+ * This method flushes any buffered bytes to the underlying stream and
+ * then flushes that stream as well.
+ */
+ public void flush ()
+ {
+ /*try
+ {
+ out.flush();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread().interrupt();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ private synchronized void print (String str, boolean println)
+ {
+ /*try
+ {
+ writeChars(str, 0, str.length());
+ if (println)
+ writeChars(line_separator, 0, line_separator.length);
+ if (auto_flush)
+ flush();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread().interrupt();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ private synchronized void print (char[] chars, int pos, int len,
+ boolean println)
+ {
+ /*try
+ {
+ writeChars(chars, pos, len);
+ if (println)
+ writeChars(line_separator, 0, line_separator.length);
+ if (auto_flush)
+ flush();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread().interrupt();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ private void writeChars(char[] buf, int offset, int count)
+ //throws IOException
+ {
+ /*byte[] bytes = (new String(buf, offset, count)).getBytes(encoding);
+ out.write(bytes, 0, bytes.length);*/
+ }
+
+ private void writeChars(String str, int offset, int count)
+ //throws IOException
+ {
+ /*byte[] bytes = str.substring(offset, offset+count).getBytes(encoding);
+ out.write(bytes, 0, bytes.length);*/
+ }
+
+ /**
+ * This methods prints a boolean value to the stream. <code>true</code>
+ * values are printed as "true" and <code>false</code> values are printed
+ * as "false".
+ *
+ * @param bool The <code>boolean</code> value to print
+ */
+ public void print (boolean bool)
+ {
+ print(String.valueOf(bool), false);
+ }
+
+ /**
+ * This method prints an integer to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ *
+ * @param inum The <code>int</code> value to be printed
+ */
+ public void print (int inum)
+ {
+ print(String.valueOf(inum), false);
+ }
+
+ /**
+ * This method prints a long to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ *
+ * @param lnum The <code>long</code> value to be printed
+ */
+ public void print (long lnum)
+ {
+ print(String.valueOf(lnum), false);
+ }
+
+ /**
+ * This method prints a float to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ *
+ * @param fnum The <code>float</code> value to be printed
+ */
+ public void print (float fnum)
+ {
+ print(String.valueOf(fnum), false);
+ }
+
+ /**
+ * This method prints a double to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ *
+ * @param dnum The <code>double</code> value to be printed
+ */
+ public void print (double dnum)
+ {
+ print(String.valueOf(dnum), false);
+ }
+
+ /**
+ * This method prints an <code>Object</code> to the stream. The actual
+ * value printed is determined by calling the <code>String.valueOf()</code>
+ * method.
+ *
+ * @param obj The <code>Object</code> to print.
+ */
+ public void print (Object obj)
+ {
+ print(obj == null ? "null" : obj.toString(), false);
+ }
+
+ /**
+ * This method prints a <code>String</code> to the stream. The actual
+ * value printed depends on the system default encoding.
+ *
+ * @param str The <code>String</code> to print.
+ */
+ public void print (String str)
+ {
+ print(str == null ? "null" : str, false);
+ }
+
+ /**
+ * This method prints a char to the stream. The actual value printed is
+ * determined by the character encoding in use.
+ *
+ * @param ch The <code>char</code> value to be printed
+ */
+ public synchronized void print (char ch)
+ {
+ print(new char[]{ch}, 0, 1, false);
+ }
+
+ /**
+ * This method prints an array of characters to the stream. The actual
+ * value printed depends on the system default encoding.
+ *
+ * @param charArray The array of characters to print.
+ */
+ public void print (char[] charArray)
+ {
+ print(charArray, 0, charArray.length, false);
+ }
+
+ /**
+ * This method prints a line separator sequence to the stream. The value
+ * printed is determined by the system property <xmp>line.separator</xmp>
+ * and is not necessarily the Unix '\n' newline character.
+ */
+ public void println ()
+ {
+ print(line_separator, 0, line_separator.length, false);
+ }
+
+ /**
+ * This methods prints a boolean value to the stream. <code>true</code>
+ * values are printed as "true" and <code>false</code> values are printed
+ * as "false".
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param bool The <code>boolean</code> value to print
+ */
+ public void println (boolean bool)
+ {
+ print(String.valueOf(bool), true);
+ }
+
+ /**
+ * This method prints an integer to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param inum The <code>int</code> value to be printed
+ */
+ public void println (int inum)
+ {
+ print(String.valueOf(inum), true);
+ }
+
+ /**
+ * This method prints a long to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param lnum The <code>long</code> value to be printed
+ */
+ public void println (long lnum)
+ {
+ print(String.valueOf(lnum), true);
+ }
+
+ /**
+ * This method prints a float to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param fnum The <code>float</code> value to be printed
+ */
+ public void println (float fnum)
+ {
+ print(String.valueOf(fnum), true);
+ }
+
+ /**
+ * This method prints a double to the stream. The value printed is
+ * determined using the <code>String.valueOf()</code> method.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param dnum The <code>double</code> value to be printed
+ */
+ public void println (double dnum)
+ {
+ print(String.valueOf(dnum), true);
+ }
+
+ /**
+ * This method prints an <code>Object</code> to the stream. The actual
+ * value printed is determined by calling the <code>String.valueOf()</code>
+ * method.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param obj The <code>Object</code> to print.
+ */
+ public void println (Object obj)
+ {
+ print(obj == null ? "null" : obj.toString(), true);
+ }
+
+ /**
+ * This method prints a <code>String</code> to the stream. The actual
+ * value printed depends on the system default encoding.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param str The <code>String</code> to print.
+ */
+ public void println (String str)
+ {
+ print (str == null ? "null" : str, true);
+ }
+
+ /**
+ * This method prints a char to the stream. The actual value printed is
+ * determined by the character encoding in use.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param ch The <code>char</code> value to be printed
+ */
+ public synchronized void println (char ch)
+ {
+ print(new char[]{ch}, 0, 1, true);
+ }
+
+ /**
+ * This method prints an array of characters to the stream. The actual
+ * value printed depends on the system default encoding.
+ * <p>
+ * This method prints a line termination sequence after printing the value.
+ *
+ * @param charArray The array of characters to print.
+ */
+ public void println (char[] charArray)
+ {
+ print(charArray, 0, charArray.length, true);
+ }
+
+ /**
+ * This method writes a byte of data to the stream. If auto-flush is
+ * enabled, printing a newline character will cause the stream to be
+ * flushed after the character is written.
+ *
+ * @param oneByte The byte to be written
+ */
+ public void write (int oneByte)
+ {
+ /*try
+ {
+ out.write (oneByte & 0xff);
+
+ if (auto_flush && (oneByte == '\n'))
+ flush ();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread ().interrupt ();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ /**
+ * This method writes <code>len</code> bytes from the specified array
+ * starting at index <code>offset</code> into the array.
+ *
+ * @param buffer The array of bytes to write
+ * @param offset The index into the array to start writing from
+ * @param len The number of bytes to write
+ */
+ public void write (byte[] buffer, int offset, int len)
+ {
+ /*try
+ {
+ out.write (buffer, offset, len);
+
+ if (auto_flush)
+ flush ();
+ }
+ catch (InterruptedIOException iioe)
+ {
+ Thread.currentThread ().interrupt ();
+ }
+ catch (IOException e)
+ {
+ setError ();
+ }*/
+ }
+
+ /** @since 1.5 */
+ public PrintStream append(char c)
+ {
+ print(c);
+ return this;
+ }
+
+ /** @since 1.5 */
+ /*public PrintStream append(CharSequence cs)
+ {
+ print(cs == null ? "null" : cs.toString());
+ return this;
+ }*/
+
+ /** @since 1.5 */
+ /*public PrintStream append(CharSequence cs, int start, int end)
+ {
+ print(cs == null ? "null" : cs.subSequence(start, end).toString());
+ return this;
+ }*/
+
+ /** @since 1.5 */
+ /*public PrintStream printf(String format, Object... args)
+ {
+ return this; //format(format, args);
+ }*/
+
+ /** @since 1.5 */
+ /*public PrintStream printf(Locale locale, String format, Object... args)
+ {
+ return format(locale, format, args);
+ }*/
+
+ /** @since 1.5 */
+ /*public PrintStream format(String format, Object... args)
+ {
+ return this; //format(Locale.getDefault(), format, args);
+ }*/
+
+ /** @since 1.5 */
+ /*public PrintStream format(Locale locale, String format, Object... args)
+ {
+ Formatter f = new Formatter(this, locale);
+ f.format(format, args);
+ return this;
+ }*/
+} // class PrintStream
--- /dev/null
+/* java.lang.Throwable -- Root class for all Exceptions and Errors
+ Copyright (C) 1998, 1999, 2002, 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. */
+
+//package java.lang;
+
+/*import gnu.classpath.SystemProperties;
+
+import gnu.java.lang.CPStringBuilder;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.Serializable;*/
+
+/**
+ * Throwable is the superclass of all exceptions that can be raised.
+ *
+ * <p>There are two special cases: {@link Error} and {@link RuntimeException}:
+ * these two classes (and their subclasses) are considered unchecked
+ * exceptions, and are either frequent enough or catastrophic enough that you
+ * do not need to declare them in <code>throws</code> clauses. Everything
+ * else is a checked exception, and is ususally a subclass of
+ * {@link Exception}; these exceptions have to be handled or declared.
+ *
+ * <p>Instances of this class are usually created with knowledge of the
+ * execution context, so that you can get a stack trace of the problem spot
+ * in the code. Also, since JDK 1.4, Throwables participate in "exception
+ * chaining." This means that one exception can be caused by another, and
+ * preserve the information of the original.
+ *
+ * <p>One reason this is useful is to wrap exceptions to conform to an
+ * interface. For example, it would be bad design to require all levels
+ * of a program interface to be aware of the low-level exceptions thrown
+ * at one level of abstraction. Another example is wrapping a checked
+ * exception in an unchecked one, to communicate that failure occured
+ * while still obeying the method throws clause of a superclass.
+ *
+ * <p>A cause is assigned in one of two ways; but can only be assigned once
+ * in the lifetime of the Throwable. There are new constructors added to
+ * several classes in the exception hierarchy that directly initialize the
+ * cause, or you can use the <code>initCause</code> method. This second
+ * method is especially useful if the superclass has not been retrofitted
+ * with new constructors:<br>
+ * <pre>
+ * try
+ * {
+ * lowLevelOp();
+ * }
+ * catch (LowLevelException lle)
+ * {
+ * throw (HighLevelException) new HighLevelException().initCause(lle);
+ * }
+ * </pre>
+ * Notice the cast in the above example; without it, your method would need
+ * a throws clase that declared Throwable, defeating the purpose of chainig
+ * your exceptions.
+ *
+ * <p>By convention, exception classes have two constructors: one with no
+ * arguments, and one that takes a String for a detail message. Further,
+ * classes which are likely to be used in an exception chain also provide
+ * a constructor that takes a Throwable, with or without a detail message
+ * string.
+ *
+ * <p>Another 1.4 feature is the StackTrace, a means of reflection that
+ * allows the program to inspect the context of the exception, and which is
+ * serialized, so that remote procedure calls can correctly pass exceptions.
+ *
+ * @author Brian Jones
+ * @author John Keiser
+ * @author Mark Wielaard
+ * @author Tom Tromey
+ * @author Eric Blake (ebb9@email.byu.edu)
+ * @since 1.0
+ * @status updated to 1.4
+ */
+public class Throwable //implements Serializable
+{
+ /**
+ * Compatible with JDK 1.0+.
+ */
+ private static final long serialVersionUID = -3042686055658047285L;
+
+ /**
+ * The detail message.
+ *
+ * @serial specific details about the exception, may be null
+ */
+ private final String detailMessage;
+
+ /**
+ * The cause of the throwable, including null for an unknown or non-chained
+ * cause. This may only be set once; so the field is set to
+ * <code>this</code> until initialized.
+ *
+ * @serial the cause, or null if unknown, or this if not yet set
+ * @since 1.4
+ */
+ private Throwable cause = null;//this;
+
+ /**
+ * The stack trace, in a serialized form.
+ *
+ * @serial the elements of the stack trace; this is non-null, and has
+ * no null entries
+ * @since 1.4
+ */
+ //private StackTraceElement[] stackTrace;
+
+ /**
+ * Instantiate this Throwable with an empty message. The cause remains
+ * uninitialized. {@link #fillInStackTrace()} will be called to set
+ * up the stack trace.
+ */
+ public Throwable()
+ {
+ //this((String) null);
+ detailMessage = null;
+ }
+
+ /**
+ * Instantiate this Throwable with the given message. The cause remains
+ * uninitialized. {@link #fillInStackTrace()} will be called to set
+ * up the stack trace.
+ *
+ * @param message the message to associate with the Throwable
+ */
+ public Throwable(String message)
+ {
+ //fillInStackTrace();
+ detailMessage = message;
+ }
+
+ /**
+ * Instantiate this Throwable with the given message and cause. Note that
+ * the message is unrelated to the message of the cause.
+ * {@link #fillInStackTrace()} will be called to set up the stack trace.
+ *
+ * @param message the message to associate with the Throwable
+ * @param cause the cause, may be null
+ * @since 1.4
+ */
+ public Throwable(String message, Throwable cause)
+ {
+ //this(message);
+ detailMessage = message;
+ this.cause = cause;
+ }
+
+ /**
+ * Instantiate this Throwable with the given cause. The message is then
+ * built as <code>cause == null ? null : cause.toString()</code>.
+ * {@link #fillInStackTrace()} will be called to set up the stack trace.
+ *
+ * @param cause the cause, may be null
+ * @since 1.4
+ */
+ public Throwable(Throwable causem)
+ {
+ //this(cause == null ? null : cause.toString(), cause);
+ String message = causem == null ? null : causem.toString();
+ detailMessage = message;
+ this.cause = causem;
+ }
+
+ /**
+ * Get the message associated with this Throwable.
+ *
+ * @return the error message associated with this Throwable, may be null
+ */
+ public String getMessage()
+ {
+ return detailMessage;
+ }
+
+ /**
+ * Get a localized version of this Throwable's error message.
+ * This method must be overridden in a subclass of Throwable
+ * to actually produce locale-specific methods. The Throwable
+ * implementation just returns getMessage().
+ *
+ * @return a localized version of this error message
+ * @see #getMessage()
+ * @since 1.1
+ */
+ public String getLocalizedMessage()
+ {
+ return getMessage();
+ }
+
+ /**
+ * Returns the cause of this exception, or null if the cause is not known
+ * or non-existant. This cause is initialized by the new constructors,
+ * or by calling initCause.
+ *
+ * @return the cause of this Throwable
+ * @since 1.4
+ */
+ public Throwable getCause()
+ {
+ return cause == this ? null : cause;
+ }
+
+ /**
+ * Initialize the cause of this Throwable. This may only be called once
+ * during the object lifetime, including implicitly by chaining
+ * constructors.
+ *
+ * @param cause the cause of this Throwable, may be null
+ * @return this
+ * @throws IllegalArgumentException if cause is this (a Throwable can't be
+ * its own cause!)
+ * @throws IllegalStateException if the cause has already been set
+ * @since 1.4
+ */
+ public Throwable initCause(Throwable cause)
+ {
+ /*if (cause == this)
+ throw new IllegalArgumentException();
+ if (this.cause != this)
+ throw new IllegalStateException();*/
+ this.cause = cause;
+ return this;
+ }
+
+ /**
+ * Get a human-readable representation of this Throwable. The detail message
+ * is retrieved by getLocalizedMessage(). Then, with a null detail
+ * message, this string is simply the object's class name; otherwise
+ * the string is <code>getClass().getName() + ": " + message</code>.
+ *
+ * @return a human-readable String represting this Throwable
+ */
+ /*public String toString()
+ {
+ String msg = getLocalizedMessage();
+ return getClass().getName() + (msg == null ? "" : ": " + msg);
+ }*/
+
+ /**
+ * Print a stack trace to the standard error stream. This stream is the
+ * current contents of <code>System.err</code>. The first line of output
+ * is the result of {@link #toString()}, and the remaining lines represent
+ * the data created by {@link #fillInStackTrace()}. While the format is
+ * unspecified, this implementation uses the suggested format, demonstrated
+ * by this example:<br>
+ * <pre>
+ * public class Junk
+ * {
+ * public static void main(String args[])
+ * {
+ * try
+ * {
+ * a();
+ * }
+ * catch(HighLevelException e)
+ * {
+ * e.printStackTrace();
+ * }
+ * }
+ * static void a() throws HighLevelException
+ * {
+ * try
+ * {
+ * b();
+ * }
+ * catch(MidLevelException e)
+ * {
+ * throw new HighLevelException(e);
+ * }
+ * }
+ * static void b() throws MidLevelException
+ * {
+ * c();
+ * }
+ * static void c() throws MidLevelException
+ * {
+ * try
+ * {
+ * d();
+ * }
+ * catch(LowLevelException e)
+ * {
+ * throw new MidLevelException(e);
+ * }
+ * }
+ * static void d() throws LowLevelException
+ * {
+ * e();
+ * }
+ * static void e() throws LowLevelException
+ * {
+ * throw new LowLevelException();
+ * }
+ * }
+ * class HighLevelException extends Exception
+ * {
+ * HighLevelException(Throwable cause) { super(cause); }
+ * }
+ * class MidLevelException extends Exception
+ * {
+ * MidLevelException(Throwable cause) { super(cause); }
+ * }
+ * class LowLevelException extends Exception
+ * {
+ * }
+ * </pre>
+ * <p>
+ * <pre>
+ * HighLevelException: MidLevelException: LowLevelException
+ * at Junk.a(Junk.java:13)
+ * at Junk.main(Junk.java:4)
+ * Caused by: MidLevelException: LowLevelException
+ * at Junk.c(Junk.java:23)
+ * at Junk.b(Junk.java:17)
+ * at Junk.a(Junk.java:11)
+ * ... 1 more
+ * Caused by: LowLevelException
+ * at Junk.e(Junk.java:30)
+ * at Junk.d(Junk.java:27)
+ * at Junk.c(Junk.java:21)
+ * ... 3 more
+ * </pre>
+ */
+ public void printStackTrace()
+ {
+ //printStackTrace(System.err);
+ }
+
+ /**
+ * Print a stack trace to the specified PrintStream. See
+ * {@link #printStackTrace()} for the sample format.
+ *
+ * @param s the PrintStream to write the trace to
+ */
+ /*public void printStackTrace(PrintStream s)
+ {
+ s.print(stackTraceString());
+ }*/
+
+ /**
+ * Prints the exception, the detailed message and the stack trace
+ * associated with this Throwable to the given <code>PrintWriter</code>.
+ * The actual output written is implemention specific. Use the result of
+ * <code>getStackTrace()</code> when more precise information is needed.
+ *
+ * <p>This implementation first prints a line with the result of this
+ * object's <code>toString()</code> method.
+ * <br>
+ * Then for all elements given by <code>getStackTrace</code> it prints
+ * a line containing three spaces, the string "at " and the result of calling
+ * the <code>toString()</code> method on the <code>StackTraceElement</code>
+ * object. If <code>getStackTrace()</code> returns an empty array it prints
+ * a line containing three spaces and the string
+ * "<<No stacktrace available>>".
+ * <br>
+ * Then if <code>getCause()</code> doesn't return null it adds a line
+ * starting with "Caused by: " and the result of calling
+ * <code>toString()</code> on the cause.
+ * <br>
+ * Then for every cause (of a cause, etc) the stacktrace is printed the
+ * same as for the top level <code>Throwable</code> except that as soon
+ * as all the remaining stack frames of the cause are the same as the
+ * the last stack frames of the throwable that the cause is wrapped in
+ * then a line starting with three spaces and the string "... X more" is
+ * printed, where X is the number of remaining stackframes.
+ *
+ * @param pw the PrintWriter to write the trace to
+ * @since 1.1
+ */
+ /*public void printStackTrace (PrintWriter pw)
+ {
+ pw.print(stackTraceString());
+ }*/
+
+ /*
+ * We use inner class to avoid a static initializer in this basic class.
+ */
+ /*private static class StaticData
+ {
+ static final String nl = SystemProperties.getProperty("line.separator");
+ }*/
+
+ // Create whole stack trace in a stringbuffer so we don't have to print
+ // it line by line. This prevents printing multiple stack traces from
+ // different threads to get mixed up when written to the same PrintWriter.
+ /*private String stackTraceString()
+ {
+ CPStringBuilder sb = new CPStringBuilder();
+
+ // Main stacktrace
+ StackTraceElement[] stack = getStackTrace();
+ stackTraceStringBuffer(sb, this.toString(), stack, 0);
+
+ // The cause(s)
+ Throwable cause = getCause();
+ while (cause != null)
+ {
+ // Cause start first line
+ sb.append("Caused by: ");
+
+ // Cause stacktrace
+ StackTraceElement[] parentStack = stack;
+ stack = cause.getStackTrace();
+ if (parentStack == null || parentStack.length == 0)
+ stackTraceStringBuffer(sb, cause.toString(), stack, 0);
+ else
+ {
+ int equal = 0; // Count how many of the last stack frames are equal
+ int frame = stack.length-1;
+ int parentFrame = parentStack.length-1;
+ while (frame > 0 && parentFrame > 0)
+ {
+ if (stack[frame].equals(parentStack[parentFrame]))
+ {
+ equal++;
+ frame--;
+ parentFrame--;
+ }
+ else
+ break;
+ }
+ stackTraceStringBuffer(sb, cause.toString(), stack, equal);
+ }
+ cause = cause.getCause();
+ }
+
+ return sb.toString();
+ }*/
+
+ // Adds to the given StringBuffer a line containing the name and
+ // all stacktrace elements minus the last equal ones.
+ /*private static void stackTraceStringBuffer(CPStringBuilder sb, String name,
+ StackTraceElement[] stack, int equal)
+ {
+ String nl = StaticData.nl;
+ // (finish) first line
+ sb.append(name);
+ sb.append(nl);
+
+ // The stacktrace
+ if (stack == null || stack.length == 0)
+ {
+ sb.append(" <<No stacktrace available>>");
+ sb.append(nl);
+ }
+ else
+ {
+ for (int i = 0; i < stack.length-equal; i++)
+ {
+ sb.append(" at ");
+ sb.append(stack[i] == null ? "<<Unknown>>" : stack[i].toString());
+ sb.append(nl);
+ }
+ if (equal > 0)
+ {
+ sb.append(" ...");
+ sb.append(equal);
+ sb.append(" more");
+ sb.append(nl);
+ }
+ }
+ }*/
+
+ /**
+ * Fill in the stack trace with the current execution stack.
+ *
+ * @return this same throwable
+ * @see #printStackTrace()
+ */
+ /*public Throwable fillInStackTrace()
+ {
+ vmState = VMThrowable.fillInStackTrace(this);
+ stackTrace = null; // Should be regenerated when used.
+
+ return this;
+ }*/
+
+ /**
+ * Provides access to the information printed in {@link #printStackTrace()}.
+ * The array is non-null, with no null entries, although the virtual
+ * machine is allowed to skip stack frames. If the array is not 0-length,
+ * then slot 0 holds the information on the stack frame where the Throwable
+ * was created (or at least where <code>fillInStackTrace()</code> was
+ * called).
+ *
+ * @return an array of stack trace information, as available from the VM
+ * @since 1.4
+ */
+ /*public StackTraceElement[] getStackTrace()
+ {
+ if (stackTrace == null)
+ if (vmState == null)
+ stackTrace = new StackTraceElement[0];
+ else
+ {
+ stackTrace = vmState.getStackTrace(this);
+ vmState = null; // No longer needed
+ }
+
+ return stackTrace;
+ }*/
+
+ /**
+ * Change the stack trace manually. This method is designed for remote
+ * procedure calls, which intend to alter the stack trace before or after
+ * serialization according to the context of the remote call.
+ * <p>
+ * The contents of the given stacktrace is copied so changes to the
+ * original array do not change the stack trace elements of this
+ * throwable.
+ *
+ * @param stackTrace the new trace to use
+ * @throws NullPointerException if stackTrace is null or has null elements
+ * @since 1.4
+ */
+ /*public void setStackTrace(StackTraceElement[] stackTrace)
+ {
+ int i = stackTrace.length;
+ StackTraceElement[] st = new StackTraceElement[i];
+
+ while (--i >= 0)
+ {
+ st[i] = stackTrace[i];
+ if (st[i] == null)
+ throw new NullPointerException("Element " + i + " null");
+ }
+
+ this.stackTrace = st;
+ }*/
+
+ /**
+ * VM state when fillInStackTrace was called.
+ * Used by getStackTrace() to get an array of StackTraceElements.
+ * Cleared when no longer needed.
+ */
+ //private transient VMThrowable vmState;
+}
projects / IRC.git / commitdiff