/***** BEGIN LICENSE BLOCK *****

* Version: EPL 2.0/GPL 2.0/LGPL 2.1

*

* The contents of this file are subject to the Eclipse Public

* License Version 2.0 (the "License"); you may not use this file

* except in compliance with the License. You may obtain a copy of

* the License at http://www.eclipse.org/legal/epl-v20.html

*

* Software distributed under the License is distributed on an "AS

* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

* implied. See the License for the specific language governing

* rights and limitations under the License.

*

* Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>

* Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>

* Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>

* Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>

* Copyright (C) 2007 Ola Bini <ola@ologix.com>

* Copyright (C) 2008-2009 Joseph LaFata <joe@quibb.org>

*

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the EPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the EPL, the GPL or the LGPL.

***** END LICENSE BLOCK *****/

package org.jruby;

import jnr.posix.FileStat;

import jnr.posix.util.Platform;

import org.jruby.anno.JRubyMethod;

import org.jruby.exceptions.RaiseException;

import org.jruby.internal.runtime.GlobalVariable;

import org.jruby.internal.runtime.GlobalVariables;

import org.jruby.internal.runtime.ValueAccessor;

import org.jruby.runtime.Arity;

import org.jruby.runtime.Block;

import org.jruby.runtime.CallSite;

import org.jruby.runtime.IAccessor;

import org.jruby.runtime.JavaSites;

import org.jruby.runtime.ThreadContext;

import org.jruby.runtime.builtin.IRubyObject;

import org.jruby.util.ByteList;

import org.jruby.util.StringSupport;

import org.jruby.util.TypeConverter;

import org.jruby.util.io.Getline;

import java.io.File;

import java.io.IOException;

import static org.jruby.RubyArgsFile.Next.NextFile;

import static org.jruby.RubyArgsFile.Next.Stream;

import static org.jruby.RubyEnumerator.enumeratorize;

import static org.jruby.anno.FrameField.LASTLINE;

import static org.jruby.api.Access.argsFile;

import static org.jruby.api.Access.fileClass;

import static org.jruby.api.Access.globalVariables;

import static org.jruby.api.Access.instanceConfig;

import static org.jruby.api.Access.objectClass;

import static org.jruby.api.Access.stringClass;

import static org.jruby.api.Convert.asBoolean;

import static org.jruby.api.Convert.asFixnum;

import static org.jruby.api.Convert.asSymbol;

import static org.jruby.api.Convert.toByte;

import static org.jruby.api.Convert.toInt;

import static org.jruby.api.Convert.toLong;

import static org.jruby.api.Create.newArray;

import static org.jruby.api.Create.newEmptyArray;

import static org.jruby.api.Create.newEmptyString;

import static org.jruby.api.Create.newString;

import static org.jruby.api.Define.defineClass;

import static org.jruby.api.Error.argumentError;

import static org.jruby.api.Warn.warn;

import static org.jruby.runtime.ThreadContext.hasKeywords;

import static org.jruby.runtime.Visibility.PRIVATE;

public class RubyArgsFile extends RubyObject {

public RubyArgsFile(Ruby runtime, RubyClass metaClass) {

super(runtime, metaClass);

}

public static void initArgsFile(ThreadContext context, RubyModule Enumerable, GlobalVariables globals) {

var Object = objectClass(context);

RubyClass ARGF = defineClass(context, "ARGFClass", Object, RubyArgsFile::new).

include(context, Enumerable).

defineMethods(context, RubyArgsFile.class);

IRubyObject argsFile = ARGF.newInstance(context, new IRubyObject[] { null }, null);

context.runtime.setArgsFile(argsFile);

globals.defineReadonly("$<", new ArgsFileAccessor(context.runtime), GlobalVariable.Scope.GLOBAL);

Object.defineConstant(context, "ARGF", argsFile);

globals.defineReadonly("$FILENAME", new ValueAccessor(newString(context, "-")), GlobalVariable.Scope.GLOBAL);

}

private static class ArgsFileAccessor implements IAccessor {

private final Ruby runtime;

ArgsFileAccessor(Ruby runtime) { this.runtime = runtime; }

public IRubyObject getValue() {

return runtime.getArgsFile();

}

public IRubyObject setValue(IRubyObject newValue) {

throw new UnsupportedOperationException("Not supported yet.");

}

}

@JRubyMethod(name = "initialize", visibility = PRIVATE, rest = true)

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

final var argv = args.length == 1 && args[0] == null ?

objectClass(context).getConstant(context, "ARGV").convertToArray() :

newArray(context, args);

// ARGF is intended to be a singleton from a Ruby perspective but it is still

// possible for someone to ARGF.class.new. We do still want a global view of

// ARGF otherwise getline and rewind in IO would have to keep track of the n

// instances in play. So all instances will share

var argsFile = argsFile(context);

if (argsFile == null) {

dataWrapStruct(new ArgsFileData(context.runtime, argv));

} else {

ArgsFileData data = (ArgsFileData) argsFile.dataGetStruct();

dataWrapStruct(data);

data.setArgs(argv);

}

return this;

}

public enum Next {

Stream, // We are only getting from $stdin

SameFile, // We are continuing to interact with the same file

NextFile // Time to advance to the next file.

}

public static final class ArgsFileData {

private final Ruby runtime;

private RubyArray argv;

public IRubyObject currentFile;

private boolean inited = false;

public Next next_p = NextFile;

public boolean binmode = false;

private IRubyObject inPlace; // false, nil, String

public ArgsFileData(Ruby runtime, RubyArray argv) {

this.runtime = runtime;

setArgs(argv);

this.currentFile = runtime.getNil();

}

// ARGF.class.new

void setArgs(RubyArray argv) {

inited = false;

this.argv = argv;

this.inPlace = runtime.getFalse();

}

public boolean next_argv(ThreadContext context) {

if (!inited) {

next_p = argv.getLength() > 0 ? NextFile : Stream;

inited = true;

runtime.setCurrentLine(0);

} else {

if (argv.isNil()) {

next_p = Stream;

} else if (next_p == Stream && argv.getLength() > 0) {

next_p = NextFile;

}

}

var globalVariables = globalVariables(context);

GlobalVariable $FILENAME = globalVariables.getVariable("$FILENAME");

if (next_p == NextFile) {

if (argv.getLength() > 0) {

RubyString filename = TypeConverter.convertToType(argv.shift(context), stringClass(context), "to_path").convertToString();

StringSupport.checkStringSafety(runtime, filename);

if ( ! filename.op_equal(context, $FILENAME.getAccessor().getValue()).isTrue() ) {

$FILENAME.forceValue(filename);

}

if (filenameEqlDash(filename)) {

currentFile = globalVariables.get("$stdin");

} else {

RubyIO currentFileIO = (RubyIO) RubyFile.open(context, fileClass(context), new IRubyObject[]{ filename }, Block.NULL_BLOCK);

currentFile = currentFileIO;

String extension = null;

if (inPlace.isTrue()) extension = inPlace.asJavaString();

if (extension == null) extension = instanceConfig(context).getInPlaceBackupExtension();

if (extension != null) {

if (Platform.IS_WINDOWS) {

inplaceEditWindows(context, currentFileIO, filename.asJavaString(), extension);

} else {

inplaceEdit(context, currentFileIO, filename.asJavaString(), extension);

}

}

if (binmode) {

currentFileIO.binmode(context);

}

}

next_p = Next.SameFile;

} else {

next_p = NextFile;

return false;

}

} else if (next_p == Stream) {

currentFile = globalVariables.get("$stdin");

if (!filenameEqlDash((RubyString) $FILENAME.getAccessor().getValue())) {

$FILENAME.forceValue(newString(context, "-"));

}

}

return true;

}

private static boolean filenameEqlDash(final RubyString filename) {

final ByteList filenameBytes = filename.getByteList();

return filenameBytes.length() == 1 && filenameBytes.get(0) == '-';

}

public static ArgsFileData getArgsFileData(Ruby runtime) {

return (ArgsFileData) runtime.getArgsFile().dataGetStruct();

}

private void createNewFile(File file) {

try {

file.createNewFile();

} catch (IOException ex) {

throw runtime.newIOErrorFromException(ex);

}

}

private void inplaceEditWindows(ThreadContext context, RubyIO argfIO, String filename, String extension) throws RaiseException {

File file = new File(filename);

if (!extension.isEmpty()) {

String backup = filename + extension;

File backupFile = new File(backup);

((RubyIO) currentFile).close(); // we can't rename a file while it's open in windows

backupFile.delete();

file.renameTo(backupFile);

currentFile = RubyFile.open(context, fileClass(context), //reopen

new IRubyObject[]{newString(context, backup)}, Block.NULL_BLOCK);

} else {

throw runtime.newIOError("Windows doesn't support inplace editing without a backup");

}

createNewFile(file);

IRubyObject writeIO = RubyFile.open(context, fileClass(context),

new IRubyObject[]{newString(context, filename), newString(context, "w")}, Block.NULL_BLOCK);

argfIO.getOpenFile().tiedIOForWriting = (RubyIO) writeIO;

globalVariables(context).set("$stdout", writeIO);

}

private void inplaceEdit(ThreadContext context, RubyIO argfIO, String filename, String extension) throws RaiseException {

File file = new File(filename);

var posix = context.runtime.getPosix();

FileStat stat = posix.stat(filename);

if (!extension.isEmpty()) {

file.renameTo(new File(filename + extension));

} else {

file.delete();

}

createNewFile(file);

posix.chmod(filename, stat.mode());

posix.chown(filename, stat.uid(), stat.gid());

IRubyObject writeIO = RubyFile.open(context, fileClass(context),

new IRubyObject[]{newString(context, filename), newString(context, "w")}, Block.NULL_BLOCK);

argfIO.getOpenFile().tiedIOForWriting = (RubyIO) writeIO;

globalVariables(context).set("$stdout", (RubyIO) writeIO);

}

public boolean isCurrentFile(RubyIO io) {

return currentFile == io;

}

}

@JRubyMethod

public static IRubyObject inplace_mode(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (data.inPlace == null) return context.nil;

if (data.inPlace.isNil()) return context.nil;

return data.inPlace.dup();

}

@JRubyMethod(name = "inplace_mode=")

public static IRubyObject inplace_mode_set(ThreadContext context, IRubyObject recv, IRubyObject test) {

return setInplaceMode(context, recv, test);

}

private static IRubyObject setInplaceMode(ThreadContext context, IRubyObject recv, IRubyObject test) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (test.isNil()) {

data.inPlace = context.nil;

} else if (!test.isTrue()) {

data.inPlace = context.fals;

} else {

test = TypeConverter.convertToType(test, stringClass(context), "to_str", false);

if (test.isNil() || ((RubyString) test).isEmpty()) {

data.inPlace = context.nil;

} else {

StringSupport.checkStringSafety(context.runtime, test);

test.setFrozen(true);

data.inPlace = test;

}

}

return recv;

}

@JRubyMethod(name = "inplace_mode=")

public IRubyObject inplace_mode_set(ThreadContext context, IRubyObject test) {

return setInplaceMode(context, this, test);

}

@JRubyMethod(name = "argv")

public static IRubyObject argv(ThreadContext context, IRubyObject recv) {

return ArgsFileData.getArgsFileData(context.runtime).argv;

}

@JRubyMethod(name = {"fileno", "to_i"})

public static IRubyObject fileno(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream").fileno(context);

}

@JRubyMethod(name = "to_io")

public static IRubyObject to_io(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream");

}

@JRubyMethod

public static IRubyObject set_encoding(ThreadContext context, IRubyObject recv, IRubyObject encoding) {

return getCurrentDataFile(context, "no stream to set encoding").set_encoding(context, encoding);

}

@JRubyMethod

public static IRubyObject set_encoding(ThreadContext context, IRubyObject recv, IRubyObject encoding, IRubyObject internalEncoding) {

return getCurrentDataFile(context, "no stream to set encoding").set_encoding(context, encoding, internalEncoding);

}

@JRubyMethod

public static IRubyObject set_encoding(ThreadContext context, IRubyObject recv, IRubyObject encoding, IRubyObject internalEncoding, IRubyObject options) {

return getCurrentDataFile(context, "no stream to set encoding").set_encoding(context, encoding, internalEncoding, options);

}

@JRubyMethod

public static IRubyObject internal_encoding(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream to set encoding").internal_encoding(context);

}

@JRubyMethod

public static IRubyObject external_encoding(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream to set encoding").external_encoding(context);

}

// MRI: argf_getline

private static IRubyObject argf_getline(ThreadContext context, final int callInfo, IRubyObject[] args) {

IRubyObject line;

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

while (true) {

if (!data.next_argv(context)) return context.nil;

RubyIO currentFile = (RubyIO) data.currentFile;

if (isGenericInput(context, data)) {

context.callInfo = callInfo; // restore callInfo for kwargs

line = data.currentFile.callMethod(context, "gets", args);

} else {

if (args.length == 0 && context.runtime.getRecordSeparatorVar().get() == globalVariables(context).getDefaultSeparator()) {

line = (currentFile).gets(context);

} else {

line = Getline.getlineCall(context, GETLINE, currentFile, currentFile.getReadEncoding(), hasKeywords(callInfo), args);

}

if (line.isNil() && data.next_p != Stream) {

argf_close(context, data.currentFile);

data.next_p = NextFile;

continue;

}

}

return line;

}

}

private static boolean isGenericInput(ThreadContext context, ArgsFileData data) {

return data.currentFile == globalVariables(context).get("$stdin") && !(data.currentFile instanceof RubyFile);

}

private static final Getline.Callback<RubyIO, IRubyObject> GETLINE =

(context, self, rs, limit, chomp, block) -> self.getlineImpl(context, rs, limit, chomp);

// ARGF methods

/** Read a line.

*

*/

@JRubyMethod(name = "gets", optional = 1, keywords = true, checkArity = false, writes = LASTLINE)

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

final int callInfo = ThreadContext.resetCallInfo(context);

Arity.checkArgumentCount(context, args, 0, 1);

return context.setLastLine(argf_getline(context, callInfo, args));

}

/** Read a line.

*

*/

@JRubyMethod(name = "readline", optional = 1, keywords = true, checkArity = false, writes = LASTLINE)

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

IRubyObject line = gets(context, recv, args);

if (line.isNil()) throw context.runtime.newEOFError();

return line;

}

@JRubyMethod(optional = 1, keywords = true, checkArity = false)

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

final int callInfo = ThreadContext.resetCallInfo(context);

Arity.checkArgumentCount(context, args, 0, 1);

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (!data.next_argv(context)) return newEmptyArray(context);

if (!(data.currentFile instanceof RubyIO)) {

// TODO do we need to restore callInfo here?

return data.currentFile.callMethod(context, "readlines", args);

}

var ary = newArray(context);

IRubyObject line;

while(!(line = argf_getline(context, callInfo, args)).isNil()) {

ary.append(context, line);

}

return ary;

}

@JRubyMethod(optional = 1, checkArity = false)

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

Arity.checkArgumentCount(context, args, 0, 1);

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (!data.next_argv(context)) return newEmptyArray(context);

if (!(data.currentFile instanceof RubyIO)) return data.currentFile.callMethod(context, "to_a", args);

var ary = newArray(context);

IRubyObject line;

while ((line = argf_getline(context, 0, args)) != context.nil) {

ary.append(context, line);

}

return ary;

}

@JRubyMethod

public static IRubyObject each_byte(final ThreadContext context, IRubyObject recv, final Block block) {

if (!block.isGiven()) return enumeratorize(context.runtime, recv, "each_byte");

IRubyObject bt;

while ((bt = getc(context, recv)) != context.nil) {

block.yield(context, bt);

}

return recv;

}

@JRubyMethod

public static IRubyObject each_byte(final ThreadContext context, IRubyObject recv, IRubyObject arg, final Block block) {

return block.isGiven() ? each_byte(context, recv, block) : enumeratorize(context.runtime, recv, "each_byte");

}

@JRubyMethod(optional = 1, checkArity = false)

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

Arity.checkArgumentCount(context, args, 0, 1);

return block.isGiven() ? each_byte(context, recv, block) : enumeratorize(context.runtime, recv, "bytes");

}

@JRubyMethod

public static IRubyObject each_char(final ThreadContext context, IRubyObject recv, Block block) {

return block.isGiven() ? each_charCommon(context, recv, block) : enumeratorize(context.runtime, recv, "each_char");

}

@JRubyMethod

public static IRubyObject chars(final ThreadContext context, IRubyObject recv, Block block) {

return block.isGiven() ? each_charCommon(context, recv, block) : enumeratorize(context.runtime, recv, "chars");

}

public static IRubyObject each_charCommon(ThreadContext context, IRubyObject recv, Block block) {

final Ruby runtime = context.runtime;

ArgsFileData data = ArgsFileData.getArgsFileData(runtime);

IRubyObject ch;

while ((ch = getc(context, recv)) != context.nil) {

boolean cont = true;

while (cont) {

cont = false;

byte c = toByte(context, ch);

int n = runtime.getKCode().getEncoding().length(c);

IRubyObject file = data.currentFile;

RubyString str = runtime.newString();

str.cat(c);

while(--n > 0) {

if ((ch = getc(context, recv)) == context.nil) {

block.yield(context, str);

return recv;

}

if (data.currentFile != file) {

block.yield(context, str);

cont = true;

continue;

}

c = toByte(context, ch);

str.cat(c);

}

block.yield(context, str);

}

}

return recv;

}

@JRubyMethod

public static IRubyObject each_codepoint(ThreadContext context, IRubyObject recv, Block block) {

if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_codepoint");

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

CallSite each_codepoint = sites(context).each_codepoint;

while (data.next_argv(context)) {

each_codepoint.call(context, recv, data.currentFile, block);

data.next_p = NextFile;

}

return recv;

}

@Deprecated(since = "9.4-")

public static IRubyObject codepoints(ThreadContext context, IRubyObject recv, Block block) {

warn(context, "ARGF#codepoints is deprecated; use #each_codepoint instead");

if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_line");

return each_codepoint(context, recv, block);

}

/** Invoke a block for each line.

*

*/

@JRubyMethod(name = "each_line", optional = 1, keywords = true, checkArity = false)

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

if (!block.isGiven()) return enumeratorize(context.runtime, recv, "each_line", args);

final int callInfo = ThreadContext.resetCallInfo(context);

Arity.checkArgumentCount(context, args, 0, 1);

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (!data.next_argv(context)) return context.nil;

if (!(data.currentFile instanceof RubyIO)) {

if (!data.next_argv(context)) return recv;

data.currentFile.callMethod(context, "each", NULL_ARRAY, block);

data.next_p = NextFile;

}

IRubyObject str;

while ((str = argf_getline(context, callInfo, args)) != context.nil) {

block.yield(context, str);

}

return recv;

}

@Deprecated(since = "10.0.0.0")

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

if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_line");

return each_line(context, recv, args, block);

}

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

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

return block.isGiven() ? each_line(context, recv, args, block) : enumeratorize(context.runtime, recv, "each", args);

}

@JRubyMethod(name = "file")

public static IRubyObject file(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

data.next_argv(context);

return data.currentFile;

}

@Deprecated(since = "10.0.0.0")

public static IRubyObject skip(IRubyObject recv) {

return skip(((RubyBasicObject) recv).getCurrentContext(), recv);

}

@JRubyMethod(name = "skip")

public static IRubyObject skip(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (data.inited && data.next_p == Next.SameFile) {

argf_close(context, data.currentFile);

data.next_p = NextFile;

}

return recv;

}

public static void argf_close(ThreadContext context, IRubyObject file) {

if (file instanceof RubyIO) {

((RubyIO) file).rbIoClose(context);

} else {

file.callMethod(context, "close");

}

}

@JRubyMethod(name = "close")

public static IRubyObject close(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

data.next_argv(context);

if (data.currentFile == globalVariables(context).get("$stdin")) return recv;

argf_close(context, data.currentFile);

if (data.next_p != Stream) data.next_p = NextFile;

context.runtime.setCurrentLine(0);

return recv;

}

@JRubyMethod(name = "closed?")

public static IRubyObject closed_p(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

data.next_argv(context);

return asBoolean(context, isClosed(context, data.currentFile));

}

private static boolean isClosed(ThreadContext context, IRubyObject currentFile) {

if (!(currentFile instanceof RubyIO)) return currentFile.callMethod(context, "closed?").isTrue();

return ((RubyIO)currentFile).closed_p(context).isTrue();

}

@JRubyMethod(name = "binmode")

public static IRubyObject binmode(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

data.binmode = true;

if (data.currentFile != context.nil) ((RubyIO) data.currentFile).binmode(context);

return recv;

}

@JRubyMethod(name = "binmode?")

public static IRubyObject op_binmode(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream").op_binmode(context);

}

@JRubyMethod(name = "lineno")

public static IRubyObject lineno(ThreadContext context, IRubyObject recv) {

return asFixnum(context, context.runtime.getCurrentLine());

}

@JRubyMethod(name = "lineno=")

public static IRubyObject lineno_set(ThreadContext context, IRubyObject recv, IRubyObject line) {

context.runtime.setCurrentLine(toInt(context, line));

return context.nil;

}

@JRubyMethod(name = "tell", alias = {"pos"})

public static IRubyObject tell(ThreadContext context, IRubyObject recv) {

return getCurrentDataFile(context, "no stream to tell").pos(context);

}

@JRubyMethod(name = "rewind")

public static IRubyObject rewind(ThreadContext context, IRubyObject recv) {

RubyIO currentFile = getCurrentDataFile(context, "no stream to rewind");

RubyFixnum retVal = currentFile.rewind(context);

currentFile.lineno_set(context, asFixnum(context, 0));

return retVal;

}

@JRubyMethod(name = {"eof"})

public static IRubyObject eof(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (!data.inited) return context.tru;

if (!(data.currentFile instanceof RubyIO)) {

return data.currentFile.callMethod(context, "eof");

} else {

return ((RubyIO) data.currentFile).eof_p(context);

}

}

@JRubyMethod(name = {"eof?"})

public static IRubyObject eof_p(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

if (!data.inited) return context.tru;

if (!(data.currentFile instanceof RubyIO)) {

return data.currentFile.callMethod(context, "eof?");

} else {

return ((RubyIO) data.currentFile).eof_p(context);

}

}

@JRubyMethod(name = "pos=")

public static IRubyObject set_pos(ThreadContext context, IRubyObject recv, IRubyObject offset) {

return getCurrentDataFile(context, "no stream to set position").pos_set(context, offset);

}

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

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

Arity.checkArgumentCount(context, args, 1, 2);

return getCurrentDataFile(context, "no stream to seek").seek(context, args);

}

@JRubyMethod(name = "readchar")

public static IRubyObject readchar(ThreadContext context, IRubyObject recv) {

IRubyObject c = getc(context, recv);

if (c == context.nil) throw context.runtime.newEOFError();

return c;

}

@JRubyMethod

public static IRubyObject getbyte(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

while (true) {

if (!data.next_argv(context)) return context.nil;

IRubyObject bt;

if (data.currentFile instanceof RubyFile) {

bt = ((RubyIO) data.currentFile).getbyte(context);

} else {

bt = data.currentFile.callMethod(context, "getbyte");

}

if (bt != context.nil) return bt;

argf_close(context, data.currentFile);

data.next_p = NextFile;

}

}

@JRubyMethod(required = 1, optional = 2, checkArity = false)

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

Arity.checkArgumentCount(context, args, 1, 3);

return getPartial(context, recv, args, true);

}

@JRubyMethod(required = 1, optional = 1, checkArity = false)

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

Arity.checkArgumentCount(context, args, 1, 2);

return getPartial(context, recv, args, false);

}

private static IRubyObject getPartial(ThreadContext context, IRubyObject recv, IRubyObject[] args, boolean nonBlocking) {

final Ruby runtime = context.runtime;

boolean noException = false;

RubyString str = null;

if (args.length > 1) {

IRubyObject opts = TypeConverter.checkHashType(runtime, args[args.length - 1]);

if ( opts != context.nil &&

context.fals == ((RubyHash) opts).op_aref(context, asSymbol(context, "exception")) ) {

noException = true;

}

if (args.length > 2 || opts == context.nil) {

if (args[1] != context.nil) {

args[1] = args[1].convertToString();

str = (RubyString) args[1];

}

}

}

final ArgsFileData data = ArgsFileData.getArgsFileData(runtime);

if (!data.next_argv(context)) {

if (str != null) str.clear(context);

return RubyIO.nonblockEOF(runtime, noException);

}

IRubyObject res = ((RubyIO) data.currentFile).getPartial(context, args, nonBlocking, noException);

if (res != context.nil) return res;

if (data.next_p == Stream) return RubyIO.nonblockEOF(runtime, noException);

argf_close(context, data.currentFile);

data.next_p = NextFile;

if (data.argv.isEmpty()) return RubyIO.nonblockEOF(runtime, noException);

return args.length > 1 && args[1] instanceof RubyString ? args[1] : newEmptyString(context);

}

@JRubyMethod

public static IRubyObject readbyte(ThreadContext context, IRubyObject recv) {

IRubyObject c = getbyte(context, recv);

if (c.isNil()) throw context.runtime.newEOFError();

return c;

}

@JRubyMethod(name = "getc")

public static IRubyObject getc(ThreadContext context, IRubyObject recv) {

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

while (true) {

if (!data.next_argv(context)) return context.nil;

IRubyObject bt;

if (data.currentFile instanceof RubyFile) {

bt = ((RubyIO) data.currentFile).getbyte(context);

} else {

bt = data.currentFile.callMethod(context,"getc");

}

if (bt != context.nil) return bt;

argf_close(context, data.currentFile);

data.next_p = NextFile;

}

}

@JRubyMethod(name = "read", optional = 2, checkArity = false)

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

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

ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);

IRubyObject tmp, str, length;

long len = 0;

var nil = context.nil;

if (argc > 0) {

length = args[0];

str = argc > 1 ? args[1] : nil;

} else {

str = length = nil;

}

if (length != nil) len = toLong(context, length);

if (str != nil) {

str = str.convertToString();

((RubyString) str).modify();

((RubyString) str).getByteList().length(0);

args[1] = nil;

}

while (true) {

if (!data.next_argv(context)) return str;

tmp = data.currentFile instanceof RubyIO file ?

file.read(context, args) : data.currentFile.callMethod(context, "read", args);

if (str == nil) {

str = tmp;

} else if (tmp != nil) {

((RubyString) str).append(tmp);

}

if (tmp == nil || length == nil) {

if (data.next_p != Stream) {

argf_close(context, data.currentFile);

data.next_p = NextFile;

continue;

}

} else if (argc >= 1) {

final int strLen = ((RubyString) str).getByteList().length();

if (strLen < len) {

args[0] = asFixnum(context, len - strLen);

continue;

}

}

return str;

}

}

@JRubyMethod(name = "filename", alias = {"path"})

public static IRubyObject filename(ThreadContext context, IRubyObject recv) {

ArgsFileData.getArgsFileData(context.runtime).next_argv(context);

return globalVariables(context).get("$FILENAME");

}

@Deprecated(since = "10.0.0.0")

public static IRubyObject to_s(IRubyObject recv) {

return to_s(((RubyBasicObject) recv).getCurrentContext(), recv);

}

@JRubyMethod(name = "to_s", alias = "inspect")

public static IRubyObject to_s(ThreadContext context, IRubyObject recv) {

return newString(context, "ARGF");

}

@JRubyMethod(name = "write", rest = true)

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

return RubyIO.writev(context, argfWriteIO(context), args);

}

@JRubyMethod(name = "write")

public static IRubyObject write(ThreadContext context, IRubyObject recv) {

return RubyIO.writev(context, argfWriteIO(context));

}

@JRubyMethod(name = "write")

public static IRubyObject write(ThreadContext context, IRubyObject recv, IRubyObject arg0) {

return RubyIO.writev(context, argfWriteIO(context), arg0);

}

@JRubyMethod(name = "write")

public static IRubyObject write(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1) {

return RubyIO.writev(context, argfWriteIO(context), arg0, arg1);

}

@JRubyMethod(name = "write")

public static IRubyObject write(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {

return RubyIO.writev(context, argfWriteIO(context), arg0, arg1, arg2);

}

@JRubyMethod(name = "print", rest = true)

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

return RubyIO.print(context, recv, args);

}

@JRubyMethod(name = "print")

public static IRubyObject print(ThreadContext context, IRubyObject recv) {

return RubyIO.print0(context, recv);

}

@JRubyMethod(name = "print")

public static IRubyObject print(ThreadContext context, IRubyObject recv, IRubyObject arg0) {

return RubyIO.print1(context, recv, arg0);

}

@JRubyMethod(name = "print")

public static IRubyObject print(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1) {

return RubyIO.print2(context, recv, arg0, arg1);

}

@JRubyMethod(name = "print")

public static IRubyObject print(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {

return RubyIO.print3(context, recv, arg0, arg1, arg2);

}

@JRubyMethod(name = "printf", rest = true)

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

return RubyIO.printf(context, recv, args);

}

@JRubyMethod(name = "putc")

public static IRubyObject putc(ThreadContext context, IRubyObject recv, IRubyObject arg0) {

return RubyIO.putc(context, recv, arg0);

}

@JRubyMethod(name = "puts", rest = true)

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

return RubyIO.puts(context, recv, args);

}