RubyIO

java.lang.Object
- org.jruby.RubyBasicObject
- - org.jruby.RubyObject
  - - org.jruby.RubyIO

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<IRubyObject>, InstanceVariables, InternalVariables, IRubyObject, CoreObjectType, IOEncodable

Direct Known Subclasses:

FileDescriptorIO, RubyBasicSocket, RubyFile
```
public class RubyIO
extends RubyObject
implements IOEncodable
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`RubyIO.ByteListCache` Caching reference to allocated byte-lists, allowing for internal byte[] to be reused, rather than reallocated.
`private static class`	`RubyIO.POpenTuple`
`private static class`	`RubyIO.Ruby19POpen`

Nested classes/interfaces inherited from class org.jruby.RubyObject
RubyObject.Data

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject
RubyBasicObject.Finalizer

Nested classes/interfaces inherited from interface org.jruby.util.io.IOEncodable
IOEncodable.ConvConfig

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.util.Set<java.lang.String>`	`ALL_SPAWN_OPTIONS`
`protected java.util.List<RubyThread>`	`blockingThreads`
`protected int`	`ecflags`
`protected IRubyObject`	`ecopts`
`private static byte[]`	`EMPTY_BYTE_ARRAY`
`protected org.jcodings.Encoding`	`enc` readEncoding/writeEncoding deserve a paragraph explanation.
`protected org.jcodings.Encoding`	`enc2`
`protected boolean`	`hasBom`
`private static ObjectAllocator`	`IO_ALLOCATOR`
`private static java.lang.String`	`msgEINTR`
`private static org.jruby.util.ByteList`	`NIL_BYTELIST`
`protected OpenFile`	`openFile`
`protected boolean`	`popenSpecial` If the stream is being used for popen, we don't want to destroy the process when we close the stream.
`protected Transcoder`	`readconv`
`private static org.jruby.util.ByteList`	`RECURSIVE_BYTELIST`
`private static java.util.Set<java.lang.String>`	`UNSUPPORTED_SPAWN_OPTIONS`
`private static java.lang.String`	`vendor`
`protected Transcoder`	`writeconv`
`protected IRubyObject`	`writeconvAsciicompat`
`protected boolean`	`writeconvInitialized`
`protected int`	`writeconvPreEcflags`
`protected IRubyObject`	`writeconvPreEcopts`

Fields inherited from class org.jruby.RubyObject
FIELD_ALLOCATED_CLASSES, FIELD_ALLOCATORS, IVAR_INSPECTING_OBJECT_ALLOCATOR, OBJECT_ALLOCATOR, OBJECT_VAR0_ALLOCATOR, OBJECT_VAR1_ALLOCATOR, OBJECT_VAR2_ALLOCATOR, OBJECT_VAR3_ALLOCATOR, OBJECT_VAR4_ALLOCATOR, OBJECT_VAR5_ALLOCATOR, OBJECT_VAR6_ALLOCATOR, OBJECT_VAR7_ALLOCATOR, OBJECT_VAR8_ALLOCATOR, OBJECT_VAR9_ALLOCATOR, REIFYING_OBJECT_ALLOCATOR

Fields inherited from class org.jruby.RubyBasicObject
ALL_F, BASICOBJECT_ALLOCATOR, COMPARE_BY_IDENTITY_F, ERR_INSECURE_SET_INST_VAR, FALSE_F, FL_USHIFT, flags, FROZEN_F, metaClass, NEVER, NIL_F, STAMP_OFFSET, TAINTED_F, UNDEF, UNTRUSTED_F, USER0_F, USER1_F, USER2_F, USER3_F, USER4_F, USER5_F, USER6_F, USER7_F, USER8_F, VAR_TABLE_OFFSET, varTable, varTableStamp

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject
NULL_ARRAY

Constructor Summary

Constructors
Constructor and Description
`RubyIO(Ruby runtime, java.nio.channels.Channel channel)`
`RubyIO(Ruby runtime, java.io.InputStream inputStream)`
`RubyIO(Ruby runtime, java.io.OutputStream outputStream)`
`RubyIO(Ruby runtime, java.io.OutputStream outputStream, boolean autoclose)`
`RubyIO(Ruby runtime, RubyClass type)`
`RubyIO(Ruby runtime, RubyClass cls, ShellLauncher.POpenProcess process, RubyHash options, IOOptions ioOptions)` Deprecated.
`RubyIO(Ruby runtime, ShellLauncher.POpenProcess process, IOOptions ioOptions)`
`RubyIO(Ruby runtime, STDIO stdio)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addBlockingThread(RubyThread thread)` Add a thread to the list of blocking threads for this IO.
`IRubyObject`	`autoclose_set(ThreadContext context, IRubyObject autoclose)`
`IRubyObject`	`autoclose(ThreadContext context)`
`IRubyObject`	`binmode()`
`static IRubyObject`	`binread(ThreadContext context, IRubyObject recv, IRubyObject[] args)` binread is just like read, except it doesn't take options and it forces mode to be "rb:ASCII-8BIT"
`static IRubyObject`	`binwrite(ThreadContext context, IRubyObject recv, IRubyObject[] args)`
`private org.jruby.util.ByteList`	`blockingFRead(Stream stream, RubyThread thread, int length)`
`IRubyObject`	`bytes(ThreadContext context)`
`IRubyObject`	`chars(ThreadContext context, Block block)`
`IRubyObject`	`chars19(ThreadContext context, Block block)`
`static void`	`checkExecOptions(IRubyObject options)` Warn when using exec with unsupported options.
`static IRubyObject`	`checkPipeCommand(ThreadContext context, IRubyObject filenameOrCommand)`
`static void`	`checkPopenOptions(IRubyObject options)` Warn when using spawn with unsupported options.
`static void`	`checkSpawnOptions(IRubyObject options)` Warn when using spawn with unsupported options.
`private static void`	`checkUnsupportedOptions(IRubyObject options, java.util.Set<java.lang.String> unsupported, java.lang.String error)` Warn when using unsupported options.
`private static void`	`checkValidOptions(IRubyObject options, java.util.Set<java.lang.String> valid)` Error when using unknown option.
`private static void`	`cleanupPOpen(RubyIO.POpenTuple tuple)`
`private void`	`clearCodeConversion()`
`private void`	`clearReadConversion()`
`IRubyObject`	`close_read(ThreadContext context)`
`IRubyObject`	`close_write(ThreadContext context)`
`IRubyObject`	`close()` Closes all open resources for the IO.
`RubyBoolean`	`closed_p(ThreadContext context)`
`IRubyObject`	`codepoints(ThreadContext context, Block block)`
`static RubyIO`	`convertToIO(ThreadContext context, IRubyObject obj)`
`static IRubyObject`	`copy_stream(ThreadContext context, IRubyObject recv, IRubyObject[] args)`
`static RubyClass`	`createIOClass(Ruby runtime)`
`IRubyObject`	`ctl(Ruby runtime, IRubyObject cmd, IRubyObject arg)`
`IRubyObject`	`doReadNonblock(ThreadContext context, IRubyObject[] args, boolean useException)`
`private RubyFixnum`	`doSeek(ThreadContext context, long offset, int whence)`
`private IRubyObject`	`doWriteConversion(ThreadContext context, IRubyObject str)`
`IRubyObject`	`doWriteNonblock(ThreadContext context, IRubyObject obj, boolean useException)`
`IRubyObject`	`each_byte(ThreadContext context, Block block)`
`IRubyObject`	`each_byteInternal(ThreadContext context, Block block)` Invoke a block for each byte.
`IRubyObject`	`each_char(ThreadContext context, Block block)`
`IRubyObject`	`each_char19(ThreadContext context, Block block)`
`IRubyObject`	`each_charInternal(ThreadContext context, Block block)`
`IRubyObject`	`each_charInternal19(ThreadContext context, Block block)`
`IRubyObject`	`each_codepoint(ThreadContext context, Block block)`
`IRubyObject`	`each_line(ThreadContext context, IRubyObject[] args, Block block)`
`RubyIO`	`each_lineInternal(ThreadContext context, IRubyObject[] args, Block block)` Invoke a block for each line.
`IRubyObject`	`each(ThreadContext context, IRubyObject[] args, Block block)`
`private IRubyObject`	`eachCodePointCommon(ThreadContext context, Block block, java.lang.String methodName)`
`protected static boolean`	`emptyBufferOrEOF(org.jruby.util.ByteList buffer, OpenFile myOpenFile)`
`org.jcodings.Encoding`	`encodingFromBOM()`
`RubyBoolean`	`eof_p(ThreadContext context)`
`IRubyObject`	`external_encoding(ThreadContext context)`
`static void`	`failIfDirectory(Ruby runtime, RubyString pathStr)`
`IRubyObject`	`fcntl(ThreadContext context, IRubyObject cmd)`
`IRubyObject`	`fcntl(ThreadContext context, IRubyObject cmd, IRubyObject arg)`
`protected Stream`	`fdopen(ChannelDescriptor existingDescriptor, ModeFlags modes)`
`RubyFixnum`	`fileno(ThreadContext context)`
`RubyIO`	`flush()` Flushes the IO output stream.
`static IRubyObject`	`foreach(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`foreach19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`private static IRubyObject`	`foreachInternal(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)` rb_io_s_foreach
`private static IRubyObject`	`foreachInternal19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)` rb_io_s_foreach
`private org.jruby.util.ByteList`	`fread(RubyThread thread, int length)`
`RubyFixnum`	`fsync(ThreadContext context)`
`protected int`	`fwrite(RubyString buffer)`
`boolean`	`getBlocking()`
`boolean`	`getBOM()`
`IRubyObject`	`getbyte19(ThreadContext context)`
`IRubyObject`	`getc()` Read a byte.
`IRubyObject`	`getc19(ThreadContext context)`
`int`	`getcCommon()`
`private IRubyObject`	`getcDirect(ThreadContext context, Stream stream, org.jcodings.Encoding enc)`
`java.nio.channels.Channel`	`getChannel()`
`private IRubyObject`	`getcTranscoded(ThreadContext context, Stream stream)`
`ChannelDescriptor`	`getDescriptorByFileno(int aFileno)` Deprecated.
`int`	`getEcflags()`
`IRubyObject`	`getEcopts()`
`org.jcodings.Encoding`	`getEnc()`
`org.jcodings.Encoding`	`getEnc2()`
`Stream`	`getHandler()` Deprecated.
`org.jcodings.Encoding`	`getInputEncoding()`
`java.io.InputStream`	`getInStream()`
`static ModeFlags`	`getIOModes(Ruby runtime, java.lang.String modesString)` Deprecated.
`static int`	`getIOModesIntFromString(Ruby runtime, java.lang.String modesString)` Deprecated.
`private long`	`getLimitFromArgs(IRubyObject[] args)`
`IRubyObject`	`getline(Ruby runtime, org.jruby.util.ByteList separator)` Deprecated.
`IRubyObject`	`getline(Ruby runtime, org.jruby.util.ByteList separator, long limit)` Deprecated.
`IRubyObject`	`getline(ThreadContext context, org.jruby.util.ByteList separator)`
`IRubyObject`	`getline(ThreadContext context, org.jruby.util.ByteList separator, long limit)` getline using logic of gets.
`private IRubyObject`	`getline(ThreadContext context, org.jruby.util.ByteList separator, long limit, RubyIO.ByteListCache cache)`
`private IRubyObject`	`getline(ThreadContext context, org.jruby.util.ByteList separator, RubyIO.ByteListCache cache)`
`private IRubyObject`	`getlineAll(ThreadContext context, OpenFile myOpenFile)`
`private IRubyObject`	`getlineEmptyString(Ruby runtime)`
`private IRubyObject`	`getlineFast(Ruby runtime, int delim, RubyIO.ByteListCache cache)`
`private IRubyObject`	`getlineInner(ThreadContext context, org.jruby.util.ByteList separator, long limit, RubyIO.ByteListCache cache)` getline using logic of gets.
`int`	`getNativeTypeIndex()` This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are.
`static int`	`getNewFileno()` Deprecated.
`private static org.jruby.util.ByteList`	`getNilByteList(Ruby runtime)`
`OpenFile`	`getOpenFile()`
`protected OpenFile`	`getOpenFileChecked()`
`java.io.OutputStream`	`getOutStream()`
`private IRubyObject`	`getPartial(ThreadContext context, IRubyObject[] args, boolean isNonblocking)`
`org.jcodings.Encoding`	`getReadEncoding()`
`IRubyObject`	`gets(ThreadContext context)` Read a line.
`IRubyObject`	`gets(ThreadContext context, IRubyObject separatorArg)`
`IRubyObject`	`gets(ThreadContext context, IRubyObject[] args)` Deprecated.
`IRubyObject`	`gets19(ThreadContext context)`
`IRubyObject`	`gets19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`gets19(ThreadContext context, IRubyObject separator, IRubyObject limit_arg)`
`private org.jruby.util.ByteList`	`getSeparatorForGets(Ruby runtime, IRubyObject[] args)`
`private org.jruby.util.ByteList`	`getSeparatorFromArgs(Ruby runtime, IRubyObject[] args, int idx)`
`private void`	`incrementLineno(Ruby runtime, OpenFile myOpenFile)`
`IRubyObject`	`initialize_copy(IRubyObject original)` rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object.
`IRubyObject`	`initialize(IRubyObject[] args, Block unusedBlock)`
`IRubyObject`	`initialize19(ThreadContext context, IRubyObject fileNumber, Block unused)`
`IRubyObject`	`initialize19(ThreadContext context, IRubyObject fileNumber, IRubyObject second, Block unused)`
`IRubyObject`	`initialize19(ThreadContext context, IRubyObject fileNumber, IRubyObject modeValue, IRubyObject options, Block unused)`
`private IRubyObject`	`initializeCommon19(ThreadContext context, int fileno, IRubyObject vmodeArg, IRubyObject opt)`
`IRubyObject`	`inspect()` rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj.
`private static IRubyObject`	`inspectPuts(ThreadContext context, IRubyObject maybeIO, RubyArray array)`
`IRubyObject`	`internal_encoding(ThreadContext context)`
`protected void`	`interruptBlockingThreads()` Fire an IOError in all threads blocking on this IO object
`protected IRubyObject`	`ioClose(Ruby runtime)`
`IRubyObject`	`ioctl(ThreadContext context, IRubyObject[] args)`
`private IRubyObject`	`ioEncStr(IRubyObject str)`
`private IRubyObject`	`ioGetc(ThreadContext context, Stream stream)`
`static IRubyObject`	`ioOpen(ThreadContext context, IRubyObject filename, IRubyObject vmode, IRubyObject vperm, IRubyObject opt)`
`boolean`	`isAutoclose()`
`boolean`	`isClosed()` Is this IO closed
`RubyFixnum`	`lineno_set(ThreadContext context, IRubyObject newLineNumber)` Sets the current line number.
`RubyFixnum`	`lineno(ThreadContext context)` Returns the current line number.
`IRubyObject`	`lines(ThreadContext context, Block block)`
`IRubyObject`	`lines19(ThreadContext context, Block block)`
`protected void`	`MakeOpenFile()`
`private void`	`makeReadConversion(ThreadContext context)`
`private RubyString`	`makeString(Ruby runtime, org.jruby.util.ByteList buffer, boolean isCached)`
`private void`	`makeWriteConversion(ThreadContext context)`
`private boolean`	`needsReadConversion()`
`private boolean`	`needsWriteConversion(ThreadContext context)`
`private static RubyIO`	`newFile(ThreadContext context, IRubyObject recv, IRubyObject... args)`
`private static RubyIO`	`newFile19(ThreadContext context, IRubyObject recv, IRubyObject... args)`
`static IRubyObject`	`newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static RubyIO`	`newIO(Ruby runtime, java.nio.channels.Channel channel)`
`static IOOptions`	`newIOOptions(Ruby runtime, int mode)`
`static IOOptions`	`newIOOptions(Ruby runtime, IOOptions oldFlags, int orOflags)`
`static IOOptions`	`newIOOptions(Ruby runtime, long mode)`
`static IOOptions`	`newIOOptions(Ruby runtime, ModeFlags modeFlags)`
`static IOOptions`	`newIOOptions(Ruby runtime, java.lang.String mode)`
`static ModeFlags`	`newModeFlags(Ruby runtime, int mode)`
`static ModeFlags`	`newModeFlags(Ruby runtime, long mode)`
`static ModeFlags`	`newModeFlags(Ruby runtime, java.lang.String mode)`
`static void`	`obliterateProcess(java.lang.Process process)` Try for around 1s to destroy the child process.
`IRubyObject`	`op_append(ThreadContext context, IRubyObject anObject)` rb_io_addstr
`IRubyObject`	`op_binmode(ThreadContext context)`
`static IRubyObject`	`open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`private static IRubyObject`	`openKeyArgs(ThreadContext context, IRubyObject recv, IRubyObject[] argv, IRubyObject opt)`
`protected IOOptions`	`parseIOOptions(IRubyObject arg)`
`protected IOOptions`	`parseIOOptions19(IRubyObject arg)`
`IRubyObject`	`pid(ThreadContext context)` Return the process id (pid) of the process this IO object spawned.
`static IRubyObject`	`pipe(ThreadContext context, IRubyObject recv)`
`static IRubyObject`	`pipe19(ThreadContext context, IRubyObject recv)`
`static IRubyObject`	`pipe19(ThreadContext context, IRubyObject recv, IRubyObject modes)`
`static IRubyObject`	`pipe19(ThreadContext context, IRubyObject recv, IRubyObject modes, IRubyObject options)`
`static IRubyObject`	`popen(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`popen19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`popen3_19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`popen3(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`popen4(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`static RubyIO.POpenTuple`	`popenSpecial(ThreadContext context, IRubyObject[] args)`
`RubyFixnum`	`pos_set(ThreadContext context, IRubyObject newPosition)`
`RubyFixnum`	`pos(ThreadContext context)`
`IRubyObject`	`print(ThreadContext context, IRubyObject[] args)` Print some objects to the stream.
`static IRubyObject`	`print(ThreadContext context, IRubyObject maybeIO, IRubyObject[] args)` Print some objects to the stream.
`static IRubyObject`	`print19(ThreadContext context, IRubyObject maybeIO, IRubyObject[] args)` Print some objects to the stream.
`IRubyObject`	`printf(ThreadContext context, IRubyObject[] args)`
`private static IRubyObject[]`	`processReadlinesMethodArguments(IRubyObject[] args)`
`IRubyObject`	`putc(ThreadContext context, IRubyObject object)`
`static IRubyObject`	`putc(ThreadContext context, IRubyObject maybeIO, IRubyObject object)`
`IRubyObject`	`puts(ThreadContext context)`
`IRubyObject`	`puts(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`puts(ThreadContext context, IRubyObject[] args)`
`static IRubyObject`	`puts(ThreadContext context, IRubyObject maybeIO, IRubyObject... args)`
`IRubyObject`	`puts(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`puts(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)`
`static IRubyObject`	`puts0(ThreadContext context, IRubyObject maybeIO)`
`static IRubyObject`	`puts1(ThreadContext context, IRubyObject maybeIO, IRubyObject arg0)`
`static IRubyObject`	`puts2(ThreadContext context, IRubyObject maybeIO, IRubyObject arg0, IRubyObject arg1)`
`static IRubyObject`	`puts3(ThreadContext context, IRubyObject maybeIO, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)`
`private static IRubyObject`	`putsArray(ThreadContext context, IRubyObject maybeIO, IRubyObject[] args)`
`private static void`	`putsSingle(ThreadContext context, Ruby runtime, IRubyObject maybeIO, IRubyObject arg, RubyString separator)`
`IRubyObject`	`read_nonblock(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`read(IRubyObject[] args)`
`IRubyObject`	`read(ThreadContext context)`
`IRubyObject`	`read(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`read(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`static IRubyObject`	`read(ThreadContext context, IRubyObject recv, IRubyObject[] args)`
`static IRubyObject`	`read(ThreadContext context, IRubyObject recv, IRubyObject path, Block unusedBlock)` Deprecated.
`static IRubyObject`	`read(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject length)` Deprecated.
`static IRubyObject`	`read(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject length, IRubyObject offset)` Deprecated.
`static IRubyObject`	`read19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock)`
`private static IRubyObject`	`read19(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject length, IRubyObject offset, IRubyObject options)` options is a hash which can contain: encoding: string or encoding mode: string open_args: array of string
`protected RubyString`	`readAll(RubyString str)`
`protected IRubyObject`	`readAll(ThreadContext context)`
`protected org.jruby.util.ByteList`	`readAllCommon(Ruby runtime)`
`IRubyObject`	`readbyte(ThreadContext context)`
`IRubyObject`	`readchar()` Read a byte.
`IRubyObject`	`readchar19(ThreadContext context)`
`private void`	`readCheck(Stream stream)`
`IRubyObject`	`readline(ThreadContext context)` Read a line.
`IRubyObject`	`readline(ThreadContext context, IRubyObject separator)`
`IRubyObject`	`readline(ThreadContext context, IRubyObject[] args)` Deprecated.
`RubyArray`	`readlines(ThreadContext context, IRubyObject[] args)`
`static IRubyObject`	`readlines(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock)`
`RubyArray`	`readlines19(ThreadContext context, IRubyObject[] args)`
`static IRubyObject`	`readlines19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock)`
`private RubyArray`	`readlinesCommon(ThreadContext context, IRubyObject[] args)`
`private static RubyArray`	`readlinesCommon(ThreadContext context, IRubyObject recv, IRubyObject[] openFileArguments, IRubyObject[] methodArguments)`
`private static RubyArray`	`readlinesCommon19(ThreadContext context, RubyIO file, IRubyObject[] newArguments)`
`private IRubyObject`	`readNotAll(ThreadContext context, OpenFile myOpenFile, int length)`
`private IRubyObject`	`readNotAll(ThreadContext context, OpenFile myOpenFile, int length, RubyString str)`
`private org.jruby.util.ByteList`	`readNotAllCommon(ThreadContext context, OpenFile myOpenFile, int length)`
`IRubyObject`	`readpartial(ThreadContext context, IRubyObject[] args)`
`static IRubyObject`	`readStatic(ThreadContext context, IRubyObject recv, IRubyObject path)`
`static IRubyObject`	`readStatic(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject length)`
`static IRubyObject`	`readStatic(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject length, IRubyObject offset)`
`void`	`registerDescriptor(ChannelDescriptor descriptor)` Deprecated.
`void`	`registerDescriptor(ChannelDescriptor descriptor, boolean isRetained)` Deprecated.
`void`	`removeBlockingThread(RubyThread thread)` Remove a thread from the list of blocking threads for this IO.
`IRubyObject`	`reopen(ThreadContext context, IRubyObject[] args)`
`protected void`	`reopenIO(Ruby runtime, RubyIO ios)`
`protected void`	`reopenPath(Ruby runtime, IRubyObject[] args)`
`static boolean`	`restartSystemCall(java.lang.Exception e)`
`RubyFixnum`	`rewind(ThreadContext context)`
`RubyFixnum`	`seek(ThreadContext context, IRubyObject arg0)`
`RubyFixnum`	`seek(ThreadContext context, IRubyObject[] args)`
`RubyFixnum`	`seek(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`static IRubyObject`	`select_static(ThreadContext context, Ruby runtime, IRubyObject[] args)`
`static IRubyObject`	`select(ThreadContext context, IRubyObject recv, IRubyObject[] args)`
`private org.jruby.util.ByteList`	`separator(Ruby runtime)`
`private org.jruby.util.ByteList`	`separator(Ruby runtime, IRubyObject separatorValue)`
`private void`	`SET_BINARY_MODE()`
`IRubyObject`	`set_encoding(ThreadContext context, IRubyObject encodingObj)`
`IRubyObject`	`set_encoding(ThreadContext context, IRubyObject encodingString, IRubyObject internalEncoding)`
`IRubyObject`	`set_encoding(ThreadContext context, IRubyObject encodingString, IRubyObject internalEncoding, IRubyObject options)`
`protected void`	`setAscii8bitBinmode()`
`void`	`setAutoclose(boolean autoclose)`
`void`	`setBOM(boolean bom)`
`void`	`setEcflags(int ecflags)`
`void`	`setEcopts(IRubyObject ecopts)`
`void`	`setEnc(org.jcodings.Encoding enc)`
`void`	`setEnc2(org.jcodings.Encoding enc2)`
`void`	`setEncoding(ThreadContext context, IRubyObject v1, IRubyObject v2, IRubyObject opt)`
`private void`	`setupPopen(ModeFlags modes, ShellLauncher.POpenProcess process)`
`IRubyObject`	`stat(ThreadContext context)`
`protected boolean`	`swallow(int term)`
`IRubyObject`	`sync_set(IRubyObject newSync)` Sets the current sync mode.
`RubyBoolean`	`sync(ThreadContext context)` Returns the current sync mode.
`private void`	`synthesizeSystemCallError(java.io.IOException e)` Java does not give us enough information for specific error conditions so we are reduced to divining them through string matches...
`static IRubyObject`	`sysopen(IRubyObject recv, IRubyObject[] args, Block block)`
`static IRubyObject`	`sysopen19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`private static IRubyObject`	`sysopenCommon(IRubyObject recv, IRubyObject[] args, Block block, IRubyObject pathString)`
`IRubyObject`	`sysread(ThreadContext context, IRubyObject[] args)`
`RubyFixnum`	`sysseek(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`syswrite(ThreadContext context, IRubyObject obj)`
`RubyIO`	`to_io()`
`java.lang.String`	`toString()` The default toString method is just a wrapper that calls the Ruby "to_s" method.
`private static long`	`transfer(java.nio.channels.FileChannel from, java.nio.channels.WritableByteChannel to, long remaining, long position)`
`private static long`	`transfer(java.nio.channels.ReadableByteChannel from, java.nio.channels.FileChannel to)`
`private static long`	`transfer(ThreadContext context, java.nio.channels.ReadableByteChannel from, java.nio.channels.WritableByteChannel to)`
`static IRubyObject`	`tryConvert(ThreadContext context, IRubyObject recv, IRubyObject arg)`
`RubyBoolean`	`tty_p(ThreadContext context)`
`IRubyObject`	`ungetc(IRubyObject number)` Pushes char represented by int back onto IOS.
`IRubyObject`	`ungetc19(IRubyObject character)`
`void`	`ungetcCommon(int ch)`
`void`	`unregisterDescriptor(int aFileno)` Deprecated.
`protected IOOptions`	`updateIOOptionsFromOptions(ThreadContext context, RubyHash options, IOOptions ioOptions)` See http://ruby-doc.org/core-1.9.3/IO.html#method-c-new for the format of modes in options
`private boolean`	`waitReadable(Stream stream)`
`private boolean`	`waitWritable(Stream stream)`
`IRubyObject`	`write_nonblock(ThreadContext context, IRubyObject obj)`
`protected IRubyObject`	`write(ThreadContext context, org.jruby.util.ByteList byteList)`
`IRubyObject`	`write(ThreadContext context, IRubyObject obj)` io_write
`protected static IRubyObject`	`write(ThreadContext context, IRubyObject maybeIO, org.jruby.util.ByteList byteList)`
`static IRubyObject`	`write(ThreadContext context, IRubyObject maybeIO, IRubyObject str)`
`private static IRubyObject`	`write19(ThreadContext context, IRubyObject recv, IRubyObject path, IRubyObject str, IRubyObject offset, RubyHash options)` options is a hash which can contain: encoding: string or encoding mode: string open_args: array of string
`boolean`	`writeDataBuffered()`
`private static IRubyObject`	`writeSeparator(ThreadContext context, IRubyObject maybeIO)`
`static IRubyObject`	`writeStatic(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock)`

Methods inherited from class org.jruby.RubyObject
attachToObjectSpace, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, convertToType, createObjectClass, eqlInternal, equalInternal, equals, hashCode, initialize, initialize, inspect, op_eqq, puts, specificEval

Methods inherited from class org.jruby.RubyBasicObject
addFinalizer, anyToString, asJavaString, asString, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callSuper, checkArrayType, checkCallMethod, checkFrozen, checkStringType, checkStringType19, compareTo, convertToArray, convertToFloat, convertToHash, convertToInteger, convertToInteger, convertToInteger, convertToString, copyInstanceVariablesInto, copySpecialInstanceVariables, createBasicObjectClass, dataGetStruct, dataGetStructChecked, dataWrapStruct, display, dup, ensureInstanceVariablesSettable, eql_p, eql, equal_p, equal_p19, evalUnder, extend, fastGetInstanceVariable, fastGetInternalVariable, fastHasInstanceVariable, fastHasInternalVariable, fastSetInstanceVariable, fastSetInternalVariable, freeze, frozen_p, getFFIHandle, getFlag, getInstanceEvalClass, getInstanceVariable, getInstanceVariableList, getInstanceVariableNameList, getInstanceVariables, getInternalVariable, getInternalVariables, getJavaClass, getMetaClass, getNativeHandle, getObjectId, getRuntime, getSingletonClass, getSingletonClassClone, getType, getVariable, getVariableCount, getVariableList, getVariableNameList, hash, hashyInspect, hasInstanceVariable, hasInternalVariable, hasVariables, id_deprecated, id, infectBy, infectBy, infectBy, initialize19, inspectHashCode, instance_eval, instance_eval, instance_eval, instance_eval, instance_eval19, instance_eval19, instance_eval19, instance_eval19, instance_exec, instance_exec19, instance_of_p, instance_variable_defined_p, instance_variable_get, instance_variable_set, instance_variables, instance_variables19, isBuiltin, isClass, isFalse, isFrozen, isImmediate, isModule, isNil, isTaint, isTrue, isUntrusted, kind_of_p, makeMetaClass, method_missing19, method, method19, methods, methods, methods19, nil_p, op_cmp, op_equal_19, op_equal, op_match, op_match19, op_not_equal, op_not_match, op_not, private_methods, private_methods19, protected_methods, protected_methods19, public_methods, public_methods19, rbClone, recacheBuiltinMethods, remove_instance_variable, removeFinalizers, removeInstanceVariable, removeInternalVariable, respond_to_p, respond_to_p, respond_to_p19, respond_to_p19, respondsTo, respondsToMissing, respondsToMissing, send, send, send, send, send, send19, send19, send19, send19, setFFIHandle, setFlag, setFrozen, setInstanceVariable, setInternalVariable, setMetaClass, setNativeHandle, setTaint, setUntrusted, setVariable, singleton_method_added19, singleton_method_removed19, singleton_method_undefined19, singleton_methods, singleton_methods19, specificEval, specificEval, specificEval, specificEval, syncVariables, syncVariables, taint, taint, tainted_p, testFrozen, testFrozen, to_a, to_s, toJava, trust, type_deprecated, type, untaint, untrust, untrusted_p, validateInstanceVariable, variableTableContains, variableTableFastContains, variableTableFastFetch, variableTableFastStore, variableTableFetch, variableTableRemove, variableTableStore, variableTableSync, yieldUnder, yieldUnder

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- IO_ALLOCATOR
```
private static ObjectAllocator IO_ALLOCATOR
```
- vendor
```
private static java.lang.String vendor
```
- msgEINTR
```
private static java.lang.String msgEINTR
```
- NIL_BYTELIST
```
private static final org.jruby.util.ByteList NIL_BYTELIST
```
- RECURSIVE_BYTELIST
```
private static final org.jruby.util.ByteList RECURSIVE_BYTELIST
```
- EMPTY_BYTE_ARRAY
```
private static final byte[] EMPTY_BYTE_ARRAY
```
- UNSUPPORTED_SPAWN_OPTIONS
```
private static final java.util.Set<java.lang.String> UNSUPPORTED_SPAWN_OPTIONS
```
- ALL_SPAWN_OPTIONS
```
private static final java.util.Set<java.lang.String> ALL_SPAWN_OPTIONS
```
- readconv
```
protected Transcoder readconv
```
- writeconvInitialized
```
protected boolean writeconvInitialized
```
- writeconv
```
protected Transcoder writeconv
```
- openFile
```
protected OpenFile openFile
```
- blockingThreads
```
protected java.util.List<RubyThread> blockingThreads
```
- enc
```
protected org.jcodings.Encoding enc
```
  readEncoding/writeEncoding deserve a paragraph explanation. In spite of appearing to be a better name than enc/enc as is used in MRI, it is probably a wash. readEncoding represents the encoding we want the string to be. If writeEncoding is not null this represents the source encoding to use. Reading: So if we are reading and there is no writeEncoding then we assume that the io is already readEncoding and read it as such. If both are set then we assume readEncoding is external encoding and we transcode to writeEncoding (internal). Writing: If writeEncoding is null then we write the bytes as readEncoding. If writeEncoding is set then we convert from writeEncoding to readEncoding. Note: This naming is clearly wrong, but it is no worse then enc/enc2 so I did not feel the need to fix it.
- enc2
```
protected org.jcodings.Encoding enc2
```
- ecflags
```
protected int ecflags
```
- ecopts
```
protected IRubyObject ecopts
```
- writeconvPreEcflags
```
protected int writeconvPreEcflags
```
- writeconvPreEcopts
```
protected IRubyObject writeconvPreEcopts
```
- writeconvAsciicompat
```
protected IRubyObject writeconvAsciicompat
```
- popenSpecial
```
protected boolean popenSpecial
```
  If the stream is being used for popen, we don't want to destroy the process when we close the stream.
- hasBom
```
protected boolean hasBom
```

Constructor Detail

RubyIO

public RubyIO(Ruby runtime,
              RubyClass type)

RubyIO

public RubyIO(Ruby runtime,
              java.io.OutputStream outputStream)

RubyIO

public RubyIO(Ruby runtime,
              java.io.OutputStream outputStream,
              boolean autoclose)

RubyIO

public RubyIO(Ruby runtime,
              java.io.InputStream inputStream)

RubyIO

public RubyIO(Ruby runtime,
              java.nio.channels.Channel channel)

RubyIO

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

RubyIO

@Deprecated
public RubyIO(Ruby runtime,
                          RubyClass cls,
                          ShellLauncher.POpenProcess process,
                          RubyHash options,
                          IOOptions ioOptions)

Deprecated.

RubyIO

public RubyIO(Ruby runtime,
              STDIO stdio)

Method Detail

newIO

public static RubyIO newIO(Ruby runtime,
                           java.nio.channels.Channel channel)

getOpenFile
```
public OpenFile getOpenFile()
```

getOpenFileChecked

protected OpenFile getOpenFileChecked()

getNativeTypeIndex
```
public int getNativeTypeIndex()
```
Description copied from class: RubyObject

This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are. Will generally return a value from org.jruby.runtime.ClassIndex

Specified by:

getNativeTypeIndex in interface CoreObjectType

Overrides:

getNativeTypeIndex in class RubyObject

Returns:

the ClassIndex of the native type this object was constructed from

See Also:

ClassIndex

createIOClass

public static RubyClass createIOClass(Ruby runtime)

getOutStream

public java.io.OutputStream getOutStream()

getInStream

public java.io.InputStream getInStream()

getChannel

public java.nio.channels.Channel getChannel()

getHandler

@Deprecated
public Stream getHandler()
                              throws BadDescriptorException

Deprecated.

Throws:: BadDescriptorException

reopenPath

protected void reopenPath(Ruby runtime,
                          IRubyObject[] args)

reopenIO

protected void reopenIO(Ruby runtime,
                        RubyIO ios)

reopen

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

getIOModes

@Deprecated
public static ModeFlags getIOModes(Ruby runtime,
                                               java.lang.String modesString)

Deprecated.

getIOModesIntFromString

@Deprecated
public static int getIOModesIntFromString(Ruby runtime,
                                                      java.lang.String modesString)

Deprecated.

separator

private org.jruby.util.ByteList separator(Ruby runtime)

separator

private org.jruby.util.ByteList separator(Ruby runtime,
                                          IRubyObject separatorValue)

getSeparatorFromArgs

private org.jruby.util.ByteList getSeparatorFromArgs(Ruby runtime,
                                                     IRubyObject[] args,
                                                     int idx)

getSeparatorForGets

private org.jruby.util.ByteList getSeparatorForGets(Ruby runtime,
                                                    IRubyObject[] args)

getline

private IRubyObject getline(ThreadContext context,
                            org.jruby.util.ByteList separator,
                            RubyIO.ByteListCache cache)

getline

public IRubyObject getline(ThreadContext context,
                           org.jruby.util.ByteList separator)

getline

public IRubyObject getline(ThreadContext context,
                           org.jruby.util.ByteList separator,
                           long limit)

getline using logic of gets. If limit is -1 then read unlimited amount.

getline

private IRubyObject getline(ThreadContext context,
                            org.jruby.util.ByteList separator,
                            long limit,
                            RubyIO.ByteListCache cache)

getlineEmptyString

private IRubyObject getlineEmptyString(Ruby runtime)

getlineAll

private IRubyObject getlineAll(ThreadContext context,
                               OpenFile myOpenFile)
                        throws java.io.IOException,
                               BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

getlineInner

private IRubyObject getlineInner(ThreadContext context,
                                 org.jruby.util.ByteList separator,
                                 long limit,
                                 RubyIO.ByteListCache cache)

getline using logic of gets. If limit is -1 then read unlimited amount. mri: rb_io_getline_1 (mostly)

getEnc
```
public org.jcodings.Encoding getEnc()
```
Specified by:

getEnc in interface IOEncodable

getReadEncoding

public org.jcodings.Encoding getReadEncoding()

getEnc2
```
public org.jcodings.Encoding getEnc2()
```
Specified by:

getEnc2 in interface IOEncodable

getInputEncoding

public org.jcodings.Encoding getInputEncoding()

makeString

private RubyString makeString(Ruby runtime,
                              org.jruby.util.ByteList buffer,
                              boolean isCached)

incrementLineno

private void incrementLineno(Ruby runtime,
                             OpenFile myOpenFile)

swallow

protected boolean swallow(int term)
                   throws java.io.IOException,
                          BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

restartSystemCall

public static boolean restartSystemCall(java.lang.Exception e)

getlineFast

private IRubyObject getlineFast(Ruby runtime,
                                int delim,
                                RubyIO.ByteListCache cache)
                         throws java.io.IOException,
                                BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

newInstance

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

initializeCommon19

private IRubyObject initializeCommon19(ThreadContext context,
                                       int fileno,
                                       IRubyObject vmodeArg,
                                       IRubyObject opt)

initialize19

public IRubyObject initialize19(ThreadContext context,
                                IRubyObject fileNumber,
                                Block unused)

initialize19

public IRubyObject initialize19(ThreadContext context,
                                IRubyObject fileNumber,
                                IRubyObject second,
                                Block unused)

initialize19

public IRubyObject initialize19(ThreadContext context,
                                IRubyObject fileNumber,
                                IRubyObject modeValue,
                                IRubyObject options,
                                Block unused)

parseIOOptions

protected IOOptions parseIOOptions(IRubyObject arg)

parseIOOptions19

protected IOOptions parseIOOptions19(IRubyObject arg)

initialize

public IRubyObject initialize(IRubyObject[] args,
                              Block unusedBlock)

fdopen

protected Stream fdopen(ChannelDescriptor existingDescriptor,
                        ModeFlags modes)

external_encoding

public IRubyObject external_encoding(ThreadContext context)

internal_encoding

public IRubyObject internal_encoding(ThreadContext context)

set_encoding

public IRubyObject set_encoding(ThreadContext context,
                                IRubyObject encodingObj)

set_encoding

public IRubyObject set_encoding(ThreadContext context,
                                IRubyObject encodingString,
                                IRubyObject internalEncoding)

set_encoding

public IRubyObject set_encoding(ThreadContext context,
                                IRubyObject encodingString,
                                IRubyObject internalEncoding,
                                IRubyObject options)

setEncoding

public void setEncoding(ThreadContext context,
                        IRubyObject v1,
                        IRubyObject v2,
                        IRubyObject opt)

open

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

sysopen

public static IRubyObject sysopen(IRubyObject recv,
                                  IRubyObject[] args,
                                  Block block)

sysopen19

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

sysopenCommon

private static IRubyObject sysopenCommon(IRubyObject recv,
                                         IRubyObject[] args,
                                         Block block,
                                         IRubyObject pathString)

isAutoclose
```
public boolean isAutoclose()
```

setAutoclose

public void setAutoclose(boolean autoclose)

autoclose

public IRubyObject autoclose(ThreadContext context)

autoclose_set

public IRubyObject autoclose_set(ThreadContext context,
                                 IRubyObject autoclose)

binmode
```
public IRubyObject binmode()
```

op_binmode

public IRubyObject op_binmode(ThreadContext context)

syswrite

public IRubyObject syswrite(ThreadContext context,
                            IRubyObject obj)

write_nonblock

public IRubyObject write_nonblock(ThreadContext context,
                                  IRubyObject obj)

doWriteNonblock

public IRubyObject doWriteNonblock(ThreadContext context,
                                   IRubyObject obj,
                                   boolean useException)

write

public IRubyObject write(ThreadContext context,
                         IRubyObject obj)

io_write

waitWritable

private boolean waitWritable(Stream stream)

waitReadable

private boolean waitReadable(Stream stream)

fwrite

protected int fwrite(RubyString buffer)

op_append

public IRubyObject op_append(ThreadContext context,
                             IRubyObject anObject)

rb_io_addstr

fileno

public RubyFixnum fileno(ThreadContext context)

lineno
```
public RubyFixnum lineno(ThreadContext context)
```
Returns the current line number.

Returns:

the current line number.

lineno_set

public RubyFixnum lineno_set(ThreadContext context,
                             IRubyObject newLineNumber)

Sets the current line number.

Parameters:: newLineNumber - The new line number.

sync
```
public RubyBoolean sync(ThreadContext context)
```
Returns the current sync mode.

Returns:

the current sync mode.

pid
```
public IRubyObject pid(ThreadContext context)
```
Return the process id (pid) of the process this IO object spawned. If no process exists (popen was not called), then nil is returned. This is not how it appears to be defined but ruby 1.8 works this way.

Returns:

the pid or nil

pos

public RubyFixnum pos(ThreadContext context)

pos_set

public RubyFixnum pos_set(ThreadContext context,
                          IRubyObject newPosition)

print

public IRubyObject print(ThreadContext context,
                         IRubyObject[] args)

Print some objects to the stream.

print

public static IRubyObject print(ThreadContext context,
                                IRubyObject maybeIO,
                                IRubyObject[] args)

Print some objects to the stream.

print19

public static IRubyObject print19(ThreadContext context,
                                  IRubyObject maybeIO,
                                  IRubyObject[] args)

Print some objects to the stream.

printf

public IRubyObject printf(ThreadContext context,
                          IRubyObject[] args)

putc

public IRubyObject putc(ThreadContext context,
                        IRubyObject object)

putc

public static IRubyObject putc(ThreadContext context,
                               IRubyObject maybeIO,
                               IRubyObject object)

seek

public RubyFixnum seek(ThreadContext context,
                       IRubyObject[] args)

seek

public RubyFixnum seek(ThreadContext context,
                       IRubyObject arg0)

seek

public RubyFixnum seek(ThreadContext context,
                       IRubyObject arg0,
                       IRubyObject arg1)

doSeek

private RubyFixnum doSeek(ThreadContext context,
                          long offset,
                          int whence)

sysseek

public RubyFixnum sysseek(ThreadContext context,
                          IRubyObject[] args)

rewind

public RubyFixnum rewind(ThreadContext context)

fsync

public RubyFixnum fsync(ThreadContext context)

sync_set
```
public IRubyObject sync_set(IRubyObject newSync)
```
Sets the current sync mode.

Parameters:

newSync - The new sync mode.

eof_p

public RubyBoolean eof_p(ThreadContext context)

tty_p

public RubyBoolean tty_p(ThreadContext context)

initialize_copy
```
public IRubyObject initialize_copy(IRubyObject original)
```
Description copied from class: RubyBasicObject

rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object. Will make sure that the argument actually has the same real class as this object. It shouldn't be possible to initialize an object with something totally different.

Overrides:

initialize_copy in class RubyBasicObject

closed_p

public RubyBoolean closed_p(ThreadContext context)

isClosed
```
public boolean isClosed()
```
Is this IO closed

Returns:

true if closed

close
```
public IRubyObject close()
```
Closes all open resources for the IO. It also removes it from our magical all open file descriptor pool.

Returns:

The IO.

ioClose

protected IRubyObject ioClose(Ruby runtime)

close_write

public IRubyObject close_write(ThreadContext context)

close_read

public IRubyObject close_read(ThreadContext context)

flush
```
public RubyIO flush()
```
Flushes the IO output stream.

Returns:

The IO.

gets

public IRubyObject gets(ThreadContext context)

Read a line.

gets

public IRubyObject gets(ThreadContext context,
                        IRubyObject separatorArg)

gets19

public IRubyObject gets19(ThreadContext context)

gets19

public IRubyObject gets19(ThreadContext context,
                          IRubyObject arg)

gets19

public IRubyObject gets19(ThreadContext context,
                          IRubyObject separator,
                          IRubyObject limit_arg)

getBlocking
```
public boolean getBlocking()
```

fcntl

public IRubyObject fcntl(ThreadContext context,
                         IRubyObject cmd)

fcntl

public IRubyObject fcntl(ThreadContext context,
                         IRubyObject cmd,
                         IRubyObject arg)

ioctl

public IRubyObject ioctl(ThreadContext context,
                         IRubyObject[] args)

ctl

public IRubyObject ctl(Ruby runtime,
                       IRubyObject cmd,
                       IRubyObject arg)

puts

public IRubyObject puts(ThreadContext context)

puts

public IRubyObject puts(ThreadContext context,
                        IRubyObject arg0)

puts

public IRubyObject puts(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1)

puts

public IRubyObject puts(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1,
                        IRubyObject arg2)

puts

public IRubyObject puts(ThreadContext context,
                        IRubyObject[] args)

puts0

public static IRubyObject puts0(ThreadContext context,
                                IRubyObject maybeIO)

puts1

public static IRubyObject puts1(ThreadContext context,
                                IRubyObject maybeIO,
                                IRubyObject arg0)

puts2

public static IRubyObject puts2(ThreadContext context,
                                IRubyObject maybeIO,
                                IRubyObject arg0,
                                IRubyObject arg1)

puts3

public static IRubyObject puts3(ThreadContext context,
                                IRubyObject maybeIO,
                                IRubyObject arg0,
                                IRubyObject arg1,
                                IRubyObject arg2)

puts

public static IRubyObject puts(ThreadContext context,
                               IRubyObject maybeIO,
                               IRubyObject... args)

writeSeparator

private static IRubyObject writeSeparator(ThreadContext context,
                                          IRubyObject maybeIO)

putsArray

private static IRubyObject putsArray(ThreadContext context,
                                     IRubyObject maybeIO,
                                     IRubyObject[] args)

putsSingle

private static void putsSingle(ThreadContext context,
                               Ruby runtime,
                               IRubyObject maybeIO,
                               IRubyObject arg,
                               RubyString separator)

write

protected IRubyObject write(ThreadContext context,
                            org.jruby.util.ByteList byteList)

write

protected static IRubyObject write(ThreadContext context,
                                   IRubyObject maybeIO,
                                   org.jruby.util.ByteList byteList)

write

public static IRubyObject write(ThreadContext context,
                                IRubyObject maybeIO,
                                IRubyObject str)

inspectPuts

private static IRubyObject inspectPuts(ThreadContext context,
                                       IRubyObject maybeIO,
                                       RubyArray array)

inspect
```
public IRubyObject inspect()
```
Description copied from class: RubyBasicObject

rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string. [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" Time.new.inspect #=> "Wed Apr 09 08:54:39 CDT 2003"

Specified by:

inspect in interface IRubyObject

Overrides:

inspect in class RubyBasicObject

Returns:

String

readline

public IRubyObject readline(ThreadContext context)

Read a line.

readline

public IRubyObject readline(ThreadContext context,
                            IRubyObject separator)

getc
```
public IRubyObject getc()
```
Read a byte. On EOF returns nil.

readchar19

public IRubyObject readchar19(ThreadContext context)

getbyte19

public IRubyObject getbyte19(ThreadContext context)

readbyte

public IRubyObject readbyte(ThreadContext context)

getcTranscoded

private IRubyObject getcTranscoded(ThreadContext context,
                                   Stream stream)
                            throws java.io.IOException,
                                   BadDescriptorException,
                                   InvalidValueException

Throws:: java.io.IOException; BadDescriptorException; InvalidValueException

ioEncStr

private IRubyObject ioEncStr(IRubyObject str)

getcDirect

private IRubyObject getcDirect(ThreadContext context,
                               Stream stream,
                               org.jcodings.Encoding enc)
                        throws InvalidValueException,
                               BadDescriptorException,
                               java.io.IOException

Throws:: InvalidValueException; BadDescriptorException; java.io.IOException

getc19

public IRubyObject getc19(ThreadContext context)

ioGetc

private IRubyObject ioGetc(ThreadContext context,
                           Stream stream)
                    throws java.io.IOException,
                           BadDescriptorException,
                           InvalidValueException

Throws:: java.io.IOException; BadDescriptorException; InvalidValueException

SET_BINARY_MODE
```
private void SET_BINARY_MODE()
```

getcCommon
```
public int getcCommon()
```

readCheck

private void readCheck(Stream stream)

ungetc
```
public IRubyObject ungetc(IRubyObject number)
```
Pushes char represented by int back onto IOS.

Parameters:

number - to push back

ungetc19

public IRubyObject ungetc19(IRubyObject character)

ungetcCommon
```
public void ungetcCommon(int ch)
```

read_nonblock

public IRubyObject read_nonblock(ThreadContext context,
                                 IRubyObject[] args)

doReadNonblock

public IRubyObject doReadNonblock(ThreadContext context,
                                  IRubyObject[] args,
                                  boolean useException)

readpartial

public IRubyObject readpartial(ThreadContext context,
                               IRubyObject[] args)

getPartial

private IRubyObject getPartial(ThreadContext context,
                               IRubyObject[] args,
                               boolean isNonblocking)

sysread

public IRubyObject sysread(ThreadContext context,
                           IRubyObject[] args)

synthesizeSystemCallError
```
private void synthesizeSystemCallError(java.io.IOException e)
```
Java does not give us enough information for specific error conditions so we are reduced to divining them through string matches...

read

public IRubyObject read(IRubyObject[] args)

read

public IRubyObject read(ThreadContext context)

read

public IRubyObject read(ThreadContext context,
                        IRubyObject arg0)

read

public IRubyObject read(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1)

readNotAll

private IRubyObject readNotAll(ThreadContext context,
                               OpenFile myOpenFile,
                               int length,
                               RubyString str)

readNotAll

private IRubyObject readNotAll(ThreadContext context,
                               OpenFile myOpenFile,
                               int length)

readNotAllCommon

private org.jruby.util.ByteList readNotAllCommon(ThreadContext context,
                                                 OpenFile myOpenFile,
                                                 int length)

emptyBufferOrEOF

protected static boolean emptyBufferOrEOF(org.jruby.util.ByteList buffer,
                                          OpenFile myOpenFile)
                                   throws BadDescriptorException,
                                          java.io.IOException

Throws:: BadDescriptorException; java.io.IOException

readAll

protected RubyString readAll(RubyString str)
                      throws BadDescriptorException,
                             java.io.EOFException,
                             java.io.IOException

Throws:: BadDescriptorException; java.io.EOFException; java.io.IOException

readAll

protected IRubyObject readAll(ThreadContext context)
                       throws BadDescriptorException,
                              java.io.EOFException,
                              java.io.IOException

Throws:: BadDescriptorException; java.io.EOFException; java.io.IOException

readAllCommon

protected org.jruby.util.ByteList readAllCommon(Ruby runtime)
                                         throws BadDescriptorException,
                                                java.io.EOFException,
                                                java.io.IOException

Throws:: BadDescriptorException; java.io.EOFException; java.io.IOException

fread

private org.jruby.util.ByteList fread(RubyThread thread,
                                      int length)
                               throws java.io.IOException,
                                      BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

blockingFRead

private org.jruby.util.ByteList blockingFRead(Stream stream,
                                              RubyThread thread,
                                              int length)
                                       throws java.io.IOException,
                                              BadDescriptorException

Throws:: java.io.IOException; BadDescriptorException

readchar
```
public IRubyObject readchar()
```
Read a byte. On EOF throw EOFError.

stat

public IRubyObject stat(ThreadContext context)

each_byteInternal

public IRubyObject each_byteInternal(ThreadContext context,
                                     Block block)

Invoke a block for each byte.

each_byte

public IRubyObject each_byte(ThreadContext context,
                             Block block)

bytes

public IRubyObject bytes(ThreadContext context)

lines

public IRubyObject lines(ThreadContext context,
                         Block block)

lines19

public IRubyObject lines19(ThreadContext context,
                           Block block)

each_charInternal

public IRubyObject each_charInternal(ThreadContext context,
                                     Block block)

each_charInternal19

public IRubyObject each_charInternal19(ThreadContext context,
                                       Block block)

each_char

public IRubyObject each_char(ThreadContext context,
                             Block block)

each_char19

public IRubyObject each_char19(ThreadContext context,
                               Block block)

chars

public IRubyObject chars(ThreadContext context,
                         Block block)

chars19

public IRubyObject chars19(ThreadContext context,
                           Block block)

codepoints

public IRubyObject codepoints(ThreadContext context,
                              Block block)

each_codepoint

public IRubyObject each_codepoint(ThreadContext context,
                                  Block block)

eachCodePointCommon

private IRubyObject eachCodePointCommon(ThreadContext context,
                                        Block block,
                                        java.lang.String methodName)

each_lineInternal

public RubyIO each_lineInternal(ThreadContext context,
                                IRubyObject[] args,
                                Block block)

Invoke a block for each line.

each

public IRubyObject each(ThreadContext context,
                        IRubyObject[] args,
                        Block block)

each_line

public IRubyObject each_line(ThreadContext context,
                             IRubyObject[] args,
                             Block block)

readlines

public RubyArray readlines(ThreadContext context,
                           IRubyObject[] args)

readlines19

public RubyArray readlines19(ThreadContext context,
                             IRubyObject[] args)

readlinesCommon

private RubyArray readlinesCommon(ThreadContext context,
                                  IRubyObject[] args)

getLimitFromArgs

private long getLimitFromArgs(IRubyObject[] args)

to_io
```
public RubyIO to_io()
```

toString
```
public java.lang.String toString()
```
Description copied from class: RubyObject

The default toString method is just a wrapper that calls the Ruby "to_s" method.

Overrides:

toString in class RubyObject

foreachInternal

private static IRubyObject foreachInternal(ThreadContext context,
                                           IRubyObject recv,
                                           IRubyObject[] args,
                                           Block block)

rb_io_s_foreach

foreachInternal19

private static IRubyObject foreachInternal19(ThreadContext context,
                                             IRubyObject recv,
                                             IRubyObject[] args,
                                             Block block)

rb_io_s_foreach

foreach

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

foreach19

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

convertToIO

public static RubyIO convertToIO(ThreadContext context,
                                 IRubyObject obj)

select

public static IRubyObject select(ThreadContext context,
                                 IRubyObject recv,
                                 IRubyObject[] args)

select_static

public static IRubyObject select_static(ThreadContext context,
                                        Ruby runtime,
                                        IRubyObject[] args)

read

public static IRubyObject read(ThreadContext context,
                               IRubyObject recv,
                               IRubyObject[] args)

newFile

private static RubyIO newFile(ThreadContext context,
                              IRubyObject recv,
                              IRubyObject... args)

newFile19

private static RubyIO newFile19(ThreadContext context,
                                IRubyObject recv,
                                IRubyObject... args)

failIfDirectory

public static void failIfDirectory(Ruby runtime,
                                   RubyString pathStr)

read

@Deprecated
public static IRubyObject read(ThreadContext context,
                                           IRubyObject recv,
                                           IRubyObject path,
                                           Block unusedBlock)

Deprecated.

read

@Deprecated
public static IRubyObject read(ThreadContext context,
                                           IRubyObject recv,
                                           IRubyObject path,
                                           IRubyObject length)

Deprecated.

read

@Deprecated
public static IRubyObject read(ThreadContext context,
                                           IRubyObject recv,
                                           IRubyObject path,
                                           IRubyObject length,
                                           IRubyObject offset)

Deprecated.

readStatic

public static IRubyObject readStatic(ThreadContext context,
                                     IRubyObject recv,
                                     IRubyObject path)

readStatic

public static IRubyObject readStatic(ThreadContext context,
                                     IRubyObject recv,
                                     IRubyObject path,
                                     IRubyObject length)

readStatic

public static IRubyObject readStatic(ThreadContext context,
                                     IRubyObject recv,
                                     IRubyObject path,
                                     IRubyObject length,
                                     IRubyObject offset)

read19

private static IRubyObject read19(ThreadContext context,
                                  IRubyObject recv,
                                  IRubyObject path,
                                  IRubyObject length,
                                  IRubyObject offset,
                                  IRubyObject options)

options is a hash which can contain: encoding: string or encoding mode: string open_args: array of string

openKeyArgs

private static IRubyObject openKeyArgs(ThreadContext context,
                                       IRubyObject recv,
                                       IRubyObject[] argv,
                                       IRubyObject opt)

ioOpen

public static IRubyObject ioOpen(ThreadContext context,
                                 IRubyObject filename,
                                 IRubyObject vmode,
                                 IRubyObject vperm,
                                 IRubyObject opt)

checkPipeCommand

public static IRubyObject checkPipeCommand(ThreadContext context,
                                           IRubyObject filenameOrCommand)

write19

private static IRubyObject write19(ThreadContext context,
                                   IRubyObject recv,
                                   IRubyObject path,
                                   IRubyObject str,
                                   IRubyObject offset,
                                   RubyHash options)

options is a hash which can contain: encoding: string or encoding mode: string open_args: array of string

binread
```
public static IRubyObject binread(ThreadContext context,
                                  IRubyObject recv,
                                  IRubyObject[] args)
```
binread is just like read, except it doesn't take options and it forces mode to be "rb:ASCII-8BIT"

Parameters:

context - the current ThreadContext

recv - the target of the call (IO or a subclass)

args - arguments; path [, length [, offset]]

Returns:

the binary contents of the given file, at specified length and offset

read19

public static IRubyObject read19(ThreadContext context,
                                 IRubyObject recv,
                                 IRubyObject[] args,
                                 Block unusedBlock)

binwrite

public static IRubyObject binwrite(ThreadContext context,
                                   IRubyObject recv,
                                   IRubyObject[] args)

writeStatic

public static IRubyObject writeStatic(ThreadContext context,
                                      IRubyObject recv,
                                      IRubyObject[] args,
                                      Block unusedBlock)

readlines

public static IRubyObject readlines(ThreadContext context,
                                    IRubyObject recv,
                                    IRubyObject[] args,
                                    Block unusedBlock)

readlines19

public static IRubyObject readlines19(ThreadContext context,
                                      IRubyObject recv,
                                      IRubyObject[] args,
                                      Block unusedBlock)

processReadlinesMethodArguments

private static IRubyObject[] processReadlinesMethodArguments(IRubyObject[] args)

readlinesCommon

private static RubyArray readlinesCommon(ThreadContext context,
                                         IRubyObject recv,
                                         IRubyObject[] openFileArguments,
                                         IRubyObject[] methodArguments)

readlinesCommon19

private static RubyArray readlinesCommon19(ThreadContext context,
                                           RubyIO file,
                                           IRubyObject[] newArguments)

popen

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

setupPopen

private void setupPopen(ModeFlags modes,
                        ShellLauncher.POpenProcess process)
                 throws RaiseException

Throws:: RaiseException

popen19

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

popen3

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

popen3_19

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

popen4

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

cleanupPOpen

private static void cleanupPOpen(RubyIO.POpenTuple tuple)

popenSpecial

public static RubyIO.POpenTuple popenSpecial(ThreadContext context,
                                             IRubyObject[] args)

pipe

public static IRubyObject pipe(ThreadContext context,
                               IRubyObject recv)

pipe19

public static IRubyObject pipe19(ThreadContext context,
                                 IRubyObject recv)

pipe19

public static IRubyObject pipe19(ThreadContext context,
                                 IRubyObject recv,
                                 IRubyObject modes)

pipe19

public static IRubyObject pipe19(ThreadContext context,
                                 IRubyObject recv,
                                 IRubyObject modes,
                                 IRubyObject options)

copy_stream

public static IRubyObject copy_stream(ThreadContext context,
                                      IRubyObject recv,
                                      IRubyObject[] args)

transfer

private static long transfer(java.nio.channels.ReadableByteChannel from,
                             java.nio.channels.FileChannel to)
                      throws java.io.IOException

Throws:: java.io.IOException

transfer

private static long transfer(java.nio.channels.FileChannel from,
                             java.nio.channels.WritableByteChannel to,
                             long remaining,
                             long position)
                      throws java.io.IOException

Throws:: java.io.IOException

transfer

private static long transfer(ThreadContext context,
                             java.nio.channels.ReadableByteChannel from,
                             java.nio.channels.WritableByteChannel to)
                      throws java.io.IOException

Throws:: java.io.IOException

tryConvert

public static IRubyObject tryConvert(ThreadContext context,
                                     IRubyObject recv,
                                     IRubyObject arg)

getNilByteList

private static org.jruby.util.ByteList getNilByteList(Ruby runtime)

addBlockingThread
```
public void addBlockingThread(RubyThread thread)
```
Add a thread to the list of blocking threads for this IO.

Parameters:

thread - A thread blocking on this IO

removeBlockingThread
```
public void removeBlockingThread(RubyThread thread)
```
Remove a thread from the list of blocking threads for this IO.

Parameters:

thread - A thread blocking on this IO

interruptBlockingThreads
```
protected void interruptBlockingThreads()
```
Fire an IOError in all threads blocking on this IO object

updateIOOptionsFromOptions

protected IOOptions updateIOOptionsFromOptions(ThreadContext context,
                                               RubyHash options,
                                               IOOptions ioOptions)

See http://ruby-doc.org/core-1.9.3/IO.html#method-c-new for the format of modes in options

encodingFromBOM

public org.jcodings.Encoding encodingFromBOM()

checkExecOptions
```
public static void checkExecOptions(IRubyObject options)
```
Warn when using exec with unsupported options.

Parameters:

options -

checkSpawnOptions
```
public static void checkSpawnOptions(IRubyObject options)
```
Warn when using spawn with unsupported options.

Parameters:

options -

checkPopenOptions
```
public static void checkPopenOptions(IRubyObject options)
```
Warn when using spawn with unsupported options.

Parameters:

options -

checkUnsupportedOptions

private static void checkUnsupportedOptions(IRubyObject options,
                                            java.util.Set<java.lang.String> unsupported,
                                            java.lang.String error)

Warn when using unsupported options.

Parameters:: options -

checkValidOptions

private static void checkValidOptions(IRubyObject options,
                                      java.util.Set<java.lang.String> valid)

Error when using unknown option.

Parameters:: options -

obliterateProcess
```
public static void obliterateProcess(java.lang.Process process)
```
Try for around 1s to destroy the child process. This is to work around issues on some JVMs where if you try to destroy the process too quickly it may not be ready and may ignore the destroy. A subsequent waitFor will then hang. This version tries to destroy and call exitValue repeatedly for up to 1000 calls with 1ms delay between iterations, with the intent that the target process ought to be "ready to die" fairly quickly and we don't get stuck in a blocking waitFor call.

Parameters:

process - The process to obliterate

newModeFlags

public static ModeFlags newModeFlags(Ruby runtime,
                                     long mode)

newModeFlags

public static ModeFlags newModeFlags(Ruby runtime,
                                     int mode)

newModeFlags

public static ModeFlags newModeFlags(Ruby runtime,
                                     java.lang.String mode)

newIOOptions

public static IOOptions newIOOptions(Ruby runtime,
                                     ModeFlags modeFlags)

newIOOptions

public static IOOptions newIOOptions(Ruby runtime,
                                     long mode)

newIOOptions

public static IOOptions newIOOptions(Ruby runtime,
                                     int mode)

newIOOptions

public static IOOptions newIOOptions(Ruby runtime,
                                     java.lang.String mode)

newIOOptions

public static IOOptions newIOOptions(Ruby runtime,
                                     IOOptions oldFlags,
                                     int orOflags)

writeDataBuffered
```
public boolean writeDataBuffered()
```

registerDescriptor

@Deprecated
public void registerDescriptor(ChannelDescriptor descriptor,
                                           boolean isRetained)

Deprecated.

registerDescriptor

@Deprecated
public void registerDescriptor(ChannelDescriptor descriptor)

Deprecated.

unregisterDescriptor

@Deprecated
public void unregisterDescriptor(int aFileno)

Deprecated.

getDescriptorByFileno

@Deprecated
public ChannelDescriptor getDescriptorByFileno(int aFileno)

Deprecated.

getNewFileno

@Deprecated
public static int getNewFileno()

Deprecated.

gets

@Deprecated
public IRubyObject gets(ThreadContext context,
                                    IRubyObject[] args)

Deprecated.

readline

@Deprecated
public IRubyObject readline(ThreadContext context,
                                        IRubyObject[] args)

Deprecated.

doWriteConversion

private IRubyObject doWriteConversion(ThreadContext context,
                                      IRubyObject str)

needsReadConversion
```
private boolean needsReadConversion()
```

needsWriteConversion

private boolean needsWriteConversion(ThreadContext context)

makeReadConversion

private void makeReadConversion(ThreadContext context)

makeWriteConversion

private void makeWriteConversion(ThreadContext context)

clearReadConversion
```
private void clearReadConversion()
```

clearCodeConversion
```
private void clearCodeConversion()
```

setEnc2

public void setEnc2(org.jcodings.Encoding enc2)

Specified by:: setEnc2 in interface IOEncodable

setEnc

public void setEnc(org.jcodings.Encoding enc)

Specified by:: setEnc in interface IOEncodable

setEcflags
```
public void setEcflags(int ecflags)
```
Specified by:

setEcflags in interface IOEncodable

getEcflags
```
public int getEcflags()
```
Specified by:

getEcflags in interface IOEncodable

setEcopts
```
public void setEcopts(IRubyObject ecopts)
```
Specified by:

setEcopts in interface IOEncodable

getEcopts
```
public IRubyObject getEcopts()
```
Specified by:

getEcopts in interface IOEncodable

setBOM
```
public void setBOM(boolean bom)
```
Specified by:

setBOM in interface IOEncodable

getBOM
```
public boolean getBOM()
```
Specified by:

getBOM in interface IOEncodable

setAscii8bitBinmode
```
protected void setAscii8bitBinmode()
```

MakeOpenFile
```
protected void MakeOpenFile()
```

getline

@Deprecated
public IRubyObject getline(Ruby runtime,
                                       org.jruby.util.ByteList separator)

Deprecated.

getline

@Deprecated
public IRubyObject getline(Ruby runtime,
                                       org.jruby.util.ByteList separator,
                                       long limit)

Deprecated.

Class RubyIO

Nested Class Summary

Nested classes/interfaces inherited from class org.jruby.RubyObject

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject

Nested classes/interfaces inherited from interface org.jruby.util.io.IOEncodable

Field Summary

Fields inherited from class org.jruby.RubyObject

Fields inherited from class org.jruby.RubyBasicObject

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject

Constructor Summary

Method Summary

Methods inherited from class org.jruby.RubyObject

Methods inherited from class org.jruby.RubyBasicObject

Methods inherited from class java.lang.Object

Field Detail

IO_ALLOCATOR

vendor

msgEINTR

NIL_BYTELIST

RECURSIVE_BYTELIST

EMPTY_BYTE_ARRAY

UNSUPPORTED_SPAWN_OPTIONS

ALL_SPAWN_OPTIONS

readconv

writeconvInitialized

writeconv

openFile

blockingThreads

enc

enc2

ecflags

ecopts

writeconvPreEcflags

writeconvPreEcopts

writeconvAsciicompat

popenSpecial

hasBom

Constructor Detail

RubyIO

RubyIO

RubyIO

RubyIO

RubyIO

RubyIO

RubyIO

RubyIO

Method Detail

newIO

getOpenFile

getOpenFileChecked

getNativeTypeIndex

createIOClass

getOutStream

getInStream

getChannel

getHandler

reopenPath

reopenIO

reopen

getIOModes

getIOModesIntFromString

separator

separator

getSeparatorFromArgs

getSeparatorForGets

getline

getline

getline

getline

getlineEmptyString

getlineAll

getlineInner

getEnc

getReadEncoding

getEnc2

getInputEncoding

makeString

incrementLineno

swallow

restartSystemCall