Returns theARGV array, which contains the arguments passed toyour script, one per element.

For example:

$ ruby argf.rb -v glark.txtARGF.argv   #=> ["-v", "glark.txt"]

                static VALUEargf_argv(VALUE argf){    return ARGF.argv;}

PutsARGF into binary mode. Once a stream is in binary mode,it cannot be reset to non-binary mode. This option has the followingeffects:

• Newline conversion is disabled.

• Encoding conversion is disabled.

• Content is treated as ASCII-8BIT.

                static VALUEargf_binmode_m(VALUE argf){    ARGF.binmode = 1;    next_argv();    ARGF_FORWARD(0, 0);    rb_io_ascii8bit_binmode(ARGF.current_file);    return argf;}

Returns true ifARGF is being read in binary mode; falseotherwise. To enable binary mode useARGF.binmode.

For example:

ARGF.binmode?#=> falseARGF.binmodeARGF.binmode?#=> true

                static VALUEargf_binmode_p(VALUE argf){    return ARGF.binmode ? Qtrue : Qfalse;}

Closes the current file and skips to the next file in ARGV. If there are nomore files to open, just closes the current file.STDIN willnot be closed.

For example:

$ ruby argf.rb foo barARGF.filename  #=> "foo"ARGF.closeARGF.filename  #=> "bar"ARGF.close

                static VALUEargf_close_m(VALUE argf){    next_argv();    argf_close(argf);    if (ARGF.next_p != -1) {        ARGF.next_p = 1;    }    ARGF.lineno = 0;    return argf;}

Returnstrue if the current file has been closed;falseotherwise. UseARGF.close to actually close the current file.

                static VALUEargf_closed(VALUE argf){    next_argv();    ARGF_FORWARD(0, 0);    return rb_io_closed(ARGF.current_file);}

Returns an enumerator which iterates over each line (separated bysep, which defaults to your platform's newline character) ofeach file inARGV. If a block is supplied, each line in turnwill be yielded to the block, otherwise an enumerator is returned. Theoptionallimit argument is anInteger specifying themaximum length of each line; longer lines will be split according to thislimit.

This method allows you to treat the files supplied on the command line as asingle file consisting of the concatenation of each named file. After thelast line of the first file has been returned, the first line of the secondfile is returned. TheARGF.filename andARGF.lineno methods can be used to determine the filename ofthe current line and line number of the whole input, respectively.

For example, the following code prints out each line of each named fileprefixed with its line number, displaying the filename once per file:

ARGF.each_linedo|line|putsARGF.filenameifARGF.file.lineno==1puts"#{ARGF.file.lineno}: #{line}"end

While the following code prints only the first file's name at first,and the contents with line number counted through all named files.

ARGF.each_linedo|line|putsARGF.filenameifARGF.lineno==1puts"#{ARGF.lineno}: #{line}"end

                static VALUEargf_each_line(int argc, VALUE *argv, VALUE argf){    RETURN_ENUMERATOR(argf, argc, argv);    FOREACH_ARGF() {        argf_block_call_line(rb_intern("each_line"), argc, argv, argf);    }    return argf;}

Iterates over each byte of each file inARGV. A byte isreturned as anInteger in the range 0..255.

This method allows you to treat the files supplied on the command line as asingle file consisting of the concatenation of each named file. After thelast byte of the first file has been returned, the first byte of the secondfile is returned. TheARGF.filename method can be used todetermine the filename of the current byte.

If no block is given, an enumerator is returned instead.

For example:

ARGF.bytes.to_a#=> [35, 32, ... 95, 10]

                static VALUEargf_each_byte(VALUE argf){    RETURN_ENUMERATOR(argf, 0, 0);    FOREACH_ARGF() {        argf_block_call(rb_intern("each_byte"), 0, 0, argf);    }    return argf;}

Iterates over each character of each file inARGF.

This method allows you to treat the files supplied on the command line as asingle file consisting of the concatenation of each named file. After thelast character of the first file has been returned, the first character ofthe second file is returned. TheARGF.filename method can beused to determine the name of the file in which the current characterappears.

If no block is given, an enumerator is returned instead.

                static VALUEargf_each_char(VALUE argf){    RETURN_ENUMERATOR(argf, 0, 0);    FOREACH_ARGF() {        argf_block_call(rb_intern("each_char"), 0, 0, argf);    }    return argf;}

Iterates over each codepoint of each file inARGF.

This method allows you to treat the files supplied on the command line as asingle file consisting of the concatenation of each named file. After thelast codepoint of the first file has been returned, the first codepoint ofthe second file is returned. TheARGF.filename method can beused to determine the name of the file in which the current codepointappears.

If no block is given, an enumerator is returned instead.

                static VALUEargf_each_codepoint(VALUE argf){    RETURN_ENUMERATOR(argf, 0, 0);    FOREACH_ARGF() {        argf_block_call(rb_intern("each_codepoint"), 0, 0, argf);    }    return argf;}

Returns an enumerator which iterates over each line (separated bysep, which defaults to your platform's newline character) ofeach file inARGV. If a block is supplied, each line in turnwill be yielded to the block, otherwise an enumerator is returned. Theoptionallimit argument is anInteger specifying themaximum length of each line; longer lines will be split according to thislimit.

This method allows you to treat the files supplied on the command line as asingle file consisting of the concatenation of each named file. After thelast line of the first file has been returned, the first line of the secondfile is returned. TheARGF.filename andARGF.lineno methods can be used to determine the filename ofthe current line and line number of the whole input, respectively.

For example, the following code prints out each line of each named fileprefixed with its line number, displaying the filename once per file:

ARGF.each_linedo|line|putsARGF.filenameifARGF.file.lineno==1puts"#{ARGF.file.lineno}: #{line}"end

While the following code prints only the first file's name at first,and the contents with line number counted through all named files.

ARGF.each_linedo|line|putsARGF.filenameifARGF.lineno==1puts"#{ARGF.lineno}: #{line}"end

                static VALUEargf_each_line(int argc, VALUE *argv, VALUE argf){    RETURN_ENUMERATOR(argf, argc, argv);    FOREACH_ARGF() {        argf_block_call_line(rb_intern("each_line"), argc, argv, argf);    }    return argf;}

Returns true if the current file inARGF is at end of file,i.e. it has no data to read. The stream must be opened for reading or anIOError will be raised.

$ echo "eof" | ruby argf.rbARGF.eof?                 #=> false3.times { ARGF.readchar }ARGF.eof?                 #=> falseARGF.readchar             #=> "\n"ARGF.eof?                 #=> true

                static VALUEargf_eof(VALUE argf){    next_argv();    if (RTEST(ARGF.current_file)) {        if (ARGF.init_p == 0) return Qtrue;        next_argv();        ARGF_FORWARD(0, 0);        if (rb_io_eof(ARGF.current_file)) {            return Qtrue;        }    }    return Qfalse;}

Returns true if the current file inARGF is at end of file,i.e. it has no data to read. The stream must be opened for reading or anIOError will be raised.

$ echo "eof" | ruby argf.rbARGF.eof?                 #=> false3.times { ARGF.readchar }ARGF.eof?                 #=> falseARGF.readchar             #=> "\n"ARGF.eof?                 #=> true

                static VALUEargf_eof(VALUE argf){    next_argv();    if (RTEST(ARGF.current_file)) {        if (ARGF.init_p == 0) return Qtrue;        next_argv();        ARGF_FORWARD(0, 0);        if (rb_io_eof(ARGF.current_file)) {            return Qtrue;        }    }    return Qfalse;}

Returns the external encoding for files read fromARGF as anEncoding object. The external encoding is the encoding of thetext as stored in a file. Contrast withARGF.internal_encoding, which is the encoding used torepresent this text within Ruby.

To set the external encoding useARGF.set_encoding.

For example:

ARGF.external_encoding#=>  #<Encoding:UTF-8>

                static VALUEargf_external_encoding(VALUE argf){    if (!RTEST(ARGF.current_file)) {        return rb_enc_from_encoding(rb_default_external_encoding());    }    return rb_io_external_encoding(rb_io_check_io(ARGF.current_file));}

Returns the current file as anIO orFile object.$stdin is returned when the current file is STDIN.

For example:

$ echo "foo" > foo$ echo "bar" > bar$ ruby argf.rb foo barARGF.file      #=> #<File:foo>ARGF.read(5)   #=> "foo\nb"ARGF.file      #=> #<File:bar>

                static VALUEargf_file(VALUE argf){    next_argv();    return ARGF.current_file;}

Returns the current filename. “-” is returned when the current file isSTDIN.

For example:

$ echo "foo" > foo$ echo "bar" > bar$ echo "glark" > glark$ ruby argf.rb foo bar glarkARGF.filename  #=> "foo"ARGF.read(5)   #=> "foo\nb"ARGF.filename  #=> "bar"ARGF.skipARGF.filename  #=> "glark"

                static VALUEargf_filename(VALUE argf){    next_argv();    return ARGF.filename;}

Returns an integer representing the numeric file descriptor for the currentfile. Raises anArgumentError if there isn't a currentfile.

ARGF.fileno#=> 3

                static VALUEargf_fileno(VALUE argf){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream");    }    ARGF_FORWARD(0, 0);    return rb_io_fileno(ARGF.current_file);}

Gets the next 8-bit byte (0..255) fromARGF. Returnsnil if called at the end of the stream.

For example:

$ echo "foo" > file$ ruby argf.rb fileARGF.getbyte #=> 102ARGF.getbyte #=> 111ARGF.getbyte #=> 111ARGF.getbyte #=> 10ARGF.getbyte #=> nil

                static VALUEargf_getbyte(VALUE argf){    VALUE ch;  retry:    if (!next_argv()) return Qnil;    if (!RB_TYPE_P(ARGF.current_file, T_FILE)) {        ch = rb_funcall3(ARGF.current_file, rb_intern("getbyte"), 0, 0);    }    else {        ch = rb_io_getbyte(ARGF.current_file);    }    if (NIL_P(ch) && ARGF.next_p != -1) {        argf_close(argf);        ARGF.next_p = 1;        goto retry;    }    return ch;}

Reads the next character fromARGF and returns it as aString. Returnsnil at the end of the stream.

ARGF treats the files named on the command line as a singlefile created by concatenating their contents. After returning the lastcharacter of the first file, it returns the first character of the secondfile, and so on.

For example:

$ echo "foo" > file$ ruby argf.rb fileARGF.getc  #=> "f"ARGF.getc  #=> "o"ARGF.getc  #=> "o"ARGF.getc  #=> "\n"ARGF.getc  #=> nilARGF.getc  #=> nil

                static VALUEargf_getc(VALUE argf){    VALUE ch;  retry:    if (!next_argv()) return Qnil;    if (ARGF_GENERIC_INPUT_P()) {        ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);    }    else {        ch = rb_io_getc(ARGF.current_file);    }    if (NIL_P(ch) && ARGF.next_p != -1) {        argf_close(argf);        ARGF.next_p = 1;        goto retry;    }    return ch;}

Returns the next line from the current file inARGF.

By default lines are assumed to be separated by$/; to use adifferent character as a separator, supply it as aString forthesep argument.

The optionallimit argument specifies how many characters of eachline to return. By default all characters are returned.

SeeIO.readlines for details aboutgetline_args.

                static VALUEargf_gets(int argc, VALUE *argv, VALUE argf){    VALUE line;    line = argf_getline(argc, argv, argf);    rb_lastline_set(line);    return line;}

Returns the file extension appended to the names of modified files underin-place edit mode. This value can be set usingARGF.inplace_mode= or passing the-i switch tothe Ruby binary.

                static VALUEargf_inplace_mode_get(VALUE argf){    if (!ARGF.inplace) return Qnil;    if (NIL_P(ARGF.inplace)) return rb_str_new(0, 0);    return rb_str_dup(ARGF.inplace);}

Sets the filename extension for in-place editing mode to the givenString. Each file being edited has this valueappended to its filename. The modified file is saved under this new name.

For example:

$ ruby argf.rb file.txtARGF.inplace_mode = '.bak'ARGF.each_line do |line|  print line.sub("foo","bar")end

Each line offile.txt has the first occurrence of “foo” replacedwith “bar”, then the new line is written out tofile.txt.bak.

                static VALUEargf_inplace_mode_set(VALUE argf, VALUE val){    if (!RTEST(val)) {        ARGF.inplace = Qfalse;    }    else if (StringValueCStr(val), !RSTRING_LEN(val)) {        ARGF.inplace = Qnil;    }    else {        ARGF.inplace = rb_str_new_frozen(val);    }    return argf;}

Returns the internal encoding for strings read fromARGF as anEncoding object.

IfARGF.set_encoding has been called with two encoding names,the second is returned. Otherwise, ifEncoding.default_external has been set, that value isreturned. Failing that, if a default external encoding was specified on thecommand-line, that value is used. If the encoding is unknown,nil is returned.

                static VALUEargf_internal_encoding(VALUE argf){    if (!RTEST(ARGF.current_file)) {        return rb_enc_from_encoding(rb_default_external_encoding());    }    return rb_io_internal_encoding(rb_io_check_io(ARGF.current_file));}

Returns the current line number ofARGF as a whole.This value can be set manually withARGF.lineno=.

For example:

ARGF.lineno#=> 0ARGF.readline#=> "This is line 1\n"ARGF.lineno#=> 1

                static VALUEargf_lineno(VALUE argf){    return INT2FIX(ARGF.lineno);}

Sets the line number ofARGF as a whole to the givenInteger.

ARGF sets the line number automatically as you read data, sonormally you will not need to set it explicitly. To access the current linenumber useARGF.lineno.

For example:

ARGF.lineno#=> 0ARGF.readline#=> "This is line 1\n"ARGF.lineno#=> 1ARGF.lineno =0#=> 0ARGF.lineno#=> 0

                static VALUEargf_set_lineno(VALUE argf, VALUE val){    ARGF.lineno = NUM2INT(val);    ARGF.last_lineno = ARGF.lineno;    return Qnil;}

Returns the current filename. “-” is returned when the current file isSTDIN.

For example:

$ echo "foo" > foo$ echo "bar" > bar$ echo "glark" > glark$ ruby argf.rb foo bar glarkARGF.filename  #=> "foo"ARGF.read(5)   #=> "foo\nb"ARGF.filename  #=> "bar"ARGF.skipARGF.filename  #=> "glark"

                static VALUEargf_filename(VALUE argf){    next_argv();    return ARGF.filename;}

Returns the current offset (in bytes) of the current file inARGF.

ARGF.pos#=> 0ARGF.gets#=> "This is line one\n"ARGF.pos#=> 17

                static VALUEargf_tell(VALUE argf){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to tell");    }    ARGF_FORWARD(0, 0);    return rb_io_tell(ARGF.current_file);}

Seeks to the position given byposition (in bytes) inARGF.

For example:

ARGF.pos =17ARGF.gets#=> "This is line two\n"

                static VALUEargf_set_pos(VALUE argf, VALUE offset){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to set position");    }    ARGF_FORWARD(1, &offset);    return rb_io_set_pos(ARGF.current_file, offset);}

Writes the given object(s) toios. Returnsnil.

The stream must be opened for writing. Each given object that isn't astring will be converted by calling itsto_s method. Whencalled without arguments, prints the contents of$_.

If the output field separator ($,) is notnil, itis inserted between objects. If the output record separator($\) is notnil, it is appended to the output.

$stdout.print("This is ",100," percent.\n")

produces:

This is 100 percent.

                VALUErb_io_print(int argc, const VALUE *argv, VALUE out){    int i;    VALUE line;    /* if no argument given, print `$_' */    if (argc == 0) {        argc = 1;        line = rb_lastline_get();        argv = &line;    }    if (argc > 1 && !NIL_P(rb_output_fs)) {        rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$, is set to non-nil value");    }    for (i=0; i<argc; i++) {        if (!NIL_P(rb_output_fs) && i>0) {            rb_io_write(out, rb_output_fs);        }        rb_io_write(out, argv[i]);    }    if (argc > 0 && !NIL_P(rb_output_rs)) {        rb_io_write(out, rb_output_rs);    }    return Qnil;}

Formats and writes toios, converting parameters under control ofthe format string. SeeKernel#sprintf for details.

                VALUErb_io_printf(int argc, const VALUE *argv, VALUE out){    rb_io_write(out, rb_f_sprintf(argc, argv));    return Qnil;}

Ifobj isNumeric, write the characterwhose code is the least-significant byte ofobj. IfobjisString, write the first character ofobj toios. Otherwise, raiseTypeError.

$stdout.putc"A"$stdout.putc65

produces:

AA

                static VALUErb_io_putc(VALUE io, VALUE ch){    VALUE str;    if (RB_TYPE_P(ch, T_STRING)) {        str = rb_str_substr(ch, 0, 1);    }    else {        char c = NUM2CHR(ch);        str = rb_str_new(&c, 1);    }    rb_io_write(io, str);    return ch;}

Writes the given object(s) toios. Writes a newline after any thatdo not already end with a newline sequence. Returnsnil.

The stream must be opened for writing. If called with an array argument,writes each element on a new line. Each given object that isn't astring or array will be converted by calling itsto_s method.If called without arguments, outputs a single newline.

$stdout.puts("this","is", ["a","test"])

produces:

thisisatest

Note thatputs always uses newlines and is not affected by theoutput record separator ($\).

                VALUErb_io_puts(int argc, const VALUE *argv, VALUE out){    int i, n;    VALUE line, args[2];    /* if no argument given, print newline. */    if (argc == 0) {        rb_io_write(out, rb_default_rs);        return Qnil;    }    for (i=0; i<argc; i++) {        if (RB_TYPE_P(argv[i], T_STRING)) {            line = argv[i];            goto string;        }        if (rb_exec_recursive(io_puts_ary, argv[i], out)) {            continue;        }        line = rb_obj_as_string(argv[i]);      string:        n = 0;        args[n++] = line;        if (RSTRING_LEN(line) == 0 ||            !rb_str_end_with_asciichar(line, '\n')) {            args[n++] = rb_default_rs;        }        rb_io_writev(out, n, args);    }    return Qnil;}

Readslength bytes fromARGF. The filesnamed on the command line are concatenated and treated as a single file bythis method, so when called without arguments the contents of this pseudofile are returned in their entirety.

length must be a non-negative integer ornil.

Iflength is a positive integer,read tries to readlength bytes without any conversion (binary mode). It returnsnil if an EOF is encountered before anything can be read.Fewer thanlength bytes are returned if an EOF is encounteredduring the read. In the case of an integerlength, the resultingstring is always in ASCII-8BIT encoding.

Iflength is omitted or isnil, it reads until EOFand the encoding conversion is applied, if applicable. A string is returnedeven if EOF is encountered before any data is read.

Iflength is zero, it returns an empty string("").

If the optionaloutbuf argument is present, it must reference aString, which will receive the data. Theoutbuf will contain only the received data after the method calleven if it is not empty at the beginning.

For example:

$ echo "small" > small.txt$ echo "large" > large.txt$ ./glark.rb small.txt large.txtARGF.read      #=> "small\nlarge"ARGF.read(200) #=> "small\nlarge"ARGF.read(2)   #=> "sm"ARGF.read(0)   #=> ""

Note that this method behaves like the fread() function in C. This means itretries to invoke read(2) system calls to read data with the specifiedlength. If you need the behavior like a single read(2) system call,consider#readpartial or#read_nonblock.

                static VALUEargf_read(int argc, VALUE *argv, VALUE argf){    VALUE tmp, str, length;    long len = 0;    rb_scan_args(argc, argv, "02", &length, &str);    if (!NIL_P(length)) {        len = NUM2LONG(argv[0]);    }    if (!NIL_P(str)) {        StringValue(str);        rb_str_resize(str,0);        argv[1] = Qnil;    }  retry:    if (!next_argv()) {        return str;    }    if (ARGF_GENERIC_INPUT_P()) {        tmp = argf_forward(argc, argv, argf);    }    else {        tmp = io_read(argc, argv, ARGF.current_file);    }    if (NIL_P(str)) str = tmp;    else if (!NIL_P(tmp)) rb_str_append(str, tmp);    if (NIL_P(tmp) || NIL_P(length)) {        if (ARGF.next_p != -1) {            argf_close(argf);            ARGF.next_p = 1;            goto retry;        }    }    else if (argc >= 1) {        long slen = RSTRING_LEN(str);        if (slen < len) {            len -= slen;            argv[0] = LONG2NUM(len);            goto retry;        }    }    return str;}

Reads at mostmaxlen bytes from theARGFstream in non-blocking mode.

                static VALUEargf_read_nonblock(int argc, VALUE *argv, VALUE argf){    VALUE opts;    rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);    if (!NIL_P(opts))        argc--;    return argf_getpartial(argc, argv, argf, opts, 1);}

Reads the next 8-bit byte fromARGF and returns itas anInteger. Raises anEOFError after the lastbyte of the last file has been read.

For example:

$ echo "foo" > file$ ruby argf.rb fileARGF.readbyte  #=> 102ARGF.readbyte  #=> 111ARGF.readbyte  #=> 111ARGF.readbyte  #=> 10ARGF.readbyte  #=> end of file reached (EOFError)

                static VALUEargf_readbyte(VALUE argf){    VALUE c;    NEXT_ARGF_FORWARD(0, 0);    c = argf_getbyte(argf);    if (NIL_P(c)) {        rb_eof_error();    }    return c;}

Reads the next character fromARGF and returns it as aString. Raises anEOFError after the lastcharacter of the last file has been read.

For example:

$ echo "foo" > file$ ruby argf.rb fileARGF.readchar  #=> "f"ARGF.readchar  #=> "o"ARGF.readchar  #=> "o"ARGF.readchar  #=> "\n"ARGF.readchar  #=> end of file reached (EOFError)

                static VALUEargf_readchar(VALUE argf){    VALUE ch;  retry:    if (!next_argv()) rb_eof_error();    if (!RB_TYPE_P(ARGF.current_file, T_FILE)) {        ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);    }    else {        ch = rb_io_getc(ARGF.current_file);    }    if (NIL_P(ch) && ARGF.next_p != -1) {        argf_close(argf);        ARGF.next_p = 1;        goto retry;    }    return ch;}

Returns the next line from the current file inARGF.

By default lines are assumed to be separated by$/; to use adifferent character as a separator, supply it as aString forthesep argument.

The optionallimit argument specifies how many characters of eachline to return. By default all characters are returned.

AnEOFError is raised at the end of the file.

                static VALUEargf_readline(int argc, VALUE *argv, VALUE argf){    VALUE line;    if (!next_argv()) rb_eof_error();    ARGF_FORWARD(argc, argv);    line = argf_gets(argc, argv, argf);    if (NIL_P(line)) {        rb_eof_error();    }    return line;}

ReadsARGF's current file in its entirety, returning anArray of its lines, one line per element. Lines are assumed tobe separated bysep.

lines =ARGF.readlineslines[0]#=> "This is line one\n"

                static VALUEargf_readlines(int argc, VALUE *argv, VALUE argf){    long lineno = ARGF.lineno;    VALUE lines, ary;    ary = rb_ary_new();    while (next_argv()) {        if (ARGF_GENERIC_INPUT_P()) {            lines = rb_funcall3(ARGF.current_file, rb_intern("readlines"), argc, argv);        }        else {            lines = rb_io_readlines(argc, argv, ARGF.current_file);            argf_close(argf);        }        ARGF.next_p = 1;        rb_ary_concat(ary, lines);        ARGF.lineno = lineno + RARRAY_LEN(ary);        ARGF.last_lineno = ARGF.lineno;    }    ARGF.init_p = 0;    return ary;}

Reads at mostmaxlen bytes from theARGFstream.

If the optionaloutbuf argument is present, it must reference aString, which will receive the data. Theoutbuf will contain only the received data after the method calleven if it is not empty at the beginning.

It raisesEOFError on end ofARGF stream. SinceARGF streamis a concatenation of multiple files, internally EOF is occur for eachfile.#readpartial returnsempty strings for EOFs except the last one and raisesEOFError for the last one.

                static VALUEargf_readpartial(int argc, VALUE *argv, VALUE argf){    return argf_getpartial(argc, argv, argf, Qnil, 0);}

Positions the current file to the beginning of input, resettingARGF.lineno to zero.

ARGF.readline#=> "This is line one\n"ARGF.rewind#=> 0ARGF.lineno#=> 0ARGF.readline#=> "This is line one\n"

                static VALUEargf_rewind(VALUE argf){    VALUE ret;    int old_lineno;    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to rewind");    }    ARGF_FORWARD(0, 0);    old_lineno = RFILE(ARGF.current_file)->fptr->lineno;    ret = rb_io_rewind(ARGF.current_file);    if (!global_argf_p(argf)) {        ARGF.last_lineno = ARGF.lineno -= old_lineno;    }    return ret;}

Seeks to offsetamount (anInteger) in theARGF stream according to the value ofwhence. SeeIO#seek for further details.

                static VALUEargf_seek_m(int argc, VALUE *argv, VALUE argf){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to seek");    }    ARGF_FORWARD(argc, argv);    return rb_io_seek_m(argc, argv, ARGF.current_file);}

If single argument is specified, strings read fromARGF are tagged with the encoding specified.

If two encoding names separated by a colon are given, e.g. “ascii:utf-8”,the read string is converted from the first encoding (external encoding) tothe second encoding (internal encoding), then tagged with the secondencoding.

If two arguments are specified, they must be encoding objects or encodingnames. Again, the first specifies the external encoding; the secondspecifies the internal encoding.

If the external encoding and the internal encoding are specified, theoptionalHash argument can be used to adjust the conversionprocess. The structure of this hash is explained in theString#encode documentation.

For example:

ARGF.set_encoding('ascii')# Tag the input as US-ASCII textARGF.set_encoding(Encoding::UTF_8)# Tag the input as UTF-8 textARGF.set_encoding('utf-8','ascii')# Transcode the input from US-ASCII# to UTF-8.

                static VALUEargf_set_encoding(int argc, VALUE *argv, VALUE argf){    rb_io_t *fptr;    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to set encoding");    }    rb_io_set_encoding(argc, argv, ARGF.current_file);    GetOpenFile(ARGF.current_file, fptr);    ARGF.encs = fptr->encs;    return argf;}

Sets the current file to the next file in ARGV. If there aren't anymore files it has no effect.

For example:

$ ruby argf.rb foo barARGF.filename  #=> "foo"ARGF.skipARGF.filename  #=> "bar"

                static VALUEargf_skip(VALUE argf){    if (ARGF.init_p && ARGF.next_p == 0) {        argf_close(argf);        ARGF.next_p = 1;    }    return argf;}

Returns the current offset (in bytes) of the current file inARGF.

ARGF.pos#=> 0ARGF.gets#=> "This is line one\n"ARGF.pos#=> 17

                static VALUEargf_tell(VALUE argf){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream to tell");    }    ARGF_FORWARD(0, 0);    return rb_io_tell(ARGF.current_file);}

ReadsARGF's current file in its entirety, returning anArray of its lines, one line per element. Lines are assumed tobe separated bysep.

lines =ARGF.readlineslines[0]#=> "This is line one\n"

                static VALUEargf_readlines(int argc, VALUE *argv, VALUE argf){    long lineno = ARGF.lineno;    VALUE lines, ary;    ary = rb_ary_new();    while (next_argv()) {        if (ARGF_GENERIC_INPUT_P()) {            lines = rb_funcall3(ARGF.current_file, rb_intern("readlines"), argc, argv);        }        else {            lines = rb_io_readlines(argc, argv, ARGF.current_file);            argf_close(argf);        }        ARGF.next_p = 1;        rb_ary_concat(ary, lines);        ARGF.lineno = lineno + RARRAY_LEN(ary);        ARGF.last_lineno = ARGF.lineno;    }    ARGF.init_p = 0;    return ary;}

Returns an integer representing the numeric file descriptor for the currentfile. Raises anArgumentError if there isn't a currentfile.

ARGF.fileno#=> 3

                static VALUEargf_fileno(VALUE argf){    if (!next_argv()) {        rb_raise(rb_eArgError, "no stream");    }    ARGF_FORWARD(0, 0);    return rb_io_fileno(ARGF.current_file);}

Returns anIO object representing the current file. This willbe aFile object unless the current file is a stream such asSTDIN.

For example:

ARGF.to_io#=> #<File:glark.txt>ARGF.to_io#=> #<IO:<STDIN>>

                static VALUEargf_to_io(VALUE argf){    next_argv();    ARGF_FORWARD(0, 0);    return ARGF.current_file;}

Returns “ARGF”.

                static VALUEargf_to_s(VALUE argf){    return rb_str_new2("ARGF");}

ReturnsIO instance tied toARGF for writingif inplace mode is enabled.

                static VALUEargf_write_io(VALUE argf){    if (!RTEST(ARGF.current_file)) {        rb_raise(rb_eIOError, "not opened for writing");    }    return GetWriteIO(ARGF.current_file);}

Writesstring if inplace mode.

                static VALUEargf_write(VALUE argf, VALUE str){    return rb_io_write(argf_write_io(argf), str);}