Unforked java/io/FileInputStream.java, java/io/FileOutputStream.java and java/io/RandomAccessFile.java.

6 files changed, 194 insertions, 1987 deletions

diff --git a/openjdk/FORKED b/openjdk/FORKED
index 6718c934..f46f6c78 100644
--- a/openjdk/FORKED
+++ b/openjdk/FORKED
@@ -22,11 +22,8 @@ jdk/src/share/classes/java/awt/image/DataBufferInt.java=java/awt/image/DataBuffe
 jdk/src/share/classes/java/awt/image/DataBufferShort.java=java/awt/image/DataBufferShort.java
 jdk/src/share/classes/java/awt/image/DataBufferUShort.java=java/awt/image/DataBufferUShort.java
 jdk/src/share/classes/java/awt/image/IndexColorModel.java=java/awt/image/IndexColorModel.java
-jdk/src/share/classes/java/io/FileInputStream.java=java/io/FileInputStream.java
-jdk/src/share/classes/java/io/FileOutputStream.java=java/io/FileOutputStream.java
 jdk/src/share/classes/java/io/ObjectStreamClass.java=java/io/ObjectStreamClass.java
 jdk/src/share/classes/java/io/ObjectStreamField.java=java/io/ObjectStreamField.java
-jdk/src/share/classes/java/io/RandomAccessFile.java=java/io/RandomAccessFile.java
 jdk/src/share/classes/java/lang/Class.java=java/lang/Class.java
 jdk/src/share/classes/java/lang/ClassLoader.java=java/lang/ClassLoader.java
 jdk/src/share/classes/java/lang/Enum.java=java/lang/Enum.java
diff --git a/openjdk/allsources.lst b/openjdk/allsources.lst
index 37dd91c6..7105481e 100644
--- a/openjdk/allsources.lst
+++ b/openjdk/allsources.lst
@@ -78,13 +78,10 @@ java/awt/image/LookupOp.java
 java/awt/image/RescaleOp.java
 java/io/DefaultFileSystem.java
 java/io/FileDescriptor.java
-java/io/FileInputStream.java
-java/io/FileOutputStream.java
 java/io/InteropObjectInputStream.java
 java/io/InteropObjectOutputStream.java
 java/io/ObjectStreamClass.java
 java/io/ObjectStreamField.java
-java/io/RandomAccessFile.java
 java/lang/Class.java
 java/lang/ClassLoader.java
 java/lang/ClassLoaderHelper.java
@@ -10046,8 +10043,10 @@ sun/security/jgss/wrapper/SunNativeProvider.java
 @OPENJDK@/jdk/src/share/classes/java/io/Externalizable.java
 @OPENJDK@/jdk/src/share/classes/java/io/File.java
 @OPENJDK@/jdk/src/share/classes/java/io/FileFilter.java
+@OPENJDK@/jdk/src/share/classes/java/io/FileInputStream.java
 @OPENJDK@/jdk/src/share/classes/java/io/FilenameFilter.java
 @OPENJDK@/jdk/src/share/classes/java/io/FileNotFoundException.java
+@OPENJDK@/jdk/src/share/classes/java/io/FileOutputStream.java
 @OPENJDK@/jdk/src/share/classes/java/io/FilePermission.java
 @OPENJDK@/jdk/src/share/classes/java/io/FileReader.java
 @OPENJDK@/jdk/src/share/classes/java/io/FileSystem.java
@@ -10086,6 +10085,7 @@ sun/security/jgss/wrapper/SunNativeProvider.java
 @OPENJDK@/jdk/src/share/classes/java/io/PrintWriter.java
 @OPENJDK@/jdk/src/share/classes/java/io/PushbackInputStream.java
 @OPENJDK@/jdk/src/share/classes/java/io/PushbackReader.java
+@OPENJDK@/jdk/src/share/classes/java/io/RandomAccessFile.java
 @OPENJDK@/jdk/src/share/classes/java/io/Reader.java
 @OPENJDK@/jdk/src/share/classes/java/io/SequenceInputStream.java
 @OPENJDK@/jdk/src/share/classes/java/io/SerialCallbackContext.java
diff --git a/openjdk/java/io/FileInputStream.java b/openjdk/java/io/FileInputStream.java
deleted file mode 100644
index 36696445..00000000
--- a/openjdk/java/io/FileInputStream.java
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package java.io;
-
-import java.nio.channels.FileChannel;
-import sun.nio.ch.FileChannelImpl;
-
-
-/**
- * A <code>FileInputStream</code> obtains input bytes
- * from a file in a file system. What files
- * are  available depends on the host environment.
- *
- * <p><code>FileInputStream</code> is meant for reading streams of raw bytes
- * such as image data. For reading streams of characters, consider using
- * <code>FileReader</code>.
- *
- * @author  Arthur van Hoff
- * @see     java.io.File
- * @see     java.io.FileDescriptor
- * @see     java.io.FileOutputStream
- * @see     java.nio.file.Files#newInputStream
- * @since   JDK1.0
- */
-public
-class FileInputStream extends InputStream
-{
-    /* File Descriptor - handle to the open file */
-    private final FileDescriptor fd;
-
-    /**
-     * The path of the referenced file
-     * (null if the stream is created with a file descriptor)
-     */
-    private final String path;
-
-    private FileChannel channel = null;
-
-    private final Object closeLock = new Object();
-    private volatile boolean closed = false;
-
-    /**
-     * Creates a <code>FileInputStream</code> by
-     * opening a connection to an actual file,
-     * the file named by the path name <code>name</code>
-     * in the file system.  A new <code>FileDescriptor</code>
-     * object is created to represent this file
-     * connection.
-     * <p>
-     * First, if there is a security
-     * manager, its <code>checkRead</code> method
-     * is called with the <code>name</code> argument
-     * as its argument.
-     * <p>
-     * If the named file does not exist, is a directory rather than a regular
-     * file, or for some other reason cannot be opened for reading then a
-     * <code>FileNotFoundException</code> is thrown.
-     *
-     * @param      name   the system-dependent file name.
-     * @exception  FileNotFoundException  if the file does not exist,
-     *                   is a directory rather than a regular file,
-     *                   or for some other reason cannot be opened for
-     *                   reading.
-     * @exception  SecurityException      if a security manager exists and its
-     *               <code>checkRead</code> method denies read access
-     *               to the file.
-     * @see        java.lang.SecurityManager#checkRead(java.lang.String)
-     */
-    public FileInputStream(String name) throws FileNotFoundException {
-        this(name != null ? new File(name) : null);
-    }
-
-    /**
-     * Creates a <code>FileInputStream</code> by
-     * opening a connection to an actual file,
-     * the file named by the <code>File</code>
-     * object <code>file</code> in the file system.
-     * A new <code>FileDescriptor</code> object
-     * is created to represent this file connection.
-     * <p>
-     * First, if there is a security manager,
-     * its <code>checkRead</code> method  is called
-     * with the path represented by the <code>file</code>
-     * argument as its argument.
-     * <p>
-     * If the named file does not exist, is a directory rather than a regular
-     * file, or for some other reason cannot be opened for reading then a
-     * <code>FileNotFoundException</code> is thrown.
-     *
-     * @param      file   the file to be opened for reading.
-     * @exception  FileNotFoundException  if the file does not exist,
-     *                   is a directory rather than a regular file,
-     *                   or for some other reason cannot be opened for
-     *                   reading.
-     * @exception  SecurityException      if a security manager exists and its
-     *               <code>checkRead</code> method denies read access to the file.
-     * @see        java.io.File#getPath()
-     * @see        java.lang.SecurityManager#checkRead(java.lang.String)
-     */
-    public FileInputStream(File file) throws FileNotFoundException {
-        String name = (file != null ? file.getPath() : null);
-        SecurityManager security = System.getSecurityManager();
-        if (security != null) {
-            security.checkRead(name);
-        }
-        if (name == null) {
-            throw new NullPointerException();
-        }
-        if (file.isInvalid()) {
-            throw new FileNotFoundException("Invalid file path");
-        }
-        fd = new FileDescriptor();
-        fd.attach(this);
-        path = name;
-        open(name);
-    }
-
-    /**
-     * Creates a <code>FileInputStream</code> by using the file descriptor
-     * <code>fdObj</code>, which represents an existing connection to an
-     * actual file in the file system.
-     * <p>
-     * If there is a security manager, its <code>checkRead</code> method is
-     * called with the file descriptor <code>fdObj</code> as its argument to
-     * see if it's ok to read the file descriptor. If read access is denied
-     * to the file descriptor a <code>SecurityException</code> is thrown.
-     * <p>
-     * If <code>fdObj</code> is null then a <code>NullPointerException</code>
-     * is thrown.
-     * <p>
-     * This constructor does not throw an exception if <code>fdObj</code>
-     * is {@link java.io.FileDescriptor#valid() invalid}.
-     * However, if the methods are invoked on the resulting stream to attempt
-     * I/O on the stream, an <code>IOException</code> is thrown.
-     *
-     * @param      fdObj   the file descriptor to be opened for reading.
-     * @throws     SecurityException      if a security manager exists and its
-     *                 <code>checkRead</code> method denies read access to the
-     *                 file descriptor.
-     * @see        SecurityManager#checkRead(java.io.FileDescriptor)
-     */
-    public FileInputStream(FileDescriptor fdObj) {
-        SecurityManager security = System.getSecurityManager();
-        if (fdObj == null) {
-            throw new NullPointerException();
-        }
-        if (security != null) {
-            security.checkRead(fdObj);
-        }
-        fd = fdObj;
-        path = null;
-
-        /*
-         * FileDescriptor is being shared by streams.
-         * Register this stream with FileDescriptor tracker.
-         */
-        fd.attach(this);
-    }
-
-    /**
-     * Opens the specified file for reading.
-     * @param name the name of the file
-     */
-    private void open(String name) throws FileNotFoundException
-    {
-        fd.openReadOnly(name);
-    }
-
-    /**
-     * Reads a byte of data from this input stream. This method blocks
-     * if no input is yet available.
-     *
-     * @return     the next byte of data, or <code>-1</code> if the end of the
-     *             file is reached.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public int read() throws IOException
-    {
-        return fd.read();
-    }
-
-    /**
-     * Reads a subarray as a sequence of bytes.
-     * @param b the data to be written
-     * @param off the start offset in the data
-     * @param len the number of bytes that are written
-     * @exception IOException If an I/O error has occurred.
-     */
-    private int readBytes(byte b[], int off, int len) throws IOException
-    {
-        return fd.readBytes(b, off, len);
-    }
-
-    /**
-     * Reads up to <code>b.length</code> bytes of data from this input
-     * stream into an array of bytes. This method blocks until some input
-     * is available.
-     *
-     * @param      b   the buffer into which the data is read.
-     * @return     the total number of bytes read into the buffer, or
-     *             <code>-1</code> if there is no more data because the end of
-     *             the file has been reached.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public int read(byte b[]) throws IOException {
-        return readBytes(b, 0, b.length);
-    }
-
-    /**
-     * Reads up to <code>len</code> bytes of data from this input stream
-     * into an array of bytes. If <code>len</code> is not zero, the method
-     * blocks until some input is available; otherwise, no
-     * bytes are read and <code>0</code> is returned.
-     *
-     * @param      b     the buffer into which the data is read.
-     * @param      off   the start offset in the destination array <code>b</code>
-     * @param      len   the maximum number of bytes read.
-     * @return     the total number of bytes read into the buffer, or
-     *             <code>-1</code> if there is no more data because the end of
-     *             the file has been reached.
-     * @exception  NullPointerException If <code>b</code> is <code>null</code>.
-     * @exception  IndexOutOfBoundsException If <code>off</code> is negative,
-     * <code>len</code> is negative, or <code>len</code> is greater than
-     * <code>b.length - off</code>
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public int read(byte b[], int off, int len) throws IOException {
-        return readBytes(b, off, len);
-    }
-
-    /**
-     * Skips over and discards <code>n</code> bytes of data from the
-     * input stream.
-     *
-     * <p>The <code>skip</code> method may, for a variety of
-     * reasons, end up skipping over some smaller number of bytes,
-     * possibly <code>0</code>. If <code>n</code> is negative, the method
-     * will try to skip backwards. In case the backing file does not support
-     * backward skip at its current position, an <code>IOException</code> is
-     * thrown. The actual number of bytes skipped is returned. If it skips
-     * forwards, it returns a positive value. If it skips backwards, it
-     * returns a negative value.
-     *
-     * <p>This method may skip more bytes than what are remaining in the
-     * backing file. This produces no exception and the number of bytes skipped
-     * may include some number of bytes that were beyond the EOF of the
-     * backing file. Attempting to read from the stream after skipping past
-     * the end will result in -1 indicating the end of the file.
-     *
-     * @param      n   the number of bytes to be skipped.
-     * @return     the actual number of bytes skipped.
-     * @exception  IOException  if n is negative, if the stream does not
-     *             support seek, or if an I/O error occurs.
-     */
-    public long skip(long n) throws IOException
-    {
-        return fd.skip(n);
-    }
-
-    /**
-     * Returns an estimate of the number of remaining bytes that can be read (or
-     * skipped over) from this input stream without blocking by the next
-     * invocation of a method for this input stream. Returns 0 when the file
-     * position is beyond EOF. The next invocation might be the same thread
-     * or another thread. A single read or skip of this many bytes will not
-     * block, but may read or skip fewer bytes.
-     *
-     * <p> In some cases, a non-blocking read (or skip) may appear to be
-     * blocked when it is merely slow, for example when reading large
-     * files over slow networks.
-     *
-     * @return     an estimate of the number of remaining bytes that can be read
-     *             (or skipped over) from this input stream without blocking.
-     * @exception  IOException  if this file input stream has been closed by calling
-     *             {@code close} or an I/O error occurs.
-     */
-    public int available() throws IOException
-    {
-        return fd.available();
-    }
-
-    /**
-     * Closes this file input stream and releases any system resources
-     * associated with the stream.
-     *
-     * <p> If this stream has an associated channel then the channel is closed
-     * as well.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     *
-     * @revised 1.4
-     * @spec JSR-51
-     */
-    public void close() throws IOException {
-        synchronized (closeLock) {
-            if (closed) {
-                return;
-            }
-            closed = true;
-        }
-        if (channel != null) {
-           channel.close();
-        }
-
-        fd.closeAll(new Closeable() {
-            public void close() throws IOException {
-               close0();
-           }
-        });
-    }
-
-    /**
-     * Returns the <code>FileDescriptor</code>
-     * object  that represents the connection to
-     * the actual file in the file system being
-     * used by this <code>FileInputStream</code>.
-     *
-     * @return     the file descriptor object associated with this stream.
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.FileDescriptor
-     */
-    public final FileDescriptor getFD() throws IOException {
-        if (fd != null) {
-            return fd;
-        }
-        throw new IOException();
-    }
-
-    /**
-     * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
-     * object associated with this file input stream.
-     *
-     * <p> The initial {@link java.nio.channels.FileChannel#position()
-     * position} of the returned channel will be equal to the
-     * number of bytes read from the file so far.  Reading bytes from this
-     * stream will increment the channel's position.  Changing the channel's
-     * position, either explicitly or by reading, will change this stream's
-     * file position.
-     *
-     * @return  the file channel associated with this file input stream
-     *
-     * @since 1.4
-     * @spec JSR-51
-     */
-    public FileChannel getChannel() {
-        synchronized (this) {
-            if (channel == null) {
-                channel = FileChannelImpl.open(fd, path, true, false, this);
-            }
-            return channel;
-        }
-    }
-
-    private void close0() throws IOException
-    {
-        fd.close();
-    }
-
-    /**
-     * Ensures that the <code>close</code> method of this file input stream is
-     * called when there are no more references to it.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.FileInputStream#close()
-     */
-    protected void finalize() throws IOException {
-        if ((fd != null) &&  (fd != FileDescriptor.in)) {
-            /* if fd is shared, the references in FileDescriptor
-             * will ensure that finalizer is only called when
-             * safe to do so. All references using the fd have
-             * become unreachable. We can call close()
-             */
-            close();
-        }
-    }
-}
diff --git a/openjdk/java/io/FileOutputStream.java b/openjdk/java/io/FileOutputStream.java
deleted file mode 100644
index 687bf0ca..00000000
--- a/openjdk/java/io/FileOutputStream.java
+++ /dev/null
@@ -1,431 +0,0 @@
-/*
- * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package java.io;
-
-import java.nio.channels.FileChannel;
-import sun.nio.ch.FileChannelImpl;
-
-
-/**
- * A file output stream is an output stream for writing data to a
- * <code>File</code> or to a <code>FileDescriptor</code>. Whether or not
- * a file is available or may be created depends upon the underlying
- * platform.  Some platforms, in particular, allow a file to be opened
- * for writing by only one <tt>FileOutputStream</tt> (or other
- * file-writing object) at a time.  In such situations the constructors in
- * this class will fail if the file involved is already open.
- *
- * <p><code>FileOutputStream</code> is meant for writing streams of raw bytes
- * such as image data. For writing streams of characters, consider using
- * <code>FileWriter</code>.
- *
- * @author  Arthur van Hoff
- * @see     java.io.File
- * @see     java.io.FileDescriptor
- * @see     java.io.FileInputStream
- * @see     java.nio.file.Files#newOutputStream
- * @since   JDK1.0
- */
-public
-class FileOutputStream extends OutputStream
-{
-    /**
-     * The system dependent file descriptor.
-     */
-    private final FileDescriptor fd;
-
-    /**
-     * True if the file is opened for append.
-     */
-    private final boolean append;
-
-    /**
-     * The associated channel, initialized lazily.
-     */
-    private FileChannel channel;
-
-    /**
-     * The path of the referenced file
-     * (null if the stream is created with a file descriptor)
-     */
-    private final String path;
-
-    private final Object closeLock = new Object();
-    private volatile boolean closed = false;
-
-    /**
-     * Creates a file output stream to write to the file with the
-     * specified name. A new <code>FileDescriptor</code> object is
-     * created to represent this file connection.
-     * <p>
-     * First, if there is a security manager, its <code>checkWrite</code>
-     * method is called with <code>name</code> as its argument.
-     * <p>
-     * If the file exists but is a directory rather than a regular file, does
-     * not exist but cannot be created, or cannot be opened for any other
-     * reason then a <code>FileNotFoundException</code> is thrown.
-     *
-     * @param      name   the system-dependent filename
-     * @exception  FileNotFoundException  if the file exists but is a directory
-     *                   rather than a regular file, does not exist but cannot
-     *                   be created, or cannot be opened for any other reason
-     * @exception  SecurityException  if a security manager exists and its
-     *               <code>checkWrite</code> method denies write access
-     *               to the file.
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     */
-    public FileOutputStream(String name) throws FileNotFoundException {
-        this(name != null ? new File(name) : null, false);
-    }
-
-    /**
-     * Creates a file output stream to write to the file with the specified
-     * name.  If the second argument is <code>true</code>, then
-     * bytes will be written to the end of the file rather than the beginning.
-     * A new <code>FileDescriptor</code> object is created to represent this
-     * file connection.
-     * <p>
-     * First, if there is a security manager, its <code>checkWrite</code>
-     * method is called with <code>name</code> as its argument.
-     * <p>
-     * If the file exists but is a directory rather than a regular file, does
-     * not exist but cannot be created, or cannot be opened for any other
-     * reason then a <code>FileNotFoundException</code> is thrown.
-     *
-     * @param     name        the system-dependent file name
-     * @param     append      if <code>true</code>, then bytes will be written
-     *                   to the end of the file rather than the beginning
-     * @exception  FileNotFoundException  if the file exists but is a directory
-     *                   rather than a regular file, does not exist but cannot
-     *                   be created, or cannot be opened for any other reason.
-     * @exception  SecurityException  if a security manager exists and its
-     *               <code>checkWrite</code> method denies write access
-     *               to the file.
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     * @since     JDK1.1
-     */
-    public FileOutputStream(String name, boolean append)
-        throws FileNotFoundException
-    {
-        this(name != null ? new File(name) : null, append);
-    }
-
-    /**
-     * Creates a file output stream to write to the file represented by
-     * the specified <code>File</code> object. A new
-     * <code>FileDescriptor</code> object is created to represent this
-     * file connection.
-     * <p>
-     * First, if there is a security manager, its <code>checkWrite</code>
-     * method is called with the path represented by the <code>file</code>
-     * argument as its argument.
-     * <p>
-     * If the file exists but is a directory rather than a regular file, does
-     * not exist but cannot be created, or cannot be opened for any other
-     * reason then a <code>FileNotFoundException</code> is thrown.
-     *
-     * @param      file               the file to be opened for writing.
-     * @exception  FileNotFoundException  if the file exists but is a directory
-     *                   rather than a regular file, does not exist but cannot
-     *                   be created, or cannot be opened for any other reason
-     * @exception  SecurityException  if a security manager exists and its
-     *               <code>checkWrite</code> method denies write access
-     *               to the file.
-     * @see        java.io.File#getPath()
-     * @see        java.lang.SecurityException
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     */
-    public FileOutputStream(File file) throws FileNotFoundException {
-        this(file, false);
-    }
-
-    /**
-     * Creates a file output stream to write to the file represented by
-     * the specified <code>File</code> object. If the second argument is
-     * <code>true</code>, then bytes will be written to the end of the file
-     * rather than the beginning. A new <code>FileDescriptor</code> object is
-     * created to represent this file connection.
-     * <p>
-     * First, if there is a security manager, its <code>checkWrite</code>
-     * method is called with the path represented by the <code>file</code>
-     * argument as its argument.
-     * <p>
-     * If the file exists but is a directory rather than a regular file, does
-     * not exist but cannot be created, or cannot be opened for any other
-     * reason then a <code>FileNotFoundException</code> is thrown.
-     *
-     * @param      file               the file to be opened for writing.
-     * @param     append      if <code>true</code>, then bytes will be written
-     *                   to the end of the file rather than the beginning
-     * @exception  FileNotFoundException  if the file exists but is a directory
-     *                   rather than a regular file, does not exist but cannot
-     *                   be created, or cannot be opened for any other reason
-     * @exception  SecurityException  if a security manager exists and its
-     *               <code>checkWrite</code> method denies write access
-     *               to the file.
-     * @see        java.io.File#getPath()
-     * @see        java.lang.SecurityException
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     * @since 1.4
-     */
-    public FileOutputStream(File file, boolean append)
-        throws FileNotFoundException
-    {
-        String name = (file != null ? file.getPath() : null);
-        SecurityManager security = System.getSecurityManager();
-        if (security != null) {
-            security.checkWrite(name);
-        }
-        if (name == null) {
-            throw new NullPointerException();
-        }
-        if (file.isInvalid()) {
-            throw new FileNotFoundException("Invalid file path");
-        }
-        this.fd = new FileDescriptor();
-        fd.attach(this);
-        this.append = append;
-        this.path = name;
-
-        open(name, append);
-    }
-
-    /**
-     * Creates a file output stream to write to the specified file
-     * descriptor, which represents an existing connection to an actual
-     * file in the file system.
-     * <p>
-     * First, if there is a security manager, its <code>checkWrite</code>
-     * method is called with the file descriptor <code>fdObj</code>
-     * argument as its argument.
-     * <p>
-     * If <code>fdObj</code> is null then a <code>NullPointerException</code>
-     * is thrown.
-     * <p>
-     * This constructor does not throw an exception if <code>fdObj</code>
-     * is {@link java.io.FileDescriptor#valid() invalid}.
-     * However, if the methods are invoked on the resulting stream to attempt
-     * I/O on the stream, an <code>IOException</code> is thrown.
-     *
-     * @param      fdObj   the file descriptor to be opened for writing
-     * @exception  SecurityException  if a security manager exists and its
-     *               <code>checkWrite</code> method denies
-     *               write access to the file descriptor
-     * @see        java.lang.SecurityManager#checkWrite(java.io.FileDescriptor)
-     */
-    public FileOutputStream(FileDescriptor fdObj) {
-        SecurityManager security = System.getSecurityManager();
-        if (fdObj == null) {
-            throw new NullPointerException();
-        }
-        if (security != null) {
-            security.checkWrite(fdObj);
-        }
-        this.fd = fdObj;
-        this.append = false;
-        this.path = null;
-
-        fd.attach(this);
-    }
-
-    /**
-     * Opens a file, with the specified name, for overwriting or appending.
-     * @param name name of file to be opened
-     * @param append whether the file is to be opened in append mode
-     */
-    private void open(String name, boolean append)
-        throws FileNotFoundException {
-        if (append) {
-            fd.openAppend(name);
-        } else {
-            fd.openWriteOnly(name);
-        }
-    }
-
-    /**
-     * Writes the specified byte to this file output stream.
-     *
-     * @param   b   the byte to be written.
-     * @param   append   {@code true} if the write operation first
-     *     advances the position to the end of file
-     */
-    private void write(int b, boolean append) throws IOException {
-        fd.write(b);
-    }
-
-    /**
-     * Writes the specified byte to this file output stream. Implements
-     * the <code>write</code> method of <code>OutputStream</code>.
-     *
-     * @param      b   the byte to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(int b) throws IOException {
-        write(b, append);
-    }
-
-    /**
-     * Writes a sub array as a sequence of bytes.
-     * @param b the data to be written
-     * @param off the start offset in the data
-     * @param len the number of bytes that are written
-     * @param append {@code true} to first advance the position to the
-     *     end of file
-     * @exception IOException If an I/O error has occurred.
-     */
-    private void writeBytes(byte b[], int off, int len, boolean append)
-        throws IOException {
-        fd.writeBytes(b, off, len);
-    }
-
-    /**
-     * Writes <code>b.length</code> bytes from the specified byte array
-     * to this file output stream.
-     *
-     * @param      b   the data.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(byte b[]) throws IOException {
-        writeBytes(b, 0, b.length, append);
-    }
-
-    /**
-     * Writes <code>len</code> bytes from the specified byte array
-     * starting at offset <code>off</code> to this file output stream.
-     *
-     * @param      b     the data.
-     * @param      off   the start offset in the data.
-     * @param      len   the number of bytes to write.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(byte b[], int off, int len) throws IOException {
-        writeBytes(b, off, len, append);
-    }
-
-    /**
-     * Closes this file output stream and releases any system resources
-     * associated with this stream. This file output stream may no longer
-     * be used for writing bytes.
-     *
-     * <p> If this stream has an associated channel then the channel is closed
-     * as well.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     *
-     * @revised 1.4
-     * @spec JSR-51
-     */
-    public void close() throws IOException {
-        synchronized (closeLock) {
-            if (closed) {
-                return;
-            }
-            closed = true;
-        }
-
-        if (channel != null) {
-            channel.close();
-        }
-
-        fd.closeAll(new Closeable() {
-            public void close() throws IOException {
-               close0();
-           }
-        });
-    }
-
-    /**
-     * Returns the file descriptor associated with this stream.
-     *
-     * @return  the <code>FileDescriptor</code> object that represents
-     *          the connection to the file in the file system being used
-     *          by this <code>FileOutputStream</code> object.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.FileDescriptor
-     */
-     public final FileDescriptor getFD()  throws IOException {
-        if (fd != null) {
-            return fd;
-        }
-        throw new IOException();
-     }
-
-    /**
-     * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
-     * object associated with this file output stream.
-     *
-     * <p> The initial {@link java.nio.channels.FileChannel#position()
-     * position} of the returned channel will be equal to the
-     * number of bytes written to the file so far unless this stream is in
-     * append mode, in which case it will be equal to the size of the file.
-     * Writing bytes to this stream will increment the channel's position
-     * accordingly.  Changing the channel's position, either explicitly or by
-     * writing, will change this stream's file position.
-     *
-     * @return  the file channel associated with this file output stream
-     *
-     * @since 1.4
-     * @spec JSR-51
-     */
-    public FileChannel getChannel() {
-        synchronized (this) {
-            if (channel == null) {
-                channel = FileChannelImpl.open(fd, path, false, true, append, this);
-            }
-            return channel;
-        }
-    }
-
-    /**
-     * Cleans up the connection to the file, and ensures that the
-     * <code>close</code> method of this file output stream is
-     * called when there are no more references to this stream.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.FileInputStream#close()
-     */
-    protected void finalize() throws IOException {
-        if (fd != null) {
-            if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
-                flush();
-            } else {
-                /* if fd is shared, the references in FileDescriptor
-                 * will ensure that finalizer is only called when
-                 * safe to do so. All references using the fd have
-                 * become unreachable. We can call close()
-                 */
-                close();
-            }
-        }
-    }
-
-    private void close0() throws IOException
-    {
-        fd.close();
-    }
-
-}
diff --git a/openjdk/java/io/RandomAccessFile.java b/openjdk/java/io/RandomAccessFile.java
deleted file mode 100644
index 9abb1dbe..00000000
--- a/openjdk/java/io/RandomAccessFile.java
+++ /dev/null
@@ -1,1151 +0,0 @@
-/*
- * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package java.io;
-
-import java.nio.channels.FileChannel;
-import sun.nio.ch.FileChannelImpl;
-
-
-/**
- * Instances of this class support both reading and writing to a
- * random access file. A random access file behaves like a large
- * array of bytes stored in the file system. There is a kind of cursor,
- * or index into the implied array, called the <em>file pointer</em>;
- * input operations read bytes starting at the file pointer and advance
- * the file pointer past the bytes read. If the random access file is
- * created in read/write mode, then output operations are also available;
- * output operations write bytes starting at the file pointer and advance
- * the file pointer past the bytes written. Output operations that write
- * past the current end of the implied array cause the array to be
- * extended. The file pointer can be read by the
- * {@code getFilePointer} method and set by the {@code seek}
- * method.
- * <p>
- * It is generally true of all the reading routines in this class that
- * if end-of-file is reached before the desired number of bytes has been
- * read, an {@code EOFException} (which is a kind of
- * {@code IOException}) is thrown. If any byte cannot be read for
- * any reason other than end-of-file, an {@code IOException} other
- * than {@code EOFException} is thrown. In particular, an
- * {@code IOException} may be thrown if the stream has been closed.
- *
- * @author  unascribed
- * @since   JDK1.0
- */
-
-public class RandomAccessFile implements DataOutput, DataInput, Closeable {
-
-    private FileDescriptor fd;
-    private FileChannel channel = null;
-    private boolean rw;
-
-    /**
-     * The path of the referenced file
-     * (null if the stream is created with a file descriptor)
-     */
-    private final String path;
-
-    private Object closeLock = new Object();
-    private volatile boolean closed = false;
-
-    private static final int O_RDONLY = 1;
-    private static final int O_RDWR =   2;
-    private static final int O_SYNC =   4;
-    private static final int O_DSYNC =  8;
-
-    /**
-     * Creates a random access file stream to read from, and optionally
-     * to write to, a file with the specified name. A new
-     * {@link FileDescriptor} object is created to represent the
-     * connection to the file.
-     *
-     * <p> The <tt>mode</tt> argument specifies the access mode with which the
-     * file is to be opened.  The permitted values and their meanings are as
-     * specified for the <a
-     * href="#mode"><tt>RandomAccessFile(File,String)</tt></a> constructor.
-     *
-     * <p>
-     * If there is a security manager, its {@code checkRead} method
-     * is called with the {@code name} argument
-     * as its argument to see if read access to the file is allowed.
-     * If the mode allows writing, the security manager's
-     * {@code checkWrite} method
-     * is also called with the {@code name} argument
-     * as its argument to see if write access to the file is allowed.
-     *
-     * @param      name   the system-dependent filename
-     * @param      mode   the access <a href="#mode">mode</a>
-     * @exception  IllegalArgumentException  if the mode argument is not equal
-     *               to one of <tt>"r"</tt>, <tt>"rw"</tt>, <tt>"rws"</tt>, or
-     *               <tt>"rwd"</tt>
-     * @exception FileNotFoundException
-     *            if the mode is <tt>"r"</tt> but the given string does not
-     *            denote an existing regular file, or if the mode begins with
-     *            <tt>"rw"</tt> but the given string does not denote an
-     *            existing, writable regular file and a new regular file of
-     *            that name cannot be created, or if some other error occurs
-     *            while opening or creating the file
-     * @exception  SecurityException         if a security manager exists and its
-     *               {@code checkRead} method denies read access to the file
-     *               or the mode is "rw" and the security manager's
-     *               {@code checkWrite} method denies write access to the file
-     * @see        java.lang.SecurityException
-     * @see        java.lang.SecurityManager#checkRead(java.lang.String)
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     * @revised 1.4
-     * @spec JSR-51
-     */
-    public RandomAccessFile(String name, String mode)
-        throws FileNotFoundException
-    {
-        this(name != null ? new File(name) : null, mode);
-    }
-
-    /**
-     * Creates a random access file stream to read from, and optionally to
-     * write to, the file specified by the {@link File} argument.  A new {@link
-     * FileDescriptor} object is created to represent this file connection.
-     *
-     * <p>The <a name="mode"><tt>mode</tt></a> argument specifies the access mode
-     * in which the file is to be opened.  The permitted values and their
-     * meanings are:
-     *
-     * <table summary="Access mode permitted values and meanings">
-     * <tr><th align="left">Value</th><th align="left">Meaning</th></tr>
-     * <tr><td valign="top"><tt>"r"</tt></td>
-     *     <td> Open for reading only.  Invoking any of the <tt>write</tt>
-     *     methods of the resulting object will cause an {@link
-     *     java.io.IOException} to be thrown. </td></tr>
-     * <tr><td valign="top"><tt>"rw"</tt></td>
-     *     <td> Open for reading and writing.  If the file does not already
-     *     exist then an attempt will be made to create it. </td></tr>
-     * <tr><td valign="top"><tt>"rws"</tt></td>
-     *     <td> Open for reading and writing, as with <tt>"rw"</tt>, and also
-     *     require that every update to the file's content or metadata be
-     *     written synchronously to the underlying storage device.  </td></tr>
-     * <tr><td valign="top"><tt>"rwd"&nbsp;&nbsp;</tt></td>
-     *     <td> Open for reading and writing, as with <tt>"rw"</tt>, and also
-     *     require that every update to the file's content be written
-     *     synchronously to the underlying storage device. </td></tr>
-     * </table>
-     *
-     * The <tt>"rws"</tt> and <tt>"rwd"</tt> modes work much like the {@link
-     * java.nio.channels.FileChannel#force(boolean) force(boolean)} method of
-     * the {@link java.nio.channels.FileChannel} class, passing arguments of
-     * <tt>true</tt> and <tt>false</tt>, respectively, except that they always
-     * apply to every I/O operation and are therefore often more efficient.  If
-     * the file resides on a local storage device then when an invocation of a
-     * method of this class returns it is guaranteed that all changes made to
-     * the file by that invocation will have been written to that device.  This
-     * is useful for ensuring that critical information is not lost in the
-     * event of a system crash.  If the file does not reside on a local device
-     * then no such guarantee is made.
-     *
-     * <p>The <tt>"rwd"</tt> mode can be used to reduce the number of I/O
-     * operations performed.  Using <tt>"rwd"</tt> only requires updates to the
-     * file's content to be written to storage; using <tt>"rws"</tt> requires
-     * updates to both the file's content and its metadata to be written, which
-     * generally requires at least one more low-level I/O operation.
-     *
-     * <p>If there is a security manager, its {@code checkRead} method is
-     * called with the pathname of the {@code file} argument as its
-     * argument to see if read access to the file is allowed.  If the mode
-     * allows writing, the security manager's {@code checkWrite} method is
-     * also called with the path argument to see if write access to the file is
-     * allowed.
-     *
-     * @param      file   the file object
-     * @param      mode   the access mode, as described
-     *                    <a href="#mode">above</a>
-     * @exception  IllegalArgumentException  if the mode argument is not equal
-     *               to one of <tt>"r"</tt>, <tt>"rw"</tt>, <tt>"rws"</tt>, or
-     *               <tt>"rwd"</tt>
-     * @exception FileNotFoundException
-     *            if the mode is <tt>"r"</tt> but the given file object does
-     *            not denote an existing regular file, or if the mode begins
-     *            with <tt>"rw"</tt> but the given file object does not denote
-     *            an existing, writable regular file and a new regular file of
-     *            that name cannot be created, or if some other error occurs
-     *            while opening or creating the file
-     * @exception  SecurityException         if a security manager exists and its
-     *               {@code checkRead} method denies read access to the file
-     *               or the mode is "rw" and the security manager's
-     *               {@code checkWrite} method denies write access to the file
-     * @see        java.lang.SecurityManager#checkRead(java.lang.String)
-     * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
-     * @see        java.nio.channels.FileChannel#force(boolean)
-     * @revised 1.4
-     * @spec JSR-51
-     */
-    public RandomAccessFile(File file, String mode)
-        throws FileNotFoundException
-    {
-        String name = (file != null ? file.getPath() : null);
-        int imode = -1;
-        if (mode.equals("r"))
-            imode = O_RDONLY;
-        else if (mode.startsWith("rw")) {
-            imode = O_RDWR;
-            rw = true;
-            if (mode.length() > 2) {
-                if (mode.equals("rws"))
-                    imode |= O_SYNC;
-                else if (mode.equals("rwd"))
-                    imode |= O_DSYNC;
-                else
-                    imode = -1;
-            }
-        }
-        if (imode < 0)
-            throw new IllegalArgumentException("Illegal mode \"" + mode
-                                               + "\" must be one of "
-                                               + "\"r\", \"rw\", \"rws\","
-                                               + " or \"rwd\"");
-        SecurityManager security = System.getSecurityManager();
-        if (security != null) {
-            security.checkRead(name);
-            if (rw) {
-                security.checkWrite(name);
-            }
-        }
-        if (name == null) {
-            throw new NullPointerException();
-        }
-        if (file.isInvalid()) {
-            throw new FileNotFoundException("Invalid file path");
-        }
-        fd = new FileDescriptor();
-        fd.attach(this);
-        path = name;
-        open(name, imode);
-    }
-
-    /**
-     * Returns the opaque file descriptor object associated with this
-     * stream.
-     *
-     * @return     the file descriptor object associated with this stream.
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.FileDescriptor
-     */
-    public final FileDescriptor getFD() throws IOException {
-        if (fd != null) {
-            return fd;
-        }
-        throw new IOException();
-    }
-
-    /**
-     * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
-     * object associated with this file.
-     *
-     * <p> The {@link java.nio.channels.FileChannel#position()
-     * position} of the returned channel will always be equal to
-     * this object's file-pointer offset as returned by the {@link
-     * #getFilePointer getFilePointer} method.  Changing this object's
-     * file-pointer offset, whether explicitly or by reading or writing bytes,
-     * will change the position of the channel, and vice versa.  Changing the
-     * file's length via this object will change the length seen via the file
-     * channel, and vice versa.
-     *
-     * @return  the file channel associated with this file
-     *
-     * @since 1.4
-     * @spec JSR-51
-     */
-    public final FileChannel getChannel() {
-        synchronized (this) {
-            if (channel == null) {
-                channel = FileChannelImpl.open(fd, path, true, rw, this);
-            }
-            return channel;
-        }
-    }
-
-    /**
-     * Opens a file and returns the file descriptor.  The file is
-     * opened in read-write mode if the O_RDWR bit in {@code mode}
-     * is true, else the file is opened as read-only.
-     * If the {@code name} refers to a directory, an IOException
-     * is thrown.
-     *
-     * @param name the name of the file
-     * @param mode the mode flags, a combination of the O_ constants
-     *             defined above
-     */
-    private void open(String name, int mode)
-        throws FileNotFoundException
-    {
-        if ((mode & O_RDWR) == O_RDWR)
-        {
-            fd.openReadWrite(name);
-        }
-        else
-        {
-            fd.openReadOnly(name);
-        }
-    }
-
-    // 'Read' primitives
-
-    /**
-     * Reads a byte of data from this file. The byte is returned as an
-     * integer in the range 0 to 255 ({@code 0x00-0x0ff}). This
-     * method blocks if no input is yet available.
-     * <p>
-     * Although {@code RandomAccessFile} is not a subclass of
-     * {@code InputStream}, this method behaves in exactly the same
-     * way as the {@link InputStream#read()} method of
-     * {@code InputStream}.
-     *
-     * @return     the next byte of data, or {@code -1} if the end of the
-     *             file has been reached.
-     * @exception  IOException  if an I/O error occurs. Not thrown if
-     *                          end-of-file has been reached.
-     */
-    public int read() throws IOException {
-        return fd.read();
-    }
-
-    /**
-     * Reads a sub array as a sequence of bytes.
-     * @param b the buffer into which the data is read.
-     * @param off the start offset of the data.
-     * @param len the number of bytes to read.
-     * @exception IOException If an I/O error has occurred.
-     */
-    private int readBytes(byte b[], int off, int len) throws IOException
-    {
-        return fd.readBytes(b, off, len);
-    }
-
-    /**
-     * Reads up to {@code len} bytes of data from this file into an
-     * array of bytes. This method blocks until at least one byte of input
-     * is available.
-     * <p>
-     * Although {@code RandomAccessFile} is not a subclass of
-     * {@code InputStream}, this method behaves in exactly the
-     * same way as the {@link InputStream#read(byte[], int, int)} method of
-     * {@code InputStream}.
-     *
-     * @param      b     the buffer into which the data is read.
-     * @param      off   the start offset in array {@code b}
-     *                   at which the data is written.
-     * @param      len   the maximum number of bytes read.
-     * @return     the total number of bytes read into the buffer, or
-     *             {@code -1} if there is no more data because the end of
-     *             the file has been reached.
-     * @exception  IOException If the first byte cannot be read for any reason
-     * other than end of file, or if the random access file has been closed, or if
-     * some other I/O error occurs.
-     * @exception  NullPointerException If {@code b} is {@code null}.
-     * @exception  IndexOutOfBoundsException If {@code off} is negative,
-     * {@code len} is negative, or {@code len} is greater than
-     * {@code b.length - off}
-     */
-    public int read(byte b[], int off, int len) throws IOException {
-        return readBytes(b, off, len);
-    }
-
-    /**
-     * Reads up to {@code b.length} bytes of data from this file
-     * into an array of bytes. This method blocks until at least one byte
-     * of input is available.
-     * <p>
-     * Although {@code RandomAccessFile} is not a subclass of
-     * {@code InputStream}, this method behaves in exactly the
-     * same way as the {@link InputStream#read(byte[])} method of
-     * {@code InputStream}.
-     *
-     * @param      b   the buffer into which the data is read.
-     * @return     the total number of bytes read into the buffer, or
-     *             {@code -1} if there is no more data because the end of
-     *             this file has been reached.
-     * @exception  IOException If the first byte cannot be read for any reason
-     * other than end of file, or if the random access file has been closed, or if
-     * some other I/O error occurs.
-     * @exception  NullPointerException If {@code b} is {@code null}.
-     */
-    public int read(byte b[]) throws IOException {
-        return readBytes(b, 0, b.length);
-    }
-
-    /**
-     * Reads {@code b.length} bytes from this file into the byte
-     * array, starting at the current file pointer. This method reads
-     * repeatedly from the file until the requested number of bytes are
-     * read. This method blocks until the requested number of bytes are
-     * read, the end of the stream is detected, or an exception is thrown.
-     *
-     * @param      b   the buffer into which the data is read.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               all the bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final void readFully(byte b[]) throws IOException {
-        readFully(b, 0, b.length);
-    }
-
-    /**
-     * Reads exactly {@code len} bytes from this file into the byte
-     * array, starting at the current file pointer. This method reads
-     * repeatedly from the file until the requested number of bytes are
-     * read. This method blocks until the requested number of bytes are
-     * read, the end of the stream is detected, or an exception is thrown.
-     *
-     * @param      b     the buffer into which the data is read.
-     * @param      off   the start offset of the data.
-     * @param      len   the number of bytes to read.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               all the bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final void readFully(byte b[], int off, int len) throws IOException {
-        int n = 0;
-        do {
-            int count = this.read(b, off + n, len - n);
-            if (count < 0)
-                throw new EOFException();
-            n += count;
-        } while (n < len);
-    }
-
-    /**
-     * Attempts to skip over {@code n} bytes of input discarding the
-     * skipped bytes.
-     * <p>
-     *
-     * This method may skip over some smaller number of bytes, possibly zero.
-     * This may result from any of a number of conditions; reaching end of
-     * file before {@code n} bytes have been skipped is only one
-     * possibility. This method never throws an {@code EOFException}.
-     * The actual number of bytes skipped is returned.  If {@code n}
-     * is negative, no bytes are skipped.
-     *
-     * @param      n   the number of bytes to be skipped.
-     * @return     the actual number of bytes skipped.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public int skipBytes(int n) throws IOException {
-        long pos;
-        long len;
-        long newpos;
-
-        if (n <= 0) {
-            return 0;
-        }
-        pos = getFilePointer();
-        len = length();
-        newpos = pos + n;
-        if (newpos > len) {
-            newpos = len;
-        }
-        seek(newpos);
-
-        /* return the actual number of bytes skipped */
-        return (int) (newpos - pos);
-    }
-
-    // 'Write' primitives
-
-    /**
-     * Writes the specified byte to this file. The write starts at
-     * the current file pointer.
-     *
-     * @param      b   the {@code byte} to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(int b) throws IOException {
-        fd.write(b);
-    }
-
-    /**
-     * Writes a sub array as a sequence of bytes.
-     * @param b the data to be written
-
-     * @param off the start offset in the data
-     * @param len the number of bytes that are written
-     * @exception IOException If an I/O error has occurred.
-     */
-    private void writeBytes(byte b[], int off, int len) throws IOException {
-        fd.writeBytes(b, off, len);
-    }
-
-    /**
-     * Writes {@code b.length} bytes from the specified byte array
-     * to this file, starting at the current file pointer.
-     *
-     * @param      b   the data.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(byte b[]) throws IOException {
-        writeBytes(b, 0, b.length);
-    }
-
-    /**
-     * Writes {@code len} bytes from the specified byte array
-     * starting at offset {@code off} to this file.
-     *
-     * @param      b     the data.
-     * @param      off   the start offset in the data.
-     * @param      len   the number of bytes to write.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public void write(byte b[], int off, int len) throws IOException {
-        writeBytes(b, off, len);
-    }
-
-    // 'Random access' stuff
-
-    /**
-     * Returns the current offset in this file.
-     *
-     * @return     the offset from the beginning of the file, in bytes,
-     *             at which the next read or write occurs.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public long getFilePointer() throws IOException
-    {
-        return fd.getFilePointer();
-    }
-
-    /**
-     * Sets the file-pointer offset, measured from the beginning of this
-     * file, at which the next read or write occurs.  The offset may be
-     * set beyond the end of the file. Setting the offset beyond the end
-     * of the file does not change the file length.  The file length will
-     * change only by writing after the offset has been set beyond the end
-     * of the file.
-     *
-     * @param      pos   the offset position, measured in bytes from the
-     *                   beginning of the file, at which to set the file
-     *                   pointer.
-     * @exception  IOException  if {@code pos} is less than
-     *                          {@code 0} or if an I/O error occurs.
-     */
-    public void seek(long pos) throws IOException {
-        if (pos < 0) {
-            throw new IOException("Negative seek offset");
-        } else {
-            fd.seek(pos);
-        }
-    }
-
-    /**
-     * Returns the length of this file.
-     *
-     * @return     the length of this file, measured in bytes.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public long length() throws IOException
-    {
-        return fd.length();
-    }
-
-    /**
-     * Sets the length of this file.
-     *
-     * <p> If the present length of the file as returned by the
-     * {@code length} method is greater than the {@code newLength}
-     * argument then the file will be truncated.  In this case, if the file
-     * offset as returned by the {@code getFilePointer} method is greater
-     * than {@code newLength} then after this method returns the offset
-     * will be equal to {@code newLength}.
-     *
-     * <p> If the present length of the file as returned by the
-     * {@code length} method is smaller than the {@code newLength}
-     * argument then the file will be extended.  In this case, the contents of
-     * the extended portion of the file are not defined.
-     *
-     * @param      newLength    The desired length of the file
-     * @exception  IOException  If an I/O error occurs
-     * @since      1.2
-     */
-    public void setLength(long newLength) throws IOException
-    {
-        fd.setLength(newLength);
-    }
-
-    /**
-     * Closes this random access file stream and releases any system
-     * resources associated with the stream. A closed random access
-     * file cannot perform input or output operations and cannot be
-     * reopened.
-     *
-     * <p> If this file has an associated channel then the channel is closed
-     * as well.
-     *
-     * @exception  IOException  if an I/O error occurs.
-     *
-     * @revised 1.4
-     * @spec JSR-51
-     */
-    public void close() throws IOException {
-        synchronized (closeLock) {
-            if (closed) {
-                return;
-            }
-            closed = true;
-        }
-        if (channel != null) {
-            channel.close();
-        }
-
-        fd.closeAll(new Closeable() {
-            public void close() throws IOException {
-               close0();
-           }
-        });
-    }
-
-    //
-    //  Some "reading/writing Java data types" methods stolen from
-    //  DataInputStream and DataOutputStream.
-    //
-
-    /**
-     * Reads a {@code boolean} from this file. This method reads a
-     * single byte from the file, starting at the current file pointer.
-     * A value of {@code 0} represents
-     * {@code false}. Any other value represents {@code true}.
-     * This method blocks until the byte is read, the end of the stream
-     * is detected, or an exception is thrown.
-     *
-     * @return     the {@code boolean} value read.
-     * @exception  EOFException  if this file has reached the end.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final boolean readBoolean() throws IOException {
-        int ch = this.read();
-        if (ch < 0)
-            throw new EOFException();
-        return (ch != 0);
-    }
-
-    /**
-     * Reads a signed eight-bit value from this file. This method reads a
-     * byte from the file, starting from the current file pointer.
-     * If the byte read is {@code b}, where
-     * <code>0&nbsp;&lt;=&nbsp;b&nbsp;&lt;=&nbsp;255</code>,
-     * then the result is:
-     * <blockquote><pre>
-     *     (byte)(b)
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the byte is read, the end of the stream
-     * is detected, or an exception is thrown.
-     *
-     * @return     the next byte of this file as a signed eight-bit
-     *             {@code byte}.
-     * @exception  EOFException  if this file has reached the end.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final byte readByte() throws IOException {
-        int ch = this.read();
-        if (ch < 0)
-            throw new EOFException();
-        return (byte)(ch);
-    }
-
-    /**
-     * Reads an unsigned eight-bit number from this file. This method reads
-     * a byte from this file, starting at the current file pointer,
-     * and returns that byte.
-     * <p>
-     * This method blocks until the byte is read, the end of the stream
-     * is detected, or an exception is thrown.
-     *
-     * @return     the next byte of this file, interpreted as an unsigned
-     *             eight-bit number.
-     * @exception  EOFException  if this file has reached the end.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final int readUnsignedByte() throws IOException {
-        int ch = this.read();
-        if (ch < 0)
-            throw new EOFException();
-        return ch;
-    }
-
-    /**
-     * Reads a signed 16-bit number from this file. The method reads two
-     * bytes from this file, starting at the current file pointer.
-     * If the two bytes read, in order, are
-     * {@code b1} and {@code b2}, where each of the two values is
-     * between {@code 0} and {@code 255}, inclusive, then the
-     * result is equal to:
-     * <blockquote><pre>
-     *     (short)((b1 &lt;&lt; 8) | b2)
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the two bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next two bytes of this file, interpreted as a signed
-     *             16-bit number.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               two bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final short readShort() throws IOException {
-        int ch1 = this.read();
-        int ch2 = this.read();
-        if ((ch1 | ch2) < 0)
-            throw new EOFException();
-        return (short)((ch1 << 8) + (ch2 << 0));
-    }
-
-    /**
-     * Reads an unsigned 16-bit number from this file. This method reads
-     * two bytes from the file, starting at the current file pointer.
-     * If the bytes read, in order, are
-     * {@code b1} and {@code b2}, where
-     * <code>0&nbsp;&lt;=&nbsp;b1, b2&nbsp;&lt;=&nbsp;255</code>,
-     * then the result is equal to:
-     * <blockquote><pre>
-     *     (b1 &lt;&lt; 8) | b2
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the two bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next two bytes of this file, interpreted as an unsigned
-     *             16-bit integer.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               two bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final int readUnsignedShort() throws IOException {
-        int ch1 = this.read();
-        int ch2 = this.read();
-        if ((ch1 | ch2) < 0)
-            throw new EOFException();
-        return (ch1 << 8) + (ch2 << 0);
-    }
-
-    /**
-     * Reads a character from this file. This method reads two
-     * bytes from the file, starting at the current file pointer.
-     * If the bytes read, in order, are
-     * {@code b1} and {@code b2}, where
-     * <code>0&nbsp;&lt;=&nbsp;b1,&nbsp;b2&nbsp;&lt;=&nbsp;255</code>,
-     * then the result is equal to:
-     * <blockquote><pre>
-     *     (char)((b1 &lt;&lt; 8) | b2)
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the two bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next two bytes of this file, interpreted as a
-     *                  {@code char}.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               two bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final char readChar() throws IOException {
-        int ch1 = this.read();
-        int ch2 = this.read();
-        if ((ch1 | ch2) < 0)
-            throw new EOFException();
-        return (char)((ch1 << 8) + (ch2 << 0));
-    }
-
-    /**
-     * Reads a signed 32-bit integer from this file. This method reads 4
-     * bytes from the file, starting at the current file pointer.
-     * If the bytes read, in order, are {@code b1},
-     * {@code b2}, {@code b3}, and {@code b4}, where
-     * <code>0&nbsp;&lt;=&nbsp;b1, b2, b3, b4&nbsp;&lt;=&nbsp;255</code>,
-     * then the result is equal to:
-     * <blockquote><pre>
-     *     (b1 &lt;&lt; 24) | (b2 &lt;&lt; 16) + (b3 &lt;&lt; 8) + b4
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the four bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next four bytes of this file, interpreted as an
-     *             {@code int}.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               four bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final int readInt() throws IOException {
-        int ch1 = this.read();
-        int ch2 = this.read();
-        int ch3 = this.read();
-        int ch4 = this.read();
-        if ((ch1 | ch2 | ch3 | ch4) < 0)
-            throw new EOFException();
-        return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
-    }
-
-    /**
-     * Reads a signed 64-bit integer from this file. This method reads eight
-     * bytes from the file, starting at the current file pointer.
-     * If the bytes read, in order, are
-     * {@code b1}, {@code b2}, {@code b3},
-     * {@code b4}, {@code b5}, {@code b6},
-     * {@code b7}, and {@code b8,} where:
-     * <blockquote><pre>
-     *     0 &lt;= b1, b2, b3, b4, b5, b6, b7, b8 &lt;=255,
-     * </pre></blockquote>
-     * <p>
-     * then the result is equal to:
-     * <blockquote><pre>
-     *     ((long)b1 &lt;&lt; 56) + ((long)b2 &lt;&lt; 48)
-     *     + ((long)b3 &lt;&lt; 40) + ((long)b4 &lt;&lt; 32)
-     *     + ((long)b5 &lt;&lt; 24) + ((long)b6 &lt;&lt; 16)
-     *     + ((long)b7 &lt;&lt; 8) + b8
-     * </pre></blockquote>
-     * <p>
-     * This method blocks until the eight bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next eight bytes of this file, interpreted as a
-     *             {@code long}.
-     * @exception  EOFException  if this file reaches the end before reading
-     *               eight bytes.
-     * @exception  IOException   if an I/O error occurs.
-     */
-    public final long readLong() throws IOException {
-        return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
-    }
-
-    /**
-     * Reads a {@code float} from this file. This method reads an
-     * {@code int} value, starting at the current file pointer,
-     * as if by the {@code readInt} method
-     * and then converts that {@code int} to a {@code float}
-     * using the {@code intBitsToFloat} method in class
-     * {@code Float}.
-     * <p>
-     * This method blocks until the four bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next four bytes of this file, interpreted as a
-     *             {@code float}.
-     * @exception  EOFException  if this file reaches the end before reading
-     *             four bytes.
-     * @exception  IOException   if an I/O error occurs.
-     * @see        java.io.RandomAccessFile#readInt()
-     * @see        java.lang.Float#intBitsToFloat(int)
-     */
-    public final float readFloat() throws IOException {
-        return Float.intBitsToFloat(readInt());
-    }
-
-    /**
-     * Reads a {@code double} from this file. This method reads a
-     * {@code long} value, starting at the current file pointer,
-     * as if by the {@code readLong} method
-     * and then converts that {@code long} to a {@code double}
-     * using the {@code longBitsToDouble} method in
-     * class {@code Double}.
-     * <p>
-     * This method blocks until the eight bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     the next eight bytes of this file, interpreted as a
-     *             {@code double}.
-     * @exception  EOFException  if this file reaches the end before reading
-     *             eight bytes.
-     * @exception  IOException   if an I/O error occurs.
-     * @see        java.io.RandomAccessFile#readLong()
-     * @see        java.lang.Double#longBitsToDouble(long)
-     */
-    public final double readDouble() throws IOException {
-        return Double.longBitsToDouble(readLong());
-    }
-
-    /**
-     * Reads the next line of text from this file.  This method successively
-     * reads bytes from the file, starting at the current file pointer,
-     * until it reaches a line terminator or the end
-     * of the file.  Each byte is converted into a character by taking the
-     * byte's value for the lower eight bits of the character and setting the
-     * high eight bits of the character to zero.  This method does not,
-     * therefore, support the full Unicode character set.
-     *
-     * <p> A line of text is terminated by a carriage-return character
-     * ({@code '\u005Cr'}), a newline character ({@code '\u005Cn'}), a
-     * carriage-return character immediately followed by a newline character,
-     * or the end of the file.  Line-terminating characters are discarded and
-     * are not included as part of the string returned.
-     *
-     * <p> This method blocks until a newline character is read, a carriage
-     * return and the byte following it are read (to see if it is a newline),
-     * the end of the file is reached, or an exception is thrown.
-     *
-     * @return     the next line of text from this file, or null if end
-     *             of file is encountered before even one byte is read.
-     * @exception  IOException  if an I/O error occurs.
-     */
-
-    public final String readLine() throws IOException {
-        StringBuffer input = new StringBuffer();
-        int c = -1;
-        boolean eol = false;
-
-        while (!eol) {
-            switch (c = read()) {
-            case -1:
-            case '\n':
-                eol = true;
-                break;
-            case '\r':
-                eol = true;
-                long cur = getFilePointer();
-                if ((read()) != '\n') {
-                    seek(cur);
-                }
-                break;
-            default:
-                input.append((char)c);
-                break;
-            }
-        }
-
-        if ((c == -1) && (input.length() == 0)) {
-            return null;
-        }
-        return input.toString();
-    }
-
-    /**
-     * Reads in a string from this file. The string has been encoded
-     * using a
-     * <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
-     * format.
-     * <p>
-     * The first two bytes are read, starting from the current file
-     * pointer, as if by
-     * {@code readUnsignedShort}. This value gives the number of
-     * following bytes that are in the encoded string, not
-     * the length of the resulting string. The following bytes are then
-     * interpreted as bytes encoding characters in the modified UTF-8 format
-     * and are converted into characters.
-     * <p>
-     * This method blocks until all the bytes are read, the end of the
-     * stream is detected, or an exception is thrown.
-     *
-     * @return     a Unicode string.
-     * @exception  EOFException            if this file reaches the end before
-     *               reading all the bytes.
-     * @exception  IOException             if an I/O error occurs.
-     * @exception  UTFDataFormatException  if the bytes do not represent
-     *               valid modified UTF-8 encoding of a Unicode string.
-     * @see        java.io.RandomAccessFile#readUnsignedShort()
-     */
-    public final String readUTF() throws IOException {
-        return DataInputStream.readUTF(this);
-    }
-
-    /**
-     * Writes a {@code boolean} to the file as a one-byte value. The
-     * value {@code true} is written out as the value
-     * {@code (byte)1}; the value {@code false} is written out
-     * as the value {@code (byte)0}. The write starts at
-     * the current position of the file pointer.
-     *
-     * @param      v   a {@code boolean} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeBoolean(boolean v) throws IOException {
-        write(v ? 1 : 0);
-        //written++;
-    }
-
-    /**
-     * Writes a {@code byte} to the file as a one-byte value. The
-     * write starts at the current position of the file pointer.
-     *
-     * @param      v   a {@code byte} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeByte(int v) throws IOException {
-        write(v);
-        //written++;
-    }
-
-    /**
-     * Writes a {@code short} to the file as two bytes, high byte first.
-     * The write starts at the current position of the file pointer.
-     *
-     * @param      v   a {@code short} to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeShort(int v) throws IOException {
-        write((v >>> 8) & 0xFF);
-        write((v >>> 0) & 0xFF);
-        //written += 2;
-    }
-
-    /**
-     * Writes a {@code char} to the file as a two-byte value, high
-     * byte first. The write starts at the current position of the
-     * file pointer.
-     *
-     * @param      v   a {@code char} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeChar(int v) throws IOException {
-        write((v >>> 8) & 0xFF);
-        write((v >>> 0) & 0xFF);
-        //written += 2;
-    }
-
-    /**
-     * Writes an {@code int} to the file as four bytes, high byte first.
-     * The write starts at the current position of the file pointer.
-     *
-     * @param      v   an {@code int} to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeInt(int v) throws IOException {
-        write((v >>> 24) & 0xFF);
-        write((v >>> 16) & 0xFF);
-        write((v >>>  8) & 0xFF);
-        write((v >>>  0) & 0xFF);
-        //written += 4;
-    }
-
-    /**
-     * Writes a {@code long} to the file as eight bytes, high byte first.
-     * The write starts at the current position of the file pointer.
-     *
-     * @param      v   a {@code long} to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeLong(long v) throws IOException {
-        write((int)(v >>> 56) & 0xFF);
-        write((int)(v >>> 48) & 0xFF);
-        write((int)(v >>> 40) & 0xFF);
-        write((int)(v >>> 32) & 0xFF);
-        write((int)(v >>> 24) & 0xFF);
-        write((int)(v >>> 16) & 0xFF);
-        write((int)(v >>>  8) & 0xFF);
-        write((int)(v >>>  0) & 0xFF);
-        //written += 8;
-    }
-
-    /**
-     * Converts the float argument to an {@code int} using the
-     * {@code floatToIntBits} method in class {@code Float},
-     * and then writes that {@code int} value to the file as a
-     * four-byte quantity, high byte first. The write starts at the
-     * current position of the file pointer.
-     *
-     * @param      v   a {@code float} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.lang.Float#floatToIntBits(float)
-     */
-    public final void writeFloat(float v) throws IOException {
-        writeInt(Float.floatToIntBits(v));
-    }
-
-    /**
-     * Converts the double argument to a {@code long} using the
-     * {@code doubleToLongBits} method in class {@code Double},
-     * and then writes that {@code long} value to the file as an
-     * eight-byte quantity, high byte first. The write starts at the current
-     * position of the file pointer.
-     *
-     * @param      v   a {@code double} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.lang.Double#doubleToLongBits(double)
-     */
-    public final void writeDouble(double v) throws IOException {
-        writeLong(Double.doubleToLongBits(v));
-    }
-
-    /**
-     * Writes the string to the file as a sequence of bytes. Each
-     * character in the string is written out, in sequence, by discarding
-     * its high eight bits. The write starts at the current position of
-     * the file pointer.
-     *
-     * @param      s   a string of bytes to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    @SuppressWarnings("deprecation")
-    public final void writeBytes(String s) throws IOException {
-        int len = s.length();
-        byte[] b = new byte[len];
-        s.getBytes(0, len, b, 0);
-        writeBytes(b, 0, len);
-    }
-
-    /**
-     * Writes a string to the file as a sequence of characters. Each
-     * character is written to the data output stream as if by the
-     * {@code writeChar} method. The write starts at the current
-     * position of the file pointer.
-     *
-     * @param      s   a {@code String} value to be written.
-     * @exception  IOException  if an I/O error occurs.
-     * @see        java.io.RandomAccessFile#writeChar(int)
-     */
-    public final void writeChars(String s) throws IOException {
-        int clen = s.length();
-        int blen = 2*clen;
-        byte[] b = new byte[blen];
-        char[] c = new char[clen];
-        s.getChars(0, clen, c, 0);
-        for (int i = 0, j = 0; i < clen; i++) {
-            b[j++] = (byte)(c[i] >>> 8);
-            b[j++] = (byte)(c[i] >>> 0);
-        }
-        writeBytes(b, 0, blen);
-    }
-
-    /**
-     * Writes a string to the file using
-     * <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
-     * encoding in a machine-independent manner.
-     * <p>
-     * First, two bytes are written to the file, starting at the
-     * current file pointer, as if by the
-     * {@code writeShort} method giving the number of bytes to
-     * follow. This value is the number of bytes actually written out,
-     * not the length of the string. Following the length, each character
-     * of the string is output, in sequence, using the modified UTF-8 encoding
-     * for each character.
-     *
-     * @param      str   a string to be written.
-     * @exception  IOException  if an I/O error occurs.
-     */
-    public final void writeUTF(String str) throws IOException {
-        DataOutputStream.writeUTF(str, this);
-    }
-
-    private void close0() throws IOException
-    {
-        fd.close();
-    }
-}
diff --git a/runtime/openjdk/java.io.cs b/runtime/openjdk/java.io.cs
index f161fa7b..78b51cb1 100644
--- a/runtime/openjdk/java.io.cs
+++ b/runtime/openjdk/java.io.cs
@@ -185,6 +185,105 @@ static class Java_java_io_FileDescriptor
 	}
 }
 
+static class Java_java_io_FileInputStream
+{
+	public static void open0(object _this, string name, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.openReadOnly(name);
+#endif
+	}
+
+	public static int read0(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.read();
+#endif
+	}
+
+	public static int readBytes(object _this, byte[] b, int off, int len, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.readBytes(b, off, len);
+#endif
+	}
+
+	public static long skip(object _this, long n, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.skip(n);
+#endif
+	}
+
+	public static int available(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.available();
+#endif
+	}
+
+	public static void close0(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.close();
+#endif
+	}
+
+	public static void initIDs()
+	{
+	}
+}
+
+static class Java_java_io_FileOutputStream
+{
+	public static void open0(object _this, string name, bool append, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		if (append)
+		{
+			fd.openAppend(name);
+		}
+		else
+		{
+			fd.openWriteOnly(name);
+		}
+#endif
+	}
+
+	public static void write(object _this, int b, bool append, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.write(b);
+#endif
+	}
+
+	public static void writeBytes(object _this, byte[] b, int off, int len, bool append, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.writeBytes(b, off, len);
+#endif
+	}
+
+	public static void close0(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.close();
+#endif
+	}
+
+	public static void initIDs()
+	{
+	}
+}
+
 static class Java_java_io_ObjectInputStream
 {
 	public static void bytesToFloats(byte[] src, int srcpos, float[] dst, int dstpos, int nfloats)
@@ -667,6 +766,98 @@ static class Java_java_io_ObjectStreamClass
 	}
 }
 
+static class Java_java_io_RandomAccessFile
+{
+	public static void open0(object _this, string name, int mode, [In] java.io.FileDescriptor fd, [In] int O_RDWR)
+	{
+#if !FIRST_PASS
+		if ((mode & O_RDWR) == O_RDWR)
+		{
+			fd.openReadWrite(name);
+		}
+		else
+		{
+			fd.openReadOnly(name);
+		}
+#endif
+	}
+
+	public static int read0(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.read();
+#endif
+	}
+
+	public static int readBytes(object _this, byte[] b, int off, int len, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.readBytes(b, off, len);
+#endif
+	}
+
+	public static void write0(object _this, int b, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.write(b);
+#endif
+	}
+
+	public static void writeBytes(object _this, byte[] b, int off, int len, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.writeBytes(b, off, len);
+#endif
+	}
+
+	public static long getFilePointer(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.getFilePointer();
+#endif
+	}
+
+	public static void seek0(object _this, long pos, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.seek(pos);
+#endif
+	}
+
+	public static long length(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if FIRST_PASS
+		return 0;
+#else
+		return fd.length();
+#endif
+	}
+
+	public static void setLength(object _this, long newLength, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.setLength(newLength);
+#endif
+	}
+
+	public static void close0(object _this, [In] java.io.FileDescriptor fd)
+	{
+#if !FIRST_PASS
+		fd.close();
+#endif
+	}
+
+	public static void initIDs()
+	{
+	}
+}
+
 static class Java_java_io_WinNTFileSystem
 {
 	internal const int ACCESS_READ = 0x04;