// would be nicer if we directly imported from os, but crazy to do so

// since in python code itself

private static class os {

public static final int SEEK_SET = 0;

public static final int SEEK_CUR = 1;

public static final int SEEK_END = 2;

}

/** The underlying file channel */

private FileChannel fileChannel;

/** The underlying RandomAccessFile, if known. May be null */

private RandomAccessFile file;

/** The underlying FileOutputStream, if known. May be null */

private FileOutputStream fileOutputStream;

/** true if the file is opened for reading ('r') */

private boolean reading;

/** true if the file is opened for writing ('w', 'a', or '+') */

private boolean writing;

/** true if the file is in appending mode ('a') */

private boolean appending;

/** true if the file is opened for reading and writing ('+') */

private boolean plus;

/** true if write will emulate O_APPEND mode */

private boolean emulateAppend;

/**

public FileIO(String name, String mode) {

this(Py.newUnicode(name), mode);

}

/**

public FileIO(PyString name, String mode) {

parseMode(mode);

File absPath = new RelativeFile(Py.fileSystemDecode(name));

try {

if ((appending && !(reading || plus)) || (writing && !reading && !plus)) {

// Take advantage of FileOutputStream's append mode

fromFileOutputStream(absPath);

} else {

fromRandomAccessFile(absPath);

emulateAppend = appending;

}

} catch (FileNotFoundException fnfe) {

if (absPath.isDirectory()) {

throw Py.IOError(Errno.EISDIR, name);

}

if ((writing && !absPath.canWrite())

|| fnfe.getMessage().endsWith("(Permission denied)")) {

throw Py.IOError(Errno.EACCES, name);

}

throw Py.IOError(Errno.ENOENT, name);

}

initPosition();

}

/**

public FileIO(FileChannel fileChannel, String mode) {

parseMode(mode);

this.fileChannel = fileChannel;

initPosition();

}

/**

private void parseMode(String mode) {

boolean rwa = false;

for (int i = 0; i < mode.length(); i++) {

switch (mode.charAt(i)) {

case 'r':

if (plus || rwa) {

badMode();

}

reading = rwa = true;

break;

case 'w':

if (plus || rwa) {

badMode();

}

writing = rwa = true;

break;

case 'a':

if (plus || rwa) {

badMode();

}

appending = writing = rwa = true;

break;

case '+':

if (plus || !rwa) {

badMode();

}

writing = plus = true;

break;

default:

throw Py.ValueError("invalid mode: '" + mode + "'");

}

}

if (!rwa) {

badMode();

}

}

/**

private void fromRandomAccessFile(File absPath) throws FileNotFoundException {

String rafMode = "r" + (writing ? "w" : "");

if (plus && reading && !absPath.isFile()) {

// suppress "permission denied"

writing = false;

throw new FileNotFoundException("");

}

file = new RandomAccessFile(absPath, rafMode);

fileChannel = file.getChannel();

}

/**

private void fromFileOutputStream(File absPath) throws FileNotFoundException {

fileOutputStream = new FileOutputStream(absPath, appending);

fileChannel = fileOutputStream.getChannel();

}

/**

private void badMode() {

throw Py.ValueError("Must have exactly one of read/write/append mode");

}

/**

private void initPosition() {

if (appending) {

seek(0, os.SEEK_END);

} else if (writing && !reading) {

try {

fileChannel.truncate(0);

} catch (IOException ioe) {

// On Solaris and Linux, ftruncate(3C) returns EINVAL if not a regular

// file whereas, e.g., open(os.devnull, "w") works. Because we have to

// simulate the "w" mode in Java, we suppress the exception.

// Likewise Windows returns ERROR_INVALID_FUNCTION in that case and

// ERROR_INVALID_HANDLE on ttys. Identifying those by the IOException

// message is tedious as their messages are localized, so we suppress them

// all =[

//

// Unfortunately attempting to distinguish by localized messages is too hard.

// Give up and swallow the exception.

// See http://bugs.jython.org/issue1944

}

}

}

@Override

public boolean isatty() {

checkClosed();

if (file == null || fileOutputStream == null) {

return false;

}

try {

return PosixModule.getPOSIX().isatty(file.getFD());

} catch (IOException e) {

return false;

}

}

@Override

public int readinto(ByteBuffer buf) {

checkClosed();

checkReadable();

try {

int n = fileChannel.read(buf);

return n > 0 ? n : 0;

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

/**

@Override

public long readinto(ByteBuffer[] bufs) {

checkClosed();

checkReadable();

try {

long n = fileChannel.read(bufs);

return n > 0L ? n : 0L;

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

/**

@Override

public ByteBuffer readall() {

checkClosed();

checkReadable();

// NOTE: This could be less accurate than multiple reads if

// the file is growing

long toRead;

try {

toRead = Math.max(0, fileChannel.size() - fileChannel.position());

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

if (toRead > Integer.MAX_VALUE) {

throw Py.OverflowError("requested number of bytes is more than a Python string can "

+ "hold");

} else if (toRead == 0) {

// Support files that the underlying OS has labeled with size=0, even though they have content,

// eg, /proc files on Linux

return readallInChunks();

} else {

ByteBuffer all = ByteBuffer.allocate((int) toRead);

readinto(all);

all.flip();

return all;

}

}

private ByteBuffer readallInChunks() {

// assumes checks have been performed

final List<ByteBuffer> chunks = new ArrayList<>();

final int MAX_CHUNK_SIZE = 8192;

int length = 0;

while (true) {

final ByteBuffer chunk = ByteBuffer.allocate(MAX_CHUNK_SIZE);

readinto(chunk);

int chunkSize = chunk.position();

length += chunkSize;

chunk.flip();

chunks.add(chunk);

if (chunkSize < MAX_CHUNK_SIZE) {

break;

}

}

// given the size of MAX_CHUNK_SIZE, perhaps most or even all files in /proc,

// or similar virtual filesystems, if any, might fit into one chunk

if (chunks.size() == 1) {

return chunks.get(0);

}

// otherwise append together into a single ByteBuffer

final ByteBuffer all = ByteBuffer.allocate(length);

for (ByteBuffer chunk : chunks) {

all.put(chunk);

}

all.flip();

return all;

}

@Override

public int write(ByteBuffer buf) {

checkClosed();

checkWritable();

try {

return emulateAppend ? appendFromByteBuffer(buf) // use this helper function to advance the file channel's position post-write

: fileChannel.write(buf); // this does change the file channel's position

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

private int appendFromByteBuffer(ByteBuffer buf) throws IOException {

int written = fileChannel.write(buf, fileChannel.position()); // this does not change the file channel's position!

if (written > 0) {

// we need to manually update the file channel's position post-write

fileChannel.position(fileChannel.position() + written);

}

return written;

}

/**

@Override

public long write(ByteBuffer[] bufs) {

checkClosed();

checkWritable();

try {

return !emulateAppend ? fileChannel.write(bufs) : writeAppend(bufs);

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

/**

private long writeAppend(ByteBuffer[] bufs) throws IOException {

long count = 0;

int bufCount;

for (ByteBuffer buf : bufs) {

if (!buf.hasRemaining()) {

continue;

}

bufCount = appendFromByteBuffer(buf);

if (bufCount == 0) {

break;

}

count += bufCount;

}

return count;

}

@Override

public long seek(long pos, int whence) {

checkClosed();

try {

switch (whence) {

case os.SEEK_SET:

break;

case os.SEEK_CUR:

pos += fileChannel.position();

break;

case os.SEEK_END:

pos += fileChannel.size();

break;

default:

throw Py.IOError(Errno.EINVAL);

}

fileChannel.position(pos);

return pos;

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

@Override

public long tell() {

checkClosed();

try {

return fileChannel.position();

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

}

@Override

public long truncate(long size) {

checkClosed();

checkWritable();

try {

long oldPosition = fileChannel.position();

fileChannel.truncate(size);

// seek necessary on Windows only, see <http://bugs.python.org/issue801631>

fileChannel.position(oldPosition);

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

return size;

}

@Override

public void close() {

if (closed()) {

return;

}

try {

fileChannel.close();

} catch (IOException ioe) {

throw Py.IOError(ioe);

}

super.close();

}

@Override

public OutputStream asOutputStream() {

return writing ? Channels.newOutputStream(fileChannel) : super.asOutputStream();

}

@Override

public InputStream asInputStream() {

return readable() ? Channels.newInputStream(fileChannel) : super.asInputStream();

}

@Override

public boolean readable() {

return reading || plus;

}

@Override

public boolean writable() {

return writing;

}

@Override

public FileChannel getChannel() {

return fileChannel;

}

public FileDescriptor getFD() {

if (file != null) {

try {

return file.getFD();

} catch (IOException ioe) {

throw Py.OSError(ioe);

}

} else if (fileOutputStream != null) {

try {

return fileOutputStream.getFD();

} catch (IOException ioe) {

throw Py.OSError(ioe);

}

}

throw Py.OSError(Errno.EBADF);

}

public PyObject __int__() {

int intFD = -1;

try {

Field fdField = FieldAccess.getProtectedField(FileDescriptor.class, "fd");

intFD = fdField.getInt(getFD());

} catch (SecurityException e) {

} catch (IllegalArgumentException e) {

} catch (IllegalAccessException e) {

}

return Py.newInteger(intFD);

}

public PyObject __add__(PyObject otherObj) {

return __int__().__add__(otherObj);

}