public static final ByteList PARAGRAPH_SEPARATOR = ByteList.create("\n\n");

public static final String CLOSED_STREAM_MSG = "closed stream";

public enum IOEvent {

IO_READABLE(1), IO_PRIORITY(2), IO_WRITABLE(4);

final int value;

IOEvent(int value) {

this.value = value;

}

int getValue() {

return value;

}

}

// This should only be called by this and RubyFile.

// It allows this object to be created without a IOHandler.

public RubyIO(Ruby runtime, RubyClass type) {

super(runtime, type);

}

public RubyIO(Ruby runtime, OutputStream outputStream) {

this(runtime, outputStream, true);

}

public RubyIO(Ruby runtime, OutputStream outputStream, boolean autoclose) {

super(runtime, runtime.getIO());

// We only want IO objects with valid streams (better to error now).

if (outputStream == null) throw runtime.newRuntimeError("Opening null stream");

openFile = MakeOpenFile();

openFile.setFD(new ChannelFD(writableChannel(outputStream), runtime.getPosix(), runtime.getFilenoUtil()));

openFile.setMode(OpenFile.WRITABLE | OpenFile.APPEND);

openFile.setAutoclose(autoclose);

}

public RubyIO(Ruby runtime, InputStream inputStream) {

super(runtime, runtime.getIO());

if (inputStream == null) throw runtime.newRuntimeError("Opening null stream");

openFile = MakeOpenFile();

openFile.setFD(new ChannelFD(readableChannel(inputStream), runtime.getPosix(), runtime.getFilenoUtil()));

openFile.setMode(OpenFile.READABLE);

}

public RubyIO(Ruby runtime, Channel channel) {

this(runtime, runtime.getIO(), channel);

}

public RubyIO(Ruby runtime, RubyClass klass, Channel channel) {

super(runtime, klass);

var context = runtime.getCurrentContext();

// We only want IO objects with valid streams (better to error now).

if (channel == null) throw runtimeError(context, "Opening null channel");

var posix = runtime.getPosix();

initializeCommon(context, new ChannelFD(channel, posix, runtime.getFilenoUtil()),

asFixnum(context, ModeFlags.oflagsFrom(posix, channel)), context.nil);

}

public RubyIO(Ruby runtime, ShellLauncher.POpenProcess process, IOOptions ioOptions) {

super(runtime, runtime.getIO());

var context = runtime.getCurrentContext();

ioOptions = updateIOOptionsFromOptions(context, null, ioOptions);

openFile = MakeOpenFile();

setupPopen(context, ioOptions.getModeFlags(), process);

}

// MRI: prep_stdio

public static RubyIO prepStdio(Ruby runtime, InputStream f, Channel c, int fmode, RubyClass klass, String path) {

OpenFile fptr;

RubyIO io = prepIO(runtime.getCurrentContext(), c, fmode | OpenFile.PREP | EncodingUtils.DEFAULT_TEXTMODE, klass, path);

fptr = io.getOpenFileChecked();

// If we can't use native IO, always force stdio to expected fileno.

if (!runtime.getPosix().isNative() || Platform.IS_WINDOWS) {

// Use standard stdio filenos if we're using System.in et al.

if (f == System.in) {

fptr.fd().realFileno = 0;

}

}

prepStdioEcflags(fptr, fmode);

fptr.stdio_file = f;

// We checkTTY again here because we're using stdout/stdin to indicate this is stdio

return recheckTTY(runtime, fptr, io);

}

// MRI: prep_stdio

public static RubyIO prepStdio(Ruby runtime, OutputStream f, Channel c, int fmode, RubyClass klass, String path) {

OpenFile fptr;

RubyIO io = prepIO(runtime.getCurrentContext(), c, fmode | OpenFile.PREP | EncodingUtils.DEFAULT_TEXTMODE, klass, path);

fptr = io.getOpenFileChecked();

// If we can't use native IO, always force stdio to expected fileno.

if (!runtime.getPosix().isNative() || Platform.IS_WINDOWS) {

// Use standard stdio filenos if we're using System.in et al.

if (f == System.out) {

fptr.fd().realFileno = 1;

} else if (f == System.err) {

fptr.fd().realFileno = 2;

}

}

prepStdioEcflags(fptr, fmode);

fptr.stdio_file = f;

return recheckTTY(runtime, fptr, io);

}

private static RubyIO recheckTTY(Ruby runtime, OpenFile fptr, RubyIO io) {

// We checkTTY again here because we're using stdout/stdin to indicate this is stdio

fptr.checkTTY();

return io;

}

// MRI: part of prep_stdio

private static void prepStdioEcflags(OpenFile fptr, int fmode) {

boolean locked = fptr.lock();

try {

fptr.encs.ecflags |= EncodingUtils.ECONV_DEFAULT_NEWLINE_DECORATOR;

if (EncodingUtils.TEXTMODE_NEWLINE_DECORATOR_ON_WRITE != 0) {

fptr.encs.ecflags |= EncodingUtils.TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;

if ((fmode & OpenFile.READABLE) != 0) {

fptr.encs.ecflags |= EConvFlags.UNIVERSAL_NEWLINE_DECORATOR;

}

}

} finally {

if (locked) fptr.unlock();

}

}

// MRI: prep_io

private static RubyIO prepIO(ThreadContext context, Channel fd, int fmode, RubyClass klass, String path) {

OpenFile fp;

RubyIO io = (RubyIO)klass.allocate(context);

fp = io.MakeOpenFile();

fp.setChannel(fd);

// Can we determine this?

// TODO: setmode O_BINARY means what via NIO?

fp.setMode(fmode);

fp.checkTTY();

if (path != null) fp.setPath(path);

return io;

}

public static RubyIO newIO(Ruby runtime, Channel channel) {

return new RubyIO(runtime, channel);

}

public OpenFile getOpenFile() {

return openFile;

}

public OpenFile getOpenFileChecked() {

checkInitialized();

openFile.checkClosed();

return openFile;

}

// MRI: rb_io_get_fptr

public OpenFile getOpenFileInitialized() {

checkInitialized();

return openFile;

}

/*

@Override

public ClassIndex getNativeClassIndex() {

return ClassIndex.FILE;

}

public static RubyClass createIOClass(ThreadContext context, RubyClass Object, RubyModule Enumerable) {

RubyClass IO = defineClass(context, "IO", Object, RubyIO::new).

reifiedClass(RubyIO.class).

kindOf(new RubyModule.JavaClassKindOf(RubyIO.class)).

classIndex(ClassIndex.IO).

include(context, Enumerable).

defineMethods(context, RubyIO.class).

// Constants for seek

defineConstant(context, "SEEK_SET", asFixnum(context, PosixShim.SEEK_SET)).

defineConstant(context, "SEEK_CUR", asFixnum(context, PosixShim.SEEK_CUR)).

defineConstant(context, "SEEK_END", asFixnum(context, PosixShim.SEEK_END)).

defineConstant(context, "READABLE", asFixnum(context, IOEvent.IO_READABLE.getValue())).

defineConstant(context, "WRITABLE", asFixnum(context, IOEvent.IO_WRITABLE.getValue())).

defineConstant(context, "PRIORITY", asFixnum(context, IOEvent.IO_PRIORITY.getValue()));

IO.defineModuleUnder(context, "WaitReadable");

IO.defineModuleUnder(context, "WaitWritable");

return IO;

}

/**

public static class TimeoutError extends IOError {

public TimeoutError(String message, RubyIOTimeoutError exception) {

super(message, exception);

}

}

@JRubyClass(name="TimeoutError", parent="IOError")

public static class RubyIOTimeoutError extends RubyIOError {

protected RubyIOTimeoutError(Ruby runtime, RubyClass exceptionClass) {

super(runtime, exceptionClass);

}

static RubyClass define(ThreadContext context, RubyClass IO, RubyClass IOError) {

return IO.defineClassUnder(context, "TimeoutError", IOError, RubyIOTimeoutError::new);

}

@Override

protected TimeoutError constructThrowable(String message) {

return new TimeoutError(message, this);

}

public static RubyIOTimeoutError newIOTimeoutError(Ruby runtime, String message) {

return ((RubyIOTimeoutError) ((RubyClass) runtime.getClassFromPath("IO::TimeoutError")).newInstance(runtime.getCurrentContext(), RubyString.newString(runtime, message)));

}

}

public OutputStream getOutStream() {

return new OutputStream() {

final Ruby runtime = getRuntime();

@Override

public void write(int b) throws IOException {

RubyIO.this.write(runtime.getCurrentContext(), b);

}

@Override

public void write(byte[] b) throws IOException {

RubyIO.this.write(runtime.getCurrentContext(), b, 0, b.length, ASCIIEncoding.INSTANCE);

}

@Override

public void write(byte[] b, int off, int len) throws IOException {

RubyIO.this.write(runtime.getCurrentContext(), b, off, len, ASCIIEncoding.INSTANCE);

}

@Override

public void flush() throws IOException {

RubyIO.this.flush(runtime.getCurrentContext());

}

@Override

public void close() throws IOException {

RubyIO.this.close();

}

};

}

public InputStream getInStream() {

return new InputStream() {

final Ruby runtime = getRuntime();

@Override

public int read() throws IOException {

return getByte(runtime.getCurrentContext());

}

@Override

public int read(byte[] b) throws IOException {

return read(b, 0, b.length);

}

@Override

public int read(byte[] b, int off, int len) throws IOException {

return RubyIO.this.read(runtime.getCurrentContext(), b, off, len);

}

@Override

public long skip(long n) throws IOException {

return doSeek(runtime.getCurrentContext(), n, PosixShim.SEEK_CUR);

}

@Override

public int available() throws IOException {

if (RubyIO.this instanceof RubyFile) {

ThreadContext context = runtime.getCurrentContext();

long size = ((RubyFile) RubyIO.this).getSize(context);

if (size == 0) return 0;

if (size >= 0) return (int) (size - pos(context).getValue());

}

return 0;

}

@Override

public void close() throws IOException {

RubyIO.this.close();

}

};

}

/**

public Channel getChannel() {

// FIXME: Do we want to make a faux channel that is backed by IO's buffering? Or turn buffering off?

return getOpenFileChecked().channel();

}

// io_reopen

protected RubyIO reopenIO(ThreadContext context, RubyIO nfile) {

OpenFile fptr, orig;

ChannelFD fd, fd2;

long pos = 0;

nfile = TypeConverter.ioGetIO(context.runtime, nfile);

fptr = getOpenFileChecked();

orig = nfile.getOpenFileChecked();

if (fptr == orig) return this;

if (fptr.IS_PREP_STDIO()) {

if ((fptr.stdio_file == System.in && !orig.isReadable()) ||

(fptr.stdio_file == System.out && !orig.isWritable()) ||

(fptr.stdio_file == System.err && !orig.isWritable())) {

throw argumentError(context, fptr.PREP_STDIO_NAME() + " can't change access mode from \"" +

fptr.getModeAsString(context) + "\" to \"" + orig.getModeAsString(context) + "\"");

}

}

Ruby runtime = context.runtime;

// FIXME: three lock acquires...trying to reduce risk of deadlock, but not sure it's possible.

boolean locked = fptr.lock();

try {

if (fptr.isWritable()) {

if (fptr.io_fflush(context) < 0)

throw runtime.newErrnoFromErrno(fptr.errno(), fptr.getPath());

} else {

fptr.tell(context);

}

} finally {

if (locked) fptr.unlock();

}

locked = orig.lock();

try {

if (orig.isReadable()) {

pos = orig.tell(context);

}

if (orig.isWritable()) {

if (orig.io_fflush(context) < 0)

throw runtime.newErrnoFromErrno(orig.errno(), fptr.getPath());

}

} finally {

if (locked) orig.unlock();

}

/* copy rb_io_t structure */

// NOTE: MRI does not copy sync here, but I can find no way to make stdout/stderr stay sync through a reopen

locked = fptr.lock();

boolean locked2 = orig.lock(); // TODO: This WILL deadlock if two threads try to reopen the same IOs in opposite directions. Fix?

try {

fptr.setMode(orig.getMode() | (fptr.getMode() & (OpenFile.PREP | OpenFile.SYNC)));

fptr.encs = orig.encs;

fptr.setProcess(orig.getProcess());

fptr.setLineNumber(orig.getLineNumber());

if (orig.getPath() != null) fptr.setPath(orig.getPath());

else if (!fptr.IS_PREP_STDIO()) fptr.setPath(null);

fptr.setFinalizer(orig.getFinalizer());

// TODO: unsure what to do here

// #if defined (__CYGWIN__) || !defined(HAVE_FORK)

// if (fptr->finalize == pipe_finalize)

// pipe_add_fptr(fptr);

// #endif

fd = fptr.fd();

fd2 = orig.fd();

if (fd != fd2) {

if (fptr.IS_PREP_STDIO() || fd.bestFileno() <= 2 || fptr.stdio_file == null) {

/* need to keep FILE objects of stdin, stdout and stderr */

checkReopenCloexecDup2(runtime, orig, fd2, fd);

// rb_update_max_fd(fd);

fptr.setFD(fd);

// // MRI does not do this, but we seem to need to set some types of channels to sync if they

// // are reopened as stdout/stderr.

// if (fptr.stdio_file == System.out || fptr.stdio_file == System.err) {

// fd.chFile.force();

// }

} else {

if (fptr.stdio_file != null) try {

fptr.stdio_file.close();

} catch (IOException ioe) {

}

fptr.clearStdio();

fptr.setFD(null);

checkReopenCloexecDup2(runtime, orig, fd2, fd);

// rb_update_max_fd(fd);

fptr.setFD(fd);

}

// TODO: clear interrupts waiting on this IO?

// rb_thread_fd_close(fd);

if (orig.isReadable() && pos >= 0) {

fptr.checkReopenSeek(context, runtime, pos);

orig.checkReopenSeek(context, runtime, pos);

}

}

if (fptr.isBinmode()) {

setBinmode();

}

} finally {

if (locked2) orig.unlock();

if (locked) fptr.unlock();

}

// We simply can't do this and still have real concrete types under RubyIO

return this;

}

private void checkReopenCloexecDup2(Ruby runtime, OpenFile orig, ChannelFD oldfd, ChannelFD newfd) {

OpenFile.cloexecDup2(new PosixShim(runtime), oldfd, newfd);

}

// rb_io_binmode

private void setBinmode() {

OpenFile fptr;

fptr = getOpenFileChecked();

boolean locked = fptr.lock();

try {

if (fptr.readconv != null)

fptr.readconv.binmode();

if (fptr.writeconv != null)

fptr.writeconv.binmode();

fptr.setBinmode();

fptr.clearTextMode();

fptr.writeconvPreEcflags &= ~EConvFlags.NEWLINE_DECORATOR_MASK;

if (OpenFlags.O_BINARY.defined()) {

// TODO: Windows

// if (fptr.readconv == null) {

// SET_BINARY_MODE_WITH_SEEK_CUR(fptr);

// }

// else {

// TODO: setmode O_BINARY means what via NIO?

// setmode(fptr->fd, O_BINARY);

// }

}

} finally {

if (locked) fptr.unlock();

}

}

// MRI: rb_io_reopen

@JRubyMethod(name = "reopen", required = 1, optional = 1, checkArity = false)

public IRubyObject reopen(ThreadContext context, IRubyObject[] args) {

int argc = Arity.checkArgumentCount(context, args, 1, 2);

final Ruby runtime = context.runtime;

final IRubyObject nil = context.nil;

RubyIO file = this;

IRubyObject fname = nil, nmode = nil, opt = nil;

int[] oflags_p = {0};

OpenFile fptr;

switch (argc) {

case 3:

opt = TypeConverter.checkHashType(runtime, args[2]);

if (opt == nil) throw argumentError(context, 3, 2);

case 2:

if (opt == nil) {

opt = TypeConverter.checkHashType(runtime, args[1]);

if (opt == nil) {

nmode = args[1];

opt = nil;

}

} else {

nmode = args[1];

}

case 1:

fname = args[0];

}

if (argc == 1) {

IRubyObject tmp = TypeConverter.ioCheckIO(runtime, fname);

if (tmp != nil) {

return file.reopenIO(context, (RubyIO) tmp);

}

}

fname = RubyFile.get_path(context, fname);

// Not implemented

fptr = file.openFile;

if (fptr == null) {

fptr = file.openFile = MakeOpenFile();

}

boolean locked = fptr.lock();

try {

if (nmode != nil || opt != nil) {

ConvConfig convconfig = new ConvConfig();

API.ModeAndPermission vmode_vperm = new API.ModeAndPermission(nmode, null);

int[] fmode_p = {0};

EncodingUtils.extractModeEncoding(context, convconfig, vmode_vperm, opt, oflags_p, fmode_p);

if (fptr.IS_PREP_STDIO() &&

((fptr.getMode() & OpenFile.READWRITE) & (fmode_p[0] & OpenFile.READWRITE)) !=

(fptr.getMode() & OpenFile.READWRITE)) {

throw argumentError(context, fptr.PREP_STDIO_NAME() + " can't change access mode from \"" +

fptr.getModeAsString(context) + "\" to \"" + OpenFile.getStringFromMode(fmode_p[0]));

}

fptr.setMode(fmode_p[0]);

fptr.encs = convconfig;

} else {

oflags_p[0] = OpenFile.getModeFlagsAsIntFrom(fptr.getMode());

}

fptr.setPath(fname.toString());

if (fptr.fd() == null) {

fptr.setFD(sysopen(runtime, fptr.getPath(), oflags_p[0], 0666));

fptr.clearStdio();

return file;

}

if (fptr.isWritable()) {

if (fptr.io_fflush(context) < 0)

throw runtime.newErrnoFromErrno(fptr.errno(), fptr.getPath());

}

fptr.rbuf.off = fptr.rbuf.len = 0;

if (fptr.isStdio()) {

// Logic here reopens the stdio FILE* with a new path and mode. For our purposes, we skip this

// since we do not want to damage the stdio streams

// if (freopen(RSTRING_PTR(fptr.pathv), rb_io_oflags_modestr(oflags), fptr.stdio_file) == 0) {

// rb_sys_fail_path(fptr.pathv);

// }

fptr.setFD(sysopen(runtime, fptr.getPath(), oflags_p[0], 0666));

OpenFile.fdFixCloexec(fptr.posix, fptr.fd().realFileno);

// This logic configures buffering (none, line, full) and buffer size to match the original stdio

// stream associated with this IO. I don't believe we can do this.

// #ifdef USE_SETVBUF

// if (setvbuf(fptr.stdio_file, NULL, _IOFBF, 0) != 0)

// rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr.pathv);

// #endif

// if (fptr.stdio_file == stderr) {

// if (setvbuf(fptr.stdio_file, NULL, _IONBF, BUFSIZ) != 0)

// rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr.pathv);

// }

// else if (fptr.stdio_file == stdout && isatty(fptr.fd)) {

// if (setvbuf(fptr.stdio_file, NULL, _IOLBF, BUFSIZ) != 0)

// rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr.pathv);

// }

} else {

ChannelFD tmpfd = sysopen(runtime, fptr.getPath(), oflags_p[0], 0666);

Errno err = null;

if (OpenFile.cloexecDup2(fptr.posix, tmpfd, fptr.fd()) < 0)

err = fptr.errno();

if (err != null) {

throw runtime.newErrnoFromErrno(err, fptr.getPath());

}

fptr.setFD(tmpfd);

}

} finally {

if (locked) fptr.unlock();

}

return file;

}

public IRubyObject getline(ThreadContext context, IRubyObject separator) {

return getlineImpl(context, separator, -1, false);

}

/**

public IRubyObject getline(ThreadContext context, IRubyObject separator, long limit) {

return getlineImpl(context, separator, (int) limit, false);

}

/**

IRubyObject getlineImpl(ThreadContext context, IRubyObject rs, final int limit, final boolean chomp) {

Ruby runtime = context.runtime;

final OpenFile fptr = getOpenFileChecked();

final boolean locked = fptr.lock();

try {

fptr.checkCharReadable(context);

if (limit == 0) {

return RubyString.newEmptyString(runtime, fptr.readEncoding(runtime));

}

RubyString str = null; Encoding enc;

if (rs == context.nil && limit < 0) {

str = (RubyString) fptr.readAll(context, 0, context.nil);

if (str.size() == 0) return context.nil;

if (chomp) str.chomp_bang(context, globalVariables(context).getDefaultSeparator());

} else if (rs == globalVariables(context).getDefaultSeparator()

&& limit < 0

&& !fptr.needsReadConversion()

&& (enc = fptr.readEncoding(runtime)).isAsciiCompatible()) {

fptr.NEED_NEWLINE_DECORATOR_ON_READ_CHECK();

return fptr.getlineFast(context, enc, this, chomp);

}

return getlineImplSlowPart(context, fptr, str, rs, limit, chomp);

} finally {

if (locked) fptr.unlock();

}

}

// MRI rb_io_getline_0

private IRubyObject getlineImplSlowPart(ThreadContext context, final OpenFile fptr,

RubyString str, IRubyObject rs, final int limit, final boolean chomp) {

Ruby runtime = context.runtime;

boolean noLimit = false;

// slow path logic

int c, newline = -1;

byte[] rsptrBytes = null;

int rsptr = 0;

int rslen = 0;

boolean rspara = false;

int extraLimit = 16;

boolean chompCR = chomp;

fptr.SET_BINARY_MODE();

final Encoding enc = getReadEncoding();

if (rs != context.nil) {

RubyString rsStr = (RubyString) rs;

ByteList rsByteList = rsStr.getByteList();

rslen = rsByteList.getRealSize();

if (rslen == 0) {

rsptrBytes = PARAGRAPH_SEPARATOR.unsafeBytes();

rsptr = PARAGRAPH_SEPARATOR.getBegin();

rslen = 2;

rspara = true;

fptr.swallow(context, '\n');

rs = null;

if (!enc.isAsciiCompatible()) {

rs = RubyString.newUsAsciiStringShared(runtime, rsptrBytes, rsptr, rslen);

rs = EncodingUtils.strConvEnc(context, (RubyString) rs, null, enc);

rs.setFrozen(true);

rsStr = (RubyString) rs;

rsByteList = rsStr.getByteList();

rsptrBytes = rsByteList.getUnsafeBytes();

rsptr = rsByteList.getBegin();

rslen = rsByteList.getRealSize();

}

newline = '\n';

} else if (enc.minLength() == 1) {

rsptr = rsByteList.begin();

rsptrBytes = rsByteList.getUnsafeBytes();

newline = Byte.toUnsignedInt(rsptrBytes[rsptr + rslen - 1]);

} else {

rs = rsStr.encode(context, encodingService(context).convertEncodingToRubyEncoding(enc));

rsStr = (RubyString) rs;

rsByteList = rsStr.getByteList();

rsptrBytes = rsByteList.getUnsafeBytes();

rsptr = rsByteList.getBegin();

rslen = rsByteList.getRealSize();

int e = rsptr + rslen;

int last = enc.prevCharHead(rsptrBytes, rsptr, e, e);

int[] n = {0};

newline = encCodepointLength(context, rsptrBytes, last, e, n, enc);

if (last + n[0] != e) throw argumentError(context, "broken separator");

}

chompCR = chomp && newline == '\n' && rslen == enc.minLength();

}

final ByteList[] strPtr = { str != null ? str.getByteList() : null };

final int[] limit_p = { limit };

while ((c = fptr.appendline(context, newline, strPtr, limit_p, enc)) != OpenFile.EOF) {

int s, p, pp, e;

final byte[] strBytes = strPtr[0].getUnsafeBytes();

final int realSize = strPtr[0].getRealSize();

final int begin = strPtr[0].getBegin();

if (c == newline) {

if (realSize < rslen) continue;

s = begin;

e = s + realSize;

p = e - rslen;

if (!atCharacterBoundary(enc, strBytes, s, p, e)) continue;

if (!rspara) rscheck(context, rsptrBytes, rslen, rs);

if (ByteList.memcmp(strBytes, p, rsptrBytes, rsptr, rslen) == 0) {

if (chomp) {

if (chompCR && p > s && strBytes[p-1] == '\r') --p;

strPtr[0].length(p - s);

}

break;

}

}

if (limit_p[0] == 0) {

s = begin;

p = s + realSize;

pp = enc.prevCharHead(strBytes, s, p, p);

if (extraLimit != 0 && pp != -1 &&

StringSupport.MBCLEN_NEEDMORE_P(StringSupport.preciseLength(enc, strBytes, pp, p))) {

limit_p[0] = 1;

extraLimit--;

} else {

noLimit = true;

break;

}

}

}

// limit = limit_p[0];

if (strPtr[0] != null) {

if (str != null) {

str.setValue(strPtr[0]);

} else {

str = runtime.newString(strPtr[0]);

}

}

if (rspara && c != OpenFile.EOF) {

// FIXME: This may block more often than it should, to clean up extraneous newlines

fptr.swallow(context, '\n');

}

if (str != null) { // io_enc_str :

str.setEncoding(enc);

}

if (str != null && !noLimit) fptr.incrementLineno(runtime, this);

return str == null ? context.nil : str;

}

private static void rscheck(ThreadContext context, byte[] strBytes, int len, IRubyObject rs) {

if (rs == null || rs.isNil()) return;

if (((RubyString) rs).getByteList().getUnsafeBytes() != strBytes && ((RubyString) rs).getByteList().getRealSize() != len) {

throw runtimeError(context, "rs modified");

}

}

private static boolean atCharacterBoundary(Encoding enc, byte[] strBytes, int s, int p, int e) {

return enc.leftAdjustCharHead(strBytes, s, p, e) == p;

}

// fptr->enc and codeconv->enc

public Encoding getEnc() {

return openFile.encs.enc;

}

// mri: io_read_encoding

public Encoding getReadEncoding() {

return openFile.readEncoding(getRuntime());

}

// fptr->enc2 and codeconv->enc2

public Encoding getEnc2() {

return openFile.encs.enc2;

}

// mri: io_input_encoding

public Encoding getInputEncoding() {

return openFile.inputEncoding(getRuntime());

}

// IO class methods.

@JRubyMethod(name = "new", rest = true, meta = true, keywords = true)

public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {

RubyClass klass = (RubyClass)recv;

if (block.isGiven()) {

IRubyObject className = types(context.runtime, klass);

warn(context, str(context.runtime, className, "::new() does not take block; use ", className, "::open() instead"));

}

return klass.newInstance(context, args, block);

}

@JRubyMethod(rest = true, meta = true, keywords = true)

public static IRubyObject for_fd(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {

RubyClass klass = (RubyClass)recv;

return klass.newInstance(context, args, block);

}

private IRubyObject initializeCommon(ThreadContext context, int fileno, IRubyObject vmodeArg, IRubyObject opt) {

Ruby runtime = context.runtime;

ChannelFD fd;

if (!FilenoUtil.isFake(fileno)) {

// try using existing ChannelFD, then fall back on creating a new one

fd = runtime.getFilenoUtil().getWrapperFromFileno(fileno);

if (fd == null) {

if (runtime.getPosix().isNative() && !Platform.IS_WINDOWS) {

fd = new ChannelFD(new NativeDeviceChannel(fileno), runtime.getPosix(), runtime.getFilenoUtil());

} else {

// Native channels don't work quite right on Windows yet. Override standard io for better nonblocking support. See jruby/jruby#3625

switch (fileno) {

case 0:

fd = new ChannelFD(Channels.newChannel(runtime.getIn()), runtime.getPosix(), runtime.getFilenoUtil());

break;

case 1:

fd = new ChannelFD(Channels.newChannel(runtime.getOut()), runtime.getPosix(), runtime.getFilenoUtil());

break;

case 2:

fd = new ChannelFD(Channels.newChannel(runtime.getErr()), runtime.getPosix(), runtime.getFilenoUtil());

break;

default:

fd = new ChannelFD(new NativeDeviceChannel(fileno), runtime.getPosix(), runtime.getFilenoUtil());

break;