file:line or file:line: in
`method'.
The optional _start_ parameter determines the number of initial stack
entries to omit from the top of the stack.
A second optional +length+ parameter can be used to limit how many entries
are returned from the stack.
Returns +nil+ if _start_ is greater than the size of
current execution stack.
Optionally you can pass a range, which will return an array containing the
entries within the specified range.
def a(skip)
caller(skip)
end
def b(skip)
a(skip)
end
def c(skip)
b(skip)
end
c(0) #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `true if yield would execute a
block in the current context. The iterator? form
is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello";T;[o;=
;3I"
overload;F;40;:block_given?;50;)I"block_given?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I"iterator?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if yield would execute a
block in the current context. The iterator? form
is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
@overload block_given?
@return [Boolean]
@overload iterator?
@return [Boolean];T; 0; @;!F;"o;#;$T;%ix ;&i ;6i ;'@$ ;(I"Rstatic VALUE
rb_f_block_given_p(VALUE _)
{
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = ec->cfp;
cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
return Qtrue;
}
else {
return Qfalse;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Kernel#block_given?;F;[ ;[[@di ;T;;;0;[ ;{ ;IC; "\Returns true if yield would execute a
block in the current context. The iterator? form
is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello";T;[o;=
;3I"
overload;F;40;;;50;)I"block_given?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I"iterator?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; @; 0; @;!F;"o;#;$T;%ix ;&i ;6i ;'@$ ;(I"Rstatic VALUE
rb_f_block_given_p(VALUE _)
{
rb_execution_context_t *ec = GET_EC();
rb_control_frame_t *cfp = ec->cfp;
cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
return Qtrue;
}
else {
return Qfalse;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Kernel#catch;F;[[@c0;[[@di;T;:
catch;0;[ ;{ ;IC; "+catch+ executes its block. If +throw+ is not called, the block executes
normally, and +catch+ returns the value of the last expression evaluated.
catch(1) { 123 } # => 123
If throw(tag2, val) is called, Ruby searches up its stack for
a +catch+ block whose +tag+ has the same +object_id+ as _tag2_. When found,
the block stops executing and returns _val_ (or +nil+ if no second argument
was given to +throw+).
catch(1) { throw(1, 456) } # => 456
catch(1) { throw(1) } # => nil
When +tag+ is passed as the first argument, +catch+ yields it as the
parameter of the block.
catch(1) {|x| x + 2 } # => 3
When no +tag+ is given, +catch+ yields a new unique object (as from
+Object.new+) as the block parameter. This object can then be used as the
argument to +throw+, and will match the correct +catch+ block.
catch do |obj_A|
catch do |obj_B|
throw(obj_B, 123)
puts "This puts is not reached"
end
puts "This puts is displayed"
456
end
# => 456
catch do |obj_A|
catch do |obj_B|
throw(obj_A, 123)
puts "This puts is still not reached"
end
puts "Now this puts is also not reached"
456
end
# => 123
;T;[o;=
;3I"
overload;F;40;;;50;)I"catch([tag]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"tag;T; @o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I""@yield [tag]
@return [Object];T; 0; @;!F;6i ;>0;[[I"
[tag];T0; @; [ ; I"+catch+ executes its block. If +throw+ is not called, the block executes
normally, and +catch+ returns the value of the last expression evaluated.
catch(1) { 123 } # => 123
If throw(tag2, val) is called, Ruby searches up its stack for
a +catch+ block whose +tag+ has the same +object_id+ as _tag2_. When found,
the block stops executing and returns _val_ (or +nil+ if no second argument
was given to +throw+).
catch(1) { throw(1, 456) } # => 456
catch(1) { throw(1) } # => nil
When +tag+ is passed as the first argument, +catch+ yields it as the
parameter of the block.
catch(1) {|x| x + 2 } # => 3
When no +tag+ is given, +catch+ yields a new unique object (as from
+Object.new+) as the block parameter. This object can then be used as the
argument to +throw+, and will match the correct +catch+ block.
catch do |obj_A|
catch do |obj_B|
throw(obj_B, 123)
puts "This puts is not reached"
end
puts "This puts is displayed"
456
end
# => 456
catch do |obj_A|
catch do |obj_B|
throw(obj_A, 123)
puts "This puts is still not reached"
end
puts "Now this puts is also not reached"
456
end
# => 123
@overload catch([tag])
@yield [tag]
@return [Object];T; 0; @;!F;"o;#;$T;%i;&i;'@$ ;(I"static VALUE
rb_f_catch(int argc, VALUE *argv, VALUE self)
{
VALUE tag = rb_check_arity(argc, 0, 1) ? argv[0] : rb_obj_alloc(rb_cObject);
return rb_catch_obj(tag, catch_i, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Kernel#throw;F;[[@c0;[[@di;T;:
throw;0;[ ;{ ;IC; "$Transfers control to the end of the active +catch+ block
waiting for _tag_. Raises +UncaughtThrowError+ if there
is no +catch+ block for the _tag_. The optional second
parameter supplies a return value for the +catch+ block,
which otherwise defaults to +nil+. For examples, see
Kernel::catch.
;T;[o;=
;3I"
overload;F;40;;;50;)I"throw(tag [, obj]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"tag[, obj];T0; @; [ ; I"CTransfers control to the end of the active +catch+ block
waiting for _tag_. Raises +UncaughtThrowError+ if there
is no +catch+ block for the _tag_. The optional second
parameter supplies a return value for the +catch+ block,
which otherwise defaults to +nil+. For examples, see
Kernel::catch.
@overload throw(tag [, obj]);T; 0; @;!F;"o;#;$T;%i|;&i;'@$ ;(I"static VALUE
rb_f_throw(int argc, VALUE *argv, VALUE _)
{
VALUE tag, value;
rb_scan_args(argc, argv, "11", &tag, &value);
rb_throw_obj(tag, value);
UNREACHABLE_RETURN(Qnil);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Kernel#loop;F;[ ;[[@dia;T;: loop;0;[ ;{ ;IC; "Repeatedly executes the block.
If no block is given, an enumerator is returned instead.
loop do
print "Input: "
line = gets
break if !line or line =~ /^qQ/
# ...
end
StopIteration raised in the block breaks the loop. In this case,
loop returns the "result" value stored in the exception.
enum = Enumerator.new { |y|
y << "one"
y << "two"
:ok
}
result = loop {
puts enum.next
} #=> :ok
;T;[o;=
;3I"
overload;F;40;;;50;)I" loop;T;IC; " ;T;[o;2
;3I"
yield;F;4I"[];T;0;50; @; [ ; I"@yield [];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I" loop;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Repeatedly executes the block.
If no block is given, an enumerator is returned instead.
loop do
print "Input: "
line = gets
break if !line or line =~ /^qQ/
# ...
end
StopIteration raised in the block breaks the loop. In this case,
loop returns the "result" value stored in the exception.
enum = Enumerator.new { |y|
y << "one"
y << "two"
:ok
}
result = loop {
puts enum.next
} #=> :ok
@overload loop
@yield []
@overload loop;T; 0; @;!F;"o;#;$T;%iC;&i^;'@$ ;(I"static VALUE
rb_f_loop(VALUE self)
{
RETURN_SIZED_ENUMERATOR(self, 0, 0, rb_f_loop_size);
return rb_rescue2(loop_i, (VALUE)0, loop_stop, (VALUE)0, rb_eStopIteration, (VALUE)0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"(Kernel#register_sample_bug_reporter;F;[[I"obj;T0;[[I"+ext/-test-/bug_reporter/bug_reporter.c;Ti;T;:!register_sample_bug_reporter;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @2;'@$ ;(I"static VALUE
register_sample_bug_reporter(VALUE self, VALUE obj)
{
rb_bug_reporter_add(sample_bug_reporter, (void *)(uintptr_t)NUM2INT(obj));
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Kernel#test;F;[[@c0;[[I" file.c;Ti;T;: test;0;[ ;{ ;IC; " Uses the character +cmd+ to perform various tests on +file1+ (first
table below) or on +file1+ and +file2+ (second table).
File tests on a single file:
Cmd Returns Meaning
"A" | Time | Last access time for file1
"b" | boolean | True if file1 is a block device
"c" | boolean | True if file1 is a character device
"C" | Time | Last change time for file1
"d" | boolean | True if file1 exists and is a directory
"e" | boolean | True if file1 exists
"f" | boolean | True if file1 exists and is a regular file
"g" | boolean | True if file1 has the \CF{setgid} bit
| | set (false under NT)
"G" | boolean | True if file1 exists and has a group
| | ownership equal to the caller's group
"k" | boolean | True if file1 exists and has the sticky bit set
"l" | boolean | True if file1 exists and is a symbolic link
"M" | Time | Last modification time for file1
"o" | boolean | True if file1 exists and is owned by
| | the caller's effective uid
"O" | boolean | True if file1 exists and is owned by
| | the caller's real uid
"p" | boolean | True if file1 exists and is a fifo
"r" | boolean | True if file1 is readable by the effective
| | uid/gid of the caller
"R" | boolean | True if file is readable by the real
| | uid/gid of the caller
"s" | int/nil | If file1 has nonzero size, return the size,
| | otherwise return nil
"S" | boolean | True if file1 exists and is a socket
"u" | boolean | True if file1 has the setuid bit set
"w" | boolean | True if file1 exists and is writable by
| | the effective uid/gid
"W" | boolean | True if file1 exists and is writable by
| | the real uid/gid
"x" | boolean | True if file1 exists and is executable by
| | the effective uid/gid
"X" | boolean | True if file1 exists and is executable by
| | the real uid/gid
"z" | boolean | True if file1 exists and has a zero length
Tests that take two files:
"-" | boolean | True if file1 and file2 are identical
"=" | boolean | True if the modification times of file1
| | and file2 are equal
"<" | boolean | True if the modification time of file1
| | is prior to that of file2
">" | boolean | True if the modification time of file1
| | is after that of file2
;T;[o;=
;3I"
overload;F;40;;;50;)I" test(cmd, file1 [, file2] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @A; [ ; I"@return [Object];T; 0; @A;!F;6i ;>0;[[I"cmd;T0[I"file1[, file2];T0; @A; [ ; I" Uses the character +cmd+ to perform various tests on +file1+ (first
table below) or on +file1+ and +file2+ (second table).
File tests on a single file:
Cmd Returns Meaning
"A" | Time | Last access time for file1
"b" | boolean | True if file1 is a block device
"c" | boolean | True if file1 is a character device
"C" | Time | Last change time for file1
"d" | boolean | True if file1 exists and is a directory
"e" | boolean | True if file1 exists
"f" | boolean | True if file1 exists and is a regular file
"g" | boolean | True if file1 has the \CF{setgid} bit
| | set (false under NT)
"G" | boolean | True if file1 exists and has a group
| | ownership equal to the caller's group
"k" | boolean | True if file1 exists and has the sticky bit set
"l" | boolean | True if file1 exists and is a symbolic link
"M" | Time | Last modification time for file1
"o" | boolean | True if file1 exists and is owned by
| | the caller's effective uid
"O" | boolean | True if file1 exists and is owned by
| | the caller's real uid
"p" | boolean | True if file1 exists and is a fifo
"r" | boolean | True if file1 is readable by the effective
| | uid/gid of the caller
"R" | boolean | True if file is readable by the real
| | uid/gid of the caller
"s" | int/nil | If file1 has nonzero size, return the size,
| | otherwise return nil
"S" | boolean | True if file1 exists and is a socket
"u" | boolean | True if file1 has the setuid bit set
"w" | boolean | True if file1 exists and is writable by
| | the effective uid/gid
"W" | boolean | True if file1 exists and is writable by
| | the real uid/gid
"x" | boolean | True if file1 exists and is executable by
| | the effective uid/gid
"X" | boolean | True if file1 exists and is executable by
| | the real uid/gid
"z" | boolean | True if file1 exists and has a zero length
Tests that take two files:
"-" | boolean | True if file1 and file2 are identical
"=" | boolean | True if the modification times of file1
| | and file2 are equal
"<" | boolean | True if the modification time of file1
| | is prior to that of file2
">" | boolean | True if the modification time of file1
| | is after that of file2
@overload test(cmd, file1 [, file2] )
@return [Object];T; 0; @A;!F;"o;#;$T;%i;&i;'@$ ;(I"l static VALUE
rb_f_test(int argc, VALUE *argv, VALUE _)
{
int cmd;
if (argc == 0) rb_check_arity(argc, 2, 3);
cmd = NUM2CHR(argv[0]);
if (cmd == 0) {
unknown:
/* unknown command */
if (ISPRINT(cmd)) {
rb_raise(rb_eArgError, "unknown command '%s%c'", cmd == '\'' || cmd == '\\' ? "\\" : "", cmd);
}
else {
rb_raise(rb_eArgError, "unknown command \"\\x%02X\"", cmd);
}
}
if (strchr("bcdefgGkloOprRsSuwWxXz", cmd)) {
CHECK(1);
switch (cmd) {
case 'b':
return rb_file_blockdev_p(0, argv[1]);
case 'c':
return rb_file_chardev_p(0, argv[1]);
case 'd':
return rb_file_directory_p(0, argv[1]);
case 'e':
return rb_file_exist_p(0, argv[1]);
case 'f':
return rb_file_file_p(0, argv[1]);
case 'g':
return rb_file_sgid_p(0, argv[1]);
case 'G':
return rb_file_grpowned_p(0, argv[1]);
case 'k':
return rb_file_sticky_p(0, argv[1]);
case 'l':
return rb_file_symlink_p(0, argv[1]);
case 'o':
return rb_file_owned_p(0, argv[1]);
case 'O':
return rb_file_rowned_p(0, argv[1]);
case 'p':
return rb_file_pipe_p(0, argv[1]);
case 'r':
return rb_file_readable_p(0, argv[1]);
case 'R':
return rb_file_readable_real_p(0, argv[1]);
case 's':
return rb_file_size_p(0, argv[1]);
case 'S':
return rb_file_socket_p(0, argv[1]);
case 'u':
return rb_file_suid_p(0, argv[1]);
case 'w':
return rb_file_writable_p(0, argv[1]);
case 'W':
return rb_file_writable_real_p(0, argv[1]);
case 'x':
return rb_file_executable_p(0, argv[1]);
case 'X':
return rb_file_executable_real_p(0, argv[1]);
case 'z':
return rb_file_zero_p(0, argv[1]);
}
}
if (strchr("MAC", cmd)) {
struct stat st;
VALUE fname = argv[1];
CHECK(1);
if (rb_stat(fname, &st) == -1) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
switch (cmd) {
case 'A':
return stat_atime(&st);
case 'M':
return stat_mtime(&st);
case 'C':
return stat_ctime(&st);
}
}
if (cmd == '-') {
CHECK(2);
return rb_file_identical_p(0, argv[1], argv[2]);
}
if (strchr("=<>", cmd)) {
struct stat st1, st2;
struct timespec t1, t2;
CHECK(2);
if (rb_stat(argv[1], &st1) < 0) return Qfalse;
if (rb_stat(argv[2], &st2) < 0) return Qfalse;
t1 = stat_mtimespec(&st1);
t2 = stat_mtimespec(&st2);
switch (cmd) {
case '=':
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec) return Qtrue;
return Qfalse;
case '>':
if (t1.tv_sec > t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec) return Qtrue;
return Qfalse;
case '<':
if (t1.tv_sec < t2.tv_sec) return Qtrue;
if (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec) return Qtrue;
return Qfalse;
}
}
goto unknown;
};T;)I"static VALUE;T;*T;A@$ ;BIC;[ ;A@$ ;CIC;[ ;A@$ ;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;: Kernel;;K;;;[ ;{ ;IC; "FThe Kernel module is included by class Object, so its methods are
available in every Ruby object.
The Kernel instance methods are documented in class Object while the
module methods are documented here. These methods are called without a
receiver and thus can be called in functional form:
sprintf "%.1f", 1.234 #=> "1.2";T;[ ; [ ; I"I
The Kernel module is included by class Object, so its methods are
available in every Ruby object.
The Kernel instance methods are documented in class Object while the
module methods are documented here. These methods are called without a
receiver and thus can be called in functional form:
sprintf "%.1f", 1.234 #=> "1.2"
;T; 0; @$ ;!F;"o;#;$T;%i;&i;6i ;'@;I" Kernel;F;A@];DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@iq[@i5[@i;T;;T;;K;;;[ ;{ ;IC; "Object is the default root of all Ruby objects. Object inherits from
BasicObject which allows creating alternate object hierarchies. Methods
on Object are available to all classes unless explicitly overridden.
Object mixes in the Kernel module, making the built-in kernel functions
globally accessible. Although the instance methods of Object are defined
by the Kernel module, we have chosen to document them here for clarity.
When referencing constants in classes inheriting from Object you do not
need to use the full namespace. For example, referencing +File+ inside
+YourClass+ will find the top-level File class.
In the descriptions of Object's methods, the parameter symbol refers
to a symbol, which is either a quoted string or a Symbol (such as
:name).;T;[ ; [ ; I"
Object is the default root of all Ruby objects. Object inherits from
BasicObject which allows creating alternate object hierarchies. Methods
on Object are available to all classes unless explicitly overridden.
Object mixes in the Kernel module, making the built-in kernel functions
globally accessible. Although the instance methods of Object are defined
by the Kernel module, we have chosen to document them here for clarity.
When referencing constants in classes inheriting from Object you do not
need to use the full namespace. For example, referencing +File+ inside
+YourClass+ will find the top-level File class.
In the descriptions of Object's methods, the parameter symbol refers
to a symbol, which is either a quoted string or a Symbol (such as
:name).
;T; 0; @];!F;"o;#;$T;%iq;&i;6i ;'@;I" Object;F;So;
;IC;[o; ; F;
;;: private;I"BasicObject#initialize;F;[ ;[[@i};T;:initialize;0;[ ;{ ;IC; "=call-seq:
BasicObject.new
Returns a new BasicObject.
;T;[ ; [ ; I"?
call-seq:
BasicObject.new
Returns a new BasicObject.
;T; 0; @;!F;"o;#;$T;%ij;&io;'@;(I"Gstatic VALUE
rb_obj_dummy0(VALUE _)
{
return rb_obj_dummy();
};T;)I"static VALUE;T;*To; ; F;
;;;;I"BasicObject#==;F;[[I" obj2;T0;[[@i;T;;`;0;[ ;{ ;IC; "Equality --- At the Object level, #== returns true
only if +obj+ and +other+ are the same object. Typically, this
method is overridden in descendant classes to provide
class-specific meaning.
Unlike #==, the #equal? method should never be overridden by
subclasses as it is used to determine object identity (that is,
a.equal?(b) if and only if a is the same
object as b):
obj = "a"
other = obj.dup
obj == other #=> true
obj.equal? other #=> false
obj.equal? obj #=> true
The #eql? method returns true if +obj+ and +other+
refer to the same hash key. This is used by Hash to test members
for equality. For any pair of objects where #eql? returns +true+,
the #hash value of both objects must be equal. So any subclass
that overrides #eql? should also override #hash appropriately.
For objects of class Object, #eql? is synonymous
with #==. Subclasses normally continue this tradition by aliasing
#eql? to their overridden #== method, but there are exceptions.
Numeric types, for example, perform type conversion across #==,
but not across #eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
;T;[o;=
;3I"
overload;F;40;;`;50;)I"==(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @o;=
;3I"
overload;F;40;;a;50;)I"equal?(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @o;=
;3I"
overload;F;40;;_;50;)I"eql?(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @; [ ; @y; 0; @;!F;"o;#;$T;%i;&i;'@;(I"}MJIT_FUNC_EXPORTED VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
};T;)I" MJIT_FUNC_EXPORTED VALUE;T;*To; ; F;
;;;;I"BasicObject#equal?;F;[[I" obj2;T0;[[@i;T;;a;0;[ ;{ ;IC; "Equality --- At the Object level, #== returns true
only if +obj+ and +other+ are the same object. Typically, this
method is overridden in descendant classes to provide
class-specific meaning.
Unlike #==, the #equal? method should never be overridden by
subclasses as it is used to determine object identity (that is,
a.equal?(b) if and only if a is the same
object as b):
obj = "a"
other = obj.dup
obj == other #=> true
obj.equal? other #=> false
obj.equal? obj #=> true
The #eql? method returns true if +obj+ and +other+
refer to the same hash key. This is used by Hash to test members
for equality. For any pair of objects where #eql? returns +true+,
the #hash value of both objects must be equal. So any subclass
that overrides #eql? should also override #hash appropriately.
For objects of class Object, #eql? is synonymous
with #==. Subclasses normally continue this tradition by aliasing
#eql? to their overridden #== method, but there are exceptions.
Numeric types, for example, perform type conversion across #==,
but not across #eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false;T;[o;=
;3I"
overload;F;40;;`;50;)I"==(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @o;=
;3I"
overload;F;40;;a;50;)I"equal?(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @o;=
;3I"
overload;F;40;;_;50;)I"eql?(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"
other;T0; @; [ ; @y; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"}MJIT_FUNC_EXPORTED VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
};T;)I" MJIT_FUNC_EXPORTED VALUE;T;*To; ; F;
;;;;I"BasicObject#!;F;[ ;[[@i;T;:!;0;[ ;{ ;IC; "Boolean negate.
;T;[o;=
;3I"
overload;F;40;;;50;)I" !obj;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @
; [ ; I"@return [Boolean];T; 0; @
;!F;6i ;>0;[ ; @
; [ ; I":Boolean negate.
@overload !obj
@return [Boolean];T; 0; @
;!F;"o;#;$T;%i;&i;'@;(I"_MJIT_FUNC_EXPORTED VALUE
rb_obj_not(VALUE obj)
{
return RTEST(obj) ? Qfalse : Qtrue;
};T;)I" MJIT_FUNC_EXPORTED VALUE;T;*To; ; F;
;;;;I"BasicObject#!=;F;[[I" obj2;T0;[[@i;T;:!=;0;[ ;{ ;IC; "@Returns true if two objects are not-equal, otherwise false.
;T;[o;=
;3I"
overload;F;40;;;50;)I"!=(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @(; [ ; I"@return [Boolean];T; 0; @(;!F;6i ;>0;[[I"
other;T0; @(; [ ; I"kReturns true if two objects are not-equal, otherwise false.
@overload !=(other)
@return [Boolean];T; 0; @(;!F;"o;#;$T;%i;&i;'@;(I"MJIT_FUNC_EXPORTED VALUE
rb_obj_not_equal(VALUE obj1, VALUE obj2)
{
VALUE result = rb_funcall(obj1, id_eq, 1, obj2);
return RTEST(result) ? Qfalse : Qtrue;
};T;)I" MJIT_FUNC_EXPORTED VALUE;T;*To; ; F;
;;;;I"'BasicObject#singleton_method_added;F;[[I"_y;T0;[[@i;T;:singleton_method_added;0;[ ;{ ;IC; "call-seq:
singleton_method_added(symbol)
Invoked as a callback whenever a singleton method is added to the
receiver.
module Chatty
def Chatty.singleton_method_added(id)
puts "Adding #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
end
produces:
Adding singleton_method_added
Adding one
Adding three
;T;[ ; [ ; I"
call-seq:
singleton_method_added(symbol)
Invoked as a callback whenever a singleton method is added to the
receiver.
module Chatty
def Chatty.singleton_method_added(id)
puts "Adding #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
end
produces:
Adding singleton_method_added
Adding one
Adding three
;T; 0; @G;!F;"o;#;$T;%i;&i;'@;(I"Rstatic VALUE
rb_obj_dummy1(VALUE _x, VALUE _y)
{
return rb_obj_dummy();
};T;)I"static VALUE;T;*To; ; F;
;;;;I")BasicObject#singleton_method_removed;F;[[I"_y;T0;[[@i;T;: singleton_method_removed;0;[ ;{ ;IC; "call-seq:
singleton_method_removed(symbol)
Invoked as a callback whenever a singleton method is removed from
the receiver.
module Chatty
def Chatty.singleton_method_removed(id)
puts "Removing #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
class << self
remove_method :three
remove_method :one
end
end
produces:
Removing three
Removing one
;T;[ ; [ ; I"
call-seq:
singleton_method_removed(symbol)
Invoked as a callback whenever a singleton method is removed from
the receiver.
module Chatty
def Chatty.singleton_method_removed(id)
puts "Removing #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
class << self
remove_method :three
remove_method :one
end
end
produces:
Removing three
Removing one
;T; 0; @W;!F;"o;#;$T;%i;&i;'@;(I"Rstatic VALUE
rb_obj_dummy1(VALUE _x, VALUE _y)
{
return rb_obj_dummy();
};T;)I"static VALUE;T;*To; ; F;
;;;;I"+BasicObject#singleton_method_undefined;F;[[I"_y;T0;[[@i;T;: singleton_method_undefined;0;[ ;{ ;IC; "call-seq:
singleton_method_undefined(symbol)
Invoked as a callback whenever a singleton method is undefined in
the receiver.
module Chatty
def Chatty.singleton_method_undefined(id)
puts "Undefining #{id.id2name}"
end
def Chatty.one() end
class << self
undef_method(:one)
end
end
produces:
Undefining one
;T;[ ; [ ; I"
call-seq:
singleton_method_undefined(symbol)
Invoked as a callback whenever a singleton method is undefined in
the receiver.
module Chatty
def Chatty.singleton_method_undefined(id)
puts "Undefining #{id.id2name}"
end
def Chatty.one() end
class << self
undef_method(:one)
end
end
produces:
Undefining one
;T; 0; @g;!F;"o;#;$T;%i;&i*;'@;(I"Rstatic VALUE
rb_obj_dummy1(VALUE _x, VALUE _y)
{
return rb_obj_dummy();
};T;)I"static VALUE;T;*To; ; F;
;;;;I" BasicObject#instance_eval;F;[[@c0;[[@di;T;:instance_eval;0;[ ;{ ;IC; "Evaluates a string containing Ruby source code, or the given block,
within the context of the receiver (_obj_). In order to set the
context, the variable +self+ is set to _obj_ while
the code is executing, giving the code access to _obj_'s
instance variables and private methods.
When instance_eval is given a block, _obj_ is also
passed in as the block's only argument.
When instance_eval is given a +String+, the optional
second and third parameters supply a filename and starting line number
that are used when reporting compilation errors.
class KlassWithSecret
def initialize
@secret = 99
end
private
def the_secret
"Ssssh! The secret is #{@secret}."
end
end
k = KlassWithSecret.new
k.instance_eval { @secret } #=> 99
k.instance_eval { the_secret } #=> "Ssssh! The secret is 99."
k.instance_eval {|obj| obj == self } #=> true
;T;[o;=
;3I"
overload;F;40;;;50;)I"3instance_eval(string [, filename [, lineno]] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @w; [ ; I"@return [Object];T; 0; @w;!F;6i ;>0;[[I""string[, filename [, lineno]];T0; @wo;=
;3I"
overload;F;40;;;50;)I"instance_eval;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @wo;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @w; [ ; I""@yield [obj]
@return [Object];T; 0; @w;!F;6i ;>0;[ ; @w; [ ; I"+Evaluates a string containing Ruby source code, or the given block,
within the context of the receiver (_obj_). In order to set the
context, the variable +self+ is set to _obj_ while
the code is executing, giving the code access to _obj_'s
instance variables and private methods.
When instance_eval is given a block, _obj_ is also
passed in as the block's only argument.
When instance_eval is given a +String+, the optional
second and third parameters supply a filename and starting line number
that are used when reporting compilation errors.
class KlassWithSecret
def initialize
@secret = 99
end
private
def the_secret
"Ssssh! The secret is #{@secret}."
end
end
k = KlassWithSecret.new
k.instance_eval { @secret } #=> 99
k.instance_eval { the_secret } #=> "Ssssh! The secret is 99."
k.instance_eval {|obj| obj == self } #=> true
@overload instance_eval(string [, filename [, lineno]] )
@return [Object]
@overload instance_eval
@yield [obj]
@return [Object];T; 0; @w;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_obj_instance_eval_internal(int argc, const VALUE *argv, VALUE self)
{
VALUE klass = singleton_class_for_eval(self);
return specific_eval(argc, argv, klass, self, RB_PASS_CALLED_KEYWORDS);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" BasicObject#instance_exec;F;[[@c0;[[@di;T;:instance_exec;0;[ ;{ ;IC; "Executes the given block within the context of the receiver
(_obj_). In order to set the context, the variable +self+ is set
to _obj_ while the code is executing, giving the code access to
_obj_'s instance variables. Arguments are passed as block parameters.
class KlassWithSecret
def initialize
@secret = 99
end
end
k = KlassWithSecret.new
k.instance_exec(5) {|x| @secret+x } #=> 104
;T;[o;=
;3I"
overload;F;40;;;50;)I"instance_exec(arg...);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" var...;T; @o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I"%@yield [var...]
@return [Object];T; 0; @;!F;6i ;>0;[[I" arg...;T0; @; [ ; I"Executes the given block within the context of the receiver
(_obj_). In order to set the context, the variable +self+ is set
to _obj_ while the code is executing, giving the code access to
_obj_'s instance variables. Arguments are passed as block parameters.
class KlassWithSecret
def initialize
@secret = 99
end
end
k = KlassWithSecret.new
k.instance_exec(5) {|x| @secret+x } #=> 104
@overload instance_exec(arg...)
@yield [var...]
@return [Object];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_obj_instance_exec_internal(int argc, const VALUE *argv, VALUE self)
{
VALUE klass = singleton_class_for_eval(self);
return yield_under(klass, self, argc, argv, RB_PASS_CALLED_KEYWORDS);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" BasicObject#method_missing;F;[[@c0;[[@di;T;:method_missing;0;[ ;{ ;IC; "Invoked by Ruby when obj is sent a message it cannot handle.
symbol is the symbol for the method called, and args
are any arguments that were passed to it. By default, the interpreter
raises an error when this method is called. However, it is possible
to override the method to provide more dynamic behavior.
If it is decided that a particular method should not be handled, then
super should be called, so that ancestors can pick up the
missing method.
The example below creates
a class Roman, which responds to methods with names
consisting of roman numerals, returning the corresponding integer
values.
class Roman
def roman_to_int(str)
# ...
end
def method_missing(symbol, *args)
str = symbol.id2name
begin
roman_to_int(str)
rescue
super(symbol, *args)
end
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
r.foo #=> NoMethodError
;T;[o;=
;3I"
overload;F;40;;;50;)I"&method_missing(symbol [, *args] );T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"symbol[, *args];T0; @; [ ; I"Invoked by Ruby when obj is sent a message it cannot handle.
symbol is the symbol for the method called, and args
are any arguments that were passed to it. By default, the interpreter
raises an error when this method is called. However, it is possible
to override the method to provide more dynamic behavior.
If it is decided that a particular method should not be handled, then
super should be called, so that ancestors can pick up the
missing method.
The example below creates
a class Roman, which responds to methods with names
consisting of roman numerals, returning the corresponding integer
values.
class Roman
def roman_to_int(str)
# ...
end
def method_missing(symbol, *args)
str = symbol.id2name
begin
roman_to_int(str)
rescue
super(symbol, *args)
end
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
r.foo #=> NoMethodError
@overload method_missing(symbol [, *args] );T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_method_missing(int argc, const VALUE *argv, VALUE obj)
{
rb_execution_context_t *ec = GET_EC();
raise_method_missing(ec, argc, argv, obj, ec->method_missing_reason);
UNREACHABLE_RETURN(Qnil);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"BasicObject#__send__;F;[[@c0;[[@di;T;;;0;[ ;{ ;IC; "Invokes the method identified by _symbol_, passing it any
arguments specified. You can use __send__ if the name
+send+ clashes with an existing method in _obj_.
When the method is identified by a string, the string is converted
to a symbol.
BasicObject implements +__send__+, Kernel implements +send+.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
;T;[ o;=
;3I"
overload;F;40;;;50;)I" send(symbol [, args...]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I"@return [Object];T; 0; @;!F;6i ;>0;[[I"symbol[, args...];T0; @o;=
;3I"
overload;F;40;;;50;)I"!__send__(symbol [, args...]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I"@return [Object];T; 0; @;!F;6i ;>0;[[I"symbol[, args...];T0; @o;=
;3I"
overload;F;40;;;50;)I" send(string [, args...]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I"@return [Object];T; 0; @;!F;6i ;>0;[[I"string[, args...];T0; @o;=
;3I"
overload;F;40;;;50;)I"!__send__(string [, args...]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @; [ ; I"@return [Object];T; 0; @;!F;6i ;>0;[[I"string[, args...];T0; @; [ ; @; 0; @;!F;"o;#;$T;%i;&i;'@;(I"vVALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal_kw(argc, argv, recv, CALL_FCALL);
};T;)I"
VALUE;T;*To; ; F;
;;;;I"BasicObject#__id__;F;[ ;[[@
i;T;: __id__;0;[ ;{ ;IC; "4call-seq:
obj.__id__ -> integer
obj.object_id -> integer
Returns an integer identifier for +obj+.
The same number will be returned on all calls to +object_id+ for a given
object, and no two active objects will share an id.
Note: that some objects of builtin classes are reused for optimization.
This is the case for immediate values and frozen string literals.
BasicObject implements +__id__+, Kernel implements +object_id+.
Immediate values are not passed by reference but are passed by value:
+nil+, +true+, +false+, Fixnums, Symbols, and some Floats.
Object.new.object_id == Object.new.object_id # => false
(21 * 2).object_id == (21 * 2).object_id # => true
"hello".object_id == "hello".object_id # => false
"hi".freeze.object_id == "hi".freeze.object_id # => true
;T;[ ; [ ; @ ; 0; @-;!F;"o;#;$T;%i;&i;'@;(I"VALUE
rb_obj_id(VALUE obj)
{
/*
* 32-bit VALUE space
* MSB ------------------------ LSB
* false 00000000000000000000000000000000
* true 00000000000000000000000000000010
* nil 00000000000000000000000000000100
* undef 00000000000000000000000000000110
* symbol ssssssssssssssssssssssss00001110
* object oooooooooooooooooooooooooooooo00 = 0 (mod sizeof(RVALUE))
* fixnum fffffffffffffffffffffffffffffff1
*
* object_id space
* LSB
* false 00000000000000000000000000000000
* true 00000000000000000000000000000010
* nil 00000000000000000000000000000100
* undef 00000000000000000000000000000110
* symbol 000SSSSSSSSSSSSSSSSSSSSSSSSSSS0 S...S % A = 4 (S...S = s...s * A + 4)
* object oooooooooooooooooooooooooooooo0 o...o % A = 0
* fixnum fffffffffffffffffffffffffffffff1 bignum if required
*
* where A = sizeof(RVALUE)/4
*
* sizeof(RVALUE) is
* 20 if 32-bit, double is 4-byte aligned
* 24 if 32-bit, double is 8-byte aligned
* 40 if 64-bit
*/
return rb_find_object_id(obj, cached_object_id);
};T;)I"
VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i<[@i4[@i;T;:BasicObject;;K;;;[ ;{ ;IC; "BasicObject is the parent class of all classes in Ruby. It's an explicit
blank class.
BasicObject can be used for creating object hierarchies independent of
Ruby's object hierarchy, proxy objects like the Delegator class, or other
uses where namespace pollution from Ruby's methods and classes must be
avoided.
To avoid polluting BasicObject for other users an appropriately named
subclass of BasicObject should be created instead of directly modifying
BasicObject:
class MyObjectSystem < BasicObject
end
BasicObject does not include Kernel (for methods like +puts+) and
BasicObject is outside of the namespace of the standard library so common
classes will not be found without using a full class path.
A variety of strategies can be used to provide useful portions of the
standard library to subclasses of BasicObject. A subclass could
include Kernel to obtain +puts+, +exit+, etc. A custom
Kernel-like module could be created and included or delegation can be used
via #method_missing:
class MyObjectSystem < BasicObject
DELEGATE = [:puts, :p]
def method_missing(name, *args, &block)
return super unless DELEGATE.include? name
::Kernel.send(name, *args, &block)
end
def respond_to_missing?(name, include_private = false)
DELEGATE.include?(name) or super
end
end
Access to classes and modules from the Ruby standard library can be
obtained in a BasicObject subclass by referencing the desired constant
from the root like ::File or ::Enumerator.
Like #method_missing, #const_missing can be used to delegate constant
lookup to +Object+:
class MyObjectSystem < BasicObject
def self.const_missing(name)
::Object.const_get(name)
end
end;T;[ ; [ ; I"
BasicObject is the parent class of all classes in Ruby. It's an explicit
blank class.
BasicObject can be used for creating object hierarchies independent of
Ruby's object hierarchy, proxy objects like the Delegator class, or other
uses where namespace pollution from Ruby's methods and classes must be
avoided.
To avoid polluting BasicObject for other users an appropriately named
subclass of BasicObject should be created instead of directly modifying
BasicObject:
class MyObjectSystem < BasicObject
end
BasicObject does not include Kernel (for methods like +puts+) and
BasicObject is outside of the namespace of the standard library so common
classes will not be found without using a full class path.
A variety of strategies can be used to provide useful portions of the
standard library to subclasses of BasicObject. A subclass could
include Kernel to obtain +puts+, +exit+, etc. A custom
Kernel-like module could be created and included or delegation can be used
via #method_missing:
class MyObjectSystem < BasicObject
DELEGATE = [:puts, :p]
def method_missing(name, *args, &block)
return super unless DELEGATE.include? name
::Kernel.send(name, *args, &block)
end
def respond_to_missing?(name, include_private = false)
DELEGATE.include?(name) or super
end
end
Access to classes and modules from the Ruby standard library can be
obtained in a BasicObject subclass by referencing the desired constant
from the root like ::File or ::Enumerator.
Like #method_missing, #const_missing can be used to delegate constant
lookup to +Object+:
class MyObjectSystem < BasicObject
def self.const_missing(name)
::Object.const_get(name)
end
end
;T; 0; @;!F;"o;#;$T;%i<;∈6i ;'@;I"BasicObject;F;So;L ;M0;N0;O0;: Qnil;'@;Q0;R;F;R;Fo;
;IC;[
o; ; F;
;F;;;I"Zlib::Deflate.deflate;F;[[@c0;[[@i;T;: deflate;0;[ ;{ ;IC; "call-seq:
Zlib.deflate(string[, level])
Zlib::Deflate.deflate(string[, level])
Compresses the given +string+. Valid values of level are
Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION,
Zlib::DEFAULT_COMPRESSION, or an integer from 0 to 9.
This method is almost equivalent to the following code:
def deflate(string, level)
z = Zlib::Deflate.new(level)
dst = z.deflate(string, Zlib::FINISH)
z.close
dst
end
See also Zlib.inflate
;T;[ ; [ ; I"
call-seq:
Zlib.deflate(string[, level])
Zlib::Deflate.deflate(string[, level])
Compresses the given +string+. Valid values of level are
Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION,
Zlib::DEFAULT_COMPRESSION, or an integer from 0 to 9.
This method is almost equivalent to the following code:
def deflate(string, level)
z = Zlib::Deflate.new(level)
dst = z.deflate(string, Zlib::FINISH)
z.close
dst
end
See also Zlib.inflate
;T; 0; @P;!F;"o;#;$T;%i;&i;'@N;(I"&static VALUE
rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass)
{
struct zstream z;
VALUE src, level, dst, args[2];
int err, lev;
rb_scan_args(argc, argv, "11", &src, &level);
lev = ARG_LEVEL(level);
StringValue(src);
zstream_init_deflate(&z);
err = deflateInit(&z.stream, lev);
if (err != Z_OK) {
raise_zlib_error(err, z.stream.msg);
}
ZSTREAM_READY(&z);
args[0] = (VALUE)&z;
args[1] = src;
dst = rb_ensure(deflate_run, (VALUE)args, zstream_ensure_end, (VALUE)&z);
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::Deflate#initialize;F;[[@c0;[[@iF;T;;;0;[ ;{ ;IC; "call-seq:
Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)
Creates a new deflate stream for compression. If a given argument is nil,
the default value of that argument is used.
The +level+ sets the compression level for the deflate stream between 0 (no
compression) and 9 (best compression). The following constants have been
defined to make code more readable:
* Zlib::DEFAULT_COMPRESSION
* Zlib::NO_COMPRESSION
* Zlib::BEST_SPEED
* Zlib::BEST_COMPRESSION
See http://www.zlib.net/manual.html#Constants for further information.
The +window_bits+ sets the size of the history buffer and should be between
8 and 15. Larger values of this parameter result in better compression at
the expense of memory usage.
The +mem_level+ specifies how much memory should be allocated for the
internal compression state. 1 uses minimum memory but is slow and reduces
compression ratio while 9 uses maximum memory for optimal speed. The
default value is 8. Two constants are defined:
* Zlib::DEF_MEM_LEVEL
* Zlib::MAX_MEM_LEVEL
The +strategy+ sets the deflate compression strategy. The following
strategies are available:
Zlib::DEFAULT_STRATEGY:: For normal data
Zlib::FILTERED:: For data produced by a filter or predictor
Zlib::FIXED:: Prevents dynamic Huffman codes
Zlib::HUFFMAN_ONLY:: Prevents string matching
Zlib::RLE:: Designed for better compression of PNG image data
See the constants for further description.
== Examples
=== Basic
open "compressed.file", "w+" do |io|
io << Zlib::Deflate.new.deflate(File.read("big.file"))
end
=== Custom compression
open "compressed.file", "w+" do |compressed_io|
deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
Zlib::MAX_WBITS,
Zlib::MAX_MEM_LEVEL,
Zlib::HUFFMAN_ONLY)
begin
open "big.file" do |big_io|
until big_io.eof? do
compressed_io << zd.deflate(big_io.read(16384))
end
end
ensure
deflate.close
end
end
While this example will work, for best optimization review the flags for
your specific time, memory usage and output space requirements.
;T;[ ; [ ; I"
call-seq:
Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)
Creates a new deflate stream for compression. If a given argument is nil,
the default value of that argument is used.
The +level+ sets the compression level for the deflate stream between 0 (no
compression) and 9 (best compression). The following constants have been
defined to make code more readable:
* Zlib::DEFAULT_COMPRESSION
* Zlib::NO_COMPRESSION
* Zlib::BEST_SPEED
* Zlib::BEST_COMPRESSION
See http://www.zlib.net/manual.html#Constants for further information.
The +window_bits+ sets the size of the history buffer and should be between
8 and 15. Larger values of this parameter result in better compression at
the expense of memory usage.
The +mem_level+ specifies how much memory should be allocated for the
internal compression state. 1 uses minimum memory but is slow and reduces
compression ratio while 9 uses maximum memory for optimal speed. The
default value is 8. Two constants are defined:
* Zlib::DEF_MEM_LEVEL
* Zlib::MAX_MEM_LEVEL
The +strategy+ sets the deflate compression strategy. The following
strategies are available:
Zlib::DEFAULT_STRATEGY:: For normal data
Zlib::FILTERED:: For data produced by a filter or predictor
Zlib::FIXED:: Prevents dynamic Huffman codes
Zlib::HUFFMAN_ONLY:: Prevents string matching
Zlib::RLE:: Designed for better compression of PNG image data
See the constants for further description.
== Examples
=== Basic
open "compressed.file", "w+" do |io|
io << Zlib::Deflate.new.deflate(File.read("big.file"))
end
=== Custom compression
open "compressed.file", "w+" do |compressed_io|
deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
Zlib::MAX_WBITS,
Zlib::MAX_MEM_LEVEL,
Zlib::HUFFMAN_ONLY)
begin
open "big.file" do |big_io|
until big_io.eof? do
compressed_io << zd.deflate(big_io.read(16384))
end
end
ensure
deflate.close
end
end
While this example will work, for best optimization review the flags for
your specific time, memory usage and output space requirements.
;T; 0; @_;!F;"o;#;$T;%i;&iC;'@N;(I"+static VALUE
rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
{
struct zstream *z;
VALUE level, wbits, memlevel, strategy;
int err;
rb_scan_args(argc, argv, "04", &level, &wbits, &memlevel, &strategy);
TypedData_Get_Struct(obj, struct zstream, &zstream_data_type, z);
err = deflateInit2(&z->stream, ARG_LEVEL(level), Z_DEFLATED,
ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel),
ARG_STRATEGY(strategy));
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
ZSTREAM_READY(z);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""Zlib::Deflate#initialize_copy;F;[[I" orig;T0;[[@i`;T;;j;0;[ ;{ ;IC; "#Duplicates the deflate stream.
;T;[ ; [ ; I"%
Duplicates the deflate stream.
;T; 0; @n;!F;"o;#;$T;%i[;&i];'@N;(I"static VALUE
rb_deflate_init_copy(VALUE self, VALUE orig)
{
struct zstream *z1, *z2;
int err;
TypedData_Get_Struct(self, struct zstream, &zstream_data_type, z1);
z2 = get_zstream(orig);
if (z1 == z2) return self;
err = deflateCopy(&z1->stream, &z2->stream);
if (err != Z_OK) {
raise_zlib_error(err, 0);
}
z1->input = NIL_P(z2->input) ? Qnil : rb_str_dup(z2->input);
z1->buf = NIL_P(z2->buf) ? Qnil : rb_str_dup(z2->buf);
z1->flags = z2->flags;
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Deflate#deflate;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "ccall-seq:
z.deflate(string, flush = Zlib::NO_FLUSH) -> String
z.deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } -> nil
Inputs +string+ into the deflate stream and returns the output from the
stream. On calling this method, both the input and the output buffers of
the stream are flushed. If +string+ is nil, this method finishes the
stream, just like Zlib::ZStream#finish.
If a block is given consecutive deflated chunks from the +string+ are
yielded to the block and +nil+ is returned.
The +flush+ parameter specifies the flush mode. The following constants
may be used:
Zlib::NO_FLUSH:: The default
Zlib::SYNC_FLUSH:: Flushes the output to a byte boundary
Zlib::FULL_FLUSH:: SYNC_FLUSH + resets the compression state
Zlib::FINISH:: Pending input is processed, pending output is flushed.
See the constants for further description.
;T;[ ; [ ; I"f
call-seq:
z.deflate(string, flush = Zlib::NO_FLUSH) -> String
z.deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } -> nil
Inputs +string+ into the deflate stream and returns the output from the
stream. On calling this method, both the input and the output buffers of
the stream are flushed. If +string+ is nil, this method finishes the
stream, just like Zlib::ZStream#finish.
If a block is given consecutive deflated chunks from the +string+ are
yielded to the block and +nil+ is returned.
The +flush+ parameter specifies the flush mode. The following constants
may be used:
Zlib::NO_FLUSH:: The default
Zlib::SYNC_FLUSH:: Flushes the output to a byte boundary
Zlib::FULL_FLUSH:: SYNC_FLUSH + resets the compression state
Zlib::FINISH:: Pending input is processed, pending output is flushed.
See the constants for further description.
;T; 0; @~;!F;"o;#;$T;%i;&i;'@N;(I"static VALUE
rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
{
struct zstream *z = get_zstream(obj);
VALUE src, flush;
rb_scan_args(argc, argv, "11", &src, &flush);
do_deflate(z, src, ARG_FLUSH(flush));
return zstream_detach_buffer(z);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Deflate#<<;F;[[I"src;T0;[[@i;T;:<<;0;[ ;{ ;IC; "call-seq: << string
Inputs +string+ into the deflate stream just like Zlib::Deflate#deflate, but
returns the Zlib::Deflate object itself. The output from the stream is
preserved in output buffer.
;T;[ ; [ ; I"
call-seq: << string
Inputs +string+ into the deflate stream just like Zlib::Deflate#deflate, but
returns the Zlib::Deflate object itself. The output from the stream is
preserved in output buffer.
;T; 0; @;!F;"o;#;$T;%i;&i;'@N;(I"{static VALUE
rb_deflate_addstr(VALUE obj, VALUE src)
{
do_deflate(get_zstream(obj), src, Z_NO_FLUSH);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Deflate#flush;F;[[@c0;[[@i;T;:
flush;0;[ ;{ ;IC; "call-seq:
flush(flush = Zlib::SYNC_FLUSH) -> String
flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } -> nil
This method is equivalent to deflate('', flush). This method is
just provided to improve the readability of your Ruby program. If a block
is given chunks of deflate output are yielded to the block until the buffer
is flushed.
See Zlib::Deflate#deflate for detail on the +flush+ constants NO_FLUSH,
SYNC_FLUSH, FULL_FLUSH and FINISH.
;T;[ ; [ ; I"
call-seq:
flush(flush = Zlib::SYNC_FLUSH) -> String
flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } -> nil
This method is equivalent to deflate('', flush). This method is
just provided to improve the readability of your Ruby program. If a block
is given chunks of deflate output are yielded to the block until the buffer
is flushed.
See Zlib::Deflate#deflate for detail on the +flush+ constants NO_FLUSH,
SYNC_FLUSH, FULL_FLUSH and FINISH.
;T; 0; @;!F;"o;#;$T;%i;&i;'@N;(I"ystatic VALUE
rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
{
struct zstream *z = get_zstream(obj);
VALUE v_flush;
int flush;
rb_scan_args(argc, argv, "01", &v_flush);
flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */
zstream_run(z, (Bytef*)"", 0, flush);
}
return zstream_detach_buffer(z);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Deflate#params;F;[[I" v_level;T0[I"v_strategy;T0;[[@i ;T;: params;0;[ ;{ ;IC; ".call-seq: params(level, strategy)
Changes the parameters of the deflate stream to allow changes between
different types of data that require different types of compression. Any
unprocessed data is flushed before changing the params.
See Zlib::Deflate.new for a description of +level+ and +strategy+.
;T;[ ; [ ; I"1
call-seq: params(level, strategy)
Changes the parameters of the deflate stream to allow changes between
different types of data that require different types of compression. Any
unprocessed data is flushed before changing the params.
See Zlib::Deflate.new for a description of +level+ and +strategy+.
;T; 0; @;!F;"o;#;$T;%i;&i;'@N;(I"-static VALUE
rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
{
struct zstream *z = get_zstream(obj);
int level, strategy;
int err;
uInt n;
long filled;
level = ARG_LEVEL(v_level);
strategy = ARG_STRATEGY(v_strategy);
n = z->stream.avail_out;
err = deflateParams(&z->stream, level, strategy);
filled = n - z->stream.avail_out;
while (err == Z_BUF_ERROR) {
rb_warning("deflateParams() returned Z_BUF_ERROR");
zstream_expand_buffer(z);
rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);
n = z->stream.avail_out;
err = deflateParams(&z->stream, level, strategy);
filled = n - z->stream.avail_out;
}
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
rb_str_set_len(z->buf, RSTRING_LEN(z->buf) + filled);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!Zlib::Deflate#set_dictionary;F;[[I"dic;T0;[[@iJ;T;:set_dictionary;0;[ ;{ ;IC; "call-seq: set_dictionary(string)
Sets the preset dictionary and returns +string+. This method is available
just only after Zlib::Deflate.new or Zlib::ZStream#reset method was called.
See zlib.h for details.
Can raise errors of Z_STREAM_ERROR if a parameter is invalid (such as
NULL dictionary) or the stream state is inconsistent, Z_DATA_ERROR if
the given dictionary doesn't match the expected one (incorrect adler32 value)
;T;[ ; [ ; I"
call-seq: set_dictionary(string)
Sets the preset dictionary and returns +string+. This method is available
just only after Zlib::Deflate.new or Zlib::ZStream#reset method was called.
See zlib.h for details.
Can raise errors of Z_STREAM_ERROR if a parameter is invalid (such as
NULL dictionary) or the stream state is inconsistent, Z_DATA_ERROR if
the given dictionary doesn't match the expected one (incorrect adler32 value)
;T; 0; @;!F;"o;#;$T;%i<;&iG;'@N;(I"]static VALUE
rb_deflate_set_dictionary(VALUE obj, VALUE dic)
{
struct zstream *z = get_zstream(obj);
VALUE src = dic;
int err;
StringValue(src);
err = deflateSetDictionary(&z->stream,
(Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
return dic;
};T;)I"static VALUE;T;*T;A@N;BIC;[ ;A@N;CIC;[ ;A@N;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;: Deflate;;K;;;[ ;{ ;IC; "^Zlib::Deflate is the class for compressing data. See Zlib::ZStream for more
information.;T;[ ; [ ; I"`
Zlib::Deflate is the class for compressing data. See Zlib::ZStream for more
information.
;T; 0; @N;!F;"o;#;$T;%i;&i;6i ;'o;L ;M0;N0;O0;;P;'@;Q@;R0;I"Zlib::Deflate;F;S@
o;
;IC;[
o; ; F;
;F;;;I"Zlib::Inflate.inflate;F;[[I"src;T0;[[@i;T;: inflate;0;[ ;{ ;IC; "call-seq:
Zlib.inflate(string)
Zlib::Inflate.inflate(string)
Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
dictionary is needed for decompression.
This method is almost equivalent to the following code:
def inflate(string)
zstream = Zlib::Inflate.new
buf = zstream.inflate(string)
zstream.finish
zstream.close
buf
end
See also Zlib.deflate
;T;[ ; [ ; I"
call-seq:
Zlib.inflate(string)
Zlib::Inflate.inflate(string)
Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
dictionary is needed for decompression.
This method is almost equivalent to the following code:
def inflate(string)
zstream = Zlib::Inflate.new
buf = zstream.inflate(string)
zstream.finish
zstream.close
buf
end
See also Zlib.deflate
;T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_inflate_s_inflate(VALUE obj, VALUE src)
{
struct zstream z;
VALUE dst, args[2];
int err;
StringValue(src);
zstream_init_inflate(&z);
err = inflateInit(&z.stream);
if (err != Z_OK) {
raise_zlib_error(err, z.stream.msg);
}
ZSTREAM_READY(&z);
args[0] = (VALUE)&z;
args[1] = src;
dst = rb_ensure(inflate_run, (VALUE)args, zstream_ensure_end, (VALUE)&z);
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::Inflate#initialize;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "call-seq:
Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)
Creates a new inflate stream for decompression. +window_bits+ sets the
size of the history buffer and can have the following values:
0::
Have inflate use the window size from the zlib header of the compressed
stream.
(8..15)::
Overrides the window size of the inflate header in the compressed stream.
The window size must be greater than or equal to the window size of the
compressed stream.
Greater than 15::
Add 32 to window_bits to enable zlib and gzip decoding with automatic
header detection, or add 16 to decode only the gzip format (a
Zlib::DataError will be raised for a non-gzip stream).
(-8..-15)::
Enables raw deflate mode which will not generate a check value, and will
not look for any check values for comparison at the end of the stream.
This is for use with other formats that use the deflate compressed data
format such as zip which provide their own check values.
== Example
open "compressed.file" do |compressed_io|
zi = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
begin
open "uncompressed.file", "w+" do |uncompressed_io|
uncompressed_io << zi.inflate(compressed_io.read)
end
ensure
zi.close
end
end
;T;[ ; [ ; I"
call-seq:
Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)
Creates a new inflate stream for decompression. +window_bits+ sets the
size of the history buffer and can have the following values:
0::
Have inflate use the window size from the zlib header of the compressed
stream.
(8..15)::
Overrides the window size of the inflate header in the compressed stream.
The window size must be greater than or equal to the window size of the
compressed stream.
Greater than 15::
Add 32 to window_bits to enable zlib and gzip decoding with automatic
header detection, or add 16 to decode only the gzip format (a
Zlib::DataError will be raised for a non-gzip stream).
(-8..-15)::
Enables raw deflate mode which will not generate a check value, and will
not look for any check values for comparison at the end of the stream.
This is for use with other formats that use the deflate compressed data
format such as zip which provide their own check values.
== Example
open "compressed.file" do |compressed_io|
zi = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
begin
open "uncompressed.file", "w+" do |uncompressed_io|
uncompressed_io << zi.inflate(compressed_io.read)
end
ensure
zi.close
end
end
;T; 0; @;!F;"o;#;$T;%in;&i;'@;(I"static VALUE
rb_inflate_initialize(int argc, VALUE *argv, VALUE obj)
{
struct zstream *z;
VALUE wbits;
int err;
rb_scan_args(argc, argv, "01", &wbits);
TypedData_Get_Struct(obj, struct zstream, &zstream_data_type, z);
err = inflateInit2(&z->stream, ARG_WBITS(wbits));
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
ZSTREAM_READY(z);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!Zlib::Inflate#add_dictionary;F;[[I"dictionary;T0;[[@i;T;:add_dictionary;0;[ ;{ ;IC; "call-seq: add_dictionary(string)
Provide the inflate stream with a dictionary that may be required in the
future. Multiple dictionaries may be provided. The inflate stream will
automatically choose the correct user-provided dictionary based on the
stream's required dictionary.
;T;[ ; [ ; I"
call-seq: add_dictionary(string)
Provide the inflate stream with a dictionary that may be required in the
future. Multiple dictionaries may be provided. The inflate stream will
automatically choose the correct user-provided dictionary based on the
stream's required dictionary.
;T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_inflate_add_dictionary(VALUE obj, VALUE dictionary)
{
VALUE dictionaries = rb_ivar_get(obj, id_dictionaries);
VALUE checksum = do_checksum(1, &dictionary, adler32);
rb_hash_aset(dictionaries, checksum, dictionary);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Inflate#inflate;F;[[I"src;T0;[[@i,;T;;;0;[ ;{ ;IC; "$call-seq:
inflate(deflate_string) -> String
inflate(deflate_string) { |chunk| ... } -> nil
Inputs +deflate_string+ into the inflate stream and returns the output from
the stream. Calling this method, both the input and the output buffer of
the stream are flushed. If string is +nil+, this method finishes the
stream, just like Zlib::ZStream#finish.
If a block is given consecutive inflated chunks from the +deflate_string+
are yielded to the block and +nil+ is returned.
Raises a Zlib::NeedDict exception if a preset dictionary is needed to
decompress. Set the dictionary by Zlib::Inflate#set_dictionary and then
call this method again with an empty string to flush the stream:
inflater = Zlib::Inflate.new
begin
out = inflater.inflate compressed
rescue Zlib::NeedDict
# ensure the dictionary matches the stream's required dictionary
raise unless inflater.adler == Zlib.adler32(dictionary)
inflater.set_dictionary dictionary
inflater.inflate ''
end
# ...
inflater.close
See also Zlib::Inflate.new
;T;[ ; [ ; I"&
call-seq:
inflate(deflate_string) -> String
inflate(deflate_string) { |chunk| ... } -> nil
Inputs +deflate_string+ into the inflate stream and returns the output from
the stream. Calling this method, both the input and the output buffer of
the stream are flushed. If string is +nil+, this method finishes the
stream, just like Zlib::ZStream#finish.
If a block is given consecutive inflated chunks from the +deflate_string+
are yielded to the block and +nil+ is returned.
Raises a Zlib::NeedDict exception if a preset dictionary is needed to
decompress. Set the dictionary by Zlib::Inflate#set_dictionary and then
call this method again with an empty string to flush the stream:
inflater = Zlib::Inflate.new
begin
out = inflater.inflate compressed
rescue Zlib::NeedDict
# ensure the dictionary matches the stream's required dictionary
raise unless inflater.adler == Zlib.adler32(dictionary)
inflater.set_dictionary dictionary
inflater.inflate ''
end
# ...
inflater.close
See also Zlib::Inflate.new
;T; 0; @;!F;"o;#;$T;%i;&i);'@;(I"static VALUE
rb_inflate_inflate(VALUE obj, VALUE src)
{
struct zstream *z = get_zstream(obj);
VALUE dst;
if (ZSTREAM_IS_FINISHED(z)) {
if (NIL_P(src)) {
dst = zstream_detach_buffer(z);
}
else {
StringValue(src);
zstream_append_buffer2(z, src);
dst = rb_str_new(0, 0);
}
}
else {
do_inflate(z, src);
dst = zstream_detach_buffer(z);
if (ZSTREAM_IS_FINISHED(z)) {
zstream_passthrough_input(z);
}
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Inflate#<<;F;[[I"src;T0;[[@iN;T;;;0;[ ;{ ;IC; "Inputs +string+ into the inflate stream just like Zlib::Inflate#inflate, but
returns the Zlib::Inflate object itself. The output from the stream is
preserved in output buffer.
;T;[o;=
;3I"
overload;F;40;;;50;)I"<< string;T;IC; " ;T;[ ; [ ; I" ;T; 0; @";!F;6i ;>0;[[I" string;T0; @"; [ ; I"Inputs +string+ into the inflate stream just like Zlib::Inflate#inflate, but
returns the Zlib::Inflate object itself. The output from the stream is
preserved in output buffer.
@overload << string;T; 0; @";!F;"o;#;$T;%iG;&iL;'@;(I"Zstatic VALUE
rb_inflate_addstr(VALUE obj, VALUE src)
{
struct zstream *z = get_zstream(obj);
if (ZSTREAM_IS_FINISHED(z)) {
if (!NIL_P(src)) {
StringValue(src);
zstream_append_buffer2(z, src);
}
}
else {
do_inflate(z, src);
if (ZSTREAM_IS_FINISHED(z)) {
zstream_passthrough_input(z);
}
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::Inflate#sync;F;[[I"src;T0;[[@ik;T;: sync;0;[ ;{ ;IC; " Inputs +string+ into the end of input buffer and skips data until a full
flush point can be found. If the point is found in the buffer, this method
flushes the buffer and returns false. Otherwise it returns +true+ and the
following data of full flush point is preserved in the buffer.
;T;[o;=
;3I"
overload;F;40;;;50;)I"sync(string);T;IC; " ;T;[ ; [ ; I" ;T; 0; @<;!F;6i ;>0;[[I" string;T0; @<; [ ; I"7Inputs +string+ into the end of input buffer and skips data until a full
flush point can be found. If the point is found in the buffer, this method
flushes the buffer and returns false. Otherwise it returns +true+ and the
following data of full flush point is preserved in the buffer.
@overload sync(string);T; 0; @<;!F;"o;#;$T;%ic;ⅈ'@;(I"static VALUE
rb_inflate_sync(VALUE obj, VALUE src)
{
struct zstream *z = get_zstream(obj);
StringValue(src);
return zstream_sync(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src));
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::Inflate#sync_point?;F;[ ;[[@i{;T;:sync_point?;0;[ ;{ ;IC; "OQuoted verbatim from original documentation:
What is this?
:);T;[o;2
;3I" return;F;4@|;0;5[@~; @V; [ ; I"PQuoted verbatim from original documentation:
What is this?
:)
;T; 0; @V;!F;"o;#;$T;%it;&iy;6i ;'@;(I"static VALUE
rb_inflate_sync_point_p(VALUE obj)
{
struct zstream *z = get_zstream(obj);
int err;
err = inflateSyncPoint(&z->stream);
if (err == 1) {
return Qtrue;
}
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!Zlib::Inflate#set_dictionary;F;[[I"dic;T0;[[@i;T;;;0;[ ;{ ;IC; "Sets the preset dictionary and returns +string+. This method is available just
only after a Zlib::NeedDict exception was raised. See zlib.h for details.
;T;[ ; [ ; I"
Sets the preset dictionary and returns +string+. This method is available just
only after a Zlib::NeedDict exception was raised. See zlib.h for details.
;T; 0; @g;!F;"o;#;$T;%i;&i;'@;(I"]static VALUE
rb_inflate_set_dictionary(VALUE obj, VALUE dic)
{
struct zstream *z = get_zstream(obj);
VALUE src = dic;
int err;
StringValue(src);
err = inflateSetDictionary(&z->stream,
(Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
if (err != Z_OK) {
raise_zlib_error(err, z->stream.msg);
}
return dic;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i^[@i;T;: Inflate;;K;;;[ ;{ ;IC; "Zlib:Inflate is the class for decompressing compressed data. Unlike
Zlib::Deflate, an instance of this class is not able to duplicate (clone,
dup) itself.;T;[ ; [ ; I"
Zlib:Inflate is the class for decompressing compressed data. Unlike
Zlib::Deflate, an instance of this class is not able to duplicate (clone,
dup) itself.
;T; 0; @;!F;"o;#;$T;%i^;&ib;6i ;'o;L ;M0;N0;O0;;P;'@;Q@;R0;I"Zlib::Inflate;F;S@
o;
;IC;[o;
;IC;[o; ; F;
;;;;I" Zlib::GzipFile::Error#input;F;[ ;[[@ic;F;:
input;;K;[ ;{ ;IC; "input gzipped string
;T;[ ; [ ; I"input gzipped string;T; 0; @;!F;"o;#;$T;%ib;&ib;'@;*To; ; F;
;;;;I""Zlib::GzipFile::Error#inspect;F;[ ;[[@i ;T;;v;0;[ ;{ ;IC; ".Constructs a String of the GzipFile Error
;T;[ ; [ ; I"0
Constructs a String of the GzipFile Error
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;(I"Cstatic VALUE
gzfile_error_inspect(VALUE error)
{
VALUE str = rb_call_super(0, 0);
VALUE input = rb_attr_get(error, id_input);
if (!NIL_P(input)) {
rb_str_resize(str, RSTRING_LEN(str)-1);
rb_str_cat2(str, ", input=");
rb_str_append(str, rb_str_inspect(input));
rb_str_cat2(str, ">");
}
return str;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{;IC;E{: read@:
write0;GT;GT;GT;H{ ;I[ ;[[@i?[@i`;T;:
Error;;K;;;[ ;{ ;IC; "@Base class of errors that occur when processing GZIP files.
;T;[ ; [ ; I"B
Base class of errors that occur when processing GZIP files.
;T; 0; @;!F;"o;#;$T;%i?;&iA;'@;I"Zlib::GzipFile::Error;F;So;
;IC;[ ;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;;;;K;;;[ ;{ ;IC; "hThe superclass for all exceptions raised by Ruby/zlib.
The following exceptions are defined as subclasses of Zlib::Error. These
exceptions are raised when zlib library functions return with an error
status.
- Zlib::StreamEnd
- Zlib::NeedDict
- Zlib::DataError
- Zlib::StreamError
- Zlib::MemError
- Zlib::BufError
- Zlib::VersionError
- Zlib::InProgressError
;T;[ ; [ ; I"k
The superclass for all exceptions raised by Ruby/zlib.
The following exceptions are defined as subclasses of Zlib::Error. These
exceptions are raised when zlib library functions return with an error
status.
- Zlib::StreamEnd
- Zlib::NeedDict
- Zlib::DataError
- Zlib::StreamError
- Zlib::MemError
- Zlib::BufError
- Zlib::VersionError
- Zlib::InProgressError
;T; 0; @;!F;"o;#;$T;%i;&i;'@;I"Zlib::Error;F;So;L ;M0;N0;O0;:StandardError;'@;Qo;
;IC;[ ;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[I" error.c;Tid[@i
;T;;;;K;;;[ ;{ ;IC; "The most standard error types are subclasses of StandardError. A
rescue clause without an explicit Exception class will rescue all
StandardErrors (and only those).
def foo
raise "Oups"
end
foo rescue "Hello" #=> "Hello"
On the other hand:
require 'does/not/exist' rescue "Hi"
raises the exception:
LoadError: no such file to load -- does/not/exist
;T;[ ; [ ; I"
The most standard error types are subclasses of StandardError. A
rescue clause without an explicit Exception class will rescue all
StandardErrors (and only those).
def foo
raise "Oups"
end
foo rescue "Hello" #=> "Hello"
On the other hand:
require 'does/not/exist' rescue "Hi"
raises the exception:
LoadError: no such file to load -- does/not/exist
;T; 0; @;!F;"o;#;$T;%id;&iv;'@;I"StandardError;F;So;
;IC;[o; ; F;
;F;;;I"Exception.exception;F;[[@c0;[[@i;T;:exception;0;[ ;{ ;IC; "DAllocates and initializes an instance of \a klass.
Equivalent to \c Class\#new in Ruby
\param[in] argc the number of arguments to \c #initialize
\param[in] argv a pointer to an array of arguments to \c #initialize
\param[in] klass a Class object
\return the new instance of \a klass
\sa rb_obj_call_init
\sa rb_obj_alloc
;T;[ ; [ ; I"EAllocates and initializes an instance of \a klass.
Equivalent to \c Class\#new in Ruby
\param[in] argc the number of arguments to \c #initialize
\param[in] argv a pointer to an array of arguments to \c #initialize
\param[in] klass a Class object
\return the new instance of \a klass
\sa rb_obj_call_init
\sa rb_obj_alloc
;T; 0; @;!F;"o;#;$T;%iy;&i;'@;(I"VALUE
rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
{
VALUE obj;
Check_Type(klass, T_CLASS);
obj = rb_class_alloc(klass);
rb_obj_call_init_kw(obj, argc, argv, RB_NO_KEYWORDS);
return obj;
};T;)I"
VALUE;T;*To; ; F;
;F;;;I"Exception.to_tty?;F;[ ;[[@i+;T;: to_tty?;0;[ ;{ ;IC; "@Returns +true+ if exception messages will be sent to a tty.;T;[o;=
;3I"
overload;F;40;;;50;)I" to_tty?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"hReturns +true+ if exception messages will be sent to a tty.
@overload to_tty?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i%;&i);6i ;'@;(I"_static VALUE
exc_s_to_tty_p(VALUE self)
{
return rb_stderr_tty_p() ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#exception;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "call-seq:
exc.exception(string) -> an_exception or exc
With no argument, or if the argument is the same as the receiver,
return the receiver. Otherwise, create a new
exception object of the same class as the receiver, but with a
message equal to string.to_str.
;T;[ ; [ ; I"
call-seq:
exc.exception(string) -> an_exception or exc
With no argument, or if the argument is the same as the receiver,
return the receiver. Otherwise, create a new
exception object of the same class as the receiver, but with a
message equal to string.to_str.
;T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"!static VALUE
exc_exception(int argc, VALUE *argv, VALUE self)
{
VALUE exc;
argc = rb_check_arity(argc, 0, 1);
if (argc == 0) return self;
if (argc == 1 && self == argv[0]) return self;
exc = rb_obj_clone(self);
rb_ivar_set(exc, id_mesg, argv[0]);
return exc;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#initialize;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "HConstruct a new Exception object, optionally passing in
a message.
;T;[o;=
;3I"
overload;F;40;:new;50;)I"new(msg = nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"Exception;T; @ ; [ ; I"@return [Exception];T; 0; @ ;!F;6i ;>0;[[I"msg;TI"nil;T; @ ; [ ; I"z Construct a new Exception object, optionally passing in
a message.
@overload new(msg = nil)
@return [Exception];T; 0; @ ;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
exc_initialize(int argc, VALUE *argv, VALUE exc)
{
VALUE arg;
arg = (!rb_check_arity(argc, 0, 1) ? Qnil : argv[0]);
return exc_init(exc, arg);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#==;F;[[I"obj;T0;[[@iC;T;;`;0;[ ;{ ;IC; "Equality---If obj is not an Exception, returns
false. Otherwise, returns true if exc and
obj share same class, messages, and backtrace.
;T;[o;=
;3I"
overload;F;40;;`;50;)I" ==(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @?; [ ; I"@return [Boolean];T; 0; @?;!F;6i ;>0;[[I"obj;T0; @?; [ ; I"Equality---If obj is not an Exception, returns
false. Otherwise, returns true if exc and
obj share same class, messages, and backtrace.
@overload ==(obj)
@return [Boolean];T; 0; @?;!F;"o;#;$T;%i:;&i@;'@;(I" static VALUE
exc_equal(VALUE exc, VALUE obj)
{
VALUE mesg, backtrace;
if (exc == obj) return Qtrue;
if (rb_obj_class(exc) != rb_obj_class(obj)) {
int state;
obj = rb_protect(try_convert_to_exception, obj, &state);
if (state || obj == Qundef) {
rb_set_errinfo(Qnil);
return Qfalse;
}
if (rb_obj_class(exc) != rb_obj_class(obj)) return Qfalse;
mesg = rb_check_funcall(obj, id_message, 0, 0);
if (mesg == Qundef) return Qfalse;
backtrace = rb_check_funcall(obj, id_backtrace, 0, 0);
if (backtrace == Qundef) return Qfalse;
}
else {
mesg = rb_attr_get(obj, id_mesg);
backtrace = exc_backtrace(obj);
}
if (!rb_equal(rb_attr_get(exc, id_mesg), mesg))
return Qfalse;
if (!rb_equal(exc_backtrace(exc), backtrace))
return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#to_s;F;[ ;[[@i;T;;u;0;[ ;{ ;IC; "UReturns exception's message (or the name of the exception if
no message is set).
;T;[o;=
;3I"
overload;F;40;;u;50;)I" to_s;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @^; [ ; I"@return [String];T; 0; @^;!F;6i ;>0;[ ; @^; [ ; I"yReturns exception's message (or the name of the exception if
no message is set).
@overload to_s
@return [String];T; 0; @^;!F;"o;#;$T;%i;&i
;'@;(I"static VALUE
exc_to_s(VALUE exc)
{
VALUE mesg = rb_attr_get(exc, idMesg);
if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
return rb_String(mesg);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#message;F;[ ;[[@ix;T;: message;0;[ ;{ ;IC; "wReturns the result of invoking exception.to_s.
Normally this returns the exception's message or name.
;T;[o;=
;3I"
overload;F;40;;;50;)I" message;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @y; [ ; I"@return [String];T; 0; @y;!F;6i ;>0;[ ; @y; [ ; I"Returns the result of invoking exception.to_s.
Normally this returns the exception's message or name.
@overload message
@return [String];T; 0; @y;!F;"o;#;$T;%ip;&iu;'@;(I"Wstatic VALUE
exc_message(VALUE exc)
{
return rb_funcallv(exc, idTo_s, 0, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#full_message;F;[[@c0;[[@iC;T;:full_message;0;[ ;{ ;IC; "Returns formatted string of _exception_.
The returned string is formatted using the same format that Ruby uses
when printing an uncaught exceptions to stderr.
If _highlight_ is +true+ the default error handler will send the
messages to a tty.
_order_ must be either of +:top+ or +:bottom+, and places the error
message and the innermost backtrace come at the top or the bottom.
The default values of these options depend on $stderr
and its +tty?+ at the timing of a call.
;T;[o;=
;3I"
overload;F;40;;;50;)I"$stderr
and its +tty?+ at the timing of a call.
@overload full_message(highlight: bool, order: [:top or :bottom])
@return [String];T; 0; @;!F;"o;#;$T;%i1;&i@;'@;(I"static VALUE
exc_full_message(int argc, VALUE *argv, VALUE exc)
{
VALUE opt, str, emesg, errat;
enum {kw_highlight, kw_order, kw_max_};
static ID kw[kw_max_];
VALUE args[kw_max_] = {Qnil, Qnil};
rb_scan_args(argc, argv, "0:", &opt);
if (!NIL_P(opt)) {
if (!kw[0]) {
#define INIT_KW(n) kw[kw_##n] = rb_intern_const(#n)
INIT_KW(highlight);
INIT_KW(order);
#undef INIT_KW
}
rb_get_kwargs(opt, kw, 0, kw_max_, args);
switch (args[kw_highlight]) {
default:
rb_raise(rb_eArgError, "expected true or false as "
"highlight: %+"PRIsVALUE, args[kw_highlight]);
case Qundef: args[kw_highlight] = Qnil; break;
case Qtrue: case Qfalse: case Qnil: break;
}
if (args[kw_order] == Qundef) {
args[kw_order] = Qnil;
}
else {
ID id = rb_check_id(&args[kw_order]);
if (id == id_bottom) args[kw_order] = Qtrue;
else if (id == id_top) args[kw_order] = Qfalse;
else {
rb_raise(rb_eArgError, "expected :top or :bottom as "
"order: %+"PRIsVALUE, args[kw_order]);
}
}
}
str = rb_str_new2("");
errat = rb_get_backtrace(exc);
emesg = rb_get_message(exc);
rb_error_write(exc, emesg, errat, str, args[kw_highlight], args[kw_order]);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#inspect;F;[ ;[[@i;T;;v;0;[ ;{ ;IC; "4Return this exception's class name and message.
;T;[o;=
;3I"
overload;F;40;;v;50;)I" inspect;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"[Return this exception's class name and message.
@overload inspect
@return [String];T; 0; @;!F;"o;#;$T;%i~;&i;'@;(I"static VALUE
exc_inspect(VALUE exc)
{
VALUE str, klass;
klass = CLASS_OF(exc);
exc = rb_obj_as_string(exc);
if (RSTRING_LEN(exc) == 0) {
return rb_class_name(klass);
}
str = rb_str_buf_new2("#<");
klass = rb_class_name(klass);
rb_str_buf_append(str, klass);
rb_str_buf_cat(str, ": ", 2);
rb_str_buf_append(str, exc);
rb_str_buf_cat(str, ">", 1);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#backtrace;F;[ ;[[@i;T;:backtrace;0;[ ;{ ;IC; "Returns any backtrace associated with the exception. The backtrace
is an array of strings, each containing either ``filename:lineNo: in
`method''' or ``filename:lineNo.''
def a
raise "boom"
end
def b
a()
end
begin
b()
rescue => detail
print detail.backtrace.join("\n")
end
produces:
prog.rb:2:in `a'
prog.rb:6:in `b'
prog.rb:10
In the case no backtrace has been set, +nil+ is returned
ex = StandardError.new
ex.backtrace
#=> nil
;T;[o;=
;3I"
overload;F;40;;;50;)I"backtrace;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;TI"nil;T; @; [ ; I"@return [Array, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"!Returns any backtrace associated with the exception. The backtrace
is an array of strings, each containing either ``filename:lineNo: in
`method''' or ``filename:lineNo.''
def a
raise "boom"
end
def b
a()
end
begin
b()
rescue => detail
print detail.backtrace.join("\n")
end
produces:
prog.rb:2:in `a'
prog.rb:6:in `b'
prog.rb:10
In the case no backtrace has been set, +nil+ is returned
ex = StandardError.new
ex.backtrace
#=> nil
@overload backtrace
@return [Array, nil];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
exc_backtrace(VALUE exc)
{
VALUE obj;
obj = rb_attr_get(exc, id_bt);
if (rb_backtrace_p(obj)) {
obj = rb_backtrace_to_str_ary(obj);
/* rb_ivar_set(exc, id_bt, obj); */
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""Exception#backtrace_locations;F;[ ;[[@i;T;:backtrace_locations;0;[ ;{ ;IC; "Returns any backtrace associated with the exception. This method is
similar to Exception#backtrace, but the backtrace is an array of
Thread::Backtrace::Location.
This method is not affected by Exception#set_backtrace().
;T;[o;=
;3I"
overload;F;40;;;50;)I"backtrace_locations;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;TI"nil;T; @; [ ; I"@return [Array, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns any backtrace associated with the exception. This method is
similar to Exception#backtrace, but the backtrace is an array of
Thread::Backtrace::Location.
This method is not affected by Exception#set_backtrace().
@overload backtrace_locations
@return [Array, nil];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
exc_backtrace_locations(VALUE exc)
{
VALUE obj;
obj = rb_attr_get(exc, id_bt_locations);
if (!NIL_P(obj)) {
obj = rb_backtrace_to_location_ary(obj);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Exception#set_backtrace;F;[[I"bt;T0;[[@i;T;:set_backtrace;0;[ ;{ ;IC; "Sets the backtrace information associated with +exc+. The +backtrace+ must
be an array of String objects or a single String in the format described
in Exception#backtrace.
;T;[o;=
;3I"
overload;F;40;;;50;)I" set_backtrace(backtrace);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"@return [Array];T; 0; @ ;!F;6i ;>0;[[I"backtrace;T0; @ ; [ ; I"Sets the backtrace information associated with +exc+. The +backtrace+ must
be an array of String objects or a single String in the format described
in Exception#backtrace.
@overload set_backtrace(backtrace)
@return [Array];T; 0; @ ;!F;"o;#;$T;%i;&i;'@;(I"xstatic VALUE
exc_set_backtrace(VALUE exc, VALUE bt)
{
return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Exception#cause;F;[ ;[[@i.;T;:
cause;0;[ ;{ ;IC; "Returns the previous exception ($!) at the time this exception was raised.
This is useful for wrapping exceptions and retaining the original exception
information.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
cause;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"Exception;TI"nil;T; @(; [ ; I" @return [Exception, nil];T; 0; @(;!F;6i ;>0;[ ; @(; [ ; I"Returns the previous exception ($!) at the time this exception was raised.
This is useful for wrapping exceptions and retaining the original exception
information.
@overload cause
@return [Exception, nil];T; 0; @(;!F;"o;#;$T;%i%;&i+;'@;(I"Qstatic VALUE
exc_cause(VALUE exc)
{
return rb_attr_get(exc, id_cause);
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i ;F;:Exception;;K;;;[ ;{ ;IC; "\Class Exception and its subclasses are used to communicate between
Kernel#raise and +rescue+ statements in begin ... end blocks.
An Exception object carries information about an exception:
- Its type (the exception's class).
- An optional descriptive message.
- Optional backtrace information.
Some built-in subclasses of Exception have additional methods: e.g., NameError#name.
== Defaults
Two Ruby statements have default exception classes:
- +raise+: defaults to RuntimeError.
- +rescue+: defaults to StandardError.
== Global Variables
When an exception has been raised but not yet handled (in +rescue+,
+ensure+, +at_exit+ and +END+ blocks), two global variables are set:
- $! contains the current exception.
- $@ contains its backtrace.
== Custom Exceptions
To provide additional or alternate information,
a program may create custom exception classes
that derive from the built-in exception classes.
A good practice is for a library to create a single "generic" exception class
(typically a subclass of StandardError or RuntimeError)
and have its other exception classes derive from that class.
This allows the user to rescue the generic exception, thus catching all exceptions
the library may raise even if future versions of the library add new
exception subclasses.
For example:
class MyLibrary
class Error < ::StandardError
end
class WidgetError < Error
end
class FrobError < Error
end
end
To handle both MyLibrary::WidgetError and MyLibrary::FrobError the library
user can rescue MyLibrary::Error.
== Built-In Exception Classes
The built-in subclasses of Exception are:
* NoMemoryError
* ScriptError
* LoadError
* NotImplementedError
* SyntaxError
* SecurityError
* SignalException
* Interrupt
* StandardError
* ArgumentError
* UncaughtThrowError
* EncodingError
* FiberError
* IOError
* EOFError
* IndexError
* KeyError
* StopIteration
* ClosedQueueError
* LocalJumpError
* NameError
* NoMethodError
* RangeError
* FloatDomainError
* RegexpError
* RuntimeError
* FrozenError
* SystemCallError
* Errno::*
* ThreadError
* TypeError
* ZeroDivisionError
* SystemExit
* SystemStackError
* fatal
;T;[ ; [ ; I"\Class Exception and its subclasses are used to communicate between
Kernel#raise and +rescue+ statements in begin ... end blocks.
An Exception object carries information about an exception:
- Its type (the exception's class).
- An optional descriptive message.
- Optional backtrace information.
Some built-in subclasses of Exception have additional methods: e.g., NameError#name.
== Defaults
Two Ruby statements have default exception classes:
- +raise+: defaults to RuntimeError.
- +rescue+: defaults to StandardError.
== Global Variables
When an exception has been raised but not yet handled (in +rescue+,
+ensure+, +at_exit+ and +END+ blocks), two global variables are set:
- $! contains the current exception.
- $@ contains its backtrace.
== Custom Exceptions
To provide additional or alternate information,
a program may create custom exception classes
that derive from the built-in exception classes.
A good practice is for a library to create a single "generic" exception class
(typically a subclass of StandardError or RuntimeError)
and have its other exception classes derive from that class.
This allows the user to rescue the generic exception, thus catching all exceptions
the library may raise even if future versions of the library add new
exception subclasses.
For example:
class MyLibrary
class Error < ::StandardError
end
class WidgetError < Error
end
class FrobError < Error
end
end
To handle both MyLibrary::WidgetError and MyLibrary::FrobError the library
user can rescue MyLibrary::Error.
== Built-In Exception Classes
The built-in subclasses of Exception are:
* NoMemoryError
* ScriptError
* LoadError
* NotImplementedError
* SyntaxError
* SecurityError
* SignalException
* Interrupt
* StandardError
* ArgumentError
* UncaughtThrowError
* EncodingError
* FiberError
* IOError
* EOFError
* IndexError
* KeyError
* StopIteration
* ClosedQueueError
* LocalJumpError
* NameError
* NoMethodError
* RangeError
* FloatDomainError
* RegexpError
* RuntimeError
* FrozenError
* SystemCallError
* Errno::*
* ThreadError
* TypeError
* ZeroDivisionError
* SystemExit
* SystemStackError
* fatal
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;I"Exception;F;S@];R;Fo;
;IC;[ ;A@U;BIC;[ ;A@U;CIC;[ ;A@U;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@iE[@if;T;:
NoFooter;;K;;;[ ;{ ;IC; "/Raised when gzip file footer is not found.
;T;[ ; [ ; I"1
Raised when gzip file footer is not found.
;T; 0; @U;!F;"o;#;$T;%iE;&iG;'@;I" Zlib::GzipFile::NoFooter;F;S@o;
;IC;[ ;A@i;BIC;[ ;A@i;CIC;[ ;A@i;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@iK[@ig;T;:
CRCError;;K;;;[ ;{ ;IC; "Raised when the CRC checksum recorded in gzip file footer is not equivalent
to the CRC checksum of the actual uncompressed data.
;T;[ ; [ ; I"
Raised when the CRC checksum recorded in gzip file footer is not equivalent
to the CRC checksum of the actual uncompressed data.
;T; 0; @i;!F;"o;#;$T;%iK;&iN;'@;I" Zlib::GzipFile::CRCError;F;S@o;
;IC;[ ;A@};BIC;[ ;A@};CIC;[ ;A@};DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@iR[@ih;T;:LengthError;;K;;;[ ;{ ;IC; "}Raised when the data length recorded in the gzip file footer is not equivalent
to the length of the actual uncompressed data.
;T;[ ; [ ; I"
Raised when the data length recorded in the gzip file footer is not equivalent
to the length of the actual uncompressed data.
;T; 0; @};!F;"o;#;$T;%iR;&iU;'@;I" Zlib::GzipFile::LengthError;F;S@o; ; F;
;F;;;I"Zlib::GzipFile.wrap;F;[[@c0;[[@iD ;T;: wrap;0;[ ;{ ;IC; "call-seq:
Zlib::GzipReader.wrap(io, ...) { |gz| ... }
Zlib::GzipWriter.wrap(io, ...) { |gz| ... }
Creates a GzipReader or GzipWriter associated with +io+, passing in any
necessary extra options, and executes the block with the newly created
object just like File.open.
The GzipFile object will be closed automatically after executing the block.
If you want to keep the associated IO object open, you may call
Zlib::GzipFile#finish method in the block.
;T;[ ; [ ; I"
call-seq:
Zlib::GzipReader.wrap(io, ...) { |gz| ... }
Zlib::GzipWriter.wrap(io, ...) { |gz| ... }
Creates a GzipReader or GzipWriter associated with +io+, passing in any
necessary extra options, and executes the block with the newly created
object just like File.open.
The GzipFile object will be closed automatically after executing the block.
If you want to keep the associated IO object open, you may call
Zlib::GzipFile#finish method in the block.
;T; 0; @;!F;"o;#;$T;%i5 ;&iA ;'@;(I"xstatic VALUE
rb_gzfile_s_wrap(int argc, VALUE *argv, VALUE klass)
{
return gzfile_wrap(argc, argv, klass, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#to_io;F;[ ;[[@i` ;T;:
to_io;0;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"
Same as IO.
;T; 0; @;!F;"o;#;$T;%i[ ;&i] ;'@;(I"Pstatic VALUE
rb_gzfile_to_io(VALUE obj)
{
return get_gzfile(obj)->io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#crc;F;[ ;[[@ik ;T;:crc;0;[ ;{ ;IC; "0Returns CRC value of the uncompressed data.
;T;[ ; [ ; I"2
Returns CRC value of the uncompressed data.
;T; 0; @;!F;"o;#;$T;%if ;&ih ;'@;(I"]static VALUE
rb_gzfile_crc(VALUE obj)
{
return rb_uint2inum(get_gzfile(obj)->crc);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#mtime;F;[ ;[[@iv ;T;:
mtime;0;[ ;{ ;IC; "EReturns last modification time recorded in the gzip file header.
;T;[ ; [ ; I"G
Returns last modification time recorded in the gzip file header.
;T; 0; @;!F;"o;#;$T;%iq ;&is ;'@;(I"kstatic VALUE
rb_gzfile_mtime(VALUE obj)
{
return rb_time_new(get_gzfile(obj)->mtime, (time_t)0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#level;F;[ ;[[@i ;T;:
level;0;[ ;{ ;IC; " Returns compression level.
;T;[ ; [ ; I"!
Returns compression level.
;T; 0; @;!F;"o;#;$T;%i| ;&i~ ;'@;(I"\static VALUE
rb_gzfile_level(VALUE obj)
{
return INT2FIX(get_gzfile(obj)->level);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#os_code;F;[ ;[[@i ;T;: os_code;0;[ ;{ ;IC; "=Returns OS code number recorded in the gzip file header.
;T;[ ; [ ; I"?
Returns OS code number recorded in the gzip file header.
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;(I"`static VALUE
rb_gzfile_os_code(VALUE obj)
{
return INT2FIX(get_gzfile(obj)->os_code);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipFile#orig_name;F;[ ;[[@i ;T;:orig_name;0;[ ;{ ;IC; "nReturns original filename recorded in the gzip file header, or +nil+ if
original filename is not present.
;T;[ ; [ ; I"p
Returns original filename recorded in the gzip file header, or +nil+ if
original filename is not present.
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;(I"static VALUE
rb_gzfile_orig_name(VALUE obj)
{
VALUE str = get_gzfile(obj)->orig_name;
if (!NIL_P(str)) {
str = rb_str_dup(str);
}
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#comment;F;[ ;[[@i ;T;: comment;0;[ ;{ ;IC; "^Returns comments recorded in the gzip file header, or nil if the comments
is not present.
;T;[ ; [ ; I"`
Returns comments recorded in the gzip file header, or nil if the comments
is not present.
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;(I"static VALUE
rb_gzfile_comment(VALUE obj)
{
VALUE str = get_gzfile(obj)->comment;
if (!NIL_P(str)) {
str = rb_str_dup(str);
}
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#close;F;[ ;[[@i$
;T;;:;0;[ ;{ ;IC; "~Closes the GzipFile object. This method calls close method of the
associated IO object. Returns the associated IO object.
;T;[ ; [ ; I"{
Closes the GzipFile object. This method calls close method of the
associated IO object. Returns the associated IO object.
;T; 0; @;!F;"o;#;$T;%i
;&i!
;'@;(I"static VALUE
rb_gzfile_close(VALUE obj)
{
struct gzfile *gz;
VALUE io;
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
if (!ZSTREAM_IS_READY(&gz->z)) {
return Qnil;
}
io = gz->io;
gzfile_close(gz, 1);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#finish;F;[ ;[[@i:
;T;;<;0;[ ;{ ;IC; "Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never
calls the close method of the associated IO object. Returns the associated IO
object.
;T;[ ; [ ; I"
Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never
calls the close method of the associated IO object. Returns the associated IO
object.
;T; 0; @;!F;"o;#;$T;%i3
;&i7
;'@;(I"static VALUE
rb_gzfile_finish(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE io;
io = gz->io;
gzfile_close(gz, 0);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#closed?;F;[ ;[[@iK
;T;;8;0;[ ;{ ;IC; "Same as IO#closed?;T;[o;2
;3I" return;F;4@|;0;5[@~; @ ; [ ; I"
Same as IO#closed?
;T; 0; @ ;!F;"o;#;$T;%iE
;&iH
;6i ;'@;(I"static VALUE
rb_gzfile_closed_p(VALUE obj)
{
struct gzfile *gz;
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
return NIL_P(gz->io) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#sync;F;[ ;[[@ie
;T;;;0;[ ;{ ;IC; "Same as IO#sync
;T;[ ; [ ; I"
Same as IO#sync
;T; 0; @/;!F;"o;#;$T;%i_
;&ib
;'@;(I"zstatic VALUE
rb_gzfile_sync(VALUE obj)
{
return (get_gzfile(obj)->z.flags & GZFILE_FLAG_SYNC) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipFile#sync=;F;[[I" mode;T0;[[@it
;T;:
sync=;0;[ ;{ ;IC; "call-seq: sync = flag
Same as IO. If flag is +true+, the associated IO object must respond to the
+flush+ method. While +sync+ mode is +true+, the compression ratio
decreases sharply.
;T;[ ; [ ; I"
call-seq: sync = flag
Same as IO. If flag is +true+, the associated IO object must respond to the
+flush+ method. While +sync+ mode is +true+, the compression ratio
decreases sharply.
;T; 0; @=;!F;"o;#;$T;%ik
;&iq
;'@;(I"static VALUE
rb_gzfile_set_sync(VALUE obj, VALUE mode)
{
struct gzfile *gz = get_gzfile(obj);
if (RTEST(mode)) {
gz->z.flags |= GZFILE_FLAG_SYNC;
}
else {
gz->z.flags &= ~GZFILE_FLAG_SYNC;
}
return mode;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i [@i_;T;:
GzipFile;;K;;;[ ;{ ;IC; "AZlib::GzipFile is an abstract class for handling a gzip formatted
compressed file. The operations are defined in the subclasses,
Zlib::GzipReader for reading, and Zlib::GzipWriter for writing.
GzipReader should be used by associating an IO, or IO-like, object.
== Method Catalogue
- ::wrap
- ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)
- #close
- #closed?
- #comment
- comment= (Zlib::GzipWriter#comment=)
- #crc
- eof? (Zlib::GzipReader#eof?)
- #finish
- #level
- lineno (Zlib::GzipReader#lineno)
- lineno= (Zlib::GzipReader#lineno=)
- #mtime
- mtime= (Zlib::GzipWriter#mtime=)
- #orig_name
- orig_name (Zlib::GzipWriter#orig_name=)
- #os_code
- path (when the underlying IO supports #path)
- #sync
- #sync=
- #to_io
(due to internal structure, documentation may appear under Zlib::GzipReader
or Zlib::GzipWriter);T;[ ; [ ; I"C
Zlib::GzipFile is an abstract class for handling a gzip formatted
compressed file. The operations are defined in the subclasses,
Zlib::GzipReader for reading, and Zlib::GzipWriter for writing.
GzipReader should be used by associating an IO, or IO-like, object.
== Method Catalogue
- ::wrap
- ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)
- #close
- #closed?
- #comment
- comment= (Zlib::GzipWriter#comment=)
- #crc
- eof? (Zlib::GzipReader#eof?)
- #finish
- #level
- lineno (Zlib::GzipReader#lineno)
- lineno= (Zlib::GzipReader#lineno=)
- #mtime
- mtime= (Zlib::GzipWriter#mtime=)
- #orig_name
- orig_name (Zlib::GzipWriter#orig_name=)
- #os_code
- path (when the underlying IO supports #path)
- #sync
- #sync=
- #to_io
(due to internal structure, documentation may appear under Zlib::GzipReader
or Zlib::GzipWriter)
;T; 0; @;!F;"o;#;$T;%i ;&i ;6i ;'o;L ;M0;N0;O0;;P;'@;Q@;R0;I"Zlib::GzipFile;F;So;L ;M0;N0;O0;;T;'@;Q@];R;Fo;
;IC;[o; ; F;
;;;;I" Zlib::GzipWriter#mtime=;F;[[I"
mtime;T0;[[@i ;T;: mtime=;0;[ ;{ ;IC; "}Specify the modification time (+mtime+) in the gzip header.
Using an Integer.
Setting the mtime in the gzip header does not effect the
mtime of the file generated. Different utilities that
expand the gzipped files may use the mtime
header. For example the gunzip utility can use the `-N`
flag which will set the resultant file's mtime to the
value in the header. By default many tools will set
the mtime of the expanded file to the mtime of the
gzipped file, not the mtime in the header.
If you do not set an mtime, the default value will be the time
when compression started. Setting a value of 0 indicates
no time stamp is available.
;T;[ ; [ ; I"
Specify the modification time (+mtime+) in the gzip header.
Using an Integer.
Setting the mtime in the gzip header does not effect the
mtime of the file generated. Different utilities that
expand the gzipped files may use the mtime
header. For example the gunzip utility can use the `-N`
flag which will set the resultant file's mtime to the
value in the header. By default many tools will set
the mtime of the expanded file to the mtime of the
gzipped file, not the mtime in the header.
If you do not set an mtime, the default value will be the time
when compression started. Setting a value of 0 indicates
no time stamp is available.
;T; 0; @c;!F;"o;#;$T;%i ;&i ;'@a;(I"_static VALUE
rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
{
struct gzfile *gz = get_gzfile(obj);
VALUE val;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
val = rb_Integer(mtime);
gz->mtime = NUM2UINT(val);
gz->z.flags |= GZFILE_FLAG_MTIME_IS_SET;
return mtime;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipWriter#orig_name=;F;[[I"str;T0;[[@i ;T;:orig_name=;0;[ ;{ ;IC; ":Specify the original name (+str+) in the gzip header.
;T;[ ; [ ; I"<
Specify the original name (+str+) in the gzip header.
;T; 0; @s;!F;"o;#;$T;%i ;&i ;'@a;(I"static VALUE
rb_gzfile_set_orig_name(VALUE obj, VALUE str)
{
struct gzfile *gz = get_gzfile(obj);
VALUE s;
char *p;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
s = rb_str_dup(rb_str_to_str(str));
p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
if (p) {
rb_str_resize(s, p - RSTRING_PTR(s));
}
gz->orig_name = s;
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipWriter#comment=;F;[[I"str;T0;[[@i
;T;:
comment=;0;[ ;{ ;IC; "4Specify the comment (+str+) in the gzip header.
;T;[ ; [ ; I"6
Specify the comment (+str+) in the gzip header.
;T; 0; @;!F;"o;#;$T;%i
;&i
;'@a;(I"static VALUE
rb_gzfile_set_comment(VALUE obj, VALUE str)
{
struct gzfile *gz = get_gzfile(obj);
VALUE s;
char *p;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
s = rb_str_dup(rb_str_to_str(str));
p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
if (p) {
rb_str_resize(s, p - RSTRING_PTR(s));
}
gz->comment = s;
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#pos;F;[ ;[[@i
;T;:pos;0;[ ;{ ;IC; "-Total number of input bytes read so far.
;T;[ ; [ ; I"/
Total number of input bytes read so far.
;T; 0; @;!F;"o;#;$T;%i
;&i
;'@a;(I"pstatic VALUE
rb_gzfile_total_in(VALUE obj)
{
return rb_uint2inum(get_gzfile(obj)->z.stream.total_in);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#tell;F;[ ;[[@i
;T;: tell;0;[ ;{ ;IC; "-Total number of input bytes read so far.
;T;[ ; [ ; @; 0; @;!F;"o;#;$T;%i
;&i
;'@a;(I"pstatic VALUE
rb_gzfile_total_in(VALUE obj)
{
return rb_uint2inum(get_gzfile(obj)->z.stream.total_in);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Zlib::GzipWriter.open;F;[[@c0;[[@i
;T;;;0;[ ;{ ;IC; "Opens a file specified by +filename+ for writing gzip compressed data, and
returns a GzipWriter object associated with that file. Further details of
this method are found in Zlib::GzipWriter.new and Zlib::GzipFile.wrap.
;T;[o;=
;3I"
overload;F;40;:Zlib::GzipWriter.open;50;)I"=Zlib::GzipWriter.open(filename, level=nil, strategy=nil);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"gz;T; @; [ ; I"@yield [gz];T; 0; @;!F;6i ;>0;[[I"
filename;T0[I"
level;TI"nil;T[I"
strategy;TI"nil;T; @; [ ; I"/Opens a file specified by +filename+ for writing gzip compressed data, and
returns a GzipWriter object associated with that file. Further details of
this method are found in Zlib::GzipWriter.new and Zlib::GzipFile.wrap.
@overload Zlib::GzipWriter.open(filename, level=nil, strategy=nil)
@yield [gz];T; 0; @;!F;"o;#;$T;%i
;&i
;'@a;(I"static VALUE
rb_gzwriter_s_open(int argc, VALUE *argv, VALUE klass)
{
return gzfile_s_open(argc, argv, klass, "wb");
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipWriter#initialize;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "Creates a GzipWriter object associated with +io+. +level+ and +strategy+
should be the same as the arguments of Zlib::Deflate.new. The GzipWriter
object writes gzipped data to +io+. +io+ must respond to the
+write+ method that behaves the same as IO#write.
The +options+ hash may be used to set the encoding of the data.
+:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
IO::new.
;T;[o;=
;3I"
overload;F;40;:Zlib::GzipWriter.new;50;)I"HZlib::GzipWriter.new(io, level = nil, strategy = nil, options = {});T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ [I"io;T0[I"
level;TI"nil;T[I"
strategy;TI"nil;T[I" options;TI"{};T; @; [ ; I"Creates a GzipWriter object associated with +io+. +level+ and +strategy+
should be the same as the arguments of Zlib::Deflate.new. The GzipWriter
object writes gzipped data to +io+. +io+ must respond to the
+write+ method that behaves the same as IO#write.
The +options+ hash may be used to set the encoding of the data.
+:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
IO::new.
@overload Zlib::GzipWriter.new(io, level = nil, strategy = nil, options = {});T; 0; @;!F;"o;#;$T;%i
;&i
;'@a;(I"static VALUE
rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz;
VALUE io, level, strategy, opt = Qnil;
int err;
if (argc > 1) {
opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
if (!NIL_P(opt)) argc--;
}
rb_scan_args(argc, argv, "12", &io, &level, &strategy);
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
/* this is undocumented feature of zlib */
gz->level = ARG_LEVEL(level);
err = deflateInit2(&gz->z.stream, gz->level, Z_DEFLATED,
-MAX_WBITS, DEF_MEM_LEVEL, ARG_STRATEGY(strategy));
if (err != Z_OK) {
raise_zlib_error(err, gz->z.stream.msg);
}
gz->io = io;
ZSTREAM_READY(&gz->z);
rb_gzfile_ecopts(gz, opt);
if (rb_respond_to(io, id_path)) {
gz->path = rb_funcall(gz->io, id_path, 0);
rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#flush;F;[[@c0;[[@i*;T;;;0;[ ;{ ;IC; "Flushes all the internal buffers of the GzipWriter object. The meaning of
+flush+ is same as in Zlib::Deflate#deflate. Zlib::SYNC_FLUSH is used if
+flush+ is omitted. It is no use giving flush Zlib::NO_FLUSH.
;T;[o;=
;3I"
overload;F;40;;;50;)I"flush(flush=nil);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"
flush;TI"nil;T; @; [ ; I"Flushes all the internal buffers of the GzipWriter object. The meaning of
+flush+ is same as in Zlib::Deflate#deflate. Zlib::SYNC_FLUSH is used if
+flush+ is omitted. It is no use giving flush Zlib::NO_FLUSH.
@overload flush(flush=nil);T; 0; @;!F;"o;#;$T;%i#;&i(;'@a;(I"static VALUE
rb_gzwriter_flush(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE v_flush;
int flush;
rb_scan_args(argc, argv, "01", &v_flush);
flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */
zstream_run(&gz->z, (Bytef*)"", 0, flush);
}
gzfile_write_raw(gz);
if (rb_respond_to(gz->io, id_flush)) {
rb_funcall(gz->io, id_flush, 0);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#write;F;[[@c0;[[@iB;T;;;0;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @;!F;"o;#;$T;%i?;&i@;'@a;(I"static VALUE
rb_gzwriter_write(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
size_t total = 0;
while (argc-- > 0) {
VALUE str = *argv++;
if (!RB_TYPE_P(str, T_STRING))
str = rb_obj_as_string(str);
if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
}
gzfile_write(gz, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
total += RSTRING_LEN(str);
RB_GC_GUARD(str);
}
return SIZET2NUM(total);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#putc;F;[[I"ch;T0;[[@iY;T;;;0;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @ ;!F;"o;#;$T;%iV;&iW;'@a;(I"static VALUE
rb_gzwriter_putc(VALUE obj, VALUE ch)
{
struct gzfile *gz = get_gzfile(obj);
char c = NUM2CHR(ch);
gzfile_write(gz, (Bytef*)&c, 1);
return ch;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipWriter#<<;F;[ ;[ ;F;;;;K;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @-;!F;"o;#;$T;%ie;&if;'@a;*To; ; F;
;;;;I" Zlib::GzipWriter#printf;F;[ ;[ ;F;;;;K;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @8;!F;"o;#;$T;%ij;&ik;'@a;*To; ; F;
;;;;I"Zlib::GzipWriter#print;F;[ ;[ ;F;;;;K;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @C;!F;"o;#;$T;%io;&ip;'@a;*To; ; F;
;;;;I"Zlib::GzipWriter#puts;F;[ ;[ ;F;;;;K;[ ;{ ;IC; "Same as IO.
;T;[ ; [ ; I"Same as IO.
;T; 0; @N;!F;"o;#;$T;%it;&iu;'@a;*T;A@a;BIC;[ ;A@a;CIC;[ ;A@a;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i
[@ij;T;:GzipWriter;;K;;;[ ;{ ;IC; "HZlib::GzipWriter is a class for writing gzipped files. GzipWriter should
be used with an instance of IO, or IO-like, object.
Following two example generate the same result.
Zlib::GzipWriter.open('hoge.gz') do |gz|
gz.write 'jugemu jugemu gokou no surikire...'
end
File.open('hoge.gz', 'w') do |f|
gz = Zlib::GzipWriter.new(f)
gz.write 'jugemu jugemu gokou no surikire...'
gz.close
end
To make like gzip(1) does, run following:
orig = 'hoge.txt'
Zlib::GzipWriter.open('hoge.gz') do |gz|
gz.mtime = File.mtime(orig)
gz.orig_name = orig
gz.write IO.binread(orig)
end
NOTE: Due to the limitation of Ruby's finalizer, you must explicitly close
GzipWriter objects by Zlib::GzipWriter#close etc. Otherwise, GzipWriter
will be not able to write the gzip footer and will generate a broken gzip
file.;T;[ ; [ ; I"J
Zlib::GzipWriter is a class for writing gzipped files. GzipWriter should
be used with an instance of IO, or IO-like, object.
Following two example generate the same result.
Zlib::GzipWriter.open('hoge.gz') do |gz|
gz.write 'jugemu jugemu gokou no surikire...'
end
File.open('hoge.gz', 'w') do |f|
gz = Zlib::GzipWriter.new(f)
gz.write 'jugemu jugemu gokou no surikire...'
gz.close
end
To make like gzip(1) does, run following:
orig = 'hoge.txt'
Zlib::GzipWriter.open('hoge.gz') do |gz|
gz.mtime = File.mtime(orig)
gz.orig_name = orig
gz.write IO.binread(orig)
end
NOTE: Due to the limitation of Ruby's finalizer, you must explicitly close
GzipWriter objects by Zlib::GzipWriter#close etc. Otherwise, GzipWriter
will be not able to write the gzip footer and will generate a broken gzip
file.
;T; 0; @a;!F;"o;#;$T;%i
;&i
;6i ;'o;L ;M0;N0;O0;;P;'@;Q@;R0;I"Zlib::GzipWriter;F;S@o;
;IC;[!o; ; F;
;;;;I" Zlib::GzipReader#lineno;F;[ ;[[@i ;T;: lineno;0;[ ;{ ;IC; "9The line number of the last row read from this file.
;T;[ ; [ ; I";
The line number of the last row read from this file.
;T; 0; @n;!F;"o;#;$T;%i ;&i ;'@l;(I"^static VALUE
rb_gzfile_lineno(VALUE obj)
{
return INT2NUM(get_gzfile(obj)->lineno);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#lineno=;F;[[I" lineno;T0;[[@i ;T;: lineno=;0;[ ;{ ;IC; "=Specify line number of the last row read from this file.
;T;[ ; [ ; I"?
Specify line number of the last row read from this file.
;T; 0; @|;!F;"o;#;$T;%i ;&i ;'@l;(I"static VALUE
rb_gzfile_set_lineno(VALUE obj, VALUE lineno)
{
struct gzfile *gz = get_gzfile(obj);
gz->lineno = NUM2INT(lineno);
return lineno;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#eof;F;[ ;[[@iX
;T;:eof;0;[ ;{ ;IC; "FReturns +true+ or +false+ whether the stream has reached the end.
;T;[ ; [ ; I"H
Returns +true+ or +false+ whether the stream has reached the end.
;T; 0; @;!F;"o;#;$T;%iS
;&iU
;'@l;(I"static VALUE
rb_gzfile_eof_p(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
return GZFILE_IS_FINISHED(gz) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#eof?;F;[ ;[[@iX
;T;: eof?;0;[ ;{ ;IC; "FReturns +true+ or +false+ whether the stream has reached the end.;T;[o;2
;3I" return;F;4@|;0;5[@~; @; [ ; @; 0; @;!F;"o;#;$T;%iS
;&iU
;6i ;'@l;(I"static VALUE
rb_gzfile_eof_p(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
return GZFILE_IS_FINISHED(gz) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#pos;F;[ ;[[@i
;T;; ;0;[ ;{ ;IC; "0Total number of output bytes output so far.
;T;[ ; [ ; I"2
Total number of output bytes output so far.
;T; 0; @;!F;"o;#;$T;%i
;&i
;'@l;(I"estatic VALUE
rb_gzfile_total_out(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
uLong total_out = gz->z.stream.total_out;
long buf_filled = ZSTREAM_BUF_FILLED(&gz->z);
if (total_out >= (uLong)buf_filled) {
return rb_uint2inum(total_out - buf_filled);
} else {
return LONG2FIX(-(buf_filled - (long)total_out));
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#tell;F;[ ;[[@i
;T;; ;0;[ ;{ ;IC; "0Total number of output bytes output so far.
;T;[ ; [ ; @; 0; @;!F;"o;#;$T;%i
;&i
;'@l;(I"estatic VALUE
rb_gzfile_total_out(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
uLong total_out = gz->z.stream.total_out;
long buf_filled = ZSTREAM_BUF_FILLED(&gz->z);
if (total_out >= (uLong)buf_filled) {
return rb_uint2inum(total_out - buf_filled);
} else {
return LONG2FIX(-(buf_filled - (long)total_out));
}
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Zlib::GzipReader.open;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "call-seq: Zlib::GzipReader.open(filename) {|gz| ... }
Opens a file specified by +filename+ as a gzipped file, and returns a
GzipReader object associated with that file. Further details of this method
are in Zlib::GzipReader.new and ZLib::GzipFile.wrap.
;T;[ ; [ ; I"
call-seq: Zlib::GzipReader.open(filename) {|gz| ... }
Opens a file specified by +filename+ as a gzipped file, and returns a
GzipReader object associated with that file. Further details of this method
are in Zlib::GzipReader.new and ZLib::GzipFile.wrap.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_s_open(int argc, VALUE *argv, VALUE klass)
{
return gzfile_s_open(argc, argv, klass, "rb");
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#initialize;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "call-seq:
Zlib::GzipReader.new(io, options = {})
Creates a GzipReader object associated with +io+. The GzipReader object reads
gzipped data from +io+, and parses/decompresses it. The +io+ must
have a +read+ method that behaves same as the IO#read.
The +options+ hash may be used to set the encoding of the data.
+:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
IO::new.
If the gzip file header is incorrect, raises an Zlib::GzipFile::Error
exception.
;T;[ ; [ ; I"
call-seq:
Zlib::GzipReader.new(io, options = {})
Creates a GzipReader object associated with +io+. The GzipReader object reads
gzipped data from +io+, and parses/decompresses it. The +io+ must
have a +read+ method that behaves same as the IO#read.
The +options+ hash may be used to set the encoding of the data.
+:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
IO::new.
If the gzip file header is incorrect, raises an Zlib::GzipFile::Error
exception.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
{
VALUE io, opt = Qnil;
struct gzfile *gz;
int err;
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
rb_scan_args(argc, argv, "1:", &io, &opt);
/* this is undocumented feature of zlib */
err = inflateInit2(&gz->z.stream, -MAX_WBITS);
if (err != Z_OK) {
raise_zlib_error(err, gz->z.stream.msg);
}
gz->io = io;
ZSTREAM_READY(&gz->z);
gzfile_read_header(gz, Qnil);
rb_gzfile_ecopts(gz, opt);
if (rb_respond_to(io, id_path)) {
gz->path = rb_funcall(gz->io, id_path, 0);
rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#rewind;F;[ ;[[@i;T;: rewind;0;[ ;{ ;IC; "Resets the position of the file pointer to the point created the GzipReader
object. The associated IO object needs to respond to the +seek+ method.
;T;[ ; [ ; I"
Resets the position of the file pointer to the point created the GzipReader
object. The associated IO object needs to respond to the +seek+ method.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_rewind(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
gzfile_reader_rewind(gz);
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#unused;F;[ ;[[@i;T;: unused;0;[ ;{ ;IC; "|Returns the rest of the data which had read for parsing gzip format, or
+nil+ if the whole gzip file is not parsed yet.
;T;[ ; [ ; I"~
Returns the rest of the data which had read for parsing gzip format, or
+nil+ if the whole gzip file is not parsed yet.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_unused(VALUE obj)
{
struct gzfile *gz;
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
return gzfile_reader_get_unused(gz);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#read;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE vlen;
long len;
rb_scan_args(argc, argv, "01", &vlen);
if (NIL_P(vlen)) {
return gzfile_read_all(gz);
}
len = NUM2INT(vlen);
if (len < 0) {
rb_raise(rb_eArgError, "negative length %ld given", len);
}
return gzfile_read(gz, len);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!Zlib::GzipReader#readpartial;F;[[@c0;[[@i3;T;:readpartial;0;[ ;{ ;IC; "qcall-seq:
gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
Reads at most maxlen bytes from the gziped stream but
it blocks only if gzipreader has no data immediately available.
If the optional outbuf argument is present,
it must reference a String, which will receive the data.
It raises EOFError on end of file.
;T;[ ; [ ; I"t
call-seq:
gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
Reads at most maxlen bytes from the gziped stream but
it blocks only if gzipreader has no data immediately available.
If the optional outbuf argument is present,
it must reference a String, which will receive the data.
It raises EOFError on end of file.
;T; 0; @;!F;"o;#;$T;%i';&i0;'@l;(I"static VALUE
rb_gzreader_readpartial(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE vlen, outbuf;
long len;
rb_scan_args(argc, argv, "11", &vlen, &outbuf);
len = NUM2INT(vlen);
if (len < 0) {
rb_raise(rb_eArgError, "negative length %ld given", len);
}
if (!NIL_P(outbuf))
Check_Type(outbuf, T_STRING);
return gzfile_readpartial(gz, len, outbuf);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#getc;F;[ ;[[@iJ;T;: getc;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @ ;!F;"o;#;$T;%iE;&iG;'@l;(I"wstatic VALUE
rb_gzreader_getc(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
return gzfile_getc(gz);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#getbyte;F;[ ;[[@ig;T;: getbyte;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @+;!F;"o;#;$T;%ib;&id;'@l;(I"static VALUE
rb_gzreader_getbyte(VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE dst;
dst = gzfile_read(gz, 1);
if (!NIL_P(dst)) {
dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#readchar;F;[ ;[[@iW;T;:
readchar;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @9;!F;"o;#;$T;%iR;&iT;'@l;(I"static VALUE
rb_gzreader_readchar(VALUE obj)
{
VALUE dst;
dst = rb_gzreader_getc(obj);
if (NIL_P(dst)) {
rb_raise(rb_eEOFError, "end of file reached");
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#readbyte;F;[ ;[[@iy;T;:
readbyte;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @G;!F;"o;#;$T;%it;&iv;'@l;(I"static VALUE
rb_gzreader_readbyte(VALUE obj)
{
VALUE dst;
dst = rb_gzreader_getbyte(obj);
if (NIL_P(dst)) {
rb_raise(rb_eEOFError, "end of file reached");
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#each_byte;F;[ ;[[@i;T;:each_byte;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @U;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_each_byte(VALUE obj)
{
VALUE c;
RETURN_ENUMERATOR(obj, 0, 0);
while (!NIL_P(c = rb_gzreader_getbyte(obj))) {
rb_yield(c);
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#each_char;F;[ ;[[@i;T;:each_char;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @c;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_each_char(VALUE obj)
{
VALUE c;
RETURN_ENUMERATOR(obj, 0, 0);
while (!NIL_P(c = rb_gzreader_getc(obj))) {
rb_yield(c);
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#bytes;F;[ ;[[@i;T;:
bytes;0;[ ;{ ;IC; ";This is a deprecated alias for each_byte.
;T;[ ; [ ; I">
This is a deprecated alias for each_byte.
;T; 0; @q;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_bytes(VALUE obj)
{
rb_warn("Zlib::GzipReader#bytes is deprecated; use #each_byte instead");
if (!rb_block_given_p())
return rb_enumeratorize(obj, ID2SYM(rb_intern("each_byte")), 0, 0);
return rb_gzreader_each_byte(obj);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#ungetc;F;[[I"s;T0;[[@i;T;: ungetc;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_ungetc(VALUE obj, VALUE s)
{
struct gzfile *gz;
if (FIXNUM_P(s))
return rb_gzreader_ungetbyte(obj, s);
gz = get_gzfile(obj);
StringValue(s);
if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
}
gzfile_ungets(gz, (const Bytef*)RSTRING_PTR(s), RSTRING_LEN(s));
RB_GC_GUARD(s);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#ungetbyte;F;[[I"ch;T0;[[@i;T;:ungetbyte;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_ungetbyte(VALUE obj, VALUE ch)
{
struct gzfile *gz = get_gzfile(obj);
gzfile_ungetbyte(gz, NUM2CHR(ch));
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#gets;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_gets(int argc, VALUE *argv, VALUE obj)
{
VALUE dst;
dst = gzreader_gets(argc, argv, obj);
if (!NIL_P(dst)) {
rb_lastline_set(dst);
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#readline;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_readline(int argc, VALUE *argv, VALUE obj)
{
VALUE dst;
dst = rb_gzreader_gets(argc, argv, obj);
if (NIL_P(dst)) {
rb_raise(rb_eEOFError, "end of file reached");
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#each;F;[[@c0;[[@i;T;: each;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
{
VALUE str;
RETURN_ENUMERATOR(obj, 0, 0);
while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
rb_yield(str);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#each_line;F;[[@c0;[[@i;T;:each_line;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; @; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
{
VALUE str;
RETURN_ENUMERATOR(obj, 0, 0);
while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
rb_yield(str);
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Zlib::GzipReader#lines;F;[[@c0;[[@i;T;:
lines;0;[ ;{ ;IC; ";This is a deprecated alias for each_line.
;T;[ ; [ ; I">
This is a deprecated alias for each_line.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"'static VALUE
rb_gzreader_lines(int argc, VALUE *argv, VALUE obj)
{
rb_warn("Zlib::GzipReader#lines is deprecated; use #each_line instead");
if (!rb_block_given_p())
return rb_enumeratorize(obj, ID2SYM(rb_intern("each_line")), argc, argv);
return rb_gzreader_each(argc, argv, obj);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Zlib::GzipReader#readlines;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"static VALUE
rb_gzreader_readlines(int argc, VALUE *argv, VALUE obj)
{
VALUE str, dst;
dst = rb_ary_new();
while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
rb_ary_push(dst, str);
}
return dst;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'Zlib::GzipReader#external_encoding;F;[ ;[[@i;T;:external_encoding;0;[ ;{ ;IC; ":See Zlib::GzipReader documentation for a description.
;T;[ ; [ ; I"<
See Zlib::GzipReader documentation for a description.
;T; 0; @;!F;"o;#;$T;%i;&i;'@l;(I"wstatic VALUE
rb_gzreader_external_encoding(VALUE self)
{
return rb_enc_from_encoding(get_gzfile(self)->enc);
};T;)I"static VALUE;T;*T;A@l;BIC;[ ;A@l;CIC;[o;L ;M0;N0;O0;:Enumerable;'@;Qo; ;IC;[@o; ; F;
;;;;I"Enumerable#chain;F;[[@c0;[[@i ;T;:
chain;0;[ ;{ ;IC; "Returns an enumerator object generated from this enumerator and
given enumerables.
e = (1..3).chain([4, 5])
e.to_a #=> [1, 2, 3, 4, 5]
;T;[o;=
;3I"
overload;F;40;;%;50;)I"chain(*enums);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[[I" *enums;T0; @ ; [ ; I"Returns an enumerator object generated from this enumerator and
given enumerables.
e = (1..3).chain([4, 5])
e.to_a #=> [1, 2, 3, 4, 5]
@overload chain(*enums);T; 0; @ ;!F;"o;#;$T;%i ;&i ;'@ ;(I"static VALUE
enum_chain(int argc, VALUE *argv, VALUE obj)
{
VALUE enums = rb_ary_new_from_values(1, &obj);
rb_ary_cat(enums, argv, argc);
return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#lazy;F;[ ;[[@i\;T;: lazy;0;[ ;{ ;IC; "Returns an Enumerator::Lazy, which redefines most Enumerable
methods to postpone enumeration and enumerate values only on an
as-needed basis.
=== Example
The following program finds pythagorean triples:
def pythagorean_triples
(1..Float::INFINITY).lazy.flat_map {|z|
(1..z).flat_map {|x|
(x..z).select {|y|
x**2 + y**2 == z**2
}.map {|y|
[x, y, z]
}
}
}
end
# show first ten pythagorean triples
p pythagorean_triples.take(10).force # take is lazy, so force is needed
p pythagorean_triples.first(10) # first is eager
# show pythagorean triples less than 100
p pythagorean_triples.take_while { |*, z| z < 100 }.force
;T;[o;=
;3I"
overload;F;40;;&;50;)I" lazy;T;IC; " ;T;[ ; [ ; I" ;T; 0; @$;!F;6i ;>0;[ ; @$; [ ; I"Returns an Enumerator::Lazy, which redefines most Enumerable
methods to postpone enumeration and enumerate values only on an
as-needed basis.
=== Example
The following program finds pythagorean triples:
def pythagorean_triples
(1..Float::INFINITY).lazy.flat_map {|z|
(1..z).flat_map {|x|
(x..z).select {|y|
x**2 + y**2 == z**2
}.map {|y|
[x, y, z]
}
}
}
end
# show first ten pythagorean triples
p pythagorean_triples.take(10).force # take is lazy, so force is needed
p pythagorean_triples.first(10) # first is eager
# show pythagorean triples less than 100
p pythagorean_triples.take_while { |*, z| z < 100 }.force
@overload lazy;T; 0; @$;!F;"o;#;$T;%i?;&iY;'@ ;(I"static VALUE
enumerable_lazy(VALUE obj)
{
VALUE result = lazy_to_enum_i(obj, sym_each, 0, 0, lazyenum_size, PASS_KW_SPLAT);
/* Qfalse indicates that the Enumerator::Lazy has no method name */
rb_ivar_set(result, id_method, Qfalse);
return result;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#to_a;F;[[@c0;[[I" enum.c;Ti;T;: to_a;0;[ ;{ ;IC; "Returns an array containing the items in enum.
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
;T;[o;=
;3I"
overload;F;40;;';50;)I"to_a(*args);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @:; [ ; I"@return [Array];T; 0; @:;!F;6i ;>0;[[I"
*args;T0; @:o;=
;3I"
overload;F;40;: entries;50;)I"entries(*args);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @:; [ ; I"@return [Array];T; 0; @:;!F;6i ;>0;[[I"
*args;T0; @:; [ ; I"\Returns an array containing the items in enum.
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
@overload to_a(*args)
@return [Array]
@overload entries(*args)
@return [Array];T; 0; @:;!F;"o;#;$T;%iy;&i;'@ ;(I"static VALUE
enum_to_a(int argc, VALUE *argv, VALUE obj)
{
VALUE ary = rb_ary_new();
rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#entries;F;[[@c0;[[@@i;T;;(;0;[ ;{ ;IC; "Returns an array containing the items in enum.
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
;T;[o;=
;3I"
overload;F;40;;';50;)I"to_a(*args);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @h; [ ; I"@return [Array];T; 0; @h;!F;6i ;>0;[[I"
*args;T0; @ho;=
;3I"
overload;F;40;;(;50;)I"entries(*args);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @h; [ ; I"@return [Array];T; 0; @h;!F;6i ;>0;[[I"
*args;T0; @h; [ ; @d; 0; @h;!F;"o;#;$T;%iy;&i;'@ ;(I"static VALUE
enum_to_a(int argc, VALUE *argv, VALUE obj)
{
VALUE ary = rb_ary_new();
rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#to_h;F;[[@c0;[[@@i;T;: to_h;0;[ ;{ ;IC; "TReturns the result of interpreting enum as a list of
[key, value] pairs.
%i[hello world].each_with_index.to_h
# => {:hello => 0, :world => 1}
If a block is given, the results of the block on each element of
the enum will be used as pairs.
(1..5).to_h {|x| [x, x ** 2]}
#=> {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}
;T;[o;=
;3I"
overload;F;40;;);50;)I"to_h(*args);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Hash;T; @; [ ; I"@return [Hash];T; 0; @;!F;6i ;>0;[[I"
*args;T0; @o;=
;3I"
overload;F;40;;);50;)I"to_h(*args);T;IC; " ;T;[o;2
;3I"
yield;F;4I"[];T;0;50; @o;2
;3I" return;F;4I" ;T;0;5[I" Hash;T; @; [ ; I" @yield []
@return [Hash];T; 0; @;!F;6i ;>0;[[I"
*args;T0; @; [ ; I"Returns the result of interpreting enum as a list of
[key, value] pairs.
%i[hello world].each_with_index.to_h
# => {:hello => 0, :world => 1}
If a block is given, the results of the block on each element of
the enum will be used as pairs.
(1..5).to_h {|x| [x, x ** 2]}
#=> {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}
@overload to_h(*args)
@return [Hash]
@overload to_h(*args)
@yield []
@return [Hash];T; 0; @;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_to_h(int argc, VALUE *argv, VALUE obj)
{
rb_block_call_func *iter = rb_block_given_p() ? enum_to_h_ii : enum_to_h_i;
return enum_hashify(obj, argc, argv, iter);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#sort;F;[ ;[[@@iA;T;: sort;0;[ ;{ ;IC; "Returns an array containing the items in enum sorted.
Comparisons for the sort will be done using the items' own
<=> operator or using an optional code block.
The block must implement a comparison between +a+ and +b+ and return
an integer less than 0 when +b+ follows +a+, +0+ when +a+ and +b+
are equivalent, or an integer greater than 0 when +a+ follows +b+.
The result is not guaranteed to be stable. When the comparison of two
elements returns +0+, the order of the elements is unpredictable.
%w(rhea kea flea).sort #=> ["flea", "kea", "rhea"]
(1..10).sort { |a, b| b <=> a } #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
See also Enumerable#sort_by. It implements a Schwartzian transform
which is useful when key computation or comparison is expensive.
;T;[o;=
;3I"
overload;F;40;;*;50;)I" sort;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @; [ ; I"@return [Array];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;*;50;)I" sort;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @; [ ; I""@yield [a, b]
@return [Array];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"jReturns an array containing the items in enum sorted.
Comparisons for the sort will be done using the items' own
<=> operator or using an optional code block.
The block must implement a comparison between +a+ and +b+ and return
an integer less than 0 when +b+ follows +a+, +0+ when +a+ and +b+
are equivalent, or an integer greater than 0 when +a+ follows +b+.
The result is not guaranteed to be stable. When the comparison of two
elements returns +0+, the order of the elements is unpredictable.
%w(rhea kea flea).sort #=> ["flea", "kea", "rhea"]
(1..10).sort { |a, b| b <=> a } #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
See also Enumerable#sort_by. It implements a Schwartzian transform
which is useful when key computation or comparison is expensive.
@overload sort
@return [Array]
@overload sort
@yield [a, b]
@return [Array];T; 0; @;!F;"o;#;$T;%i);&i@;'@ ;(I"]static VALUE
enum_sort(VALUE obj)
{
return rb_ary_sort_bang(enum_to_a(0, 0, obj));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#sort_by;F;[ ;[[@@i;T;: sort_by;0;[ ;{ ;IC; "k Sorts enum using a set of keys generated by mapping the
values in enum through the given block.
The result is not guaranteed to be stable. When two keys are equal,
the order of the corresponding elements is unpredictable.
If no block is given, an enumerator is returned instead.
%w{apple pear fig}.sort_by { |word| word.length }
#=> ["fig", "pear", "apple"]
The current implementation of #sort_by generates an array of
tuples containing the original collection element and the mapped
value. This makes #sort_by fairly expensive when the keysets are
simple.
require 'benchmark'
a = (1..100000).map { rand(100000) }
Benchmark.bm(10) do |b|
b.report("Sort") { a.sort }
b.report("Sort by") { a.sort_by { |a| a } }
end
produces:
user system total real
Sort 0.180000 0.000000 0.180000 ( 0.175469)
Sort by 1.980000 0.040000 2.020000 ( 2.013586)
However, consider the case where comparing the keys is a non-trivial
operation. The following code sorts some files on modification time
using the basic #sort method.
files = Dir["*"]
sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime }
sorted #=> ["mon", "tues", "wed", "thurs"]
This sort is inefficient: it generates two new File
objects during every comparison. A slightly better technique is to
use the Kernel#test method to generate the modification
times directly.
files = Dir["*"]
sorted = files.sort { |a, b|
test(?M, a) <=> test(?M, b)
}
sorted #=> ["mon", "tues", "wed", "thurs"]
This still generates many unnecessary Time objects. A more
efficient technique is to cache the sort keys (modification times
in this case) before the sort. Perl users often call this approach
a Schwartzian transform, after Randal Schwartz. We construct a
temporary array, where each element is an array containing our
sort key along with the filename. We sort this array, and then
extract the filename from the result.
sorted = Dir["*"].collect { |f|
[test(?M, f), f]
}.sort.collect { |f| f[1] }
sorted #=> ["mon", "tues", "wed", "thurs"]
This is exactly what #sort_by does internally.
sorted = Dir["*"].sort_by { |f| test(?M, f) }
sorted #=> ["mon", "tues", "wed", "thurs"]
To produce the reverse of a specific order, the following can be used:
ary.sort_by { ... }.reverse!
;T;[o;=
;3I"
overload;F;40;;+;50;)I" sort_by;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @; [ ; I"!@yield [obj]
@return [Array];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;+;50;)I" sort_by;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; I" Sorts enum using a set of keys generated by mapping the
values in enum through the given block.
The result is not guaranteed to be stable. When two keys are equal,
the order of the corresponding elements is unpredictable.
If no block is given, an enumerator is returned instead.
%w{apple pear fig}.sort_by { |word| word.length }
#=> ["fig", "pear", "apple"]
The current implementation of #sort_by generates an array of
tuples containing the original collection element and the mapped
value. This makes #sort_by fairly expensive when the keysets are
simple.
require 'benchmark'
a = (1..100000).map { rand(100000) }
Benchmark.bm(10) do |b|
b.report("Sort") { a.sort }
b.report("Sort by") { a.sort_by { |a| a } }
end
produces:
user system total real
Sort 0.180000 0.000000 0.180000 ( 0.175469)
Sort by 1.980000 0.040000 2.020000 ( 2.013586)
However, consider the case where comparing the keys is a non-trivial
operation. The following code sorts some files on modification time
using the basic #sort method.
files = Dir["*"]
sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime }
sorted #=> ["mon", "tues", "wed", "thurs"]
This sort is inefficient: it generates two new File
objects during every comparison. A slightly better technique is to
use the Kernel#test method to generate the modification
times directly.
files = Dir["*"]
sorted = files.sort { |a, b|
test(?M, a) <=> test(?M, b)
}
sorted #=> ["mon", "tues", "wed", "thurs"]
This still generates many unnecessary Time objects. A more
efficient technique is to cache the sort keys (modification times
in this case) before the sort. Perl users often call this approach
a Schwartzian transform, after Randal Schwartz. We construct a
temporary array, where each element is an array containing our
sort key along with the filename. We sort this array, and then
extract the filename from the result.
sorted = Dir["*"].collect { |f|
[test(?M, f), f]
}.sort.collect { |f| f[1] }
sorted #=> ["mon", "tues", "wed", "thurs"]
This is exactly what #sort_by does internally.
sorted = Dir["*"].sort_by { |f| test(?M, f) }
sorted #=> ["mon", "tues", "wed", "thurs"]
To produce the reverse of a specific order, the following can be used:
ary.sort_by { ... }.reverse!
@overload sort_by
@yield [obj]
@return [Array]
@overload sort_by;T; 0; @;!F;"o;#;$T;%i|;&i;'@ ;(I"static VALUE
enum_sort_by(VALUE obj)
{
VALUE ary, buf;
struct MEMO *memo;
long i;
struct sort_by_data *data;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
if (RB_TYPE_P(obj, T_ARRAY) && RARRAY_LEN(obj) <= LONG_MAX/2) {
ary = rb_ary_new2(RARRAY_LEN(obj)*2);
}
else {
ary = rb_ary_new();
}
RBASIC_CLEAR_CLASS(ary);
buf = rb_ary_tmp_new(SORT_BY_BUFSIZE*2);
rb_ary_store(buf, SORT_BY_BUFSIZE*2-1, Qnil);
memo = MEMO_NEW(0, 0, 0);
data = (struct sort_by_data *)&memo->v1;
RB_OBJ_WRITE(memo, &data->ary, ary);
RB_OBJ_WRITE(memo, &data->buf, buf);
data->n = 0;
rb_block_call(obj, id_each, 0, 0, sort_by_i, (VALUE)memo);
ary = data->ary;
buf = data->buf;
if (data->n) {
rb_ary_resize(buf, data->n*2);
rb_ary_concat(ary, buf);
}
if (RARRAY_LEN(ary) > 2) {
RARRAY_PTR_USE(ary, ptr,
ruby_qsort(ptr, RARRAY_LEN(ary)/2, 2*sizeof(VALUE),
sort_by_cmp, (void *)ary));
}
if (RBASIC(ary)->klass) {
rb_raise(rb_eRuntimeError, "sort_by reentered");
}
for (i=1; iPattern === element. If the optional block is
supplied, each matching element is passed to it, and the block's
result is stored in the output array.
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
c = IO.constants
c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END]
res = c.grep(/SEEK/) { |v| IO.const_get(v) }
res #=> [0, 1, 2]
;T;[o;=
;3I"
overload;F;40;;,;50;)I"grep(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"@return [Array];T; 0; @ ;!F;6i ;>0;[[I" pattern;T0; @ o;=
;3I"
overload;F;40;;,;50;)I"grep(pattern);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[[I" pattern;T0; @ ; [ ; I"3Returns an array of every element in enum for which
Pattern === element. If the optional block is
supplied, each matching element is passed to it, and the block's
result is stored in the output array.
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
c = IO.constants
c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END]
res = c.grep(/SEEK/) { |v| IO.const_get(v) }
res #=> [0, 1, 2]
@overload grep(pattern)
@return [Array]
@overload grep(pattern)
@yield [obj]
@return [Array];T; 0; @ ;!F;"o;#;$T;%i_;&ip;'@ ;(I"static VALUE
enum_grep(VALUE obj, VALUE pat)
{
VALUE ary = rb_ary_new();
struct MEMO *memo = MEMO_NEW(pat, ary, Qtrue);
rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)memo);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#grep_v;F;[[I"pat;T0;[[@@i;T;: grep_v;0;[ ;{ ;IC; "Inverted version of Enumerable#grep.
Returns an array of every element in enum for which
not Pattern === element.
(1..10).grep_v 2..5 #=> [1, 6, 7, 8, 9, 10]
res =(1..10).grep_v(2..5) { |v| v * 2 }
res #=> [2, 12, 14, 16, 18, 20]
;T;[o;=
;3I"
overload;F;40;;-;50;)I"grep_v(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @M ; [ ; I"@return [Array];T; 0; @M ;!F;6i ;>0;[[I" pattern;T0; @M o;=
;3I"
overload;F;40;;-;50;)I"grep_v(pattern);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @M o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @M ; [ ; I"!@yield [obj]
@return [Array];T; 0; @M ;!F;6i ;>0;[[I" pattern;T0; @M ; [ ; I"Inverted version of Enumerable#grep.
Returns an array of every element in enum for which
not Pattern === element.
(1..10).grep_v 2..5 #=> [1, 6, 7, 8, 9, 10]
res =(1..10).grep_v(2..5) { |v| v * 2 }
res #=> [2, 12, 14, 16, 18, 20]
@overload grep_v(pattern)
@return [Array]
@overload grep_v(pattern)
@yield [obj]
@return [Array];T; 0; @M ;!F;"o;#;$T;%i|;&i;'@ ;(I"static VALUE
enum_grep_v(VALUE obj, VALUE pat)
{
VALUE ary = rb_ary_new();
struct MEMO *memo = MEMO_NEW(pat, ary, Qfalse);
rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)memo);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#count;F;[[@c0;[[@@i;T;:
count;0;[ ;{ ;IC; "_Returns the number of items in +enum+ through enumeration.
If an argument is given, the number of items in +enum+ that
are equal to +item+ are counted. If a block is given, it
counts the number of elements yielding a true value.
ary = [1, 2, 4, 2]
ary.count #=> 4
ary.count(2) #=> 2
ary.count{ |x| x%2==0 } #=> 3
;T;[o;=
;3I"
overload;F;40;;.;50;)I"
count;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ ; [ ; I"@return [Integer];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;.;50;)I"count(item);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ ; [ ; I"@return [Integer];T; 0; @ ;!F;6i ;>0;[[I" item;T0; @ o;=
;3I"
overload;F;40;;.;50;)I"
count;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ ; [ ; I"#@yield [obj]
@return [Integer];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns the number of items in +enum+ through enumeration.
If an argument is given, the number of items in +enum+ that
are equal to +item+ are counted. If a block is given, it
counts the number of elements yielding a true value.
ary = [1, 2, 4, 2]
ary.count #=> 4
ary.count(2) #=> 2
ary.count{ |x| x%2==0 } #=> 3
@overload count
@return [Integer]
@overload count(item)
@return [Integer]
@overload count
@yield [obj]
@return [Integer];T; 0; @ ;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_count(int argc, VALUE *argv, VALUE obj)
{
VALUE item = Qnil;
struct MEMO *memo;
rb_block_call_func *func;
if (argc == 0) {
if (rb_block_given_p()) {
func = count_iter_i;
}
else {
func = count_all_i;
}
}
else {
rb_scan_args(argc, argv, "1", &item);
if (rb_block_given_p()) {
rb_warn("given block not used");
}
func = count_i;
}
memo = MEMO_NEW(item, 0, 0);
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
return imemo_count_value(memo);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#find;F;[[@c0;[[@@i$;T;: find;0;[ ;{ ;IC; "'Passes each entry in enum to block. Returns the
first for which block is not false. If no
object matches, calls ifnone and returns its result when it
is specified, or returns nil otherwise.
If no block is given, an enumerator is returned instead.
(1..100).detect #=> #nil otherwise.
If no block is given, an enumerator is returned instead.
(1..100).detect #=> #nil otherwise.
If no block is given, an enumerator is returned instead.
(1..100).detect #=> #nil
If neither block nor argument is given, an enumerator is returned instead.
(1..10).find_index { |i| i % 5 == 0 && i % 7 == 0 } #=> nil
(1..100).find_index { |i| i % 5 == 0 && i % 7 == 0 } #=> 34
(1..100).find_index(50) #=> 49
;T;[o;=
;3I"
overload;F;40;;1;50;)I"find_index(value);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @^ ; [ ; I"@return [Integer, nil];T; 0; @^ ;!F;6i ;>0;[[I"
value;T0; @^ o;=
;3I"
overload;F;40;;1;50;)I"find_index;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @^ o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @^ ; [ ; I"(@yield [obj]
@return [Integer, nil];T; 0; @^ ;!F;6i ;>0;[ ; @^ o;=
;3I"
overload;F;40;;1;50;)I"find_index;T;IC; " ;T;[ ; [ ; I" ;T; 0; @^ ;!F;6i ;>0;[ ; @^ ; [ ; I"hCompares each entry in enum with value or passes
to block. Returns the index for the first for which the
evaluated value is non-false. If no object matches, returns
nil
If neither block nor argument is given, an enumerator is returned instead.
(1..10).find_index { |i| i % 5 == 0 && i % 7 == 0 } #=> nil
(1..100).find_index { |i| i % 5 == 0 && i % 7 == 0 } #=> 34
(1..100).find_index(50) #=> 49
@overload find_index(value)
@return [Integer, nil]
@overload find_index
@yield [obj]
@return [Integer, nil]
@overload find_index;T; 0; @^ ;!F;"o;#;$T;%iS;&ie;'@ ;(I"Fstatic VALUE
enum_find_index(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo; /* [return value, current index, ] */
VALUE condition_value = Qnil;
rb_block_call_func *func;
if (argc == 0) {
RETURN_ENUMERATOR(obj, 0, 0);
func = find_index_iter_i;
}
else {
rb_scan_args(argc, argv, "1", &condition_value);
if (rb_block_given_p()) {
rb_warn("given block not used");
}
func = find_index_i;
}
memo = MEMO_NEW(Qnil, condition_value, 0);
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#find_all;F;[ ;[[@@i;T;:
find_all;0;[ ;{ ;IC; "Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
The find_all and select methods are aliases.
There is no performance benefit to either.
If no block is given, an Enumerator is returned instead.
(1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9]
[1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
[:foo, :bar].filter { |x| x == :foo } #=> [:foo]
See also Enumerable#reject, Enumerable#grep.
;T;[ o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;: filter;50;)I" filter;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;3;50;)I" filter;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
The find_all and select methods are aliases.
There is no performance benefit to either.
If no block is given, an Enumerator is returned instead.
(1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9]
[1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
[:foo, :bar].filter { |x| x == :foo } #=> [:foo]
See also Enumerable#reject, Enumerable#grep.
@overload find_all
@yield [obj]
@return [Array]
@overload select
@yield [obj]
@return [Array]
@overload filter
@yield [obj]
@return [Array]
@overload find_all
@overload select
@overload filter;T; 0; @ ;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_find_all(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, find_all_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#select;F;[ ;[[@@i;T;;;0;[ ;{ ;IC; "Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
The find_all and select methods are aliases.
There is no performance benefit to either.
If no block is given, an Enumerator is returned instead.
(1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9]
[1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
[:foo, :bar].filter { |x| x == :foo } #=> [:foo]
See also Enumerable#reject, Enumerable#grep.
;T;[ o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;3;50;)I" filter;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;3;50;)I" filter;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; @ ; 0; @ ;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_find_all(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, find_all_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#filter;F;[ ;[[@@i;T;;3;0;[ ;{ ;IC; "Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
The find_all and select methods are aliases.
There is no performance benefit to either.
If no block is given, an Enumerator is returned instead.
(1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9]
[1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
[:foo, :bar].filter { |x| x == :foo } #=> [:foo]
See also Enumerable#reject, Enumerable#grep.
;T;[ o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @O o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @O ; [ ; I"!@yield [obj]
@return [Array];T; 0; @O ;!F;6i ;>0;[ ; @O o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @O o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @O ; [ ; I"!@yield [obj]
@return [Array];T; 0; @O ;!F;6i ;>0;[ ; @O o;=
;3I"
overload;F;40;;3;50;)I" filter;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @O o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @O ; [ ; I"!@yield [obj]
@return [Array];T; 0; @O ;!F;6i ;>0;[ ; @O o;=
;3I"
overload;F;40;;2;50;)I"
find_all;T;IC; " ;T;[ ; [ ; I" ;T; 0; @O ;!F;6i ;>0;[ ; @O o;=
;3I"
overload;F;40;;;50;)I" select;T;IC; " ;T;[ ; [ ; I" ;T; 0; @O ;!F;6i ;>0;[ ; @O o;=
;3I"
overload;F;40;;3;50;)I" filter;T;IC; " ;T;[ ; [ ; I" ;T; 0; @O ;!F;6i ;>0;[ ; @O ; [ ; @ ; 0; @O ;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_find_all(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, find_all_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#filter_map;F;[ ;[[@@i;T;:filter_map;0;[ ;{ ;IC; " Returns a new array containing the truthy results (everything except
+false+ or +nil+) of running the +block+ for every element in +enum+.
If no block is given, an Enumerator is returned instead.
(1..10).filter_map { |i| i * 2 if i.even? } #=> [4, 8, 12, 16, 20]
;T;[o;=
;3I"
overload;F;40;;4;50;)I"filter_map;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;4;50;)I"filter_map;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"ZReturns a new array containing the truthy results (everything except
+false+ or +nil+) of running the +block+ for every element in +enum+.
If no block is given, an Enumerator is returned instead.
(1..10).filter_map { |i| i * 2 if i.even? } #=> [4, 8, 12, 16, 20]
@overload filter_map
@yield [obj]
@return [Array]
@overload filter_map;T; 0; @ ;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_filter_map(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, filter_map_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#reject;F;[ ;[[@@i
;T;: reject;0;[ ;{ ;IC; "=Returns an array for all elements of +enum+ for which the given
+block+ returns false.
If no block is given, an Enumerator is returned instead.
(1..10).reject { |i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10]
[1, 2, 3, 4, 5].reject { |num| num.even? } #=> [1, 3, 5]
See also Enumerable#find_all.
;T;[o;=
;3I"
overload;F;40;;5;50;)I" reject;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;5;50;)I" reject;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns an array for all elements of +enum+ for which the given
+block+ returns false.
If no block is given, an Enumerator is returned instead.
(1..10).reject { |i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10]
[1, 2, 3, 4, 5].reject { |num| num.even? } #=> [1, 3, 5]
See also Enumerable#find_all.
@overload reject
@yield [obj]
@return [Array]
@overload reject;T; 0; @ ;!F;"o;#;$T;%i;&i ;'@ ;(I"static VALUE
enum_reject(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, reject_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#collect;F;[ ;[[@@i;;T;: collect;0;[ ;{ ;IC; "Returns a new array with the results of running block once
for every element in enum.
If no block is given, an enumerator is returned instead.
(1..4).map { |i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
;T;[ o;=
;3I"
overload;F;40;;6;50;)I" collect;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;:map;50;)I"map;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;6;50;)I" collect;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;7;50;)I"map;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns a new array with the results of running block once
for every element in enum.
If no block is given, an enumerator is returned instead.
(1..4).map { |i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
@overload collect
@yield [obj]
@return [Array]
@overload map
@yield [obj]
@return [Array]
@overload collect
@overload map;T; 0; @ ;!F;"o;#;$T;%i*;&i;;'@ ;(I"/static VALUE
enum_collect(VALUE obj)
{
VALUE ary;
int min_argc, max_argc;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
min_argc = rb_block_min_max_arity(&max_argc);
rb_lambda_call(obj, id_each, 0, 0, collect_i, min_argc, max_argc, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#map;F;[ ;[[@@i;;T;;7;0;[ ;{ ;IC; "Returns a new array with the results of running block once
for every element in enum.
If no block is given, an enumerator is returned instead.
(1..4).map { |i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
;T;[ o;=
;3I"
overload;F;40;;6;50;)I" collect;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @< o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @< ; [ ; I"!@yield [obj]
@return [Array];T; 0; @< ;!F;6i ;>0;[ ; @< o;=
;3I"
overload;F;40;;7;50;)I"map;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @< o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @< ; [ ; I"!@yield [obj]
@return [Array];T; 0; @< ;!F;6i ;>0;[ ; @< o;=
;3I"
overload;F;40;;6;50;)I" collect;T;IC; " ;T;[ ; [ ; I" ;T; 0; @< ;!F;6i ;>0;[ ; @< o;=
;3I"
overload;F;40;;7;50;)I"map;T;IC; " ;T;[ ; [ ; I" ;T; 0; @< ;!F;6i ;>0;[ ; @< ; [ ; @8 ; 0; @< ;!F;"o;#;$T;%i*;&i;;'@ ;(I"/static VALUE
enum_collect(VALUE obj)
{
VALUE ary;
int min_argc, max_argc;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
min_argc = rb_block_min_max_arity(&max_argc);
rb_lambda_call(obj, id_each, 0, 0, collect_i, min_argc, max_argc, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#flat_map;F;[ ;[[@@il;T;:
flat_map;0;[ ;{ ;IC; "AReturns a new array with the concatenated results of running
block once for every element in enum.
If no block is given, an enumerator is returned instead.
[1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4]
[[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100]
;T;[ o;=
;3I"
overload;F;40;;8;50;)I"
flat_map;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @} o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @} ; [ ; I"!@yield [obj]
@return [Array];T; 0; @} ;!F;6i ;>0;[ ; @} o;=
;3I"
overload;F;40;:collect_concat;50;)I"collect_concat;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @} o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @} ; [ ; I"!@yield [obj]
@return [Array];T; 0; @} ;!F;6i ;>0;[ ; @} o;=
;3I"
overload;F;40;;8;50;)I"
flat_map;T;IC; " ;T;[ ; [ ; I" ;T; 0; @} ;!F;6i ;>0;[ ; @} o;=
;3I"
overload;F;40;;9;50;)I"collect_concat;T;IC; " ;T;[ ; [ ; I" ;T; 0; @} ;!F;6i ;>0;[ ; @} ; [ ; I"Returns a new array with the concatenated results of running
block once for every element in enum.
If no block is given, an enumerator is returned instead.
[1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4]
[[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100]
@overload flat_map
@yield [obj]
@return [Array]
@overload collect_concat
@yield [obj]
@return [Array]
@overload flat_map
@overload collect_concat;T; 0; @} ;!F;"o;#;$T;%i[;&il;'@ ;(I"static VALUE
enum_flat_map(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, flat_map_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Enumerable#collect_concat;F;[ ;[[@@il;T;;9;0;[ ;{ ;IC; "AReturns a new array with the concatenated results of running
block once for every element in enum.
If no block is given, an enumerator is returned instead.
[1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4]
[[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100]
;T;[ o;=
;3I"
overload;F;40;;8;50;)I"
flat_map;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;9;50;)I"collect_concat;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @ ; [ ; I"!@yield [obj]
@return [Array];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;8;50;)I"
flat_map;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;9;50;)I"collect_concat;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; @ ; 0; @ ;!F;"o;#;$T;%i[;&il;'@ ;(I"static VALUE
enum_flat_map(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, flat_map_i, ary);
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#inject;F;[[@c0;[[@@iM;T;: inject;0;[ ;{ ;IC; "ICombines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
The inject and reduce methods are aliases. There
is no performance benefit to either.
If you specify a block, then for each element in enum
the block is passed an accumulator value (memo) and the element.
If you specify a symbol instead, then each element in the collection
will be passed to the named method of memo.
In either case, the result becomes the new value for memo.
At the end of the iteration, the final value of memo is the
return value for the method.
If you do not explicitly specify an initial value for memo,
then the first element of collection is used as the initial value
of memo.
# Sum some numbers
(5..10).reduce(:+) #=> 45
# Same using a block and inject
(5..10).inject { |sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).reduce(1, :*) #=> 151200
# Same using a block
(5..10).inject(1) { |product, n| product * n } #=> 151200
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo, word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
;T;[
o;=
;3I"
overload;F;40;;:;50;)I"inject(initial, sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0[I"sym;T0; @ o;=
;3I"
overload;F;40;;:;50;)I"inject(sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I"sym;T0; @ o;=
;3I"
overload;F;40;;:;50;)I"inject(initial);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0; @ o;=
;3I"
overload;F;40;;:;50;)I" inject;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;: reduce;50;)I"reduce(initial, sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0[I"sym;T0; @ o;=
;3I"
overload;F;40;;;;50;)I"reduce(sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I"sym;T0; @ o;=
;3I"
overload;F;40;;;;50;)I"reduce(initial);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0; @ o;=
;3I"
overload;F;40;;;;50;)I" reduce;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Combines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
The inject and reduce methods are aliases. There
is no performance benefit to either.
If you specify a block, then for each element in enum
the block is passed an accumulator value (memo) and the element.
If you specify a symbol instead, then each element in the collection
will be passed to the named method of memo.
In either case, the result becomes the new value for memo.
At the end of the iteration, the final value of memo is the
return value for the method.
If you do not explicitly specify an initial value for memo,
then the first element of collection is used as the initial value
of memo.
# Sum some numbers
(5..10).reduce(:+) #=> 45
# Same using a block and inject
(5..10).inject { |sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).reduce(1, :*) #=> 151200
# Same using a block
(5..10).inject(1) { |product, n| product * n } #=> 151200
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo, word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
@overload inject(initial, sym)
@return [Object]
@overload inject(sym)
@return [Object]
@overload inject(initial)
@yield [memo, obj]
@return [Object]
@overload inject
@yield [memo, obj]
@return [Object]
@overload reduce(initial, sym)
@return [Object]
@overload reduce(sym)
@return [Object]
@overload reduce(initial)
@yield [memo, obj]
@return [Object]
@overload reduce
@yield [memo, obj]
@return [Object];T; 0; @ ;!F;"o;#;$T;%i ;&iV;'@ ;(I"static VALUE
enum_inject(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
VALUE init, op;
rb_block_call_func *iter = inject_i;
ID id;
switch (rb_scan_args(argc, argv, "02", &init, &op)) {
case 0:
init = Qundef;
break;
case 1:
if (rb_block_given_p()) {
break;
}
id = rb_check_id(&init);
op = id ? ID2SYM(id) : init;
init = Qundef;
iter = inject_op_i;
break;
case 2:
if (rb_block_given_p()) {
rb_warning("given block not used");
}
id = rb_check_id(&op);
if (id) op = ID2SYM(id);
iter = inject_op_i;
break;
}
if (iter == inject_op_i &&
SYMBOL_P(op) &&
RB_TYPE_P(obj, T_ARRAY) &&
rb_method_basic_definition_p(CLASS_OF(obj), id_each)) {
return ary_inject_op(obj, init, op);
}
memo = MEMO_NEW(init, Qnil, op);
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
if (memo->v1 == Qundef) return Qnil;
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#reduce;F;[[@c0;[[@@iM;T;;;;0;[ ;{ ;IC; "ICombines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
The inject and reduce methods are aliases. There
is no performance benefit to either.
If you specify a block, then for each element in enum
the block is passed an accumulator value (memo) and the element.
If you specify a symbol instead, then each element in the collection
will be passed to the named method of memo.
In either case, the result becomes the new value for memo.
At the end of the iteration, the final value of memo is the
return value for the method.
If you do not explicitly specify an initial value for memo,
then the first element of collection is used as the initial value
of memo.
# Sum some numbers
(5..10).reduce(:+) #=> 45
# Same using a block and inject
(5..10).inject { |sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).reduce(1, :*) #=> 151200
# Same using a block
(5..10).inject(1) { |product, n| product * n } #=> 151200
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo, word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
;T;[
o;=
;3I"
overload;F;40;;:;50;)I"inject(initial, sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0[I"sym;T0; @ o;=
;3I"
overload;F;40;;:;50;)I"inject(sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I"sym;T0; @ o;=
;3I"
overload;F;40;;:;50;)I"inject(initial);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0; @ o;=
;3I"
overload;F;40;;:;50;)I" inject;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;;50;)I"reduce(initial, sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0[I"sym;T0; @ o;=
;3I"
overload;F;40;;;;50;)I"reduce(sym);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"@return [Object];T; 0; @ ;!F;6i ;>0;[[I"sym;T0; @ o;=
;3I"
overload;F;40;;;;50;)I"reduce(initial);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[[I" initial;T0; @ o;=
;3I"
overload;F;40;;;;50;)I" reduce;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" memo;TI"obj;T; @ o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @ ; [ ; I"(@yield [memo, obj]
@return [Object];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; @ ; 0; @ ;!F;"o;#;$T;%i ;&iV;'@ ;(I"static VALUE
enum_inject(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
VALUE init, op;
rb_block_call_func *iter = inject_i;
ID id;
switch (rb_scan_args(argc, argv, "02", &init, &op)) {
case 0:
init = Qundef;
break;
case 1:
if (rb_block_given_p()) {
break;
}
id = rb_check_id(&init);
op = id ? ID2SYM(id) : init;
init = Qundef;
iter = inject_op_i;
break;
case 2:
if (rb_block_given_p()) {
rb_warning("given block not used");
}
id = rb_check_id(&op);
if (id) op = ID2SYM(id);
iter = inject_op_i;
break;
}
if (iter == inject_op_i &&
SYMBOL_P(op) &&
RB_TYPE_P(obj, T_ARRAY) &&
rb_method_basic_definition_p(CLASS_OF(obj), id_each)) {
return ary_inject_op(obj, init, op);
}
memo = MEMO_NEW(init, Qnil, op);
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
if (memo->v1 == Qundef) return Qnil;
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#partition;F;[ ;[[@@i;T;:partition;0;[ ;{ ;IC; "Returns two arrays, the first containing the elements of
enum for which the block evaluates to true, the second
containing the rest.
If no block is given, an enumerator is returned instead.
(1..6).partition { |v| v.even? } #=> [[2, 4, 6], [1, 3, 5]]
;T;[o;=
;3I"
overload;F;40;;<;50;)I"partition;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @=!o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @=!; [ ; I"!@yield [obj]
@return [Array];T; 0; @=!;!F;6i ;>0;[ ; @=!o;=
;3I"
overload;F;40;;<;50;)I"partition;T;IC; " ;T;[ ; [ ; I" ;T; 0; @=!;!F;6i ;>0;[ ; @=!; [ ; I"RReturns two arrays, the first containing the elements of
enum for which the block evaluates to true, the second
containing the rest.
If no block is given, an enumerator is returned instead.
(1..6).partition { |v| v.even? } #=> [[2, 4, 6], [1, 3, 5]]
@overload partition
@yield [obj]
@return [Array]
@overload partition;T; 0; @=!;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_partition(VALUE obj)
{
struct MEMO *memo;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
memo = MEMO_NEW(rb_ary_new(), rb_ary_new(), 0);
rb_block_call(obj, id_each, 0, 0, partition_i, (VALUE)memo);
return rb_assoc_new(memo->v1, memo->v2);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#group_by;F;[ ;[[@@i;T;:
group_by;0;[ ;{ ;IC; "AGroups the collection by result of the block. Returns a hash where the
keys are the evaluated result from the block and the values are
arrays of elements in the collection that correspond to the key.
If no block is given an enumerator is returned.
(1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
;T;[o;=
;3I"
overload;F;40;;=;50;)I"
group_by;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @e!o;2
;3I" return;F;4I" ;T;0;5[I" Hash;T; @e!; [ ; I" @yield [obj]
@return [Hash];T; 0; @e!;!F;6i ;>0;[ ; @e!o;=
;3I"
overload;F;40;;=;50;)I"
group_by;T;IC; " ;T;[ ; [ ; I" ;T; 0; @e!;!F;6i ;>0;[ ; @e!; [ ; I"Groups the collection by result of the block. Returns a hash where the
keys are the evaluated result from the block and the values are
arrays of elements in the collection that correspond to the key.
If no block is given an enumerator is returned.
(1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
@overload group_by
@yield [obj]
@return [Hash]
@overload group_by;T; 0; @e!;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_group_by(VALUE obj)
{
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
return enum_hashify(obj, 0, 0, group_by_i);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#tally;F;[ ;[[@@i;T;:
tally;0;[ ;{ ;IC; "Tallies the collection, i.e., counts the occurrences of each element.
Returns a hash with the elements of the collection as keys and the
corresponding counts as values.
["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1}
;T;[o;=
;3I"
overload;F;40;;>;50;)I"
tally;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Hash;T; @!; [ ; I"@return [Hash];T; 0; @!;!F;6i ;>0;[ ; @!; [ ; I"Tallies the collection, i.e., counts the occurrences of each element.
Returns a hash with the elements of the collection as keys and the
corresponding counts as values.
["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1}
@overload tally
@return [Hash];T; 0; @!;!F;"o;#;$T;%i;&i;'@ ;(I"Xstatic VALUE
enum_tally(VALUE obj)
{
return enum_hashify(obj, 0, 0, tally_i);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#first;F;[[@c0;[[@@i;T;:
first;0;[ ;{ ;IC; "Returns the first element, or the first +n+ elements, of the enumerable.
If the enumerable is empty, the first form returns nil, and the
second form returns an empty array.
%w[foo bar baz].first #=> "foo"
%w[foo bar baz].first(2) #=> ["foo", "bar"]
%w[foo bar baz].first(10) #=> ["foo", "bar", "baz"]
[].first #=> nil
[].first(10) #=> []
;T;[o;=
;3I"
overload;F;40;;?;50;)I"
first;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;TI"nil;T; @!; [ ; I"@return [Object, nil];T; 0; @!;!F;6i ;>0;[ ; @!o;=
;3I"
overload;F;40;;?;50;)I"
first(n);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @!; [ ; I"@return [Array];T; 0; @!;!F;6i ;>0;[[I"n;T0; @!; [ ; I"Returns the first element, or the first +n+ elements, of the enumerable.
If the enumerable is empty, the first form returns nil, and the
second form returns an empty array.
%w[foo bar baz].first #=> "foo"
%w[foo bar baz].first(2) #=> ["foo", "bar"]
%w[foo bar baz].first(10) #=> ["foo", "bar", "baz"]
[].first #=> nil
[].first(10) #=> []
@overload first
@return [Object, nil]
@overload first(n)
@return [Array];T; 0; @!;!F;"o;#;$T;%i;&i;'@ ;(I"*static VALUE
enum_first(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
rb_check_arity(argc, 0, 1);
if (argc > 0) {
return enum_take(obj, argv[0]);
}
else {
memo = MEMO_NEW(Qnil, 0, 0);
rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo);
return memo->v1;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#all?;F;[[@c0;[[@@i>;T;: all?;0;[ ;{ ;IC; "LPasses each element of the collection to the given block. The method
returns true if the block never returns
false or nil. If the block is not given,
Ruby adds an implicit block of { |obj| obj } which will
cause #all? to return +true+ when none of the collection members are
+false+ or +nil+.
If instead a pattern is supplied, the method returns whether
pattern === element for every collection member.
%w[ant bear cat].all? { |word| word.length >= 3 } #=> true
%w[ant bear cat].all? { |word| word.length >= 4 } #=> false
%w[ant bear cat].all?(/t/) #=> false
[1, 2i, 3.14].all?(Numeric) #=> true
[nil, true, 99].all? #=> false
[].all? #=> true;T;[o;=
;3I"
overload;F;40;;@;50;)I" all?;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @!o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @!; [ ; I"#@yield [obj]
@return [Boolean];T; 0; @!;!F;6i ;>0;[ ; @!o;=
;3I"
overload;F;40;;@;50;)I"all?(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @!; [ ; I"@return [Boolean];T; 0; @!;!F;6i ;>0;[[I" pattern;T0; @!; [ ; I"Passes each element of the collection to the given block. The method
returns true if the block never returns
false or nil. If the block is not given,
Ruby adds an implicit block of { |obj| obj } which will
cause #all? to return +true+ when none of the collection members are
+false+ or +nil+.
If instead a pattern is supplied, the method returns whether
pattern === element for every collection member.
%w[ant bear cat].all? { |word| word.length >= 3 } #=> true
%w[ant bear cat].all? { |word| word.length >= 4 } #=> false
%w[ant bear cat].all?(/t/) #=> false
[1, 2i, 3.14].all?(Numeric) #=> true
[nil, true, 99].all? #=> false
[].all? #=> true
@overload all?
@yield [obj]
@return [Boolean]
@overload all?(pattern)
@return [Boolean];T; 0; @!;!F;"o;#;$T;%i&;&i=;6i ;'@ ;(I"static VALUE
enum_all(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);
WARN_UNUSED_BLOCK(argc);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(all), (VALUE)memo);
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#any?;F;[[@c0;[[@@ih;T;: any?;0;[ ;{ ;IC; "cPasses each element of the collection to the given block. The method
returns true if the block ever returns a value other
than false or nil. If the block is not
given, Ruby adds an implicit block of { |obj| obj } that
will cause #any? to return +true+ if at least one of the collection
members is not +false+ or +nil+.
If instead a pattern is supplied, the method returns whether
pattern === element for any collection member.
%w[ant bear cat].any? { |word| word.length >= 3 } #=> true
%w[ant bear cat].any? { |word| word.length >= 4 } #=> true
%w[ant bear cat].any?(/d/) #=> false
[nil, true, 99].any?(Integer) #=> true
[nil, true, 99].any? #=> true
[].any? #=> false;T;[o;=
;3I"
overload;F;40;;A;50;)I" any?;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @"o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @"; [ ; I"#@yield [obj]
@return [Boolean];T; 0; @";!F;6i ;>0;[ ; @"o;=
;3I"
overload;F;40;;A;50;)I"any?(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @"; [ ; I"@return [Boolean];T; 0; @";!F;6i ;>0;[[I" pattern;T0; @"; [ ; I"Passes each element of the collection to the given block. The method
returns true if the block ever returns a value other
than false or nil. If the block is not
given, Ruby adds an implicit block of { |obj| obj } that
will cause #any? to return +true+ if at least one of the collection
members is not +false+ or +nil+.
If instead a pattern is supplied, the method returns whether
pattern === element for any collection member.
%w[ant bear cat].any? { |word| word.length >= 3 } #=> true
%w[ant bear cat].any? { |word| word.length >= 4 } #=> true
%w[ant bear cat].any?(/d/) #=> false
[nil, true, 99].any?(Integer) #=> true
[nil, true, 99].any? #=> true
[].any? #=> false
@overload any?
@yield [obj]
@return [Boolean]
@overload any?(pattern)
@return [Boolean];T; 0; @";!F;"o;#;$T;%iP;&ig;6i ;'@ ;(I"static VALUE
enum_any(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo = MEMO_ENUM_NEW(Qfalse);
WARN_UNUSED_BLOCK(argc);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(any), (VALUE)memo);
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#one?;F;[[@c0;[[@@iu;T;: one?;0;[ ;{ ;IC; "Passes each element of the collection to the given block. The method
returns true if the block returns true
exactly once. If the block is not given, one? will return
true only if exactly one of the collection members is
true.
If instead a pattern is supplied, the method returns whether
pattern === element for exactly one collection member.
%w{ant bear cat}.one? { |word| word.length == 4 } #=> true
%w{ant bear cat}.one? { |word| word.length > 4 } #=> false
%w{ant bear cat}.one? { |word| word.length < 4 } #=> false
%w{ant bear cat}.one?(/t/) #=> false
[ nil, true, 99 ].one? #=> false
[ nil, true, false ].one? #=> true
[ nil, true, 99 ].one?(Integer) #=> true
[].one? #=> false;T;[o;=
;3I"
overload;F;40;;B;50;)I" one?;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @4"o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @4"; [ ; I"#@yield [obj]
@return [Boolean];T; 0; @4";!F;6i ;>0;[ ; @4"o;=
;3I"
overload;F;40;;B;50;)I"one?(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @4"; [ ; I"@return [Boolean];T; 0; @4";!F;6i ;>0;[[I" pattern;T0; @4"; [ ; I"Passes each element of the collection to the given block. The method
returns true if the block returns true
exactly once. If the block is not given, one? will return
true only if exactly one of the collection members is
true.
If instead a pattern is supplied, the method returns whether
pattern === element for exactly one collection member.
%w{ant bear cat}.one? { |word| word.length == 4 } #=> true
%w{ant bear cat}.one? { |word| word.length > 4 } #=> false
%w{ant bear cat}.one? { |word| word.length < 4 } #=> false
%w{ant bear cat}.one?(/t/) #=> false
[ nil, true, 99 ].one? #=> false
[ nil, true, false ].one? #=> true
[ nil, true, 99 ].one?(Integer) #=> true
[].one? #=> false
@overload one?
@yield [obj]
@return [Boolean]
@overload one?(pattern)
@return [Boolean];T; 0; @4";!F;"o;#;$T;%i];&iu;6i ;'@ ;(I"0static VALUE
enum_one(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo = MEMO_ENUM_NEW(Qundef);
VALUE result;
WARN_UNUSED_BLOCK(argc);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(one), (VALUE)memo);
result = memo->v1;
if (result == Qundef) return Qfalse;
return result;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#none?;F;[[@c0;[[@@i;T;:
none?;0;[ ;{ ;IC; "Passes each element of the collection to the given block. The method
returns true if the block never returns true
for all elements. If the block is not given, none? will return
true only if none of the collection members is true.
If instead a pattern is supplied, the method returns whether
pattern === element for none of the collection members.
%w{ant bear cat}.none? { |word| word.length == 5 } #=> true
%w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
%w{ant bear cat}.none?(/d/) #=> true
[1, 3.14, 42].none?(Float) #=> false
[].none? #=> true
[nil].none? #=> true
[nil, false].none? #=> true
[nil, false, true].none? #=> false;T;[o;=
;3I"
overload;F;40;;C;50;)I"
none?;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @d"o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @d"; [ ; I"#@yield [obj]
@return [Boolean];T; 0; @d";!F;6i ;>0;[ ; @d"o;=
;3I"
overload;F;40;;C;50;)I"none?(pattern);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @d"; [ ; I"@return [Boolean];T; 0; @d";!F;6i ;>0;[[I" pattern;T0; @d"; [ ; I"Passes each element of the collection to the given block. The method
returns true if the block never returns true
for all elements. If the block is not given, none? will return
true only if none of the collection members is true.
If instead a pattern is supplied, the method returns whether
pattern === element for none of the collection members.
%w{ant bear cat}.none? { |word| word.length == 5 } #=> true
%w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
%w{ant bear cat}.none?(/d/) #=> true
[1, 3.14, 42].none?(Float) #=> false
[].none? #=> true
[nil].none? #=> true
[nil, false].none? #=> true
[nil, false, true].none? #=> false
@overload none?
@yield [obj]
@return [Boolean]
@overload none?(pattern)
@return [Boolean];T; 0; @d";!F;"o;#;$T;%i;&i;6i ;'@ ;(I"static VALUE
enum_none(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);
WARN_UNUSED_BLOCK(argc);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(none), (VALUE)memo);
return memo->v1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#min;F;[[@c0;[[@@i;T;:min;0;[ ;{ ;IC; "jReturns the object in _enum_ with the minimum value. The
first form assumes all objects implement Comparable;
the second uses the block to return a <=> b.
a = %w(albatross dog horse)
a.min #=> "albatross"
a.min { |a, b| a.length <=> b.length } #=> "dog"
If the +n+ argument is given, minimum +n+ elements are returned
as a sorted array.
a = %w[albatross dog horse]
a.min(2) #=> ["albatross", "dog"]
a.min(2) {|a, b| a.length <=> b.length } #=> ["dog", "horse"]
[5, 1, 3, 4, 2].min(3) #=> [1, 2, 3]
;T;[ o;=
;3I"
overload;F;40;;D;50;)I"min;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @"; [ ; I"@return [Object];T; 0; @";!F;6i ;>0;[ ; @"o;=
;3I"
overload;F;40;;D;50;)I"min;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @"o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @"; [ ; I"#@yield [a, b]
@return [Object];T; 0; @";!F;6i ;>0;[ ; @"o;=
;3I"
overload;F;40;;D;50;)I" min(n);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @"; [ ; I"@return [Array];T; 0; @";!F;6i ;>0;[[I"n;T0; @"o;=
;3I"
overload;F;40;;D;50;)I" min(n);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @"o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @"; [ ; I""@yield [a, b]
@return [Array];T; 0; @";!F;6i ;>0;[[I"n;T0; @"; [ ; I"Returns the object in _enum_ with the minimum value. The
first form assumes all objects implement Comparable;
the second uses the block to return a <=> b.
a = %w(albatross dog horse)
a.min #=> "albatross"
a.min { |a, b| a.length <=> b.length } #=> "dog"
If the +n+ argument is given, minimum +n+ elements are returned
as a sorted array.
a = %w[albatross dog horse]
a.min(2) #=> ["albatross", "dog"]
a.min(2) {|a, b| a.length <=> b.length } #=> ["dog", "horse"]
[5, 1, 3, 4, 2].min(3) #=> [1, 2, 3]
@overload min
@return [Object]
@overload min
@yield [a, b]
@return [Object]
@overload min(n)
@return [Array]
@overload min(n)
@yield [a, b]
@return [Array];T; 0; @";!F;"o;#;$T;%i;&i;'@ ;(I"Pstatic VALUE
enum_min(int argc, VALUE *argv, VALUE obj)
{
VALUE memo;
struct min_t *m = NEW_CMP_OPT_MEMO(struct min_t, memo);
VALUE result;
VALUE num;
if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
return rb_nmin_run(obj, num, 0, 0, 0);
m->min = Qundef;
m->cmp_opt.opt_methods = 0;
m->cmp_opt.opt_inited = 0;
if (rb_block_given_p()) {
rb_block_call(obj, id_each, 0, 0, min_ii, memo);
}
else {
rb_block_call(obj, id_each, 0, 0, min_i, memo);
}
result = m->min;
if (result == Qundef) return Qnil;
return result;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#max;F;[[@c0;[[@@iK;T;:max;0;[ ;{ ;IC; "Returns the object in _enum_ with the maximum value. The
first form assumes all objects implement Comparable;
the second uses the block to return a <=> b.
a = %w(albatross dog horse)
a.max #=> "horse"
a.max { |a, b| a.length <=> b.length } #=> "albatross"
If the +n+ argument is given, maximum +n+ elements are returned
as an array, sorted in descending order.
a = %w[albatross dog horse]
a.max(2) #=> ["horse", "dog"]
a.max(2) {|a, b| a.length <=> b.length } #=> ["albatross", "horse"]
[5, 1, 3, 4, 2].max(3) #=> [5, 4, 3]
;T;[ o;=
;3I"
overload;F;40;;E;50;)I"max;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @"; [ ; I"@return [Object];T; 0; @";!F;6i ;>0;[ ; @"o;=
;3I"
overload;F;40;;E;50;)I"max;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @"o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @"; [ ; I"#@yield [a, b]
@return [Object];T; 0; @";!F;6i ;>0;[ ; @"o;=
;3I"
overload;F;40;;E;50;)I" max(n);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @"; [ ; I"@return [Array];T; 0; @";!F;6i ;>0;[[I"n;T0; @"o;=
;3I"
overload;F;40;;E;50;)I" max(n);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @"o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @"; [ ; I""@yield [a, b]
@return [Array];T; 0; @";!F;6i ;>0;[[I"n;T0; @"; [ ; I".Returns the object in _enum_ with the maximum value. The
first form assumes all objects implement Comparable;
the second uses the block to return a <=> b.
a = %w(albatross dog horse)
a.max #=> "horse"
a.max { |a, b| a.length <=> b.length } #=> "albatross"
If the +n+ argument is given, maximum +n+ elements are returned
as an array, sorted in descending order.
a = %w[albatross dog horse]
a.max(2) #=> ["horse", "dog"]
a.max(2) {|a, b| a.length <=> b.length } #=> ["albatross", "horse"]
[5, 1, 3, 4, 2].max(3) #=> [5, 4, 3]
@overload max
@return [Object]
@overload max
@yield [a, b]
@return [Object]
@overload max(n)
@return [Array]
@overload max(n)
@yield [a, b]
@return [Array];T; 0; @";!F;"o;#;$T;%i3;&iM;'@ ;(I"^static VALUE
enum_max(int argc, VALUE *argv, VALUE obj)
{
VALUE memo;
struct max_t *m = NEW_CMP_OPT_MEMO(struct max_t, memo);
VALUE result;
VALUE num;
if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
return rb_nmin_run(obj, num, 0, 1, 0);
m->max = Qundef;
m->cmp_opt.opt_methods = 0;
m->cmp_opt.opt_inited = 0;
if (rb_block_given_p()) {
rb_block_call(obj, id_each, 0, 0, max_ii, (VALUE)memo);
}
else {
rb_block_call(obj, id_each, 0, 0, max_i, (VALUE)memo);
}
result = m->max;
if (result == Qundef) return Qnil;
return result;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#minmax;F;[ ;[[@@i;T;: minmax;0;[ ;{ ;IC; "}Returns a two element array which contains the minimum and the
maximum value in the enumerable. The first form assumes all
objects implement Comparable; the second uses the
block to return a <=> b.
a = %w(albatross dog horse)
a.minmax #=> ["albatross", "horse"]
a.minmax { |a, b| a.length <=> b.length } #=> ["dog", "albatross"]
;T;[o;=
;3I"
overload;F;40;;F;50;)I" minmax;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @:#; [ ; I"@return [Array];T; 0; @:#;!F;6i ;>0;[ ; @:#o;=
;3I"
overload;F;40;;F;50;)I" minmax;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"a;TI"b;T; @:#o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @:#; [ ; I""@yield [a, b]
@return [Array];T; 0; @:#;!F;6i ;>0;[ ; @:#; [ ; I"Returns a two element array which contains the minimum and the
maximum value in the enumerable. The first form assumes all
objects implement Comparable; the second uses the
block to return a <=> b.
a = %w(albatross dog horse)
a.minmax #=> ["albatross", "horse"]
a.minmax { |a, b| a.length <=> b.length } #=> ["dog", "albatross"]
@overload minmax
@return [Array]
@overload minmax
@yield [a, b]
@return [Array];T; 0; @:#;!F;"o;#;$T;%i;&i;'@ ;(I"vstatic VALUE
enum_minmax(VALUE obj)
{
VALUE memo;
struct minmax_t *m = NEW_CMP_OPT_MEMO(struct minmax_t, memo);
m->min = Qundef;
m->last = Qundef;
m->cmp_opt.opt_methods = 0;
m->cmp_opt.opt_inited = 0;
if (rb_block_given_p()) {
rb_block_call(obj, id_each, 0, 0, minmax_ii, memo);
if (m->last != Qundef)
minmax_ii_update(m->last, m->last, m);
}
else {
rb_block_call(obj, id_each, 0, 0, minmax_i, memo);
if (m->last != Qundef)
minmax_i_update(m->last, m->last, m);
}
if (m->min != Qundef) {
return rb_assoc_new(m->min, m->max);
}
return rb_assoc_new(Qnil, Qnil);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#min_by;F;[[@c0;[[@@i(;T;: min_by;0;[ ;{ ;IC; "Returns the object in enum that gives the minimum
value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.min_by { |x| x.length } #=> "dog"
If the +n+ argument is given, minimum +n+ elements are returned
as an array. These +n+ elements are sorted by the value from the
given block.
a = %w[albatross dog horse]
p a.min_by(2) {|x| x.length } #=> ["dog", "horse"]
;T;[ o;=
;3I"
overload;F;40;;G;50;)I" min_by;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @h#o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @h#; [ ; I""@yield [obj]
@return [Object];T; 0; @h#;!F;6i ;>0;[ ; @h#o;=
;3I"
overload;F;40;;G;50;)I" min_by;T;IC; " ;T;[ ; [ ; I" ;T; 0; @h#;!F;6i ;>0;[ ; @h#o;=
;3I"
overload;F;40;;G;50;)I"min_by(n);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @h#o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @h#; [ ; I"!@yield [obj]
@return [Array];T; 0; @h#;!F;6i ;>0;[[I"n;T0; @h#o;=
;3I"
overload;F;40;;G;50;)I"min_by(n);T;IC; " ;T;[ ; [ ; I" ;T; 0; @h#;!F;6i ;>0;[[I"n;T0; @h#; [ ; I"KReturns the object in enum that gives the minimum
value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.min_by { |x| x.length } #=> "dog"
If the +n+ argument is given, minimum +n+ elements are returned
as an array. These +n+ elements are sorted by the value from the
given block.
a = %w[albatross dog horse]
p a.min_by(2) {|x| x.length } #=> ["dog", "horse"]
@overload min_by
@yield [obj]
@return [Object]
@overload min_by
@overload min_by(n)
@yield [obj]
@return [Array]
@overload min_by(n);T; 0; @h#;!F;"o;#;$T;%i;&i(;'@ ;(I"static VALUE
enum_min_by(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
VALUE num;
rb_check_arity(argc, 0, 1);
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
if (argc && !NIL_P(num = argv[0]))
return rb_nmin_run(obj, num, 1, 0, 0);
memo = MEMO_NEW(Qundef, Qnil, 0);
rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo);
return memo->v2;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#max_by;F;[[@c0;[[@@i;T;: max_by;0;[ ;{ ;IC; "Returns the object in enum that gives the maximum
value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.max_by { |x| x.length } #=> "albatross"
If the +n+ argument is given, maximum +n+ elements are returned
as an array. These +n+ elements are sorted by the value from the
given block, in descending order.
a = %w[albatross dog horse]
a.max_by(2) {|x| x.length } #=> ["albatross", "horse"]
enum.max_by(n) can be used to implement weighted random sampling.
Following example implements and use Enumerable#wsample.
module Enumerable
# weighted random sampling.
#
# Pavlos S. Efraimidis, Paul G. Spirakis
# Weighted random sampling with a reservoir
# Information Processing Letters
# Volume 97, Issue 5 (16 March 2006)
def wsample(n)
self.max_by(n) {|v| rand ** (1.0/yield(v)) }
end
end
e = (-20..20).to_a*10000
a = e.wsample(20000) {|x|
Math.exp(-(x/5.0)**2) # normal distribution
}
# a is 20000 samples from e.
p a.length #=> 20000
h = a.group_by {|x| x }
-10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] }
#=> *
# ***
# ******
# ***********
# ******************
# *****************************
# *****************************************
# ****************************************************
# ***************************************************************
# ********************************************************************
# ***********************************************************************
# ***********************************************************************
# **************************************************************
# ****************************************************
# ***************************************
# ***************************
# ******************
# ***********
# *******
# ***
# *
;T;[ o;=
;3I"
overload;F;40;;H;50;)I" max_by;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @#o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @#; [ ; I""@yield [obj]
@return [Object];T; 0; @#;!F;6i ;>0;[ ; @#o;=
;3I"
overload;F;40;;H;50;)I" max_by;T;IC; " ;T;[ ; [ ; I" ;T; 0; @#;!F;6i ;>0;[ ; @#o;=
;3I"
overload;F;40;;H;50;)I"max_by(n);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @#o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @#; [ ; I""@yield [obj]
@return [Object];T; 0; @#;!F;6i ;>0;[[I"n;T0; @#o;=
;3I"
overload;F;40;;H;50;)I"max_by(n);T;IC; " ;T;[ ; [ ; I" ;T; 0; @#;!F;6i ;>0;[[I"n;T0; @#; [ ; I"gReturns the object in enum that gives the maximum
value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.max_by { |x| x.length } #=> "albatross"
If the +n+ argument is given, maximum +n+ elements are returned
as an array. These +n+ elements are sorted by the value from the
given block, in descending order.
a = %w[albatross dog horse]
a.max_by(2) {|x| x.length } #=> ["albatross", "horse"]
enum.max_by(n) can be used to implement weighted random sampling.
Following example implements and use Enumerable#wsample.
module Enumerable
# weighted random sampling.
#
# Pavlos S. Efraimidis, Paul G. Spirakis
# Weighted random sampling with a reservoir
# Information Processing Letters
# Volume 97, Issue 5 (16 March 2006)
def wsample(n)
self.max_by(n) {|v| rand ** (1.0/yield(v)) }
end
end
e = (-20..20).to_a*10000
a = e.wsample(20000) {|x|
Math.exp(-(x/5.0)**2) # normal distribution
}
# a is 20000 samples from e.
p a.length #=> 20000
h = a.group_by {|x| x }
-10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] }
#=> *
# ***
# ******
# ***********
# ******************
# *****************************
# *****************************************
# ****************************************************
# ***************************************************************
# ********************************************************************
# ***********************************************************************
# ***********************************************************************
# **************************************************************
# ****************************************************
# ***************************************
# ***************************
# ******************
# ***********
# *******
# ***
# *
@overload max_by
@yield [obj]
@return [Object]
@overload max_by
@overload max_by(n)
@yield [obj]
@return [Object]
@overload max_by(n);T; 0; @#;!F;"o;#;$T;%iO;&i;'@ ;(I"static VALUE
enum_max_by(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
VALUE num;
rb_check_arity(argc, 0, 1);
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
if (argc && !NIL_P(num = argv[0]))
return rb_nmin_run(obj, num, 1, 1, 0);
memo = MEMO_NEW(Qundef, Qnil, 0);
rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo);
return memo->v2;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#minmax_by;F;[ ;[[@@i;T;:minmax_by;0;[ ;{ ;IC; "+Returns a two element array containing the objects in
enum that correspond to the minimum and maximum values respectively
from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.minmax_by { |x| x.length } #=> ["dog", "albatross"]
;T;[o;=
;3I"
overload;F;40;;I;50;)I"minmax_by;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @#o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @#; [ ; I"!@yield [obj]
@return [Array];T; 0; @#;!F;6i ;>0;[ ; @#o;=
;3I"
overload;F;40;;I;50;)I"minmax_by;T;IC; " ;T;[ ; [ ; I" ;T; 0; @#;!F;6i ;>0;[ ; @#; [ ; I"vReturns a two element array containing the objects in
enum that correspond to the minimum and maximum values respectively
from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse)
a.minmax_by { |x| x.length } #=> ["dog", "albatross"]
@overload minmax_by
@yield [obj]
@return [Array]
@overload minmax_by;T; 0; @#;!F;"o;#;$T;%i;&i;'@ ;(I".static VALUE
enum_minmax_by(VALUE obj)
{
VALUE memo;
struct minmax_by_t *m = NEW_MEMO_FOR(struct minmax_by_t, memo);
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
m->min_bv = Qundef;
m->max_bv = Qundef;
m->min = Qnil;
m->max = Qnil;
m->last_bv = Qundef;
m->last = Qundef;
rb_block_call(obj, id_each, 0, 0, minmax_by_i, memo);
if (m->last_bv != Qundef)
minmax_by_i_update(m->last_bv, m->last_bv, m->last, m->last, m);
m = MEMO_FOR(struct minmax_by_t, memo);
return rb_assoc_new(m->min, m->max);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#member?;F;[[I"val;T0;[[@@i- ;T;: member?;0;[ ;{ ;IC; "Returns true if any member of enum equals
obj. Equality is tested using ==.
(1..10).include? 5 #=> true
(1..10).include? 15 #=> false
(1..10).member? 5 #=> true
(1..10).member? 15 #=> false;T;[o;=
;3I"
overload;F;40;:
include?;50;)I"include?(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ $; [ ; I"@return [Boolean];T; 0; @ $;!F;6i ;>0;[[I"obj;T0; @ $o;=
;3I"
overload;F;40;;J;50;)I"member?(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ $; [ ; I"@return [Boolean];T; 0; @ $;!F;6i ;>0;[[I"obj;T0; @ $; [ ; I"PReturns true if any member of enum equals
obj. Equality is tested using ==.
(1..10).include? 5 #=> true
(1..10).include? 15 #=> false
(1..10).member? 5 #=> true
(1..10).member? 15 #=> false
@overload include?(obj)
@return [Boolean]
@overload member?(obj)
@return [Boolean];T; 0; @ $;!F;"o;#;$T;%i ;&i+ ;6i ;'@ ;(I"static VALUE
enum_member(VALUE obj, VALUE val)
{
struct MEMO *memo = MEMO_NEW(val, Qfalse, 0);
rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
return memo->v2;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#include?;F;[[I"val;T0;[[@@i- ;T;;K;0;[ ;{ ;IC; "Returns true if any member of enum equals
obj. Equality is tested using ==.
(1..10).include? 5 #=> true
(1..10).include? 15 #=> false
(1..10).member? 5 #=> true
(1..10).member? 15 #=> false;T;[o;=
;3I"
overload;F;40;;K;50;)I"include?(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @L$; [ ; I"@return [Boolean];T; 0; @L$;!F;6i ;>0;[[I"obj;T0; @L$o;=
;3I"
overload;F;40;;J;50;)I"member?(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @L$; [ ; I"@return [Boolean];T; 0; @L$;!F;6i ;>0;[[I"obj;T0; @L$; [ ; @H$; 0; @L$;!F;"o;#;$T;%i ;&i+ ;6i ;'@ ;(I"static VALUE
enum_member(VALUE obj, VALUE val)
{
struct MEMO *memo = MEMO_NEW(val, Qfalse, 0);
rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
return memo->v2;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Enumerable#each_with_index;F;[[@c0;[[@@iS ;T;:each_with_index;0;[ ;{ ;IC; "_Calls block with two arguments, the item and its index,
for each item in enum. Given arguments are passed through
to #each().
If no block is given, an enumerator is returned instead.
hash = Hash.new
%w(cat dog wombat).each_with_index { |item, index|
hash[item] = index
}
hash #=> {"cat"=>0, "dog"=>1, "wombat"=>2}
;T;[o;=
;3I"
overload;F;40;;L;50;)I"each_with_index(*args);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;TI"i;T; @y$o;2
;3I" return;F;4I" ;T;0;5[I"Enumerator;T; @y$; [ ; I")@yield [obj, i]
@return [Enumerator];T; 0; @y$;!F;6i ;>0;[[I"
*args;T0; @y$o;=
;3I"
overload;F;40;;L;50;)I"each_with_index(*args);T;IC; " ;T;[ ; [ ; I" ;T; 0; @y$;!F;6i ;>0;[[I"
*args;T0; @y$; [ ; I"Calls block with two arguments, the item and its index,
for each item in enum. Given arguments are passed through
to #each().
If no block is given, an enumerator is returned instead.
hash = Hash.new
%w(cat dog wombat).each_with_index { |item, index|
hash[item] = index
}
hash #=> {"cat"=>0, "dog"=>1, "wombat"=>2}
@overload each_with_index(*args)
@yield [obj, i]
@return [Enumerator]
@overload each_with_index(*args);T; 0; @y$;!F;"o;#;$T;%i@ ;&iQ ;'@ ;(I"static VALUE
enum_each_with_index(int argc, VALUE *argv, VALUE obj)
{
struct MEMO *memo;
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
memo = MEMO_NEW(0, 0, 0);
rb_block_call(obj, id_each, argc, argv, each_with_index_i, (VALUE)memo);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Enumerable#reverse_each;F;[[@c0;[[@@ir ;T;:reverse_each;0;[ ;{ ;IC; "Builds a temporary array and traverses that array in reverse order.
If no block is given, an enumerator is returned instead.
(1..3).reverse_each { |v| p v }
produces:
3
2
1
;T;[o;=
;3I"
overload;F;40;;M;50;)I"reverse_each(*args);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" item;T; @$o;2
;3I" return;F;4I" ;T;0;5[I"Enumerator;T; @$; [ ; I"'@yield [item]
@return [Enumerator];T; 0; @$;!F;6i ;>0;[[I"
*args;T0; @$o;=
;3I"
overload;F;40;;M;50;)I"reverse_each(*args);T;IC; " ;T;[ ; [ ; I" ;T; 0; @$;!F;6i ;>0;[[I"
*args;T0; @$; [ ; I"!Builds a temporary array and traverses that array in reverse order.
If no block is given, an enumerator is returned instead.
(1..3).reverse_each { |v| p v }
produces:
3
2
1
@overload reverse_each(*args)
@yield [item]
@return [Enumerator]
@overload reverse_each(*args);T; 0; @$;!F;"o;#;$T;%i` ;&ip ;'@ ;(I"static VALUE
enum_reverse_each(int argc, VALUE *argv, VALUE obj)
{
VALUE ary;
long len;
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
ary = enum_to_a(argc, argv, obj);
len = RARRAY_LEN(ary);
while (len--) {
long nlen;
rb_yield(RARRAY_AREF(ary, len));
nlen = RARRAY_LEN(ary);
if (nlen < len) {
len = nlen;
}
}
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#each_entry;F;[[@c0;[[@@i ;T;:each_entry;0;[ ;{ ;IC; "zCalls block once for each element in +self+, passing that
element as a parameter, converting multiple values from yield to an
array.
If no block is given, an enumerator is returned instead.
class Foo
include Enumerable
def each
yield 1
yield 1, 2
yield
end
end
Foo.new.each_entry{ |o| p o }
produces:
1
[1, 2]
nil
;T;[o;=
;3I"
overload;F;40;;N;50;)I"each_entry;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"obj;T; @$o;2
;3I" return;F;4I" ;T;0;5[I"Enumerator;T; @$; [ ; I"&@yield [obj]
@return [Enumerator];T; 0; @$;!F;6i ;>0;[ ; @$o;=
;3I"
overload;F;40;;N;50;)I"each_entry;T;IC; " ;T;[ ; [ ; I" ;T; 0; @$;!F;6i ;>0;[ ; @$; [ ; I"Calls block once for each element in +self+, passing that
element as a parameter, converting multiple values from yield to an
array.
If no block is given, an enumerator is returned instead.
class Foo
include Enumerable
def each
yield 1
yield 1, 2
yield
end
end
Foo.new.each_entry{ |o| p o }
produces:
1
[1, 2]
nil
@overload each_entry
@yield [obj]
@return [Enumerator]
@overload each_entry;T; 0; @$;!F;"o;#;$T;%i ;&i ;'@ ;(I"static VALUE
enum_each_entry(int argc, VALUE *argv, VALUE obj)
{
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
rb_block_call(obj, id_each, argc, argv, each_val_i, 0);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#each_slice;F;[[I"n;T0;[[@@i
;T;:each_slice;0;[ ;{ ;IC; "Iterates the given block for each slice of enum#size. If the size of any argument is less than
enum#size, nil values are supplied. If
a block is given, it is invoked for each output array, otherwise
an array of arrays is returned.
a = [ 4, 5, 6 ]
b = [ 7, 8, 9 ]
a.zip(b) #=> [[4, 7], [5, 8], [6, 9]]
[1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
c = []
a.zip(b) { |x, y| c << x + y } #=> nil
c #=> [11, 13, 15]
;T;[o;=
;3I"
overload;F;40;;R;50;)I"zip(arg, ...);T;IC; " ;T;[ ; [ ; I" ;T; 0; @%;!F;6i ;>0;[[I"arg;T0[I"...;T0; @%o;=
;3I"
overload;F;40;;R;50;)I"zip(arg, ...);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"arr;T; @%o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @%; [ ; I" @yield [arr]
@return [nil];T; 0; @%;!F;6i ;>0;[[I"arg;T0[I"...;T0; @%; [ ; I"Takes one element from enum and merges corresponding
elements from each args. This generates a sequence of
n-element arrays, where n is one more than the
count of arguments. The length of the resulting sequence will be
enum#size. If the size of any argument is less than
enum#size, nil values are supplied. If
a block is given, it is invoked for each output array, otherwise
an array of arrays is returned.
a = [ 4, 5, 6 ]
b = [ 7, 8, 9 ]
a.zip(b) #=> [[4, 7], [5, 8], [6, 9]]
[1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
c = []
a.zip(b) { |x, y| c << x + y } #=> nil
c #=> [11, 13, 15]
@overload zip(arg, ...)
@overload zip(arg, ...)
@yield [arr]
@return [nil];T; 0; @%;!F;"o;#;$T;%i
;&i
;'@ ;(I"static VALUE
enum_zip(int argc, VALUE *argv, VALUE obj)
{
int i;
ID conv;
struct MEMO *memo;
VALUE result = Qnil;
VALUE args = rb_ary_new4(argc, argv);
int allary = TRUE;
argv = RARRAY_PTR(args);
for (i=0; i_pattern_ === _elt_ returns true or the block
returns true for the element, the element is beginning of a
chunk.
The === and _block_ is called from the first element to the last
element of _enum_. The result for the first element is ignored.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_before(pattern).each { |ary| ... }
enum.slice_before { |elt| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, iteration over ChangeLog entries can be implemented as
follows:
# iterate over ChangeLog entries.
open("ChangeLog") { |f|
f.slice_before(/\A\S/).each { |e| pp e }
}
# same as above. block is used instead of pattern argument.
open("ChangeLog") { |f|
f.slice_before { |line| /\A\S/ === line }.each { |e| pp e }
}
"svn proplist -R" produces multiline output for each file.
They can be chunked as follows:
IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f|
f.lines.slice_before(/\AProp/).each { |lines| p lines }
}
#=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"]
# ["Properties on 'goruby.c':\n", " svn:eol-style\n"]
# ["Properties on 'complex.c':\n", " svn:mime-type\n", " svn:eol-style\n"]
# ["Properties on 'regparse.c':\n", " svn:eol-style\n"]
# ...
If the block needs to maintain state over multiple elements,
local variables can be used.
For example, three or more consecutive increasing numbers can be squashed
as follows (see +chunk_while+ for a better way):
a = [0, 2, 3, 4, 6, 7, 9]
prev = a[0]
p a.slice_before { |e|
prev, prev2 = e, prev
prev2 + 1 != e
}.map { |es|
es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"
However local variables should be used carefully
if the result enumerator is enumerated twice or more.
The local variables should be initialized for each enumeration.
Enumerator.new can be used to do it.
# Word wrapping. This assumes all characters have same width.
def wordwrap(words, maxwidth)
Enumerator.new {|y|
# cols is initialized in Enumerator.new.
cols = 0
words.slice_before { |w|
cols += 1 if cols != 0
cols += w.length
if maxwidth < cols
cols = w.length
true
else
false
end
}.each {|ws| y.yield ws }
}
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # first enumeration.
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # second enumeration generates same result as the first.
puts "-"*10
#=> ----------
# 1 2 3 4 5
# 6 7 8 9 10
# 11 12 13
# 14 15 16
# 17 18 19
# 20
# ----------
# 1 2 3 4 5
# 6 7 8 9 10
# 11 12 13
# 14 15 16
# 17 18 19
# 20
# ----------
mbox contains series of mails which start with Unix From line.
So each mail can be extracted by slice before Unix From line.
# parse mbox
open("mbox") { |f|
f.slice_before { |line|
line.start_with? "From "
}.each { |mail|
unix_from = mail.shift
i = mail.index("\n")
header = mail[0...i]
body = mail[(i+1)..-1]
body.pop if body.last == "\n"
fields = header.slice_before { |line| !" \t".include?(line[0]) }.to_a
p unix_from
pp fields
pp body
}
}
# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") { |f|
emp = true
f.slice_before { |line|
prevemp = emp
emp = line == "\n"
prevemp && line.start_with?("From ")
}.each { |mail|
mail.pop if mail.last == "\n"
pp mail
}
}
;T;[o;=
;3I"
overload;F;40;;Y;50;)I"slice_before(pattern);T;IC; " ;T;[ ; [ ; I" ;T; 0; @&;!F;6i ;>0;[[I" pattern;T0; @&o;=
;3I"
overload;F;40;;Y;50;)I"slice_before;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"elt;T; @&; [ ; I"@yield [elt];T; 0; @&;!F;6i ;>0;[ ; @&; [ ; I"Creates an enumerator for each chunked elements.
The beginnings of chunks are defined by _pattern_ and the block.
If _pattern_ === _elt_ returns true or the block
returns true for the element, the element is beginning of a
chunk.
The === and _block_ is called from the first element to the last
element of _enum_. The result for the first element is ignored.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_before(pattern).each { |ary| ... }
enum.slice_before { |elt| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, iteration over ChangeLog entries can be implemented as
follows:
# iterate over ChangeLog entries.
open("ChangeLog") { |f|
f.slice_before(/\A\S/).each { |e| pp e }
}
# same as above. block is used instead of pattern argument.
open("ChangeLog") { |f|
f.slice_before { |line| /\A\S/ === line }.each { |e| pp e }
}
"svn proplist -R" produces multiline output for each file.
They can be chunked as follows:
IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f|
f.lines.slice_before(/\AProp/).each { |lines| p lines }
}
#=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"]
# ["Properties on 'goruby.c':\n", " svn:eol-style\n"]
# ["Properties on 'complex.c':\n", " svn:mime-type\n", " svn:eol-style\n"]
# ["Properties on 'regparse.c':\n", " svn:eol-style\n"]
# ...
If the block needs to maintain state over multiple elements,
local variables can be used.
For example, three or more consecutive increasing numbers can be squashed
as follows (see +chunk_while+ for a better way):
a = [0, 2, 3, 4, 6, 7, 9]
prev = a[0]
p a.slice_before { |e|
prev, prev2 = e, prev
prev2 + 1 != e
}.map { |es|
es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"
However local variables should be used carefully
if the result enumerator is enumerated twice or more.
The local variables should be initialized for each enumeration.
Enumerator.new can be used to do it.
# Word wrapping. This assumes all characters have same width.
def wordwrap(words, maxwidth)
Enumerator.new {|y|
# cols is initialized in Enumerator.new.
cols = 0
words.slice_before { |w|
cols += 1 if cols != 0
cols += w.length
if maxwidth < cols
cols = w.length
true
else
false
end
}.each {|ws| y.yield ws }
}
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # first enumeration.
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # second enumeration generates same result as the first.
puts "-"*10
#=> ----------
# 1 2 3 4 5
# 6 7 8 9 10
# 11 12 13
# 14 15 16
# 17 18 19
# 20
# ----------
# 1 2 3 4 5
# 6 7 8 9 10
# 11 12 13
# 14 15 16
# 17 18 19
# 20
# ----------
mbox contains series of mails which start with Unix From line.
So each mail can be extracted by slice before Unix From line.
# parse mbox
open("mbox") { |f|
f.slice_before { |line|
line.start_with? "From "
}.each { |mail|
unix_from = mail.shift
i = mail.index("\n")
header = mail[0...i]
body = mail[(i+1)..-1]
body.pop if body.last == "\n"
fields = header.slice_before { |line| !" \t".include?(line[0]) }.to_a
p unix_from
pp fields
pp body
}
}
# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") { |f|
emp = true
f.slice_before { |line|
prevemp = emp
emp = line == "\n"
prevemp && line.start_with?("From ")
}.each { |mail|
mail.pop if mail.last == "\n"
pp mail
}
}
@overload slice_before(pattern)
@overload slice_before
@yield [elt];T; 0; @&;!F;"o;#;$T;%i
;&i
;'@ ;(I"static VALUE
enum_slice_before(int argc, VALUE *argv, VALUE enumerable)
{
VALUE enumerator;
if (rb_block_given_p()) {
if (argc != 0)
rb_error_arity(argc, 0, 0);
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("slicebefore_sep_pred"), rb_block_proc());
}
else {
VALUE sep_pat;
rb_scan_args(argc, argv, "1", &sep_pat);
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("slicebefore_sep_pat"), sep_pat);
}
rb_ivar_set(enumerator, rb_intern("slicebefore_enumerable"), enumerable);
rb_block_call(enumerator, idInitialize, 0, 0, slicebefore_i, enumerator);
return enumerator;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#slice_after;F;[[@c0;[[@@i ;T;:slice_after;0;[ ;{ ;IC; "
Creates an enumerator for each chunked elements.
The ends of chunks are defined by _pattern_ and the block.
If _pattern_ === _elt_ returns true or the block
returns true for the element, the element is end of a
chunk.
The === and _block_ is called from the first element to the last
element of _enum_.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_after(pattern).each { |ary| ... }
enum.slice_after { |elt| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +map+, etc., are also usable.
For example, continuation lines (lines end with backslash) can be
concatenated as follows:
lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"]
e = lines.slice_after(/(? [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]
;T;[o;=
;3I"
overload;F;40;;Z;50;)I"slice_after(pattern);T;IC; " ;T;[ ; [ ; I" ;T; 0; @&;!F;6i ;>0;[[I" pattern;T0; @&o;=
;3I"
overload;F;40;;Z;50;)I"slice_after;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"elt;T; @&; [ ; I"@yield [elt];T; 0; @&;!F;6i ;>0;[ ; @&; [ ; I"TCreates an enumerator for each chunked elements.
The ends of chunks are defined by _pattern_ and the block.
If _pattern_ === _elt_ returns true or the block
returns true for the element, the element is end of a
chunk.
The === and _block_ is called from the first element to the last
element of _enum_.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_after(pattern).each { |ary| ... }
enum.slice_after { |elt| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +map+, etc., are also usable.
For example, continuation lines (lines end with backslash) can be
concatenated as follows:
lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"]
e = lines.slice_after(/(? [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]
@overload slice_after(pattern)
@overload slice_after
@yield [elt];T; 0; @&;!F;"o;#;$T;%i
;&i;'@ ;(I"static VALUE
enum_slice_after(int argc, VALUE *argv, VALUE enumerable)
{
VALUE enumerator;
VALUE pat = Qnil, pred = Qnil;
if (rb_block_given_p()) {
if (0 < argc)
rb_raise(rb_eArgError, "both pattern and block are given");
pred = rb_block_proc();
}
else {
rb_scan_args(argc, argv, "1", &pat);
}
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("sliceafter_enum"), enumerable);
rb_ivar_set(enumerator, rb_intern("sliceafter_pat"), pat);
rb_ivar_set(enumerator, rb_intern("sliceafter_pred"), pred);
rb_block_call(enumerator, idInitialize, 0, 0, sliceafter_i, enumerator);
return enumerator;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#slice_when;F;[ ;[[@@i;T;:slice_when;0;[ ;{ ;IC; "UCreates an enumerator for each chunked elements.
The beginnings of chunks are defined by the block.
This method split each chunk using adjacent elements,
_elt_before_ and _elt_after_,
in the receiver enumerator.
This method split chunks between _elt_before_ and _elt_after_ where
the block returns true.
The block is called the length of the receiver enumerator minus one.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, one-by-one increasing subsequence can be chunked as follows:
a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.slice_when {|i, j| i+1 != j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"
Near elements (threshold: 6) in sorted array can be chunked as follows:
a = [3, 11, 14, 25, 28, 29, 29, 41, 55, 57]
p a.slice_when {|i, j| 6 < j - i }.to_a
#=> [[3], [11, 14], [25, 28, 29, 29], [41], [55, 57]]
Increasing (non-decreasing) subsequence can be chunked as follows:
a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.slice_when {|i, j| i > j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]
Adjacent evens and odds can be chunked as follows:
(Enumerable#chunk is another way to do it.)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.slice_when {|i, j| i.even? != j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]
Paragraphs (non-empty lines with trailing empty lines) can be chunked as follows:
(See Enumerable#chunk to ignore empty lines.)
lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"]
p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a
#=> [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]]
Enumerable#chunk_while does the same, except splitting when the block
returns false instead of true.
;T;[o;=
;3I"
overload;F;40;;[;50;)I"slice_when;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"elt_before;TI"elt_after;T; @&; [ ; I"#@yield [elt_before, elt_after];T; 0; @&;!F;6i ;>0;[ ; @&; [ ; I"Creates an enumerator for each chunked elements.
The beginnings of chunks are defined by the block.
This method split each chunk using adjacent elements,
_elt_before_ and _elt_after_,
in the receiver enumerator.
This method split chunks between _elt_before_ and _elt_after_ where
the block returns true.
The block is called the length of the receiver enumerator minus one.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, one-by-one increasing subsequence can be chunked as follows:
a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.slice_when {|i, j| i+1 != j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"
Near elements (threshold: 6) in sorted array can be chunked as follows:
a = [3, 11, 14, 25, 28, 29, 29, 41, 55, 57]
p a.slice_when {|i, j| 6 < j - i }.to_a
#=> [[3], [11, 14], [25, 28, 29, 29], [41], [55, 57]]
Increasing (non-decreasing) subsequence can be chunked as follows:
a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.slice_when {|i, j| i > j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]
Adjacent evens and odds can be chunked as follows:
(Enumerable#chunk is another way to do it.)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.slice_when {|i, j| i.even? != j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]
Paragraphs (non-empty lines with trailing empty lines) can be chunked as follows:
(See Enumerable#chunk to ignore empty lines.)
lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"]
p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a
#=> [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]]
Enumerable#chunk_while does the same, except splitting when the block
returns false instead of true.
@overload slice_when
@yield [elt_before, elt_after];T; 0; @&;!F;"o;#;$T;%ij;&i;'@ ;(I"static VALUE
enum_slice_when(VALUE enumerable)
{
VALUE enumerator;
VALUE pred;
pred = rb_block_proc();
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("slicewhen_enum"), enumerable);
rb_ivar_set(enumerator, rb_intern("slicewhen_pred"), pred);
rb_ivar_set(enumerator, rb_intern("slicewhen_inverted"), Qfalse);
rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
return enumerator;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#chunk_while;F;[ ;[[@@i;T;:chunk_while;0;[ ;{ ;IC; "PCreates an enumerator for each chunked elements.
The beginnings of chunks are defined by the block.
This method split each chunk using adjacent elements,
_elt_before_ and _elt_after_,
in the receiver enumerator.
This method split chunks between _elt_before_ and _elt_after_ where
the block returns false.
The block is called the length of the receiver enumerator minus one.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.chunk_while { |elt_before, elt_after| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, one-by-one increasing subsequence can be chunked as follows:
a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.chunk_while {|i, j| i+1 == j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"
Increasing (non-decreasing) subsequence can be chunked as follows:
a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.chunk_while {|i, j| i <= j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]
Adjacent evens and odds can be chunked as follows:
(Enumerable#chunk is another way to do it.)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.chunk_while {|i, j| i.even? == j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]
Enumerable#slice_when does the same, except splitting when the block
returns true instead of false.
;T;[o;=
;3I"
overload;F;40;;\;50;)I"chunk_while;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"elt_before;TI"elt_after;T; @&; [ ; I"#@yield [elt_before, elt_after];T; 0; @&;!F;6i ;>0;[ ; @&; [ ; I"Creates an enumerator for each chunked elements.
The beginnings of chunks are defined by the block.
This method split each chunk using adjacent elements,
_elt_before_ and _elt_after_,
in the receiver enumerator.
This method split chunks between _elt_before_ and _elt_after_ where
the block returns false.
The block is called the length of the receiver enumerator minus one.
The result enumerator yields the chunked elements as an array.
So +each+ method can be called as follows:
enum.chunk_while { |elt_before, elt_after| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as +to_a+, +map+, etc., are also usable.
For example, one-by-one increasing subsequence can be chunked as follows:
a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.chunk_while {|i, j| i+1 == j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"
Increasing (non-decreasing) subsequence can be chunked as follows:
a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.chunk_while {|i, j| i <= j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]
Adjacent evens and odds can be chunked as follows:
(Enumerable#chunk is another way to do it.)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.chunk_while {|i, j| i.even? == j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]
Enumerable#slice_when does the same, except splitting when the block
returns true instead of false.
@overload chunk_while
@yield [elt_before, elt_after];T; 0; @&;!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_chunk_while(VALUE enumerable)
{
VALUE enumerator;
VALUE pred;
pred = rb_block_proc();
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("slicewhen_enum"), enumerable);
rb_ivar_set(enumerator, rb_intern("slicewhen_pred"), pred);
rb_ivar_set(enumerator, rb_intern("slicewhen_inverted"), Qtrue);
rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
return enumerator;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#sum;F;[[@c0;[[@@i;T;:sum;0;[ ;{ ;IC; "rReturns the sum of elements in an Enumerable.
If a block is given, the block is applied to each element
before addition.
If enum is empty, it returns init.
For example:
{ 1 => 10, 2 => 20 }.sum {|k, v| k * v } #=> 50
(1..10).sum #=> 55
(1..10).sum {|v| v * 2 } #=> 110
('a'..'z').sum #=> TypeError
This method can be used for non-numeric objects by
explicit init argument.
{ 1 => 10, 2 => 20 }.sum([]) #=> [1, 10, 2, 20]
"a\nb\nc".each_line.lazy.map(&:chomp).sum("") #=> "abc"
If the method is applied to an Integer range without a block,
the sum is not done by iteration, but instead using Gauss's summation
formula.
Enumerable#sum method may not respect method redefinition of "+"
methods such as Integer#+, or "each" methods such as Range#each.
;T;[o;=
;3I"
overload;F;40;;];50;)I"sum(init=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @'; [ ; I"@return [Numeric];T; 0; @';!F;6i ;>0;[[I" init;TI"0;T; @'o;=
;3I"
overload;F;40;;];50;)I"sum(init=0);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"e;T; @'o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @'; [ ; I"!@yield [e]
@return [Numeric];T; 0; @';!F;6i ;>0;[[I" init;TI"0;T; @'; [ ; I"Returns the sum of elements in an Enumerable.
If a block is given, the block is applied to each element
before addition.
If enum is empty, it returns init.
For example:
{ 1 => 10, 2 => 20 }.sum {|k, v| k * v } #=> 50
(1..10).sum #=> 55
(1..10).sum {|v| v * 2 } #=> 110
('a'..'z').sum #=> TypeError
This method can be used for non-numeric objects by
explicit init argument.
{ 1 => 10, 2 => 20 }.sum([]) #=> [1, 10, 2, 20]
"a\nb\nc".each_line.lazy.map(&:chomp).sum("") #=> "abc"
If the method is applied to an Integer range without a block,
the sum is not done by iteration, but instead using Gauss's summation
formula.
Enumerable#sum method may not respect method redefinition of "+"
methods such as Integer#+, or "each" methods such as Range#each.
@overload sum(init=0)
@return [Numeric]
@overload sum(init=0)
@yield [e]
@return [Numeric];T; 0; @';!F;"o;#;$T;%i;&i;'@ ;(I"static VALUE
enum_sum(int argc, VALUE* argv, VALUE obj)
{
struct enum_sum_memo memo;
VALUE beg, end;
int excl;
memo.v = (rb_check_arity(argc, 0, 1) == 0) ? LONG2FIX(0) : argv[0];
memo.block_given = rb_block_given_p();
memo.n = 0;
memo.r = Qundef;
if ((memo.float_value = RB_FLOAT_TYPE_P(memo.v))) {
memo.f = RFLOAT_VALUE(memo.v);
memo.c = 0.0;
}
else {
memo.f = 0.0;
memo.c = 0.0;
}
if (RTEST(rb_range_values(obj, &beg, &end, &excl))) {
if (!memo.block_given && !memo.float_value &&
(FIXNUM_P(beg) || RB_TYPE_P(beg, T_BIGNUM)) &&
(FIXNUM_P(end) || RB_TYPE_P(end, T_BIGNUM))) {
return int_range_sum(beg, end, excl, memo.v);
}
}
if (RB_TYPE_P(obj, T_HASH) &&
rb_method_basic_definition_p(CLASS_OF(obj), id_each))
hash_sum(obj, &memo);
else
rb_block_call(obj, id_each, 0, 0, enum_sum_i, (VALUE)&memo);
if (memo.float_value) {
return DBL2NUM(memo.f + memo.c);
}
else {
if (memo.n != 0)
memo.v = rb_fix_plus(LONG2FIX(memo.n), memo.v);
if (memo.r != Qundef) {
/* r can be an Integer when mathn is loaded */
if (FIXNUM_P(memo.r))
memo.v = rb_fix_plus(memo.r, memo.v);
else if (RB_TYPE_P(memo.r, T_BIGNUM))
memo.v = rb_big_plus(memo.r, memo.v);
else
memo.v = rb_rational_plus(memo.r, memo.v);
}
return memo.v;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Enumerable#uniq;F;[ ;[[@@i;T;: uniq;0;[ ;{ ;IC; "VReturns a new array by removing duplicate values in +self+.
See also Array#uniq.
;T;[o;=
;3I"
overload;F;40;;^;50;)I" uniq;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @E'; [ ; I"@return [Array];T; 0; @E';!F;6i ;>0;[ ; @E'o;=
;3I"
overload;F;40;;^;50;)I" uniq;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" item;T; @E'o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @E'; [ ; I""@yield [item]
@return [Array];T; 0; @E';!F;6i ;>0;[ ; @E'; [ ; I"Returns a new array by removing duplicate values in +self+.
See also Array#uniq.
@overload uniq
@return [Array]
@overload uniq
@yield [item]
@return [Array];T; 0; @E';!F;"o;#;$T;%i
;&i;'@ ;(I"0static VALUE
enum_uniq(VALUE obj)
{
VALUE hash, ret;
rb_block_call_func *const func =
rb_block_given_p() ? uniq_iter : uniq_func;
hash = rb_obj_hide(rb_hash_new());
rb_block_call(obj, id_each, 0, 0, func, hash);
ret = rb_hash_values(hash);
rb_hash_clear(hash);
return ret;
};T;)I"static VALUE;T;*T;A@ ;BIC;[ ;A@ ;CIC;[ ;A@ ;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@@i5;F;;$;;K;;;[ ;{ ;IC; "The Enumerable mixin provides collection classes with several
traversal and searching methods, and with the ability to sort. The
class must provide a method #each, which yields
successive members of the collection. If Enumerable#max, #min, or
#sort is used, the objects in the collection must also implement a
meaningful <=> operator, as these methods rely on an
ordering between members of the collection.
;T;[ ; [ ; I"The Enumerable mixin provides collection classes with several
traversal and searching methods, and with the ability to sort. The
class must provide a method #each, which yields
successive members of the collection. If Enumerable#max, #min, or
#sort is used, the objects in the collection must also implement a
meaningful <=> operator, as these methods rely on an
ordering between members of the collection.
;T; 0; @ ;!F;"o;#;$T;%i%;&i,;'@;I"Enumerable;F;R0;A@l;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i}[@ik;T;:GzipReader;;K;;;[ ;{ ;IC; "Zlib::GzipReader is the class for reading a gzipped file. GzipReader should
be used as an IO, or -IO-like, object.
Zlib::GzipReader.open('hoge.gz') {|gz|
print gz.read
}
File.open('hoge.gz') do |f|
gz = Zlib::GzipReader.new(f)
print gz.read
gz.close
end
== Method Catalogue
The following methods in Zlib::GzipReader are just like their counterparts
in IO, but they raise Zlib::Error or Zlib::GzipFile::Error exception if an
error was found in the gzip file.
- #each
- #each_line
- #each_byte
- #gets
- #getc
- #lineno
- #lineno=
- #read
- #readchar
- #readline
- #readlines
- #ungetc
Be careful of the footer of the gzip file. A gzip file has the checksum of
pre-compressed data in its footer. GzipReader checks all uncompressed data
against that checksum at the following cases, and if it fails, raises
Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, or
Zlib::GzipFile::LengthError exception.
- When an reading request is received beyond the end of file (the end of
compressed data). That is, when Zlib::GzipReader#read,
Zlib::GzipReader#gets, or some other methods for reading returns nil.
- When Zlib::GzipFile#close method is called after the object reaches the
end of file.
- When Zlib::GzipReader#unused method is called after the object reaches
the end of file.
The rest of the methods are adequately described in their own
documentation.;T;[ ; [ ; I"
Zlib::GzipReader is the class for reading a gzipped file. GzipReader should
be used as an IO, or -IO-like, object.
Zlib::GzipReader.open('hoge.gz') {|gz|
print gz.read
}
File.open('hoge.gz') do |f|
gz = Zlib::GzipReader.new(f)
print gz.read
gz.close
end
== Method Catalogue
The following methods in Zlib::GzipReader are just like their counterparts
in IO, but they raise Zlib::Error or Zlib::GzipFile::Error exception if an
error was found in the gzip file.
- #each
- #each_line
- #each_byte
- #gets
- #getc
- #lineno
- #lineno=
- #read
- #readchar
- #readline
- #readlines
- #ungetc
Be careful of the footer of the gzip file. A gzip file has the checksum of
pre-compressed data in its footer. GzipReader checks all uncompressed data
against that checksum at the following cases, and if it fails, raises
Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, or
Zlib::GzipFile::LengthError exception.
- When an reading request is received beyond the end of file (the end of
compressed data). That is, when Zlib::GzipReader#read,
Zlib::GzipReader#gets, or some other methods for reading returns nil.
- When Zlib::GzipFile#close method is called after the object reaches the
end of file.
- When Zlib::GzipReader#unused method is called after the object reaches
the end of file.
The rest of the methods are adequately described in their own
documentation.
;T; 0; @l;!F;"o;#;$T;%i};&i;6i ;'o;L ;M0;N0;O0;;P;'@;Q@;R0;I"Zlib::GzipReader;F;S@@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;:StreamEnd;;K;;;[ ;{ ;IC; "Subclass of Zlib::Error
When zlib returns a Z_STREAM_END
is return if the end of the compressed data has been reached
and all uncompressed out put has been produced.
;T;[ ; [ ; I"
Subclass of Zlib::Error
When zlib returns a Z_STREAM_END
is return if the end of the compressed data has been reached
and all uncompressed out put has been produced.
;T; 0; @';!F;"o;#;$T;%i;&i;'@;I"Zlib::StreamEnd;F;S@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;:
NeedDict;;K;;;[ ;{ ;IC; "Subclass of Zlib::Error
When zlib returns a Z_NEED_DICT
if a preset dictionary is needed at this point.
Used by Zlib::Inflate.inflate and Zlib.inflate
;T;[ ; [ ; I"
Subclass of Zlib::Error
When zlib returns a Z_NEED_DICT
if a preset dictionary is needed at this point.
Used by Zlib::Inflate.inflate and Zlib.inflate
;T; 0; @';!F;"o;#;$T;%i;&i;'@;I"Zlib::NeedDict;F;S@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i([@i;T;:DataError;;K;;;[ ;{ ;IC; "jSubclass of Zlib::Error when zlib returns a Z_DATA_ERROR.
Usually if a stream was prematurely freed.
;T;[ ; [ ; I"m
Subclass of Zlib::Error when zlib returns a Z_DATA_ERROR.
Usually if a stream was prematurely freed.
;T; 0; @';!F;"o;#;$T;%i(;&i-;'@;I"Zlib::DataError;F;S@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i[@i;T;:StreamError;;K;;;[ ;{ ;IC; "oSubclass of Zlib::Error
When zlib returns a Z_STREAM_ERROR,
usually if the stream state was inconsistent.
;T;[ ; [ ; I"r
Subclass of Zlib::Error
When zlib returns a Z_STREAM_ERROR,
usually if the stream state was inconsistent.
;T; 0; @';!F;"o;#;$T;%i;&i;'@;I"Zlib::StreamError;F;S@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i [@i;T;:
MemError;;K;;;[ ;{ ;IC; "fSubclass of Zlib::Error
When zlib returns a Z_MEM_ERROR,
usually if there was not enough memory.
;T;[ ; [ ; I"i
Subclass of Zlib::Error
When zlib returns a Z_MEM_ERROR,
usually if there was not enough memory.
;T; 0; @';!F;"o;#;$T;%i ;&i;'@;I"Zlib::MemError;F;S@o;
;IC;[ ;A@';BIC;[ ;A@';CIC;[ ;A@';DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i [@i;T;:
BufError;;K;;;[ ;{ ;IC; "bSubclass of Zlib::Error when zlib returns a Z_BUF_ERROR.
Usually if no progress is possible.
;T;[ ; [ ; I"e
Subclass of Zlib::Error when zlib returns a Z_BUF_ERROR.
Usually if no progress is possible.
;T; 0; @';!F;"o;#;$T;%i ;&i$;'@;I"Zlib::BufError;F;S@o;
;IC;[ ;A@ (;BIC;[ ;A@ (;CIC;[ ;A@ (;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i [@i;T;:VersionError;;K;;;[ ;{ ;IC; "Subclass of Zlib::Error
When zlib returns a Z_VERSION_ERROR,
usually if the zlib library version is incompatible with the
version assumed by the caller.
;T;[ ; [ ; I"
Subclass of Zlib::Error
When zlib returns a Z_VERSION_ERROR,
usually if the zlib library version is incompatible with the
version assumed by the caller.
;T; 0; @ (;!F;"o;#;$T;%i ;&i;'@;I"Zlib::VersionError;F;S@o;
;IC;[ ;A@ (;BIC;[ ;A@ (;CIC;[ ;A@ (;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i1[@i;T;:InProgressError;;K;;;[ ;{ ;IC; "Subclass of Zlib::Error. This error is raised when the zlib
stream is currently in progress.
For example:
inflater = Zlib::Inflate.new
inflater.inflate(compressed) do
inflater.inflate(compressed) # Raises Zlib::InProgressError
end
;T;[ ; [ ; I"
Subclass of Zlib::Error. This error is raised when the zlib
stream is currently in progress.
For example:
inflater = Zlib::Inflate.new
inflater.inflate(compressed) do
inflater.inflate(compressed) # Raises Zlib::InProgressError
end
;T; 0; @ (;!F;"o;#;$T;%i1;&i;;'@;I"Zlib::InProgressError;F;S@o; ; F;
;;;;I"Zlib#zlib_version;F;[ ;[[@in;T;:zlib_version;0;[ ;{ ;IC; "EReturns the string which represents the version of zlib library.
;T;[ ; [ ; I"EReturns the string which represents the version of zlib library.;T; 0; @4(;!F;>0;'@;(I"Ystatic VALUE
rb_zlib_version(VALUE klass)
{
return rb_str_new2(zlibVersion());
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.zlib_version;F;@6(;@7(;T;;h;0;@9(;{ ;IC; "EReturns the string which represents the version of zlib library.;T;[ ; [ ; I"G
Returns the string which represents the version of zlib library.
;T; 0; @A(;!F;"o;#;$T;%ii;&ik;6i ;'@;(@?(;)@@(;*To; ; F;
;;;;I"Zlib#adler32;F;[[@c0;[[@i;T;: adler32;0;[ ;{ ;IC; "call-seq: Zlib.adler32(string, adler)
Calculates Adler-32 checksum for +string+, and returns updated value of
+adler+. If +string+ is omitted, it returns the Adler-32 initial value. If
+adler+ is omitted, it assumes that the initial value is given to +adler+.
Example usage:
require "zlib"
data = "foo"
puts "Adler32 checksum: #{Zlib.adler32(data).to_s(16)}"
#=> Adler32 checksum: 2820145
;T;[ ; [ ; I"call-seq: Zlib.adler32(string, adler)
Calculates Adler-32 checksum for +string+, and returns updated value of
+adler+. If +string+ is omitted, it returns the Adler-32 initial value. If
+adler+ is omitted, it assumes that the initial value is given to +adler+.
Example usage:
require "zlib"
data = "foo"
puts "Adler32 checksum: #{Zlib.adler32(data).to_s(16)}"
#=> Adler32 checksum: 2820145;T; 0; @I(;!F;>0;'@;(I"vstatic VALUE
rb_zlib_adler32(int argc, VALUE *argv, VALUE klass)
{
return do_checksum(argc, argv, adler32);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.adler32;F;@K(;@M(;T;;i;0;@O(;{ ;IC; "call-seq: Zlib.adler32(string, adler)
Calculates Adler-32 checksum for +string+, and returns updated value of
+adler+. If +string+ is omitted, it returns the Adler-32 initial value. If
+adler+ is omitted, it assumes that the initial value is given to +adler+.
Example usage:
require "zlib"
data = "foo"
puts "Adler32 checksum: #{Zlib.adler32(data).to_s(16)}"
#=> Adler32 checksum: 2820145;T;[ ; [ ; I"
call-seq: Zlib.adler32(string, adler)
Calculates Adler-32 checksum for +string+, and returns updated value of
+adler+. If +string+ is omitted, it returns the Adler-32 initial value. If
+adler+ is omitted, it assumes that the initial value is given to +adler+.
Example usage:
require "zlib"
data = "foo"
puts "Adler32 checksum: #{Zlib.adler32(data).to_s(16)}"
#=> Adler32 checksum: 2820145
;T; 0; @W(;!F;"o;#;$T;%i;&i;6i ;'@;(@U(;)@V(;*To; ; F;
;;;;I"Zlib#adler32_combine;F;[[I" adler1;T0[I" adler2;T0[I" len2;T0;[[@i;T;:adler32_combine;0;[ ;{ ;IC; "call-seq: Zlib.adler32_combine(adler1, adler2, len2)
Combine two Adler-32 check values in to one. +alder1+ is the first Adler-32
value, +adler2+ is the second Adler-32 value. +len2+ is the length of the
string used to generate +adler2+.
;T;[ ; [ ; I"call-seq: Zlib.adler32_combine(adler1, adler2, len2)
Combine two Adler-32 check values in to one. +alder1+ is the first Adler-32
value, +adler2+ is the second Adler-32 value. +len2+ is the length of the
string used to generate +adler2+.;T; 0; @_(;!F;>0;'@;(I"static VALUE
rb_zlib_adler32_combine(VALUE klass, VALUE adler1, VALUE adler2, VALUE len2)
{
return ULONG2NUM(
adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.adler32_combine;F;@a(;@h(;T;;j;0;@j(;{ ;IC; "call-seq: Zlib.adler32_combine(adler1, adler2, len2)
Combine two Adler-32 check values in to one. +alder1+ is the first Adler-32
value, +adler2+ is the second Adler-32 value. +len2+ is the length of the
string used to generate +adler2+.;T;[ ; [ ; I"
call-seq: Zlib.adler32_combine(adler1, adler2, len2)
Combine two Adler-32 check values in to one. +alder1+ is the first Adler-32
value, +adler2+ is the second Adler-32 value. +len2+ is the length of the
string used to generate +adler2+.
;T; 0; @r(;!F;"o;#;$T;%i;&i;6i ;'@;(@p(;)@q(;*To; ; F;
;;;;I"Zlib#crc32;F;[[@c0;[[@i;T;:
crc32;0;[ ;{ ;IC; "call-seq: Zlib.crc32(string, crc)
Calculates CRC checksum for +string+, and returns updated value of +crc+. If
+string+ is omitted, it returns the CRC initial value. If +crc+ is omitted, it
assumes that the initial value is given to +crc+.
FIXME: expression.
;T;[ ; [ ; I"call-seq: Zlib.crc32(string, crc)
Calculates CRC checksum for +string+, and returns updated value of +crc+. If
+string+ is omitted, it returns the CRC initial value. If +crc+ is omitted, it
assumes that the initial value is given to +crc+.
FIXME: expression.;T; 0; @z(;!F;>0;'@;(I"rstatic VALUE
rb_zlib_crc32(int argc, VALUE *argv, VALUE klass)
{
return do_checksum(argc, argv, crc32);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.crc32;F;@|(;@~(;T;;k;0;@(;{ ;IC; "call-seq: Zlib.crc32(string, crc)
Calculates CRC checksum for +string+, and returns updated value of +crc+. If
+string+ is omitted, it returns the CRC initial value. If +crc+ is omitted, it
assumes that the initial value is given to +crc+.
FIXME: expression.;T;[ ; [ ; I"
call-seq: Zlib.crc32(string, crc)
Calculates CRC checksum for +string+, and returns updated value of +crc+. If
+string+ is omitted, it returns the CRC initial value. If +crc+ is omitted, it
assumes that the initial value is given to +crc+.
FIXME: expression.
;T; 0; @(;!F;"o;#;$T;%i;&i;6i ;'@;(@(;)@(;*To; ; F;
;;;;I"Zlib#crc32_combine;F;[[I" crc1;T0[I" crc2;T0[I" len2;T0;[[@i;T;:crc32_combine;0;[ ;{ ;IC; "call-seq: Zlib.crc32_combine(crc1, crc2, len2)
Combine two CRC-32 check values in to one. +crc1+ is the first CRC-32
value, +crc2+ is the second CRC-32 value. +len2+ is the length of the
string used to generate +crc2+.
;T;[ ; [ ; I"call-seq: Zlib.crc32_combine(crc1, crc2, len2)
Combine two CRC-32 check values in to one. +crc1+ is the first CRC-32
value, +crc2+ is the second CRC-32 value. +len2+ is the length of the
string used to generate +crc2+.;T; 0; @(;!F;>0;'@;(I"static VALUE
rb_zlib_crc32_combine(VALUE klass, VALUE crc1, VALUE crc2, VALUE len2)
{
return ULONG2NUM(
crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.crc32_combine;F;@(;@(;T;;l;0;@(;{ ;IC; "call-seq: Zlib.crc32_combine(crc1, crc2, len2)
Combine two CRC-32 check values in to one. +crc1+ is the first CRC-32
value, +crc2+ is the second CRC-32 value. +len2+ is the length of the
string used to generate +crc2+.;T;[ ; [ ; I"
call-seq: Zlib.crc32_combine(crc1, crc2, len2)
Combine two CRC-32 check values in to one. +crc1+ is the first CRC-32
value, +crc2+ is the second CRC-32 value. +len2+ is the length of the
string used to generate +crc2+.
;T; 0; @(;!F;"o;#;$T;%i;&i;6i ;'@;(@(;)@(;*To; ; F;
;;;;I"Zlib#crc_table;F;[ ;[[@i;T;:crc_table;0;[ ;{ ;IC; "@Returns the table for calculating CRC checksum as an array.
;T;[ ; [ ; I"@Returns the table for calculating CRC checksum as an array.;T; 0; @(;!F;>0;'@;(I"ystatic VALUE
rb_zlib_crc_table(VALUE obj)
{
#if !defined(HAVE_TYPE_Z_CRC_T)
/* z_crc_t is defined since zlib-1.2.7. */
typedef unsigned long z_crc_t;
#endif
const z_crc_t *crctbl;
VALUE dst;
int i;
crctbl = get_crc_table();
dst = rb_ary_new2(256);
for (i = 0; i < 256; i++) {
rb_ary_push(dst, rb_uint2inum(crctbl[i]));
}
return dst;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Zlib.crc_table;F;@(;@(;T;;m;0;@(;{ ;IC; "@Returns the table for calculating CRC checksum as an array.;T;[ ; [ ; I"B
Returns the table for calculating CRC checksum as an array.
;T; 0; @(;!F;"o;#;$T;%i;&i;6i ;'@;(@(;)@(;*To;;[[@i;F;: VERSION;;;;;[ ;{ ;IC; ""The Ruby/zlib version string.
;T;[ ; [ ; I""The Ruby/zlib version string.;T; 0; @(;!F;"o;#;$T;%i;&i;'@;I"Zlib::VERSION;F;I"#rb_str_new2(RUBY_ZLIB_VERSION);To;;[[@i;F;:ZLIB_VERSION;;;;;[ ;{ ;IC; "6The string which represents the version of zlib.h
;T;[ ; [ ; I"6The string which represents the version of zlib.h;T; 0; @(;!F;"o;#;$T;%i;&i;'@;I"Zlib::ZLIB_VERSION;F;I" rb_str_new2(ZLIB_VERSION);To;;[[@i;F;: BINARY;;;;;[ ;{ ;IC; ":Deflate#data_type.
;T;[ ; [ ; I":Deflate#data_type.;T; 0; @(;!F;"o;#;$T;%i;&i;'@;I"Zlib::BINARY;F;I"exit() call or finishing the
program).;T;[o;=
;3I"
overload;F;40;;;50;)I" exited?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @-; [ ; I"@return [Boolean];T; 0; @-;!F;6i ;>0;[ ; @-; [ ; I"Returns +true+ if _stat_ exited normally (for
example using an exit() call or finishing the
program).
@overload exited?
@return [Boolean];T; 0; @-;!F;"o;#;$T;%ia;&ig;6i ;'@+;(I"static VALUE
pst_wifexited(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return Qtrue;
else
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Process::Status#exitstatus;F;[ ;[[@]i;T;:exitstatus;0;[ ;{ ;IC; "eReturns the least significant eight bits of the return code of
_stat_. Only available if #exited? is +true+.
fork { } #=> 26572
Process.wait #=> 26572
$?.exited? #=> true
$?.exitstatus #=> 0
fork { exit 99 } #=> 26573
Process.wait #=> 26573
$?.exited? #=> true
$?.exitstatus #=> 99
;T;[o;=
;3I"
overload;F;40;;;50;)I"exitstatus;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @,-; [ ; I"@return [Integer, nil];T; 0; @,-;!F;6i ;>0;[ ; @,-; [ ; I"Returns the least significant eight bits of the return code of
_stat_. Only available if #exited? is +true+.
fork { } #=> 26572
Process.wait #=> 26572
$?.exited? #=> true
$?.exitstatus #=> 0
fork { exit 99 } #=> 26573
Process.wait #=> 26573
$?.exited? #=> true
$?.exitstatus #=> 99
@overload exitstatus
@return [Integer, nil];T; 0; @,-;!F;"o;#;$T;%iv;&i;'@+;(I"static VALUE
pst_wexitstatus(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return INT2NUM(WEXITSTATUS(status));
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Process::Status#success?;F;[ ;[[@]i;T;:
success?;0;[ ;{ ;IC; "eReturns +true+ if _stat_ is successful, +false+ if not.
Returns +nil+ if #exited? is not +true+.;T;[o;=
;3I"
overload;F;40;;;50;)I"
success?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;TI"
false;TI"nil;T; @H-; [ ; I" @return [true, false, nil];T; 0; @H-;!F;6i ;>0;[ ; @H-; [ ; I"Returns +true+ if _stat_ is successful, +false+ if not.
Returns +nil+ if #exited? is not +true+.
@overload success?
@return [true, false, nil];T; 0; @H-;!F;"o;#;$T;%i;&i;6i ;'@+;(I"static VALUE
pst_success_p(VALUE st)
{
int status = PST2INT(st);
if (!WIFEXITED(status))
return Qnil;
return WEXITSTATUS(status) == EXIT_SUCCESS ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Process::Status#coredump?;F;[ ;[[@]i;T;:coredump?;0;[ ;{ ;IC; "fReturns +true+ if _stat_ generated a coredump
when it terminated. Not available on all platforms.;T;[o;=
;3I"
overload;F;40;;;50;)I"coredump?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @e-; [ ; I"@return [Boolean];T; 0; @e-;!F;6i ;>0;[ ; @e-; [ ; I"Returns +true+ if _stat_ generated a coredump
when it terminated. Not available on all platforms.
@overload coredump?
@return [Boolean];T; 0; @e-;!F;"o;#;$T;%i;&i;6i ;'@+;(I"static VALUE
pst_wcoredump(VALUE st)
{
#ifdef WCOREDUMP
int status = PST2INT(st);
if (WCOREDUMP(status))
return Qtrue;
else
return Qfalse;
#else
return Qfalse;
#endif
};T;)I"static VALUE;T;*T;A@+;BIC;[ ;A@+;CIC;[ ;A@+;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@]i[@]i !;T;: Status;;K;;;[ ;{ ;IC; "*******************************************************************
Process::Status encapsulates the information on the
status of a running or terminated system process. The built-in
variable $? is either +nil+ or a
Process::Status object.
fork { exit 99 } #=> 26557
Process.wait #=> 26557
$?.class #=> Process::Status
$?.to_i #=> 25344
$? >> 8 #=> 99
$?.stopped? #=> false
$?.exited? #=> true
$?.exitstatus #=> 99
Posix systems record information on processes using a 16-bit
integer. The lower bits record the process status (stopped,
exited, signaled) and the upper bits possibly contain additional
information (for example the program's return code in the case of
exited processes). Pre Ruby 1.8, these bits were exposed directly
to the Ruby program. Ruby now encapsulates these in a
Process::Status object. To maximize compatibility,
however, these objects retain a bit-oriented interface. In the
descriptions that follow, when we talk about the integer value of
_stat_, we're referring to this 16 bit value.;T;[ ; [ ; I"*******************************************************************
Process::Status encapsulates the information on the
status of a running or terminated system process. The built-in
variable $? is either +nil+ or a
Process::Status object.
fork { exit 99 } #=> 26557
Process.wait #=> 26557
$?.class #=> Process::Status
$?.to_i #=> 25344
$? >> 8 #=> 99
$?.stopped? #=> false
$?.exited? #=> true
$?.exitstatus #=> 99
Posix systems record information on processes using a 16-bit
integer. The lower bits record the process status (stopped,
exited, signaled) and the upper bits possibly contain additional
information (for example the program's return code in the case of
exited processes). Pre Ruby 1.8, these bits were exposed directly
to the Ruby program. Ruby now encapsulates these in a
Process::Status object. To maximize compatibility,
however, these objects retain a bit-oriented interface. In the
descriptions that follow, when we talk about the integer value of
_stat_, we're referring to this 16 bit value.
;T; 0; @+;!F;"o;#;$T;%i;&i ;6i ;'o;L ;M0;N0;O0;: Process;'@;Q@{+;R0;I"Process::Status;F;S@]o;;[[@]i [@]i ;F;: WNOHANG;;;;;[ ;{ ;IC; "see Process.wait
;T;[ ; [ ; I"see Process.wait;T; 0; @-;!F;"o;#;$T;%i ;&i ;'@{+;I"Process::WNOHANG;F;I"INT2FIX(0);To;;[[@]i [@]i ;F;:WUNTRACED;;;;;[ ;{ ;IC; "see Process.wait
;T;[ ; [ ; I"see Process.wait;T; 0; @-;!F;"o;#;$T;%i ;&i ;'@{+;I"Process::WUNTRACED;F;I"INT2FIX(0);To; ; F;
;F;;;I"Process.exec;F;[[I"*a;T0[I"_;T0;[[@]i ;T;;;0;[ ;{ ;IC; "4
Replaces the current process by running the given external _command_, which
can take one of the following forms:
[exec(commandline)]
command line string which is passed to the standard shell
[exec(cmdname, arg1, ...)]
command name and one or more arguments (no shell)
[exec([cmdname, argv0], arg1, ...)]
command name, argv[0] and zero or more arguments (no shell)
In the first form, the string is taken as a command line that is subject to
shell expansion before being executed.
The standard shell always means "/bin/sh" on Unix-like systems,
same as ENV["RUBYSHELL"]
(or ENV["COMSPEC"] on Windows NT series), and similar.
If the string from the first form (exec("command")) follows
these simple rules:
* no meta characters
* no shell reserved word and no special built-in
* Ruby invokes the command directly without shell
You can force shell invocation by adding ";" to the string (because ";" is
a meta character).
Note that this behavior is observable by pid obtained
(return value of spawn() and IO#pid for IO.popen) is the pid of the invoked
command, not shell.
In the second form (exec("command1", "arg1", ...)), the first
is taken as a command name and the rest are passed as parameters to command
with no shell expansion.
In the third form (exec(["command", "argv0"], "arg1", ...)),
starting a two-element array at the beginning of the command, the first
element is the command to be executed, and the second argument is used as
the argv[0] value, which may show up in process listings.
In order to execute the command, one of the exec(2) system
calls are used, so the running command may inherit some of the environment
of the original program (including open file descriptors).
This behavior is modified by the given +env+ and +options+ parameters. See
::spawn for details.
If the command fails to execute (typically Errno::ENOENT when
it was not found) a SystemCallError exception is raised.
This method modifies process attributes according to given +options+ before
exec(2) system call. See ::spawn for more details about the
given +options+.
The modified attributes may be retained when exec(2) system
call fails.
For example, hard resource limits are not restorable.
Consider to create a child process using ::spawn or Kernel#system if this
is not acceptable.
exec "echo *" # echoes list of files in current directory
# never get here
exec "echo", "*" # echoes an asterisk
# never get here
;T;[o;=
;3I"
overload;F;40;;;50;)I"'exec([env,] command... [,options]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @-;!F;6i ;>0;[[I"[env,][,options];T0; @-; [ ; @m; 0; @-;!F;"o;#;$T;%i} ;&i ;'@{+;(I"Xstatic VALUE
f_exec(int c, const VALUE *a, VALUE _)
{
return rb_f_exec(c, a);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Process.fork;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @-;'@{+;*To; ; F;
;F;;;I"Process.spawn;F;[[@c0;[[@]i;T;;;0;[ ;{ ;IC; "7*spawn executes specified command and return its pid.
pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
Process.wait pid
pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
Process.wait pid
This method is similar to Kernel#system but it doesn't wait for the command
to finish.
The parent process should
use Process.wait to collect
the termination status of its child or
use Process.detach to register
disinterest in their status;
otherwise, the operating system may accumulate zombie processes.
spawn has bunch of options to specify process attributes:
env: hash
name => val : set the environment variable
name => nil : unset the environment variable
the keys and the values except for +nil+ must be strings.
command...:
commandline : command line string which is passed to the standard shell
cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.)
[cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
options: hash
clearing environment variables:
:unsetenv_others => true : clear environment variables except specified by env
:unsetenv_others => false : don't clear (default)
process group:
:pgroup => true or 0 : make a new process group
:pgroup => pgid : join the specified process group
:pgroup => nil : don't change the process group (default)
create new process group: Windows only
:new_pgroup => true : the new process is the root process of a new process group
:new_pgroup => false : don't create a new process group (default)
resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit.
:rlimit_resourcename => limit
:rlimit_resourcename => [cur_limit, max_limit]
umask:
:umask => int
redirection:
key:
FD : single file descriptor in child process
[FD, FD, ...] : multiple file descriptor in child process
value:
FD : redirect to the file descriptor in parent process
string : redirect to file with open(string, "r" or "w")
[string] : redirect to file with open(string, File::RDONLY)
[string, open_mode] : redirect to file with open(string, open_mode, 0644)
[string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
[:child, FD] : redirect to the redirected file descriptor
:close : close the file descriptor in child process
FD is one of follows
:in : the file descriptor 0 which is the standard input
:out : the file descriptor 1 which is the standard output
:err : the file descriptor 2 which is the standard error
integer : the file descriptor of specified the integer
io : the file descriptor specified as io.fileno
file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
:close_others => false : inherit
current directory:
:chdir => str
The cmdname, arg1, ... form does not use the shell.
However, on different OSes, different things are provided as
built-in commands. An example of this is +'echo'+, which is a
built-in on Windows, but is a normal program on Linux and Mac OS X.
This means that Process.spawn 'echo', '%Path%' will
display the contents of the %Path% environment variable
on Windows, but Process.spawn 'echo', '$PATH' prints
the literal $PATH.
If a hash is given as +env+, the environment is
updated by +env+ before exec(2) in the child process.
If a pair in +env+ has nil as the value, the variable is deleted.
# set FOO as BAR and unset BAZ.
pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command)
If a hash is given as +options+,
it specifies
process group,
create new process group,
resource limit,
current directory,
umask and
redirects for the child process.
Also, it can be specified to clear environment variables.
The :unsetenv_others key in +options+ specifies
to clear environment variables, other than specified by +env+.
pid = spawn(command, :unsetenv_others=>true) # no environment variable
pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only
The :pgroup key in +options+ specifies a process group.
The corresponding value should be true, zero, a positive integer, or nil.
true and zero cause the process to be a process leader of a new process group.
A non-zero positive integer causes the process to join the provided process group.
The default value, nil, causes the process to remain in the same process group.
pid = spawn(command, :pgroup=>true) # process leader
pid = spawn(command, :pgroup=>10) # belongs to the process group 10
The :new_pgroup key in +options+ specifies to pass
+CREATE_NEW_PROCESS_GROUP+ flag to CreateProcessW() that is
Windows API. This option is only for Windows.
true means the new process is the root process of the new process group.
The new process has CTRL+C disabled. This flag is necessary for
Process.kill(:SIGINT, pid) on the subprocess.
:new_pgroup is false by default.
pid = spawn(command, :new_pgroup=>true) # new process group
pid = spawn(command, :new_pgroup=>false) # same process group
The :rlimit_foo key specifies a resource limit.
foo should be one of resource types such as core.
The corresponding value should be an integer or an array which have one or
two integers: same as cur_limit and max_limit arguments for
Process.setrlimit.
cur, max = Process.getrlimit(:CORE)
pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary.
pid = spawn(command, :rlimit_core=>max) # enable core dump
pid = spawn(command, :rlimit_core=>0) # never dump core.
The :umask key in +options+ specifies the umask.
pid = spawn(command, :umask=>077)
The :in, :out, :err, an integer, an IO and an array key specifies a redirection.
The redirection maps a file descriptor in the child process.
For example, stderr can be merged into stdout as follows:
pid = spawn(command, :err=>:out)
pid = spawn(command, 2=>1)
pid = spawn(command, STDERR=>:out)
pid = spawn(command, STDERR=>STDOUT)
The hash keys specifies a file descriptor in the child process
started by #spawn.
:err, 2 and STDERR specifies the standard error stream (stderr).
The hash values specifies a file descriptor in the parent process
which invokes #spawn.
:out, 1 and STDOUT specifies the standard output stream (stdout).
In the above example,
the standard output in the child process is not specified.
So it is inherited from the parent process.
The standard input stream (stdin) can be specified by :in, 0 and STDIN.
A filename can be specified as a hash value.
pid = spawn(command, :in=>"/dev/null") # read mode
pid = spawn(command, :out=>"/dev/null") # write mode
pid = spawn(command, :err=>"log") # write mode
pid = spawn(command, [:out, :err]=>"/dev/null") # write mode
pid = spawn(command, 3=>"/dev/null") # read mode
For stdout and stderr (and combination of them),
it is opened in write mode.
Otherwise read mode is used.
For specifying flags and permission of file creation explicitly,
an array is used instead.
pid = spawn(command, :in=>["file"]) # read mode is assumed
pid = spawn(command, :in=>["file", "r"])
pid = spawn(command, :out=>["log", "w"]) # 0644 assumed
pid = spawn(command, :out=>["log", "w", 0600])
pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])
The array specifies a filename, flags and permission.
The flags can be a string or an integer.
If the flags is omitted or nil, File::RDONLY is assumed.
The permission should be an integer.
If the permission is omitted or nil, 0644 is assumed.
If an array of IOs and integers are specified as a hash key,
all the elements are redirected.
# stdout and stderr is redirected to log file.
# The file "log" is opened just once.
pid = spawn(command, [:out, :err]=>["log", "w"])
Another way to merge multiple file descriptors is [:child, fd].
\[:child, fd] means the file descriptor in the child process.
This is different from fd.
For example, :err=>:out means redirecting child stderr to parent stdout.
But :err=>[:child, :out] means redirecting child stderr to child stdout.
They differ if stdout is redirected in the child process as follows.
# stdout and stderr is redirected to log file.
# The file "log" is opened just once.
pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out])
\[:child, :out] can be used to merge stderr into stdout in IO.popen.
In this case, IO.popen redirects stdout to a pipe in the child process
and [:child, :out] refers the redirected stdout.
io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]])
p io.read #=> "out\nerr\n"
The :chdir key in +options+ specifies the current directory.
pid = spawn(command, :chdir=>"/var/tmp")
spawn closes all non-standard unspecified descriptors by default.
The "standard" descriptors are 0, 1 and 2.
This behavior is specified by :close_others option.
:close_others doesn't affect the standard descriptors which are
closed only if :close is specified explicitly.
pid = spawn(command, :close_others=>true) # close 3,4,5,... (default)
pid = spawn(command, :close_others=>false) # don't close 3,4,5,...
:close_others is false by default for spawn and IO.popen.
Note that fds which close-on-exec flag is already set are closed
regardless of :close_others option.
So IO.pipe and spawn can be used as IO.popen.
# similar to r = IO.popen(command)
r, w = IO.pipe
pid = spawn(command, :out=>w) # r, w is closed in the child process.
w.close
:close is specified as a hash value to close a fd individually.
f = open(foo)
system(command, f=>:close) # don't inherit f.
If a file descriptor need to be inherited,
io=>io can be used.
# valgrind has --log-fd option for log destination.
# log_w=>log_w indicates log_w.fileno inherits to child process.
log_r, log_w = IO.pipe
pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
log_w.close
p log_r.read
It is also possible to exchange file descriptors.
pid = spawn(command, :out=>:err, :err=>:out)
The hash keys specify file descriptors in the child process.
The hash values specifies file descriptors in the parent process.
So the above specifies exchanging stdout and stderr.
Internally, +spawn+ uses an extra file descriptor to resolve such cyclic
file descriptor mapping.
See Kernel.exec for the standard shell.
;T;[o;=
;3I"
overload;F;40;;;50;)I"(spawn([env,] command... [,options]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @-;!F;6i ;>0;[[I"[env,][,options];T0; @-o;=
;3I"
overload;F;40;;;50;)I"(spawn([env,] command... [,options]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @-;!F;6i ;>0;[[I"[env,][,options];T0; @-; [ ; @; 0; @-;!F;"o;#;$T;%i;&i;'@{+;(I"static VALUE
rb_f_spawn(int argc, VALUE *argv, VALUE _)
{
rb_pid_t pid;
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
eargp = rb_execarg_get(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));
if (pid == -1) {
int err = errno;
rb_exec_fail(eargp, err, errmsg);
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(err, fail_str);
}
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Process.exit!;F;[[@c0;[[@]ip;T;;;0;[ ;{ ;IC; "Exits the process immediately. No exit handlers are
run. status is returned to the underlying system as the
exit status.
Process.exit!(true)
;T;[o;=
;3I"
overload;F;40;;;50;)I"exit!(status=false);T;IC; " ;T;[ ; [ ; I" ;T; 0; @-;!F;6i ;>0;[[I" status;TI"
false;T; @-; [ ; @; 0; @-;!F;"o;#;$T;%ie;&il;'@{+;(I"static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
int istatus;
if (rb_check_arity(argc, 0, 1) == 1) {
istatus = exit_status_code(argv[0]);
}
else {
istatus = EXIT_FAILURE;
}
_exit(istatus);
UNREACHABLE_RETURN(Qnil);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Process.exit;F;[[I"*a;T0[I"_;T0;[[@]i;T;;;0;[ ;{ ;IC; "Initiates the termination of the Ruby script by raising the
SystemExit exception. This exception may be caught. The
optional parameter is used to return a status code to the invoking
environment.
+true+ and +FALSE+ of _status_ means success and failure
respectively. The interpretation of other integer values are
system dependent.
begin
exit
puts "never get here"
rescue SystemExit
puts "rescued a SystemExit exception"
end
puts "after begin block"
produces:
rescued a SystemExit exception
after begin block
Just prior to termination, Ruby executes any at_exit
functions (see Kernel::at_exit) and runs any object finalizers
(see ObjectSpace::define_finalizer).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer("string", proc { puts "in finalizer" })
exit
produces:
at_exit function
in finalizer
;T;[o;=
;3I"
overload;F;40;;;50;)I"exit(status=true);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ .;!F;6i ;>0;[[I" status;TI" true;T; @ .o;=
;3I"
overload;F;40;;;50;)I" Kernel::exit(status=true);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ .;!F;6i ;>0;[[I" status;TI" true;T; @ .o;=
;3I"
overload;F;40;;;50;)I" Process::exit(status=true);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ .;!F;6i ;>0;[[I" status;TI" true;T; @ .; [ ; @'; 0; @ .;!F;"o;#;$T;%i;&i;'@{+;(I"Xstatic VALUE
f_exit(int c, const VALUE *a, VALUE _)
{
return rb_f_exit(c, a);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Process.abort;F;[[I"*a;T0[I"_;T0;[[@]i;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @>.;'@{+;(I"Zstatic VALUE
f_abort(int c, const VALUE *a, VALUE _)
{
return rb_f_abort(c, a);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Process.last_status;F;[ ;[[@]i6;T;:last_status;0;[ ;{ ;IC; "?Returns the status of the last executed child process in the
current thread.
Process.wait Process.spawn("ruby", "-e", "exit 13")
Process.last_status #=> #$? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900
;T;[o;=
;3I"
overload;F;40;;;50;)I" wait();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[ ; @.o;=
;3I"
overload;F;40;;;50;)I"wait(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @.o;=
;3I"
overload;F;40;: waitpid;50;)I" waitpid(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @.; [ ; I")Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900
@overload wait()
@return [Integer]
@overload wait(pid=-1, flags=0)
@return [Integer]
@overload waitpid(pid=-1, flags=0)
@return [Integer];T; 0; @.;!F;>0;'@{+;(I"Wstatic VALUE
proc_m_wait(int c, VALUE *v, VALUE _)
{
return proc_wait(c, v);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.wait;F;@.;@.;T;;;0;@.;{ ;IC; "Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900;T;[o;=
;3I"
overload;F;40;;;50;)I" wait();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[ ; @.o;=
;3I"
overload;F;40;;;50;)I"wait(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @.o;=
;3I"
overload;F;40;;;50;)I" waitpid(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @.; [ ; I"(Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900
@overload wait()
@return [Integer]
@overload wait(pid=-1, flags=0)
@return [Integer]
@overload waitpid(pid=-1, flags=0)
@return [Integer];T; 0; @.;!F;"o;#;$T;%i ;&iJ;6i ;'@{+;(@.;)@.;*To; ; F;
;;;;I"Process#wait2;F;[[@c0;[[@]ib;T;:
wait2;0;[ ;{ ;IC; "Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
;T;[o;=
;3I"
overload;F;40;;;50;)I"wait2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @(/; [ ; I"@return [Array];T; 0; @(/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @(/o;=
;3I"
overload;F;40;:
waitpid2;50;)I" waitpid2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @(/; [ ; I"@return [Array];T; 0; @(/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @(/; [ ; I"Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
@overload wait2(pid=-1, flags=0)
@return [Array]
@overload waitpid2(pid=-1, flags=0)
@return [Array];T; 0; @(/;!F;>0;'@{+;(I"static VALUE
proc_wait2(int argc, VALUE *argv, VALUE _)
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status_get());
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.wait2;F;@*/;@,/;T;;;0;@./;{ ;IC; "Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99;T;[o;=
;3I"
overload;F;40;;;50;)I"wait2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @\/; [ ; I"@return [Array];T; 0; @\/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @\/o;=
;3I"
overload;F;40;;;50;)I" waitpid2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @\/; [ ; I"@return [Array];T; 0; @\/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @\/; [ ; I"Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
@overload wait2(pid=-1, flags=0)
@return [Array]
@overload waitpid2(pid=-1, flags=0)
@return [Array];T; 0; @\/;!F;"o;#;$T;%iR;&i`;6i ;'@{+;(@Z/;)@[/;*To; ; F;
;;;;I"Process#waitpid;F;[[I"*v;T0[I"_;T0;[[@]iK;T;;;0;[ ;{ ;IC; "Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900
;T;[o;=
;3I"
overload;F;40;;;50;)I" wait();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[ ; @/o;=
;3I"
overload;F;40;;;50;)I"wait(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @/o;=
;3I"
overload;F;40;;;50;)I" waitpid(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @/; [ ; I")Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900
@overload wait()
@return [Integer]
@overload wait(pid=-1, flags=0)
@return [Integer]
@overload waitpid(pid=-1, flags=0)
@return [Integer];T; 0; @/;!F;>0;'@{+;(I"Wstatic VALUE
proc_m_wait(int c, VALUE *v, VALUE _)
{
return proc_wait(c, v);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.waitpid;F;@/;@/;T;;;0;@/;{ ;IC; "Waits for a child process to exit, returns its process id, and
sets $? to a Process::Status object
containing information on that process. Which child it waits on
depends on the value of _pid_:
> 0:: Waits for the child whose process ID equals _pid_.
0:: Waits for any child whose process group ID equals that of the
calling process.
-1:: Waits for any child process (the default if no _pid_ is
given).
< -1:: Waits for any child whose process group ID equals the absolute
value of _pid_.
The _flags_ argument may be a logical or of the flag values
Process::WNOHANG (do not block if no child available)
or Process::WUNTRACED (return stopped children that
haven't been reported). Not all flags are available on all
platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemCallError if there are no child
processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> 2008-03-08 19:56:16 +0900
waitpid(pid, 0) #=> 27440
Time.now #=> 2008-03-08 19:56:19 +0900;T;[o;=
;3I"
overload;F;40;;;50;)I" wait();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[ ; @/o;=
;3I"
overload;F;40;;;50;)I"wait(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @/o;=
;3I"
overload;F;40;;;50;)I" waitpid(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @/; [ ; I"@return [Integer];T; 0; @/;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @/; [ ; @&/; 0; @/;!F;"o;#;$T;%i ;&iJ;6i ;'@{+;(@/;)@/;*To; ; F;
;;;;I"Process#waitpid2;F;[[@c0;[[@]ib;T;;;0;[ ;{ ;IC; "Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
;T;[o;=
;3I"
overload;F;40;;;50;)I"wait2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @0; [ ; I"@return [Array];T; 0; @0;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @0o;=
;3I"
overload;F;40;;;50;)I" waitpid2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @0; [ ; I"@return [Array];T; 0; @0;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @0; [ ; I"Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
@overload wait2(pid=-1, flags=0)
@return [Array]
@overload waitpid2(pid=-1, flags=0)
@return [Array];T; 0; @0;!F;>0;'@{+;(I"static VALUE
proc_wait2(int argc, VALUE *argv, VALUE _)
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status_get());
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.waitpid2;F;@
0;@ 0;T;;;0;@0;{ ;IC; "Waits for a child process to exit (see Process::waitpid for exact
semantics) and returns an array containing the process id and the
exit status (a Process::Status object) of that
child. Raises a SystemCallError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99;T;[o;=
;3I"
overload;F;40;;;50;)I"wait2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @<0; [ ; I"@return [Array];T; 0; @<0;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @<0o;=
;3I"
overload;F;40;;;50;)I" waitpid2(pid=-1, flags=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @<0; [ ; I"@return [Array];T; 0; @<0;!F;6i ;>0;[[I"pid;TI"-1;T[I"
flags;TI"0;T; @<0; [ ; @/; 0; @<0;!F;"o;#;$T;%iR;&i`;6i ;'@{+;(@:0;)@;0;*To; ; F;
;;;;I"Process#waitall;F;[ ;[[@]i;T;: waitall;0;[ ;{ ;IC; "Waits for all children, returning an array of
_pid_/_status_ pairs (where _status_ is a
Process::Status object).
fork { sleep 0.2; exit 2 } #=> 27432
fork { sleep 0.1; exit 1 } #=> 27433
fork { exit 0 } #=> 27434
p Process.waitall
produces:
[[30982, #wait()). If the parent never collects
this status, the child stays around as a zombie process.
Process::detach prevents this by setting up a separate Ruby thread
whose sole job is to reap the status of the process _pid_ when it
terminates. Use #detach only when you do not intend to explicitly
wait for the child to terminate.
The waiting thread returns the exit status of the detached process
when it terminates, so you can use Thread#join to
know the result. If specified _pid_ is not a valid child process
ID, the thread returns +nil+ immediately.
The waiting thread has #pid method which returns the pid.
In this first example, we don't reap the first child process, so
it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach is used to reap
the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output)
;T;[o;=
;3I"
overload;F;40;;;50;)I"detach(pid);T;IC; " ;T;[ ; [ ; I" ;T; 0; @0;!F;6i ;>0;[[I"pid;T0; @0; [ ; I"9Some operating systems retain the status of terminated child
processes until the parent collects that status (normally using
some variant of wait()). If the parent never collects
this status, the child stays around as a zombie process.
Process::detach prevents this by setting up a separate Ruby thread
whose sole job is to reap the status of the process _pid_ when it
terminates. Use #detach only when you do not intend to explicitly
wait for the child to terminate.
The waiting thread returns the exit status of the detached process
when it terminates, so you can use Thread#join to
know the result. If specified _pid_ is not a valid child process
ID, the thread returns +nil+ immediately.
The waiting thread has #pid method which returns the pid.
In this first example, we don't reap the first child process, so
it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach is used to reap
the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output)
@overload detach(pid)
;T; 0; @0;!F;>0;'@{+;(I"dstatic VALUE
proc_detach(VALUE obj, VALUE pid)
{
return rb_detach_process(NUM2PIDT(pid));
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.detach;F;@0;@0;T;;;0;@0;{ ;IC; ""Some operating systems retain the status of terminated child
processes until the parent collects that status (normally using
some variant of wait()). If the parent never collects
this status, the child stays around as a zombie process.
Process::detach prevents this by setting up a separate Ruby thread
whose sole job is to reap the status of the process _pid_ when it
terminates. Use #detach only when you do not intend to explicitly
wait for the child to terminate.
The waiting thread returns the exit status of the detached process
when it terminates, so you can use Thread#join to
know the result. If specified _pid_ is not a valid child process
ID, the thread returns +nil+ immediately.
The waiting thread has #pid method which returns the pid.
In this first example, we don't reap the first child process, so
it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach is used to reap
the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output);T;[o;=
;3I"
overload;F;40;;;50;)I"detach(pid);T;IC; " ;T;[ ; [ ; I" ;T; 0; @0;!F;6i ;>0;[[I"pid;T0; @0; [ ; I":Some operating systems retain the status of terminated child
processes until the parent collects that status (normally using
some variant of wait()). If the parent never collects
this status, the child stays around as a zombie process.
Process::detach prevents this by setting up a separate Ruby thread
whose sole job is to reap the status of the process _pid_ when it
terminates. Use #detach only when you do not intend to explicitly
wait for the child to terminate.
The waiting thread returns the exit status of the detached process
when it terminates, so you can use Thread#join to
know the result. If specified _pid_ is not a valid child process
ID, the thread returns +nil+ immediately.
The waiting thread has #pid method which returns the pid.
In this first example, we don't reap the first child process, so
it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach is used to reap
the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output)
@overload detach(pid);T; 0; @0;!F;"o;#;$T;%i;&i;6i ;'@{+;(@0;)@0;*To;
;IC;[o; ; F;
;;;;I"Process::Waiter#pid;F;[ ;[[@]i;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @0;'@0;(I"gstatic VALUE
detach_process_pid(VALUE thread)
{
return rb_thread_local_aref(thread, id_pid);
};T;)I"static VALUE;T;*T;A@0;BIC;[ ;A@0;CIC;[ ;A@0;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@]i!;F;: Waiter;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @0;'@{+;I"Process::Waiter;F;So;
;IC;[Ao; ; F;
;;;;I"Thread#set_trace_func;F;[[I"
trace;T0;[[@ i?;T;;;0;[ ;{ ;IC; "Establishes _proc_ on _thr_ as the handler for tracing, or
disables tracing if the parameter is +nil+.
See Kernel#set_trace_func.
;T;[o;=
;3I"
overload;F;40;;;50;)I"set_trace_func(proc);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Proc;T; @0; [ ; I"@return [Proc];T; 0; @0;!F;6i ;>0;[[I" proc;T0; @0o;=
;3I"
overload;F;40;;;50;)I"set_trace_func(nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @0; [ ; I"@return [nil];T; 0; @0;!F;6i ;>0;[[I"nil;T0; @0; [ ; I"Establishes _proc_ on _thr_ as the handler for tracing, or
disables tracing if the parameter is +nil+.
See Kernel#set_trace_func.
@overload set_trace_func(proc)
@return [Proc]
@overload set_trace_func(nil)
@return [nil];T; 0; @0;!F;"o;#;$T;%i4;&i=;'@0;(I"xstatic VALUE
thread_set_trace_func_m(VALUE target_thread, VALUE trace)
{
rb_execution_context_t *ec = GET_EC();
rb_thread_t *target_th = rb_thread_ptr(target_thread);
rb_threadptr_remove_event_hook(ec, target_th, call_trace_func, Qundef);
if (NIL_P(trace)) {
return Qnil;
}
else {
thread_add_trace_func(ec, target_th, trace);
return trace;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#add_trace_func;F;[[I"
trace;T0;[[@ i-;T;:add_trace_func;0;[ ;{ ;IC; "`Adds _proc_ as a handler for tracing.
See Thread#set_trace_func and Kernel#set_trace_func.
;T;[o;=
;3I"
overload;F;40;;;50;)I"add_trace_func(proc);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Proc;T; @1; [ ; I"@return [Proc];T; 0; @1;!F;6i ;>0;[[I" proc;T0; @1; [ ; I"Adds _proc_ as a handler for tracing.
See Thread#set_trace_func and Kernel#set_trace_func.
@overload add_trace_func(proc)
@return [Proc];T; 0; @1;!F;"o;#;$T;%i$;&i*;'@0;(I"static VALUE
thread_add_trace_func_m(VALUE obj, VALUE trace)
{
thread_add_trace_func(GET_EC(), rb_thread_ptr(obj), trace);
return trace;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Thread.new;F;[[@c0;[[I"
thread.c;Ti~;T;;;0;[ ;{ ;IC; "Thread.new(*args, &proc) -> thread
Thread.new(*args) { |args| ... } -> thread
Creates a new thread executing the given block.
Any +args+ given to ::new will be passed to the block:
arr = []
a, b, c = 1, 2, 3
Thread.new(a,b,c) { |d,e,f| arr << d << e << f }.join
arr #=> [1, 2, 3]
A ThreadError exception is raised if ::new is called without a block.
If you're going to subclass Thread, be sure to call super in your
+initialize+ method, otherwise a ThreadError will be raised.
;T;[ ; [ ; I" Thread.new(*args, &proc) -> thread
Thread.new(*args) { |args| ... } -> thread
Creates a new thread executing the given block.
Any +args+ given to ::new will be passed to the block:
arr = []
a, b, c = 1, 2, 3
Thread.new(a,b,c) { |d,e,f| arr << d << e << f }.join
arr #=> [1, 2, 3]
A ThreadError exception is raised if ::new is called without a block.
If you're going to subclass Thread, be sure to call super in your
+initialize+ method, otherwise a ThreadError will be raised.
;T; 0; @/1;!F;"o;#;$T;%ij;&i{;'@0;(I"static VALUE
thread_s_new(int argc, VALUE *argv, VALUE klass)
{
rb_thread_t *th;
VALUE thread = rb_thread_alloc(klass);
if (GET_VM()->main_thread->status == THREAD_KILLED)
rb_raise(rb_eThreadError, "can't alloc thread");
rb_obj_call_init_kw(thread, argc, argv, RB_PASS_CALLED_KEYWORDS);
th = rb_thread_ptr(thread);
if (!threadptr_initialized(th)) {
rb_raise(rb_eThreadError, "uninitialized thread - check `%"PRIsVALUE"#initialize'",
klass);
}
return thread;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Thread.start;F;[[I" args;T0;[[@51i;T;:
start;0;[ ;{ ;IC; "Basically the same as ::new. However, if class Thread is subclassed, then
calling +start+ in that subclass will not invoke the subclass's
+initialize+ method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"start([args]*);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" args;T; @?1; [ ; I"@yield [args];T; 0; @?1;!F;6i ;>0;[[I" [args];T0; @?1o;=
;3I"
overload;F;40;;;50;)I"fork([args]*);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" args;T; @?1; [ ; I"@yield [args];T; 0; @?1;!F;6i ;>0;[[I" [args];T0; @?1; [ ; I"Basically the same as ::new. However, if class Thread is subclassed, then
calling +start+ in that subclass will not invoke the subclass's
+initialize+ method.
@overload start([args]*)
@yield [args]
@overload fork([args]*)
@yield [args];T; 0; @?1;!F;"o;#;$T;%i;&i;'@0;(I"{static VALUE
thread_start(VALUE klass, VALUE args)
{
return thread_create_core(rb_thread_alloc(klass), args, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Thread.fork;F;[[I" args;T0;[[@51i;T;;;0;[ ;{ ;IC; "Basically the same as ::new. However, if class Thread is subclassed, then
calling +start+ in that subclass will not invoke the subclass's
+initialize+ method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"start([args]*);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" args;T; @m1; [ ; I"@yield [args];T; 0; @m1;!F;6i ;>0;[[I" [args];T0; @m1o;=
;3I"
overload;F;40;;;50;)I"fork([args]*);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" args;T; @m1; [ ; I"@yield [args];T; 0; @m1;!F;6i ;>0;[[I" [args];T0; @m1; [ ; @i1; 0; @m1;!F;"o;#;$T;%i;&i;'@0;(I"{static VALUE
thread_start(VALUE klass, VALUE args)
{
return thread_create_core(rb_thread_alloc(klass), args, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Thread.main;F;[ ;[[@51i
;T;: main;0;[ ;{ ;IC; " Returns the main thread.
;T;[o;=
;3I"
overload;F;40;;;50;)I" main;T;IC; " ;T;[ ; [ ; I" ;T; 0; @1;!F;6i ;>0;[ ; @1; [ ; I".Returns the main thread.
@overload main;T; 0; @1;!F;"o;#;$T;%i
;&i
;'@0;(I"Pstatic VALUE
rb_thread_s_main(VALUE klass)
{
return rb_thread_main();
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"Thread.current;F;[ ;[[@51i
;T;: current;0;[ ;{ ;IC; "^Returns the currently executing thread.
Thread.current #=> #Thread.current.report_on_exception = false
when starting the Thread.
However, this might handle the exception much later, or not at all
if the Thread is never joined due to the parent thread being blocked, etc.
See also ::report_on_exception=.
There is also an instance level method to set this for a specific thread,
see #report_on_exception=.
;T;[o;=
;3I"
overload;F;40;;;50;)I"report_on_exception;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @2; [ ; I"@return [Boolean];T; 0; @2;!F;6i ;>0;[ ; @2; [ ; I"Returns the status of the global ``report on exception'' condition.
The default is +true+ since Ruby 2.5.
All threads created when this flag is true will report
a message on $stderr if an exception kills the thread.
Thread.new { 1.times { raise } }
will produce this output on $stderr:
#Thread.current.report_on_exception = false
when starting the Thread.
However, this might handle the exception much later, or not at all
if the Thread is never joined due to the parent thread being blocked, etc.
See also ::report_on_exception=.
There is also an instance level method to set this for a specific thread,
see #report_on_exception=.
@overload report_on_exception
@return [Boolean];T; 0; @2;!F;"o;#;$T;%i ;&i. ;'@0;(I"static VALUE
rb_thread_s_report_exc(VALUE _)
{
return GET_THREAD()->vm->thread_report_on_exception ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I" Thread.report_on_exception=;F;[[I"val;T0;[[@51iV ;T;:report_on_exception=;0;[ ;{ ;IC; "Returns the new state.
When set to +true+, all threads created afterwards will inherit the
condition and report a message on $stderr if an exception kills a thread:
Thread.report_on_exception = true
t1 = Thread.new do
puts "In new thread"
raise "Exception from thread"
end
sleep(1)
puts "In the main thread"
This will produce:
In new thread
#ExceptionClass =>
:TimingSymbol. Where the ExceptionClass is the interrupt handled by
the given block. The TimingSymbol can be one of the following symbols:
[+:immediate+] Invoke interrupts immediately.
[+:on_blocking+] Invoke interrupts while _BlockingOperation_.
[+:never+] Never invoke all interrupts.
_BlockingOperation_ means that the operation will block the calling thread,
such as read and write. On CRuby implementation, _BlockingOperation_ is any
operation executed without GVL.
Masked asynchronous interrupts are delayed until they are enabled.
This method is similar to sigprocmask(3).
=== NOTE
Asynchronous interrupts are difficult to use.
If you need to communicate between threads, please consider to use another way such as Queue.
Or use them with deep understanding about this method.
=== Usage
In this example, we can guard from Thread#raise exceptions.
Using the +:never+ TimingSymbol the RuntimeError exception will always be
ignored in the first block of the main thread. In the second
::handle_interrupt block we can purposefully handle RuntimeError exceptions.
th = Thread.new do
Thread.handle_interrupt(RuntimeError => :never) {
begin
# You can write resource allocation code safely.
Thread.handle_interrupt(RuntimeError => :immediate) {
# ...
}
ensure
# You can write resource deallocation code safely.
end
}
end
Thread.pass
# ...
th.raise "stop"
While we are ignoring the RuntimeError exception, it's safe to write our
resource allocation code. Then, the ensure block is where we can safely
deallocate your resources.
==== Guarding from Timeout::Error
In the next example, we will guard from the Timeout::Error exception. This
will help prevent from leaking resources when Timeout::Error exceptions occur
during normal ensure clause. For this example we use the help of the
standard library Timeout, from lib/timeout.rb
require 'timeout'
Thread.handle_interrupt(Timeout::Error => :never) {
timeout(10){
# Timeout::Error doesn't occur here
Thread.handle_interrupt(Timeout::Error => :on_blocking) {
# possible to be killed by Timeout::Error
# while blocking operation
}
# Timeout::Error doesn't occur here
}
}
In the first part of the +timeout+ block, we can rely on Timeout::Error being
ignored. Then in the Timeout::Error => :on_blocking block, any
operation that will block the calling thread is susceptible to a
Timeout::Error exception being raised.
==== Stack control settings
It's possible to stack multiple levels of ::handle_interrupt blocks in order
to control more than one ExceptionClass and TimingSymbol at a time.
Thread.handle_interrupt(FooError => :never) {
Thread.handle_interrupt(BarError => :never) {
# FooError and BarError are prohibited.
}
}
==== Inheritance with ExceptionClass
All exceptions inherited from the ExceptionClass parameter will be considered.
Thread.handle_interrupt(Exception => :never) {
# all exceptions inherited from Exception are prohibited.
}
;T;[o;=
;3I"
overload;F;40;;;50;)I"handle_interrupt(hash);T;IC; " ;T;[o;2
;3I"
yield;F;4I"[];T;0;50; @2; [ ; I"@yield [];T; 0; @2;!F;6i ;>0;[[I" hash;T0; @2; [ ; I"
Changes asynchronous interrupt timing.
_interrupt_ means asynchronous event and corresponding procedure
by Thread#raise, Thread#kill, signal trap (not supported yet)
and main thread termination (if main thread terminates, then all
other thread will be killed).
The given +hash+ has pairs like ExceptionClass =>
:TimingSymbol. Where the ExceptionClass is the interrupt handled by
the given block. The TimingSymbol can be one of the following symbols:
[+:immediate+] Invoke interrupts immediately.
[+:on_blocking+] Invoke interrupts while _BlockingOperation_.
[+:never+] Never invoke all interrupts.
_BlockingOperation_ means that the operation will block the calling thread,
such as read and write. On CRuby implementation, _BlockingOperation_ is any
operation executed without GVL.
Masked asynchronous interrupts are delayed until they are enabled.
This method is similar to sigprocmask(3).
=== NOTE
Asynchronous interrupts are difficult to use.
If you need to communicate between threads, please consider to use another way such as Queue.
Or use them with deep understanding about this method.
=== Usage
In this example, we can guard from Thread#raise exceptions.
Using the +:never+ TimingSymbol the RuntimeError exception will always be
ignored in the first block of the main thread. In the second
::handle_interrupt block we can purposefully handle RuntimeError exceptions.
th = Thread.new do
Thread.handle_interrupt(RuntimeError => :never) {
begin
# You can write resource allocation code safely.
Thread.handle_interrupt(RuntimeError => :immediate) {
# ...
}
ensure
# You can write resource deallocation code safely.
end
}
end
Thread.pass
# ...
th.raise "stop"
While we are ignoring the RuntimeError exception, it's safe to write our
resource allocation code. Then, the ensure block is where we can safely
deallocate your resources.
==== Guarding from Timeout::Error
In the next example, we will guard from the Timeout::Error exception. This
will help prevent from leaking resources when Timeout::Error exceptions occur
during normal ensure clause. For this example we use the help of the
standard library Timeout, from lib/timeout.rb
require 'timeout'
Thread.handle_interrupt(Timeout::Error => :never) {
timeout(10){
# Timeout::Error doesn't occur here
Thread.handle_interrupt(Timeout::Error => :on_blocking) {
# possible to be killed by Timeout::Error
# while blocking operation
}
# Timeout::Error doesn't occur here
}
}
In the first part of the +timeout+ block, we can rely on Timeout::Error being
ignored. Then in the Timeout::Error => :on_blocking block, any
operation that will block the calling thread is susceptible to a
Timeout::Error exception being raised.
==== Stack control settings
It's possible to stack multiple levels of ::handle_interrupt blocks in order
to control more than one ExceptionClass and TimingSymbol at a time.
Thread.handle_interrupt(FooError => :never) {
Thread.handle_interrupt(BarError => :never) {
# FooError and BarError are prohibited.
}
}
==== Inheritance with ExceptionClass
All exceptions inherited from the ExceptionClass parameter will be considered.
Thread.handle_interrupt(Exception => :never) {
# all exceptions inherited from Exception are prohibited.
}
@overload handle_interrupt(hash)
@yield [];T; 0; @2;!F;"o;#;$T;%ix;&i;'@0;(I"tstatic VALUE
rb_thread_s_handle_interrupt(VALUE self, VALUE mask_arg)
{
VALUE mask;
rb_execution_context_t * volatile ec = GET_EC();
rb_thread_t * volatile th = rb_ec_thread_ptr(ec);
volatile VALUE r = Qnil;
enum ruby_tag_type state;
if (!rb_block_given_p()) {
rb_raise(rb_eArgError, "block is needed.");
}
mask = 0;
mask_arg = rb_to_hash_type(mask_arg);
rb_hash_foreach(mask_arg, handle_interrupt_arg_check_i, (VALUE)&mask);
if (!mask) {
return rb_yield(Qnil);
}
OBJ_FREEZE_RAW(mask);
rb_ary_push(th->pending_interrupt_mask_stack, mask);
if (!rb_threadptr_pending_interrupt_empty_p(th)) {
th->pending_interrupt_queue_checked = 0;
RUBY_VM_SET_INTERRUPT(th->ec);
}
EC_PUSH_TAG(th->ec);
if ((state = EC_EXEC_TAG()) == TAG_NONE) {
r = rb_yield(Qnil);
}
EC_POP_TAG();
rb_ary_pop(th->pending_interrupt_mask_stack);
if (!rb_threadptr_pending_interrupt_empty_p(th)) {
th->pending_interrupt_queue_checked = 0;
RUBY_VM_SET_INTERRUPT(th->ec);
}
RUBY_VM_CHECK_INTS(th->ec);
if (state) {
EC_JUMP_TAG(th->ec, state);
}
return r;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I" Thread.pending_interrupt?;F;[[@c0;[[@51ip;T;:pending_interrupt?;0;[ ;{ ;IC; "Returns whether or not the asynchronous queue is empty.
Since Thread::handle_interrupt can be used to defer asynchronous events,
this method can be used to determine if there are any deferred events.
If you find this method returns true, then you may finish +:never+ blocks.
For example, the following method processes deferred asynchronous events
immediately.
def Thread.kick_interrupt_immediately
Thread.handle_interrupt(Object => :immediate) {
Thread.pass
}
end
If +error+ is given, then check only for +error+ type deferred events.
=== Usage
th = Thread.new{
Thread.handle_interrupt(RuntimeError => :on_blocking){
while true
...
# reach safe point to invoke interrupt
if Thread.pending_interrupt?
Thread.handle_interrupt(Object => :immediate){}
end
...
end
}
}
...
th.raise # stop thread
This example can also be written as the following, which you should use to
avoid asynchronous interrupts.
flag = true
th = Thread.new{
Thread.handle_interrupt(RuntimeError => :on_blocking){
while true
...
# reach safe point to invoke interrupt
break if flag == false
...
end
}
}
...
flag = false # stop thread;T;[o;=
;3I"
overload;F;40;;;50;)I"$pending_interrupt?(error = nil);T;IC; " ;T;[ ; [ ; I" ;T; 0; @
3;!F;6i ;>0;[[I"
error;TI"nil;T; @
3o;2
;3I" return;F;4@|;0;5[@~; @
3; [ ; I" Returns whether or not the asynchronous queue is empty.
Since Thread::handle_interrupt can be used to defer asynchronous events,
this method can be used to determine if there are any deferred events.
If you find this method returns true, then you may finish +:never+ blocks.
For example, the following method processes deferred asynchronous events
immediately.
def Thread.kick_interrupt_immediately
Thread.handle_interrupt(Object => :immediate) {
Thread.pass
}
end
If +error+ is given, then check only for +error+ type deferred events.
=== Usage
th = Thread.new{
Thread.handle_interrupt(RuntimeError => :on_blocking){
while true
...
# reach safe point to invoke interrupt
if Thread.pending_interrupt?
Thread.handle_interrupt(Object => :immediate){}
end
...
end
}
}
...
th.raise # stop thread
This example can also be written as the following, which you should use to
avoid asynchronous interrupts.
flag = true
th = Thread.new{
Thread.handle_interrupt(RuntimeError => :on_blocking){
while true
...
# reach safe point to invoke interrupt
break if flag == false
...
end
}
}
...
flag = false # stop thread
@overload pending_interrupt?(error = nil);T; 0; @
3;!F;"o;#;$T;%i7;&il;6i ;'@0;(I"static VALUE
rb_thread_s_pending_interrupt_p(int argc, VALUE *argv, VALUE self)
{
return rb_thread_pending_interrupt_p(argc, argv, GET_THREAD()->self);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" Thread#pending_interrupt?;F;[[@c0;[[@51i;T;;;0;[ ;{ ;IC; "Returns whether or not the asynchronous queue is empty for the target thread.
If +error+ is given, then check only for +error+ type deferred events.
See ::pending_interrupt? for more information.;T;[o;=
;3I"
overload;F;40;;;50;)I"$pending_interrupt?(error = nil);T;IC; " ;T;[ ; [ ; I" ;T; 0; @*3;!F;6i ;>0;[[I"
error;TI"nil;T; @*3o;2
;3I" return;F;4@|;0;5[@~; @*3; [ ; I"Returns whether or not the asynchronous queue is empty for the target thread.
If +error+ is given, then check only for +error+ type deferred events.
See ::pending_interrupt? for more information.
@overload pending_interrupt?(error = nil);T; 0; @*3;!F;"o;#;$T;%i;&i;6i ;'@0;(I"static VALUE
rb_thread_pending_interrupt_p(int argc, VALUE *argv, VALUE target_thread)
{
rb_thread_t *target_th = rb_thread_ptr(target_thread);
if (!target_th->pending_interrupt_queue) {
return Qfalse;
}
if (rb_threadptr_pending_interrupt_empty_p(target_th)) {
return Qfalse;
}
if (rb_check_arity(argc, 0, 1)) {
VALUE err = argv[0];
if (!rb_obj_is_kind_of(err, rb_cModule)) {
rb_raise(rb_eTypeError, "class or module required for rescue clause");
}
if (rb_threadptr_pending_interrupt_include_p(target_th, err)) {
return Qtrue;
}
else {
return Qfalse;
}
}
else {
return Qtrue;
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#initialize;F;[[I" args;T0;[[@51i;T;;;0;[ ;{ ;IC; " :nodoc:
;T;[ ; [ ; I" :nodoc:;T; 0; @G3;!F;"o;#;$T;%i;&i;'@0;(I"static VALUE
thread_initialize(VALUE thread, VALUE args)
{
rb_thread_t *th = rb_thread_ptr(thread);
if (!rb_block_given_p()) {
rb_raise(rb_eThreadError, "must be called with a block");
}
else if (th->invoke_type != thread_invoke_type_none) {
VALUE loc = threadptr_invoke_proc_location(th);
if (!NIL_P(loc)) {
rb_raise(rb_eThreadError,
"already initialized thread - %"PRIsVALUE":%"PRIsVALUE,
RARRAY_AREF(loc, 0), RARRAY_AREF(loc, 1));
}
else {
rb_raise(rb_eThreadError, "already initialized thread");
}
}
else {
return thread_create_core(thread, args, NULL);
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#raise;F;[[@c0;[[@51ip ;T;;;0;[ ;{ ;IC; "]Raises an exception from the given thread. The caller does not have to be
+thr+. See Kernel#raise for more information.
Thread.abort_on_exception = true
a = Thread.new { sleep(200) }
a.raise("Gotcha")
This will produce:
prog.rb:3: Gotcha (RuntimeError)
from prog.rb:2:in `initialize'
from prog.rb:2:in `new'
from prog.rb:2
;T;[o;=
;3I"
overload;F;40;;;50;)I"
raise;T;IC; " ;T;[ ; [ ; I" ;T; 0; @W3;!F;6i ;>0;[ ; @W3o;=
;3I"
overload;F;40;;;50;)I"raise(string);T;IC; " ;T;[ ; [ ; I" ;T; 0; @W3;!F;6i ;>0;[[I" string;T0; @W3o;=
;3I"
overload;F;40;;;50;)I"*raise(exception [, string [, array]]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @W3;!F;6i ;>0;[[I""exception[, string [, array]];T0; @W3; [ ; I"Raises an exception from the given thread. The caller does not have to be
+thr+. See Kernel#raise for more information.
Thread.abort_on_exception = true
a = Thread.new { sleep(200) }
a.raise("Gotcha")
This will produce:
prog.rb:3: Gotcha (RuntimeError)
from prog.rb:2:in `initialize'
from prog.rb:2:in `new'
from prog.rb:2
@overload raise
@overload raise(string)
@overload raise(exception [, string [, array]]);T; 0; @W3;!F;"o;#;$T;%i[ ;&il ;'@0;(I"static VALUE
thread_raise_m(int argc, VALUE *argv, VALUE self)
{
rb_thread_t *target_th = rb_thread_ptr(self);
const rb_thread_t *current_th = GET_THREAD();
threadptr_check_pending_interrupt_queue(target_th);
rb_threadptr_raise(target_th, argc, argv);
/* To perform Thread.current.raise as Kernel.raise */
if (current_th == target_th) {
RUBY_VM_CHECK_INTS(target_th->ec);
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#join;F;[[@c0;[[@51in;T;: join;0;[ ;{ ;IC; "The calling thread will suspend execution and run this +thr+.
Does not return until +thr+ exits or until the given +limit+ seconds have
passed.
If the time limit expires, +nil+ will be returned, otherwise +thr+ is
returned.
Any threads not joined will be killed when the main program exits.
If +thr+ had previously raised an exception and the ::abort_on_exception or
$DEBUG flags are not set, (so the exception has not yet been processed), it
will be processed at this time.
a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
x.join # Let thread x finish, thread a will be killed on exit.
#=> "axyz"
The following example illustrates the +limit+ parameter.
y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}
puts "Waiting" until y.join(0.15)
This will produce:
tick...
Waiting
tick...
Waiting
tick...
tick...
;T;[o;=
;3I"
overload;F;40;;;50;)I" join;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3o;=
;3I"
overload;F;40;;;50;)I"join(limit);T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[[I"
limit;T0; @3; [ ; I"The calling thread will suspend execution and run this +thr+.
Does not return until +thr+ exits or until the given +limit+ seconds have
passed.
If the time limit expires, +nil+ will be returned, otherwise +thr+ is
returned.
Any threads not joined will be killed when the main program exits.
If +thr+ had previously raised an exception and the ::abort_on_exception or
$DEBUG flags are not set, (so the exception has not yet been processed), it
will be processed at this time.
a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
x.join # Let thread x finish, thread a will be killed on exit.
#=> "axyz"
The following example illustrates the +limit+ parameter.
y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}
puts "Waiting" until y.join(0.15)
This will produce:
tick...
Waiting
tick...
Waiting
tick...
tick...
@overload join
@overload join(limit);T; 0; @3;!F;"o;#;$T;%iG;&ij;'@0;(I")static VALUE
thread_join_m(int argc, VALUE *argv, VALUE self)
{
VALUE limit;
rb_hrtime_t rel, *to = 0;
/*
* This supports INFINITY and negative values, so we can't use
* rb_time_interval right now...
*/
if (!rb_check_arity(argc, 0, 1) || NIL_P(argv[0])) {
/* unlimited */
}
else if (FIXNUM_P(limit = argv[0])) {
rel = rb_sec2hrtime(NUM2TIMET(limit));
to = &rel;
}
else {
to = double2hrtime(&rel, rb_num2dbl(limit));
}
return thread_join(rb_thread_ptr(self), to);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#value;F;[ ;[[@51i;T;:
value;0;[ ;{ ;IC; " Waits for +thr+ to complete, using #join, and returns its value or raises
the exception which terminated the thread.
a = Thread.new { 2 + 2 }
a.value #=> 4
b = Thread.new { raise 'something went wrong' }
b.value #=> RuntimeError: something went wrong
;T;[o;=
;3I"
overload;F;40;;;50;)I"
value;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @3; [ ; I"@return [Object];T; 0; @3;!F;6i ;>0;[ ; @3; [ ; I"1Waits for +thr+ to complete, using #join, and returns its value or raises
the exception which terminated the thread.
a = Thread.new { 2 + 2 }
a.value #=> 4
b = Thread.new { raise 'something went wrong' }
b.value #=> RuntimeError: something went wrong
@overload value
@return [Object];T; 0; @3;!F;"o;#;$T;%i;&i;'@0;(I"static VALUE
thread_value(VALUE self)
{
rb_thread_t *th = rb_thread_ptr(self);
thread_join(th, 0);
return th->value;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Thread#kill;F;[ ;[[@51i ;T;;;0;[ ;{ ;IC; "Terminates +thr+ and schedules another thread to be run, returning
the terminated Thread. If this is the main thread, or the last
thread, exits the process.
;T;[o;=
;3I"
overload;F;40;;;50;)I" exit;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3o;=
;3I"
overload;F;40;;;50;)I" kill;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3o;=
;3I"
overload;F;40;:terminate;50;)I"terminate;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3; [ ; I"Terminates +thr+ and schedules another thread to be run, returning
the terminated Thread. If this is the main thread, or the last
thread, exits the process.
@overload exit
@overload kill
@overload terminate;T; 0; @3;!F;"o;#;$T;%i ;&i ;'@0;(I"FVALUE
rb_thread_kill(VALUE thread)
{
rb_thread_t *th = rb_thread_ptr(thread);
if (th->to_kill || th->status == THREAD_KILLED) {
return thread;
}
if (th == th->vm->main_thread) {
rb_exit(EXIT_SUCCESS);
}
thread_debug("rb_thread_kill: %p (%"PRI_THREAD_ID")\n", (void *)th, thread_id_str(th));
if (th == GET_THREAD()) {
/* kill myself immediately */
rb_threadptr_to_kill(th);
}
else {
threadptr_check_pending_interrupt_queue(th);
rb_threadptr_pending_interrupt_enque(th, eKillSignal);
rb_threadptr_interrupt(th);
}
return thread;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"Thread#terminate;F;[ ;[[@51i ;T;;;0;[ ;{ ;IC; "Terminates +thr+ and schedules another thread to be run, returning
the terminated Thread. If this is the main thread, or the last
thread, exits the process.
;T;[o;=
;3I"
overload;F;40;;;50;)I" exit;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3o;=
;3I"
overload;F;40;;;50;)I" kill;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3o;=
;3I"
overload;F;40;;;50;)I"terminate;T;IC; " ;T;[ ; [ ; I" ;T; 0; @3;!F;6i ;>0;[ ; @3; [ ; @3; 0; @3;!F;"o;#;$T;%i ;&i ;'@0;(I"FVALUE
rb_thread_kill(VALUE thread)
{
rb_thread_t *th = rb_thread_ptr(thread);
if (th->to_kill || th->status == THREAD_KILLED) {
return thread;
}
if (th == th->vm->main_thread) {
rb_exit(EXIT_SUCCESS);
}
thread_debug("rb_thread_kill: %p (%"PRI_THREAD_ID")\n", (void *)th, thread_id_str(th));
if (th == GET_THREAD()) {
/* kill myself immediately */
rb_threadptr_to_kill(th);
}
else {
threadptr_check_pending_interrupt_queue(th);
rb_threadptr_pending_interrupt_enque(th, eKillSignal);
rb_threadptr_interrupt(th);
}
return thread;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"Thread#exit;F;[ ;[[@51i ;T;;;0;[ ;{ ;IC; "Terminates +thr+ and schedules another thread to be run, returning
the terminated Thread. If this is the main thread, or the last
thread, exits the process.
;T;[o;=
;3I"
overload;F;40;;;50;)I" exit;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ 4;!F;6i ;>0;[ ; @ 4o;=
;3I"
overload;F;40;;;50;)I" kill;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ 4;!F;6i ;>0;[ ; @ 4o;=
;3I"
overload;F;40;;;50;)I"terminate;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ 4;!F;6i ;>0;[ ; @ 4; [ ; @3; 0; @ 4;!F;"o;#;$T;%i ;&i ;'@0;(I"FVALUE
rb_thread_kill(VALUE thread)
{
rb_thread_t *th = rb_thread_ptr(thread);
if (th->to_kill || th->status == THREAD_KILLED) {
return thread;
}
if (th == th->vm->main_thread) {
rb_exit(EXIT_SUCCESS);
}
thread_debug("rb_thread_kill: %p (%"PRI_THREAD_ID")\n", (void *)th, thread_id_str(th));
if (th == GET_THREAD()) {
/* kill myself immediately */
rb_threadptr_to_kill(th);
}
else {
threadptr_check_pending_interrupt_queue(th);
rb_threadptr_pending_interrupt_enque(th, eKillSignal);
rb_threadptr_interrupt(th);
}
return thread;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"Thread#run;F;[ ;[[@51i
;T;:run;0;[ ;{ ;IC; "Wakes up +thr+, making it eligible for scheduling.
a = Thread.new { puts "a"; Thread.stop; puts "c" }
sleep 0.1 while a.status!='sleep'
puts "Got here"
a.run
a.join
This will produce:
a
Got here
c
See also the instance method #wakeup.
;T;[o;=
;3I"
overload;F;40;;;50;)I"run;T;IC; " ;T;[ ; [ ; I" ;T; 0; @.4;!F;6i ;>0;[ ; @.4; [ ; I"Wakes up +thr+, making it eligible for scheduling.
a = Thread.new { puts "a"; Thread.stop; puts "c" }
sleep 0.1 while a.status!='sleep'
puts "Got here"
a.run
a.join
This will produce:
a
Got here
c
See also the instance method #wakeup.
@overload run;T; 0; @.4;!F;"o;#;$T;%i
;&i
;'@0;(I"uVALUE
rb_thread_run(VALUE thread)
{
rb_thread_wakeup(thread);
rb_thread_schedule();
return thread;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"Thread#wakeup;F;[ ;[[@51i ;T;: wakeup;0;[ ;{ ;IC; "!Marks a given thread as eligible for scheduling, however it may still
remain blocked on I/O.
*Note:* This does not invoke the scheduler, see #run for more information.
c = Thread.new { Thread.stop; puts "hey!" }
sleep 0.1 while c.status!='sleep'
c.wakeup
c.join
#=> "hey!"
;T;[o;=
;3I"
overload;F;40;;;50;)I" wakeup;T;IC; " ;T;[ ; [ ; I" ;T; 0; @D4;!F;6i ;>0;[ ; @D4; [ ; I"4Marks a given thread as eligible for scheduling, however it may still
remain blocked on I/O.
*Note:* This does not invoke the scheduler, see #run for more information.
c = Thread.new { Thread.stop; puts "hey!" }
sleep 0.1 while c.status!='sleep'
c.wakeup
c.join
#=> "hey!"
@overload wakeup;T; 0; @D4;!F;"o;#;$T;%i ;&i ;'@0;(I"VALUE
rb_thread_wakeup(VALUE thread)
{
if (!RTEST(rb_thread_wakeup_alive(thread))) {
rb_raise(rb_eThreadError, "killed thread");
}
return thread;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"Thread#[];F;[[I"key;T0;[[@51i ;T;:[];0;[ ;{ ;IC; "Attribute Reference---Returns the value of a fiber-local variable (current thread's root fiber
if not explicitly inside a Fiber), using either a symbol or a string name.
If the specified variable does not exist, returns +nil+.
[
Thread.new { Thread.current["name"] = "A" },
Thread.new { Thread.current[:name] = "B" },
Thread.new { Thread.current["name"] = "C" }
].each do |th|
th.join
puts "#{th.inspect}: #{th[:name]}"
end
This will produce:
#setpgid(0,0). Not available on all
platforms.
;T;[o;=
;3I"
overload;F;40;;;50;)I" setpgrp;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @8; [ ; I"@return [0];T; 0; @8;!F;6i ;>0;[ ; @8; [ ; I"nEquivalent to setpgid(0,0). Not available on all
platforms.
@overload setpgrp
@return [0];T; 0; @8;!F;>0;'@{+;(I"static VALUE
proc_setpgrp(VALUE _)
{
/* check for posix setpgid() first; this matches the posix */
/* getpgrp() above. It appears that configure will set SETPGRP_VOID */
/* even though setpgrp(0,0) would be preferred. The posix call avoids */
/* this confusion. */
#ifdef HAVE_SETPGID
if (setpgid(0,0) < 0) rb_sys_fail(0);
#elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)
if (setpgrp() < 0) rb_sys_fail(0);
#endif
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.setpgrp;F;@8;@8;T;;;0;@8;{ ;IC; "MEquivalent to setpgid(0,0). Not available on all
platforms.;T;[o;=
;3I"
overload;F;40;;;50;)I" setpgrp;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @8; [ ; I"@return [0];T; 0; @8;!F;6i ;>0;[ ; @8; [ ; I"oEquivalent to setpgid(0,0). Not available on all
platforms.
@overload setpgrp
@return [0];T; 0; @8;!F;"o;#;$T;%i\;&ia;6i ;'@{+;(@8;)@8;*To; ; F;
;;;;I"Process#getpgid;F;[[I"pid;T0;[[@]i;T;: getpgid;0;[ ;{ ;IC; "Returns the process group ID for the given process id. Not
available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
;T;[o;=
;3I"
overload;F;40;;;50;)I"getpgid(pid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @8; [ ; I"@return [Integer];T; 0; @8;!F;6i ;>0;[[I"pid;T0; @8; [ ; I"Returns the process group ID for the given process id. Not
available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
@overload getpgid(pid)
@return [Integer];T; 0; @8;!F;>0;'@{+;(I"static VALUE
proc_getpgid(VALUE obj, VALUE pid)
{
rb_pid_t i;
i = getpgid(NUM2PIDT(pid));
if (i < 0) rb_sys_fail(0);
return PIDT2NUM(i);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.getpgid;F;@8;@8;T;;;0;@8;{ ;IC; "Returns the process group ID for the given process id. Not
available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527;T;[o;=
;3I"
overload;F;40;;;50;)I"getpgid(pid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @8; [ ; I"@return [Integer];T; 0; @8;!F;6i ;>0;[[I"pid;T0; @8; [ ; I"Returns the process group ID for the given process id. Not
available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
@overload getpgid(pid)
@return [Integer];T; 0; @8;!F;"o;#;$T;%ix;&i;6i ;'@{+;(@8;)@8;*To; ; F;
;;;;I"Process#setpgid;F;[[I"pid;T0[I" pgrp;T0;[[@]i;T;: setpgid;0;[ ;{ ;IC; "wSets the process group ID of _pid_ (0 indicates this
process) to integer. Not available on all platforms.
;T;[o;=
;3I"
overload;F;40;;;50;)I"setpgid(pid, integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @9; [ ; I"@return [0];T; 0; @9;!F;6i ;>0;[[I"pid;T0[I" integer;T0; @9; [ ; I"Sets the process group ID of _pid_ (0 indicates this
process) to integer. Not available on all platforms.
@overload setpgid(pid, integer)
@return [0];T; 0; @9;!F;>0;'@{+;(I"static VALUE
proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
{
rb_pid_t ipid, ipgrp;
ipid = NUM2PIDT(pid);
ipgrp = NUM2PIDT(pgrp);
if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0);
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.setpgid;F;@9;@
9;T;;;0;@9;{ ;IC; "wSets the process group ID of _pid_ (0 indicates this
process) to integer. Not available on all platforms.;T;[o;=
;3I"
overload;F;40;;;50;)I"setpgid(pid, integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @(9; [ ; I"@return [0];T; 0; @(9;!F;6i ;>0;[[I"pid;T0[I" integer;T0; @(9; [ ; I"Sets the process group ID of _pid_ (0 indicates this
process) to integer. Not available on all platforms.
@overload setpgid(pid, integer)
@return [0];T; 0; @(9;!F;"o;#;$T;%i;&i;6i ;'@{+;(@&9;)@'9;*To; ; F;
;;;;I"Process#getsid;F;[[@c0;[[@]i;T;: getsid;0;[ ;{ ;IC; "Returns the session ID for the given process id. If not given,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422
;T;[o;=
;3I"
overload;F;40;;;50;)I"
getsid();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A9; [ ; I"@return [Integer];T; 0; @A9;!F;6i ;>0;[ ; @A9o;=
;3I"
overload;F;40;;;50;)I"getsid(pid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A9; [ ; I"@return [Integer];T; 0; @A9;!F;6i ;>0;[[I"pid;T0; @A9; [ ; I"UReturns the session ID for the given process id. If not given,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422
@overload getsid()
@return [Integer]
@overload getsid(pid)
@return [Integer];T; 0; @A9;!F;>0;'@{+;(I"static VALUE
proc_getsid(int argc, VALUE *argv, VALUE _)
{
rb_pid_t sid;
rb_pid_t pid = 0;
if (rb_check_arity(argc, 0, 1) == 1 && !NIL_P(argv[0]))
pid = NUM2PIDT(argv[0]);
sid = getsid(pid);
if (sid < 0) rb_sys_fail(0);
return PIDT2NUM(sid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.getsid;F;@C9;@E9;T;;;0;@G9;{ ;IC; "Returns the session ID for the given process id. If not given,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422;T;[o;=
;3I"
overload;F;40;;;50;)I"
getsid();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @k9; [ ; I"@return [Integer];T; 0; @k9;!F;6i ;>0;[ ; @k9o;=
;3I"
overload;F;40;;;50;)I"getsid(pid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @k9; [ ; I"@return [Integer];T; 0; @k9;!F;6i ;>0;[[I"pid;T0; @k9; [ ; I"UReturns the session ID for the given process id. If not given,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422
@overload getsid()
@return [Integer]
@overload getsid(pid)
@return [Integer];T; 0; @k9;!F;"o;#;$T;%i;&i;6i ;'@{+;(@i9;)@j9;*To; ; F;
;;;;I"Process#setsid;F;[ ;[[@]i;T;: setsid;0;[ ;{ ;IC; "Establishes this process as a new session and process group
leader, with no controlling tty. Returns the session id. Not
available on all platforms.
Process.setsid #=> 27422
;T;[o;=
;3I"
overload;F;40;;;50;)I" setsid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @9; [ ; I"@return [Integer];T; 0; @9;!F;6i ;>0;[ ; @9; [ ; I"Establishes this process as a new session and process group
leader, with no controlling tty. Returns the session id. Not
available on all platforms.
Process.setsid #=> 27422
@overload setsid
@return [Integer];T; 0; @9;!F;>0;'@{+;(I"static VALUE
proc_setsid(VALUE _)
{
rb_pid_t pid;
pid = setsid();
if (pid < 0) rb_sys_fail(0);
return PIDT2NUM(pid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.setsid;F;@9;@9;T;;;0;@9;{ ;IC; "Establishes this process as a new session and process group
leader, with no controlling tty. Returns the session id. Not
available on all platforms.
Process.setsid #=> 27422;T;[o;=
;3I"
overload;F;40;;;50;)I" setsid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @9; [ ; I"@return [Integer];T; 0; @9;!F;6i ;>0;[ ; @9; [ ; I"Establishes this process as a new session and process group
leader, with no controlling tty. Returns the session id. Not
available on all platforms.
Process.setsid #=> 27422
@overload setsid
@return [Integer];T; 0; @9;!F;"o;#;$T;%i;&i;6i ;'@{+;(@9;)@9;*To; ; F;
;;;;I"Process#getpriority;F;[[I"
which;T0[I"who;T0;[[@]i;T;:getpriority;0;[ ;{ ;IC; "Gets the scheduling priority for specified process, process group,
or user. kind indicates the kind of entity to find: one
of Process::PRIO_PGRP,
Process::PRIO_USER, or
Process::PRIO_PROCESS. _integer_ is an id
indicating the particular process, process group, or user (an id
of 0 means _current_). Lower priorities are more favorable
for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
;T;[o;=
;3I"
overload;F;40;;;50;)I" getpriority(kind, integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @9; [ ; I"@return [Integer];T; 0; @9;!F;6i ;>0;[[I" kind;T0[I" integer;T0; @9; [ ; I"6Gets the scheduling priority for specified process, process group,
or user. kind indicates the kind of entity to find: one
of Process::PRIO_PGRP,
Process::PRIO_USER, or
Process::PRIO_PROCESS. _integer_ is an id
indicating the particular process, process group, or user (an id
of 0 means _current_). Lower priorities are more favorable
for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
@overload getpriority(kind, integer)
@return [Integer];T; 0; @9;!F;>0;'@{+;(I"static VALUE
proc_getpriority(VALUE obj, VALUE which, VALUE who)
{
int prio, iwhich, iwho;
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
errno = 0;
prio = getpriority(iwhich, iwho);
if (errno) rb_sys_fail(0);
return INT2FIX(prio);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.getpriority;F;@9;@9;T;;;0;@9;{ ;IC; "Gets the scheduling priority for specified process, process group,
or user. kind indicates the kind of entity to find: one
of Process::PRIO_PGRP,
Process::PRIO_USER, or
Process::PRIO_PROCESS. _integer_ is an id
indicating the particular process, process group, or user (an id
of 0 means _current_). Lower priorities are more favorable
for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19;T;[o;=
;3I"
overload;F;40;;;50;)I" getpriority(kind, integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @9; [ ; I"@return [Integer];T; 0; @9;!F;6i ;>0;[[I" kind;T0[I" integer;T0; @9; [ ; I"7Gets the scheduling priority for specified process, process group,
or user. kind indicates the kind of entity to find: one
of Process::PRIO_PGRP,
Process::PRIO_USER, or
Process::PRIO_PROCESS. _integer_ is an id
indicating the particular process, process group, or user (an id
of 0 means _current_). Lower priorities are more favorable
for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
@overload getpriority(kind, integer)
@return [Integer];T; 0; @9;!F;"o;#;$T;%i;&i;6i ;'@{+;(@9;)@9;*To; ; F;
;;;;I"Process#setpriority;F;[[I"
which;T0[I"who;T0[I" prio;T0;[[@]i3;T;:setpriority;0;[ ;{ ;IC; "See Process.getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
;T;[o;=
;3I"
overload;F;40;;;50;)I")setpriority(kind, integer, priority);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @9; [ ; I"@return [0];T; 0; @9;!F;6i ;>0;[[I" kind;T0[I" integer;T0[I"
priority;T0; @9; [ ; I"MSee Process.getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
@overload setpriority(kind, integer, priority)
@return [0];T; 0; @9;!F;>0;'@{+;(I"static VALUE
proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio)
{
int iwhich, iwho, iprio;
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
iprio = NUM2INT(prio);
if (setpriority(iwhich, iwho, iprio) < 0)
rb_sys_fail(0);
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.setpriority;F;@9;@:;T;;;0;@:;{ ;IC; "See Process.getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19;T;[o;=
;3I"
overload;F;40;;;50;)I")setpriority(kind, integer, priority);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @ :; [ ; I"@return [0];T; 0; @ :;!F;6i ;>0;[[I" kind;T0[I" integer;T0[I"
priority;T0; @ :; [ ; I"NSee Process.getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
@overload setpriority(kind, integer, priority)
@return [0];T; 0; @ :;!F;"o;#;$T;%i';&i0;6i ;'@{+;(@ :;)@ :;*To;;[[@]i0!;F;:PRIO_PROCESS;;;;;[ ;{ ;IC; " see Process.setpriority
;T;[ ; [ ; I" see Process.setpriority;T; 0; @::;!F;"o;#;$T;%i/!;&i/!;'@{+;I"Process::PRIO_PROCESS;F;I"INT2FIX(PRIO_PROCESS);To;;[[@]i2!;F;:PRIO_PGRP;;;;;[ ;{ ;IC; " see Process.setpriority
;T;[ ; [ ; I" see Process.setpriority;T; 0; @F:;!F;"o;#;$T;%i1!;&i1!;'@{+;I"Process::PRIO_PGRP;F;I"INT2FIX(PRIO_PGRP);To;;[[@]i4!;F;:PRIO_USER;;;;;[ ;{ ;IC; " see Process.setpriority
;T;[ ; [ ; I" see Process.setpriority;T; 0; @R:;!F;"o;#;$T;%i3!;&i3!;'@{+;I"Process::PRIO_USER;F;I"INT2FIX(PRIO_USER);To; ; F;
;;;;I"Process#getrlimit;F;[[I"
resource;T0;[[@]i7;T;:getrlimit;0;[ ;{ ;IC; "Gets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
_resource_ indicates the kind of resource to limit.
It is specified as a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
See Process.setrlimit for details.
_cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY,
Process::RLIM_SAVED_MAX or
Process::RLIM_SAVED_CUR.
See Process.setrlimit and the system getrlimit(2) manual for details.
;T;[o;=
;3I"
overload;F;40;;;50;)I"getrlimit(resource);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @^:; [ ; I"@return [Array];T; 0; @^:;!F;6i ;>0;[[I"
resource;T0; @^:; [ ; I"BGets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
_resource_ indicates the kind of resource to limit.
It is specified as a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
See Process.setrlimit for details.
_cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY,
Process::RLIM_SAVED_MAX or
Process::RLIM_SAVED_CUR.
See Process.setrlimit and the system getrlimit(2) manual for details.
@overload getrlimit(resource)
@return [Array];T; 0; @^:;!F;>0;'@{+;(I"static VALUE
proc_getrlimit(VALUE obj, VALUE resource)
{
struct rlimit rlim;
if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) {
rb_sys_fail("getrlimit");
}
return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max));
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.getrlimit;F;@`:;@c:;T;;;0;@e:;{ ;IC; "Gets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
_resource_ indicates the kind of resource to limit.
It is specified as a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
See Process.setrlimit for details.
_cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY,
Process::RLIM_SAVED_MAX or
Process::RLIM_SAVED_CUR.
See Process.setrlimit and the system getrlimit(2) manual for details.;T;[o;=
;3I"
overload;F;40;;;50;)I"getrlimit(resource);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @|:; [ ; I"@return [Array];T; 0; @|:;!F;6i ;>0;[[I"
resource;T0; @|:; [ ; I"CGets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
_resource_ indicates the kind of resource to limit.
It is specified as a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
See Process.setrlimit for details.
_cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY,
Process::RLIM_SAVED_MAX or
Process::RLIM_SAVED_CUR.
See Process.setrlimit and the system getrlimit(2) manual for details.
@overload getrlimit(resource)
@return [Array];T; 0; @|:;!F;"o;#;$T;%i#;&i4;6i ;'@{+;(@z:;)@{:;*To; ; F;
;;;;I"Process#setrlimit;F;[[@c0;[[@]iy;T;:setrlimit;0;[ ;{ ;IC; "Sets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
If _max_limit_ is not given, _cur_limit_ is used.
_resource_ indicates the kind of resource to limit.
It should be a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
The available resources are OS dependent.
Ruby may support following resources.
[AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
[CORE] core size (bytes) (SUSv3)
[CPU] CPU time (seconds) (SUSv3)
[DATA] data segment (bytes) (SUSv3)
[FSIZE] file size (bytes) (SUSv3)
[MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
[MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux)
[NICE] ceiling on process's nice(2) value (number) (GNU/Linux)
[NOFILE] file descriptors (number) (SUSv3)
[NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux)
[RSS] resident memory size (bytes) (4.2BSD, GNU/Linux)
[RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux)
[RTTIME] CPU time for real-time process (us) (GNU/Linux)
[SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD)
[SIGPENDING] number of queued signals allowed (signals) (GNU/Linux)
[STACK] stack size (bytes) (SUSv3)
_cur_limit_ and _max_limit_ may be
:INFINITY, "INFINITY" or
Process::RLIM_INFINITY,
which means that the resource is not limited.
They may be Process::RLIM_SAVED_MAX,
Process::RLIM_SAVED_CUR and
corresponding symbols and strings too.
See system setrlimit(2) manual for details.
The following example raises the soft limit of core size to
the hard limit to try to make core dump possible.
Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])
;T;[o;=
;3I"
overload;F;40;;;50;)I".setrlimit(resource, cur_limit, max_limit);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @:; [ ; I"@return [nil];T; 0; @:;!F;6i ;>0;[[I"
resource;T0[I"cur_limit;T0[I"max_limit;T0; @:o;=
;3I"
overload;F;40;;;50;)I"#setrlimit(resource, cur_limit);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @:; [ ; I"@return [nil];T; 0; @:;!F;6i ;>0;[[I"
resource;T0[I"cur_limit;T0; @:; [ ; I"tSets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
If _max_limit_ is not given, _cur_limit_ is used.
_resource_ indicates the kind of resource to limit.
It should be a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
The available resources are OS dependent.
Ruby may support following resources.
[AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
[CORE] core size (bytes) (SUSv3)
[CPU] CPU time (seconds) (SUSv3)
[DATA] data segment (bytes) (SUSv3)
[FSIZE] file size (bytes) (SUSv3)
[MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
[MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux)
[NICE] ceiling on process's nice(2) value (number) (GNU/Linux)
[NOFILE] file descriptors (number) (SUSv3)
[NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux)
[RSS] resident memory size (bytes) (4.2BSD, GNU/Linux)
[RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux)
[RTTIME] CPU time for real-time process (us) (GNU/Linux)
[SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD)
[SIGPENDING] number of queued signals allowed (signals) (GNU/Linux)
[STACK] stack size (bytes) (SUSv3)
_cur_limit_ and _max_limit_ may be
:INFINITY, "INFINITY" or
Process::RLIM_INFINITY,
which means that the resource is not limited.
They may be Process::RLIM_SAVED_MAX,
Process::RLIM_SAVED_CUR and
corresponding symbols and strings too.
See system setrlimit(2) manual for details.
The following example raises the soft limit of core size to
the hard limit to try to make core dump possible.
Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])
@overload setrlimit(resource, cur_limit, max_limit)
@return [nil]
@overload setrlimit(resource, cur_limit)
@return [nil];T; 0; @:;!F;>0;'@{+;(I"static VALUE
proc_setrlimit(int argc, VALUE *argv, VALUE obj)
{
VALUE resource, rlim_cur, rlim_max;
struct rlimit rlim;
rb_check_arity(argc, 2, 3);
resource = argv[0];
rlim_cur = argv[1];
if (argc < 3 || NIL_P(rlim_max = argv[2]))
rlim_max = rlim_cur;
rlim.rlim_cur = rlimit_resource_value(rlim_cur);
rlim.rlim_max = rlimit_resource_value(rlim_max);
if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) {
rb_sys_fail("setrlimit");
}
return Qnil;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.setrlimit;F;@:;@:;T;;;0;@:;{ ;IC; "Sets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
If _max_limit_ is not given, _cur_limit_ is used.
_resource_ indicates the kind of resource to limit.
It should be a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
The available resources are OS dependent.
Ruby may support following resources.
[AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
[CORE] core size (bytes) (SUSv3)
[CPU] CPU time (seconds) (SUSv3)
[DATA] data segment (bytes) (SUSv3)
[FSIZE] file size (bytes) (SUSv3)
[MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
[MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux)
[NICE] ceiling on process's nice(2) value (number) (GNU/Linux)
[NOFILE] file descriptors (number) (SUSv3)
[NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux)
[RSS] resident memory size (bytes) (4.2BSD, GNU/Linux)
[RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux)
[RTTIME] CPU time for real-time process (us) (GNU/Linux)
[SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD)
[SIGPENDING] number of queued signals allowed (signals) (GNU/Linux)
[STACK] stack size (bytes) (SUSv3)
_cur_limit_ and _max_limit_ may be
:INFINITY, "INFINITY" or
Process::RLIM_INFINITY,
which means that the resource is not limited.
They may be Process::RLIM_SAVED_MAX,
Process::RLIM_SAVED_CUR and
corresponding symbols and strings too.
See system setrlimit(2) manual for details.
The following example raises the soft limit of core size to
the hard limit to try to make core dump possible.
Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1]);T;[o;=
;3I"
overload;F;40;;;50;)I".setrlimit(resource, cur_limit, max_limit);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @:; [ ; I"@return [nil];T; 0; @:;!F;6i ;>0;[[I"
resource;T0[I"cur_limit;T0[I"max_limit;T0; @:o;=
;3I"
overload;F;40;;;50;)I"#setrlimit(resource, cur_limit);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @:; [ ; I"@return [nil];T; 0; @:;!F;6i ;>0;[[I"
resource;T0[I"cur_limit;T0; @:; [ ; I"uSets the resource limit of the process.
_cur_limit_ means current (soft) limit and
_max_limit_ means maximum (hard) limit.
If _max_limit_ is not given, _cur_limit_ is used.
_resource_ indicates the kind of resource to limit.
It should be a symbol such as :CORE,
a string such as "CORE" or
a constant such as Process::RLIMIT_CORE.
The available resources are OS dependent.
Ruby may support following resources.
[AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
[CORE] core size (bytes) (SUSv3)
[CPU] CPU time (seconds) (SUSv3)
[DATA] data segment (bytes) (SUSv3)
[FSIZE] file size (bytes) (SUSv3)
[MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
[MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux)
[NICE] ceiling on process's nice(2) value (number) (GNU/Linux)
[NOFILE] file descriptors (number) (SUSv3)
[NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux)
[RSS] resident memory size (bytes) (4.2BSD, GNU/Linux)
[RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux)
[RTTIME] CPU time for real-time process (us) (GNU/Linux)
[SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD)
[SIGPENDING] number of queued signals allowed (signals) (GNU/Linux)
[STACK] stack size (bytes) (SUSv3)
_cur_limit_ and _max_limit_ may be
:INFINITY, "INFINITY" or
Process::RLIM_INFINITY,
which means that the resource is not limited.
They may be Process::RLIM_SAVED_MAX,
Process::RLIM_SAVED_CUR and
corresponding symbols and strings too.
See system setrlimit(2) manual for details.
The following example raises the soft limit of core size to
the hard limit to try to make core dump possible.
Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])
@overload setrlimit(resource, cur_limit, max_limit)
@return [nil]
@overload setrlimit(resource, cur_limit)
@return [nil];T; 0; @:;!F;"o;#;$T;%iF;&iw;6i ;'@{+;(@:;)@:;*To;;[[@]i@!;F;:RLIM_SAVED_MAX;;;;;[ ;{ ;IC; "see Process.setrlimit
;T;[ ; [ ; I"see Process.setrlimit;T; 0; @:;!F;"o;#;$T;%i?!;&i?!;'@{+;I" Process::RLIM_SAVED_MAX;F;I"v;To;;[[@]iD!;F;:RLIM_INFINITY;;;;;[ ;{ ;IC; "see Process.setrlimit
;T;[ ; [ ; I"see Process.setrlimit;T; 0; @:;!F;"o;#;$T;%iC!;&iC!;'@{+;I"Process::RLIM_INFINITY;F;I"inf;To;;[[@]iI!;F;:RLIM_SAVED_CUR;;;;;[ ;{ ;IC; "see Process.setrlimit
;T;[ ; [ ; I"see Process.setrlimit;T; 0; @ ;;!F;"o;#;$T;%iH!;&iH!;'@{+;I" Process::RLIM_SAVED_CUR;F;I"v;To;;[[@]iR!;F;:RLIMIT_AS;;;;;[ ;{ ;IC; "|Maximum size of the process's virtual memory (address space) in bytes.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"}Maximum size of the process's virtual memory (address space) in bytes.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%iN!;&iQ!;'@{+;I"Process::RLIMIT_AS;F;I"INT2FIX(RLIMIT_AS);To;;[[@]iY!;F;:RLIMIT_CORE;;;;;[ ;{ ;IC; "TMaximum size of the core file.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"UMaximum size of the core file.
see the system getrlimit(2) manual for details.
;T; 0; @!;;!F;"o;#;$T;%iU!;&iX!;'@{+;I"Process::RLIMIT_CORE;F;I"INT2FIX(RLIMIT_CORE);To;;[[@]i`!;F;:RLIMIT_CPU;;;;;[ ;{ ;IC; "PCPU time limit in seconds.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"QCPU time limit in seconds.
see the system getrlimit(2) manual for details.
;T; 0; @-;;!F;"o;#;$T;%i\!;&i_!;'@{+;I"Process::RLIMIT_CPU;F;I"INT2FIX(RLIMIT_CPU);To;;[[@]ig!;F;:RLIMIT_DATA;;;;;[ ;{ ;IC; "aMaximum size of the process's data segment.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"bMaximum size of the process's data segment.
see the system getrlimit(2) manual for details.
;T; 0; @9;;!F;"o;#;$T;%ic!;&if!;'@{+;I"Process::RLIMIT_DATA;F;I"INT2FIX(RLIMIT_DATA);To;;[[@]in!;F;:RLIMIT_FSIZE;;;;;[ ;{ ;IC; "hMaximum size of files that the process may create.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"iMaximum size of files that the process may create.
see the system getrlimit(2) manual for details.
;T; 0; @E;;!F;"o;#;$T;%ij!;&im!;'@{+;I"Process::RLIMIT_FSIZE;F;I"INT2FIX(RLIMIT_FSIZE);To;;[[@]iu!;F;:RLIMIT_MEMLOCK;;;;;[ ;{ ;IC; "tMaximum number of bytes of memory that may be locked into RAM.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"uMaximum number of bytes of memory that may be locked into RAM.
see the system getrlimit(2) manual for details.
;T; 0; @Q;;!F;"o;#;$T;%iq!;&it!;'@{+;I" Process::RLIMIT_MEMLOCK;F;I" INT2FIX(RLIMIT_MEMLOCK);To;;[[@]i}!;F;:RLIMIT_MSGQUEUE;;;;;[ ;{ ;IC; "Specifies the limit on the number of bytes that can be allocated
for POSIX message queues for the real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"Specifies the limit on the number of bytes that can be allocated
for POSIX message queues for the real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T; 0; @];;!F;"o;#;$T;%ix!;&i|!;'@{+;I" Process::RLIMIT_MSGQUEUE;F;I" INT2FIX(RLIMIT_MSGQUEUE);To;;[[@]i!;F;:RLIMIT_NICE;;;;;[ ;{ ;IC; "zSpecifies a ceiling to which the process's nice value can be raised.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"{Specifies a ceiling to which the process's nice value can be raised.
see the system getrlimit(2) manual for details.
;T; 0; @i;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_NICE;F;I"INT2FIX(RLIMIT_NICE);To;;[[@]i!;F;:RLIMIT_NOFILE;;;;;[ ;{ ;IC; "Specifies a value one greater than the maximum file descriptor
number that can be opened by this process.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"Specifies a value one greater than the maximum file descriptor
number that can be opened by this process.
see the system getrlimit(2) manual for details.
;T; 0; @u;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_NOFILE;F;I"INT2FIX(RLIMIT_NOFILE);To;;[[@]i!;F;:RLIMIT_NPROC;;;;;[ ;{ ;IC; "The maximum number of processes that can be created for the
real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"The maximum number of processes that can be created for the
real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_NPROC;F;I"INT2FIX(RLIMIT_NPROC);To;;[[@]i!;F;:RLIMIT_RSS;;;;;[ ;{ ;IC; "sSpecifies the limit (in pages) of the process's resident set.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"tSpecifies the limit (in pages) of the process's resident set.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_RSS;F;I"INT2FIX(RLIMIT_RSS);To;;[[@]i!;F;:RLIMIT_RTPRIO;;;;;[ ;{ ;IC; "Specifies a ceiling on the real-time priority that may be set for this process.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"Specifies a ceiling on the real-time priority that may be set for this process.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_RTPRIO;F;I"INT2FIX(RLIMIT_RTPRIO);To;;[[@]i!;F;:RLIMIT_RTTIME;;;;;[ ;{ ;IC; "Specifies limit on CPU time this process scheduled under a real-time
scheduling policy can consume.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"Specifies limit on CPU time this process scheduled under a real-time
scheduling policy can consume.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_RTTIME;F;I"INT2FIX(RLIMIT_RTTIME);To;;[[@]i!;F;:RLIMIT_SBSIZE;;;;;[ ;{ ;IC; "'Maximum size of the socket buffer.
;T;[ ; [ ; I"(Maximum size of the socket buffer.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_SBSIZE;F;I"INT2FIX(RLIMIT_SBSIZE);To;;[[@]i!;F;:RLIMIT_SIGPENDING;;;;;[ ;{ ;IC; "Specifies a limit on the number of signals that may be queued for
the real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"Specifies a limit on the number of signals that may be queued for
the real user ID of the calling process.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I" Process::RLIMIT_SIGPENDING;F;I" INT2FIX(RLIMIT_SIGPENDING);To;;[[@]i!;F;:RLIMIT_STACK;;;;;[ ;{ ;IC; "ZMaximum size of the stack, in bytes.
see the system getrlimit(2) manual for details.
;T;[ ; [ ; I"[Maximum size of the stack, in bytes.
see the system getrlimit(2) manual for details.
;T; 0; @;;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::RLIMIT_STACK;F;I"INT2FIX(RLIMIT_STACK);To; ; F;
;;;;I"Process#uid;F;[ ;[[@]i;T;:uid;0;[ ;{ ;IC; "JReturns the (real) user ID of this process.
Process.uid #=> 501
;T;[o;=
;3I"
overload;F;40;;
;50;)I"uid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @;; [ ; I"@return [Integer];T; 0; @;;!F;6i ;>0;[ ; @;o;=
;3I"
overload;F;40;:Process::UID.rid;50;)I"Process::UID.rid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @;; [ ; I"@return [Integer];T; 0; @;;!F;6i ;>0;[ ; @;o;=
;3I"
overload;F;40;:Process::Sys.getuid;50;)I"Process::Sys.getuid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @;; [ ; I"@return [Integer];T; 0; @;;!F;6i ;>0;[ ; @;; [ ; I"Returns the (real) user ID of this process.
Process.uid #=> 501
@overload uid
@return [Integer]
@overload Process::UID.rid
@return [Integer]
@overload Process::Sys.getuid
@return [Integer];T; 0; @;;!F;>0;'@{+;(I"cstatic VALUE
proc_getuid(VALUE obj)
{
rb_uid_t uid = getuid();
return UIDT2NUM(uid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.uid;F;@;;@;;T;;
;0;@;;{ ;IC; "JReturns the (real) user ID of this process.
Process.uid #=> 501;T;[o;=
;3I"
overload;F;40;;
;50;)I"uid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ <; [ ; I"@return [Integer];T; 0; @ <;!F;6i ;>0;[ ; @ Tms structure (see Process::Tms)
that contains user and system CPU times for this process,
and also for children processes.
t = Process.times
[ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00]
;T;[o;=
;3I"
overload;F;40;; ;50;)I"
times;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"aProcessTms;T; @_?; [ ; I"@return [aProcessTms];T; 0; @_?;!F;6i ;>0;[ ; @_?; [ ; I"Returns a Tms structure (see Process::Tms)
that contains user and system CPU times for this process,
and also for children processes.
t = Process.times
[ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00]
@overload times
@return [aProcessTms];T; 0; @_?;!F;>0;'@{+;(I"fVALUE
rb_proc_times(VALUE obj)
{
VALUE utime, stime, cutime, cstime, ret;
#if defined(RUSAGE_SELF) && defined(RUSAGE_CHILDREN)
struct rusage usage_s, usage_c;
if (getrusage(RUSAGE_SELF, &usage_s) != 0 || getrusage(RUSAGE_CHILDREN, &usage_c) != 0)
rb_sys_fail("getrusage");
utime = DBL2NUM((double)usage_s.ru_utime.tv_sec + (double)usage_s.ru_utime.tv_usec/1e6);
stime = DBL2NUM((double)usage_s.ru_stime.tv_sec + (double)usage_s.ru_stime.tv_usec/1e6);
cutime = DBL2NUM((double)usage_c.ru_utime.tv_sec + (double)usage_c.ru_utime.tv_usec/1e6);
cstime = DBL2NUM((double)usage_c.ru_stime.tv_sec + (double)usage_c.ru_stime.tv_usec/1e6);
#else
const double hertz = (double)get_clk_tck();
struct tms buf;
times(&buf);
utime = DBL2NUM(buf.tms_utime / hertz);
stime = DBL2NUM(buf.tms_stime / hertz);
cutime = DBL2NUM(buf.tms_cutime / hertz);
cstime = DBL2NUM(buf.tms_cstime / hertz);
#endif
ret = rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime);
RB_GC_GUARD(utime);
RB_GC_GUARD(stime);
RB_GC_GUARD(cutime);
RB_GC_GUARD(cstime);
return ret;
};T;)I"
VALUE;T;*To; ; T;
;F;;;I"Process.times;F;@a?;@b?;T;; ;0;@d?;{ ;IC; "Returns a Tms structure (see Process::Tms)
that contains user and system CPU times for this process,
and also for children processes.
t = Process.times
[ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00];T;[o;=
;3I"
overload;F;40;; ;50;)I"
times;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"aProcessTms;T; @y?; [ ; I"@return [aProcessTms];T; 0; @y?;!F;6i ;>0;[ ; @y?; [ ; I" Returns a Tms structure (see Process::Tms)
that contains user and system CPU times for this process,
and also for children processes.
t = Process.times
[ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00]
@overload times
@return [aProcessTms];T; 0; @y?;!F;"o;#;$T;%i ;&i ;6i ;'@{+;(@w?;)@x?;*To;;[[@]i![@]i!;F;:CLOCK_REALTIME;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I" Process::CLOCK_REALTIME;F;I"+RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME;To;;[[@]i![@]i!;F;:CLOCK_MONOTONIC;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I" Process::CLOCK_MONOTONIC;F;I"2RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC;To;;[[@]i![@]i!;F;: CLOCK_PROCESS_CPUTIME_ID;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"&Process::CLOCK_PROCESS_CPUTIME_ID;F;I"2RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID;To;;[[@]i!;F;: CLOCK_THREAD_CPUTIME_ID;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"%Process::CLOCK_THREAD_CPUTIME_ID;F;I")CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID);To;;[[@]i!;F;:CLOCK_VIRTUAL;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::CLOCK_VIRTUAL;F;I" CLOCKID2NUM(CLOCK_VIRTUAL);To;;[[@]i!;F;:CLOCK_PROF;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"Process::CLOCK_PROF;F;I" CLOCKID2NUM(CLOCK_PROF);To;;[[@]i!;F;:CLOCK_REALTIME_FAST;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"!Process::CLOCK_REALTIME_FAST;F;I"%CLOCKID2NUM(CLOCK_REALTIME_FAST);To;;[[@]i!;F;:CLOCK_REALTIME_PRECISE;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"$Process::CLOCK_REALTIME_PRECISE;F;I"(CLOCKID2NUM(CLOCK_REALTIME_PRECISE);To;;[[@]i!;F;:CLOCK_REALTIME_COARSE;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i!;&i!;'@{+;I"#Process::CLOCK_REALTIME_COARSE;F;I"'CLOCKID2NUM(CLOCK_REALTIME_COARSE);To;;[[@]i";F;:CLOCK_REALTIME_ALARM;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @?;!F;"o;#;$T;%i";&i";'@{+;I""Process::CLOCK_REALTIME_ALARM;F;I"&CLOCKID2NUM(CLOCK_REALTIME_ALARM);To;;[[@]i";F;:CLOCK_MONOTONIC_FAST;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @ @;!F;"o;#;$T;%i";&i";'@{+;I""Process::CLOCK_MONOTONIC_FAST;F;I"&CLOCKID2NUM(CLOCK_MONOTONIC_FAST);To;;[[@]i ";F;: CLOCK_MONOTONIC_PRECISE;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @@;!F;"o;#;$T;%i
";&i
";'@{+;I"%Process::CLOCK_MONOTONIC_PRECISE;F;I")CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE);To;;[[@]i";F;:CLOCK_MONOTONIC_RAW;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @!@;!F;"o;#;$T;%i";&i";'@{+;I"!Process::CLOCK_MONOTONIC_RAW;F;I"%CLOCKID2NUM(CLOCK_MONOTONIC_RAW);To;;[[@]i";F;: CLOCK_MONOTONIC_RAW_APPROX;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @-@;!F;"o;#;$T;%i";&i";'@{+;I"(Process::CLOCK_MONOTONIC_RAW_APPROX;F;I",CLOCKID2NUM(CLOCK_MONOTONIC_RAW_APPROX);To;;[[@]i";F;:CLOCK_MONOTONIC_COARSE;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @9@;!F;"o;#;$T;%i";&i";'@{+;I"$Process::CLOCK_MONOTONIC_COARSE;F;I"(CLOCKID2NUM(CLOCK_MONOTONIC_COARSE);To;;[[@]i";F;:CLOCK_BOOTTIME;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @E@;!F;"o;#;$T;%i";&i";'@{+;I" Process::CLOCK_BOOTTIME;F;I" CLOCKID2NUM(CLOCK_BOOTTIME);To;;[[@]i ";F;:CLOCK_BOOTTIME_ALARM;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @Q@;!F;"o;#;$T;%i ";&i ";'@{+;I""Process::CLOCK_BOOTTIME_ALARM;F;I"&CLOCKID2NUM(CLOCK_BOOTTIME_ALARM);To;;[[@]i#";F;:CLOCK_UPTIME;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @]@;!F;"o;#;$T;%i"";&i"";'@{+;I"Process::CLOCK_UPTIME;F;I" CLOCKID2NUM(CLOCK_UPTIME);To;;[[@]i'";F;:CLOCK_UPTIME_FAST;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @i@;!F;"o;#;$T;%i&";&i&";'@{+;I" Process::CLOCK_UPTIME_FAST;F;I"#CLOCKID2NUM(CLOCK_UPTIME_FAST);To;;[[@]i+";F;:CLOCK_UPTIME_PRECISE;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @u@;!F;"o;#;$T;%i*";&i*";'@{+;I""Process::CLOCK_UPTIME_PRECISE;F;I"&CLOCKID2NUM(CLOCK_UPTIME_PRECISE);To;;[[@]i/";F;:CLOCK_UPTIME_RAW;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @@;!F;"o;#;$T;%i.";&i.";'@{+;I" Process::CLOCK_UPTIME_RAW;F;I""CLOCKID2NUM(CLOCK_UPTIME_RAW);To;;[[@]i3";F;: CLOCK_UPTIME_RAW_APPROX;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @@;!F;"o;#;$T;%i2";&i2";'@{+;I"%Process::CLOCK_UPTIME_RAW_APPROX;F;I")CLOCKID2NUM(CLOCK_UPTIME_RAW_APPROX);To;;[[@]i7";F;:CLOCK_SECOND;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @@;!F;"o;#;$T;%i6";&i6";'@{+;I"Process::CLOCK_SECOND;F;I" CLOCKID2NUM(CLOCK_SECOND);To;;[[@]i;";F;:CLOCK_TAI;;;;;[ ;{ ;IC; " see Process.clock_gettime
;T;[ ; [ ; I" see Process.clock_gettime;T; 0; @@;!F;"o;#;$T;%i:";&i:";'@{+;I"Process::CLOCK_TAI;F;I"CLOCKID2NUM(CLOCK_TAI);To; ; F;
;;;;I"Process#clock_gettime;F;[[@c0;[[@]if ;T;:clock_gettime;0;[ ;{ ;IC; "pReturns a time returned by POSIX clock_gettime() function.
p Process.clock_gettime(Process::CLOCK_MONOTONIC)
#=> 896053.968060096
+clock_id+ specifies a kind of clock.
It is specified as a constant which begins with Process::CLOCK_
such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.
The supported constants depends on OS and version.
Ruby provides following types of +clock_id+ if available.
[CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
[CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_REALTIME_FAST] FreeBSD 8.1
[CLOCK_REALTIME_PRECISE] FreeBSD 8.1
[CLOCK_REALTIME_COARSE] Linux 2.6.32
[CLOCK_REALTIME_ALARM] Linux 3.0
[CLOCK_MONOTONIC_FAST] FreeBSD 8.1
[CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1
[CLOCK_MONOTONIC_COARSE] Linux 2.6.32
[CLOCK_MONOTONIC_RAW] Linux 2.6.28, macOS 10.12
[CLOCK_MONOTONIC_RAW_APPROX] macOS 10.12
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_RAW] macOS 10.12
[CLOCK_UPTIME_RAW_APPROX] macOS 10.12
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
[CLOCK_TAI] Linux 3.10
Note that SUS stands for Single Unix Specification.
SUS contains POSIX and clock_gettime is defined in the POSIX part.
SUS defines CLOCK_REALTIME mandatory but
CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
Also, several symbols are accepted as +clock_id+.
There are emulations for clock_gettime().
For example, Process::CLOCK_REALTIME is defined as
+:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available.
Emulations for +CLOCK_REALTIME+:
[:GETTIMEOFDAY_BASED_CLOCK_REALTIME]
Use gettimeofday() defined by SUS.
(SUSv4 obsoleted it, though.)
The resolution is 1 microsecond.
[:TIME_BASED_CLOCK_REALTIME]
Use time() defined by ISO C.
The resolution is 1 second.
Emulations for +CLOCK_MONOTONIC+:
[:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC]
Use mach_absolute_time(), available on Darwin.
The resolution is CPU dependent.
[:TIMES_BASED_CLOCK_MONOTONIC]
Use the result value of times() defined by POSIX.
POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)".
For example, GNU/Linux returns a value based on jiffies and it is monotonic.
However, 4.4BSD uses gettimeofday() and it is not monotonic.
(FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.)
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and
cannot represent over 497 days.
Emulations for +CLOCK_PROCESS_CPUTIME_ID+:
[:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use getrusage() defined by SUS.
getrusage() is used with RUSAGE_SELF to obtain the time only for
the calling process (excluding the time for child processes).
The result is addition of user time (ru_utime) and system time (ru_stime).
The resolution is 1 microsecond.
[:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use times() defined by POSIX.
The result is addition of user time (tms_utime) and system time (tms_stime).
tms_cutime and tms_cstime are ignored to exclude the time for child processes.
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100, the resolution is 10 millisecond.
[:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use clock() defined by ISO C.
The resolution is 1/CLOCKS_PER_SEC.
CLOCKS_PER_SEC is the C-level macro defined by time.h.
SUS defines CLOCKS_PER_SEC is 1000000.
Non-Unix systems may define it a different value, though.
If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond.
If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
[:float_second] number of seconds as a float (default)
[:float_millisecond] number of milliseconds as a float
[:float_microsecond] number of microseconds as a float
[:second] number of seconds as an integer
[:millisecond] number of milliseconds as an integer
[:microsecond] number of microseconds as an integer
[:nanosecond] number of nanoseconds as an integer
The underlying function, clock_gettime(), returns a number of nanoseconds.
Float object (IEEE 754 double) is not enough to represent
the return value for CLOCK_REALTIME.
If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+.
The origin (zero) of the returned value varies.
For example, system start up time, process start up time, the Epoch, etc.
The origin in CLOCK_REALTIME is defined as the Epoch
(1970-01-01 00:00:00 UTC).
But some systems count leap seconds and others doesn't.
So the result can be interpreted differently across systems.
Time.now is recommended over CLOCK_REALTIME.
;T;[o;=
;3I"
overload;F;40;;9;50;)I"%clock_gettime(clock_id [, unit]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @@; [ ; I"@return [Numeric];T; 0; @@;!F;6i ;>0;[[I"clock_id[, unit];T0; @@; [ ; I"Returns a time returned by POSIX clock_gettime() function.
p Process.clock_gettime(Process::CLOCK_MONOTONIC)
#=> 896053.968060096
+clock_id+ specifies a kind of clock.
It is specified as a constant which begins with Process::CLOCK_
such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.
The supported constants depends on OS and version.
Ruby provides following types of +clock_id+ if available.
[CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
[CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_REALTIME_FAST] FreeBSD 8.1
[CLOCK_REALTIME_PRECISE] FreeBSD 8.1
[CLOCK_REALTIME_COARSE] Linux 2.6.32
[CLOCK_REALTIME_ALARM] Linux 3.0
[CLOCK_MONOTONIC_FAST] FreeBSD 8.1
[CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1
[CLOCK_MONOTONIC_COARSE] Linux 2.6.32
[CLOCK_MONOTONIC_RAW] Linux 2.6.28, macOS 10.12
[CLOCK_MONOTONIC_RAW_APPROX] macOS 10.12
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_RAW] macOS 10.12
[CLOCK_UPTIME_RAW_APPROX] macOS 10.12
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
[CLOCK_TAI] Linux 3.10
Note that SUS stands for Single Unix Specification.
SUS contains POSIX and clock_gettime is defined in the POSIX part.
SUS defines CLOCK_REALTIME mandatory but
CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
Also, several symbols are accepted as +clock_id+.
There are emulations for clock_gettime().
For example, Process::CLOCK_REALTIME is defined as
+:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available.
Emulations for +CLOCK_REALTIME+:
[:GETTIMEOFDAY_BASED_CLOCK_REALTIME]
Use gettimeofday() defined by SUS.
(SUSv4 obsoleted it, though.)
The resolution is 1 microsecond.
[:TIME_BASED_CLOCK_REALTIME]
Use time() defined by ISO C.
The resolution is 1 second.
Emulations for +CLOCK_MONOTONIC+:
[:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC]
Use mach_absolute_time(), available on Darwin.
The resolution is CPU dependent.
[:TIMES_BASED_CLOCK_MONOTONIC]
Use the result value of times() defined by POSIX.
POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)".
For example, GNU/Linux returns a value based on jiffies and it is monotonic.
However, 4.4BSD uses gettimeofday() and it is not monotonic.
(FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.)
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and
cannot represent over 497 days.
Emulations for +CLOCK_PROCESS_CPUTIME_ID+:
[:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use getrusage() defined by SUS.
getrusage() is used with RUSAGE_SELF to obtain the time only for
the calling process (excluding the time for child processes).
The result is addition of user time (ru_utime) and system time (ru_stime).
The resolution is 1 microsecond.
[:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use times() defined by POSIX.
The result is addition of user time (tms_utime) and system time (tms_stime).
tms_cutime and tms_cstime are ignored to exclude the time for child processes.
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100, the resolution is 10 millisecond.
[:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use clock() defined by ISO C.
The resolution is 1/CLOCKS_PER_SEC.
CLOCKS_PER_SEC is the C-level macro defined by time.h.
SUS defines CLOCKS_PER_SEC is 1000000.
Non-Unix systems may define it a different value, though.
If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond.
If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
[:float_second] number of seconds as a float (default)
[:float_millisecond] number of milliseconds as a float
[:float_microsecond] number of microseconds as a float
[:second] number of seconds as an integer
[:millisecond] number of milliseconds as an integer
[:microsecond] number of microseconds as an integer
[:nanosecond] number of nanoseconds as an integer
The underlying function, clock_gettime(), returns a number of nanoseconds.
Float object (IEEE 754 double) is not enough to represent
the return value for CLOCK_REALTIME.
If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+.
The origin (zero) of the returned value varies.
For example, system start up time, process start up time, the Epoch, etc.
The origin in CLOCK_REALTIME is defined as the Epoch
(1970-01-01 00:00:00 UTC).
But some systems count leap seconds and others doesn't.
So the result can be interpreted differently across systems.
Time.now is recommended over CLOCK_REALTIME.
@overload clock_gettime(clock_id [, unit])
@return [Numeric];T; 0; @@;!F;>0;'@{+;(I"static VALUE
rb_clock_gettime(int argc, VALUE *argv, VALUE _)
{
int ret;
struct timetick tt;
timetick_int_t numerators[2];
timetick_int_t denominators[2];
int num_numerators = 0;
int num_denominators = 0;
VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil;
VALUE clk_id = argv[0];
if (SYMBOL_P(clk_id)) {
/*
* Non-clock_gettime clocks are provided by symbol clk_id.
*/
#ifdef HAVE_GETTIMEOFDAY
/*
* GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for
* CLOCK_REALTIME if clock_gettime is not available.
*/
#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(id_GETTIMEOFDAY_BASED_CLOCK_REALTIME)
if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
struct timeval tv;
ret = gettimeofday(&tv, 0);
if (ret != 0)
rb_sys_fail("gettimeofday");
tt.giga_count = tv.tv_sec;
tt.count = (int32_t)tv.tv_usec * 1000;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
#define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(id_TIME_BASED_CLOCK_REALTIME)
if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) {
time_t t;
t = time(NULL);
if (t == (time_t)-1)
rb_sys_fail("time");
tt.giga_count = t;
tt.count = 0;
denominators[num_denominators++] = 1000000000;
goto success;
}
#ifdef HAVE_TIMES
#define RUBY_TIMES_BASED_CLOCK_MONOTONIC \
ID2SYM(id_TIMES_BASED_CLOCK_MONOTONIC)
if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
struct tms buf;
clock_t c;
unsigned_clock_t uc;
c = times(&buf);
if (c == (clock_t)-1)
rb_sys_fail("times");
uc = (unsigned_clock_t)c;
tt.count = (int32_t)(uc % 1000000000);
tt.giga_count = (uc / 1000000000);
denominators[num_denominators++] = get_clk_tck();
goto success;
}
#endif
#ifdef RUSAGE_SELF
#define RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \
ID2SYM(id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID)
if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
struct rusage usage;
int32_t usec;
ret = getrusage(RUSAGE_SELF, &usage);
if (ret != 0)
rb_sys_fail("getrusage");
tt.giga_count = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec;
usec = (int32_t)(usage.ru_utime.tv_usec + usage.ru_stime.tv_usec);
if (1000000 <= usec) {
tt.giga_count++;
usec -= 1000000;
}
tt.count = usec * 1000;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
#ifdef HAVE_TIMES
#define RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \
ID2SYM(id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID)
if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
struct tms buf;
unsigned_clock_t utime, stime;
if (times(&buf) == (clock_t)-1)
rb_sys_fail("times");
utime = (unsigned_clock_t)buf.tms_utime;
stime = (unsigned_clock_t)buf.tms_stime;
tt.count = (int32_t)((utime % 1000000000) + (stime % 1000000000));
tt.giga_count = (utime / 1000000000) + (stime / 1000000000);
if (1000000000 <= tt.count) {
tt.count -= 1000000000;
tt.giga_count++;
}
denominators[num_denominators++] = get_clk_tck();
goto success;
}
#endif
#define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \
ID2SYM(id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID)
if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
clock_t c;
unsigned_clock_t uc;
errno = 0;
c = clock();
if (c == (clock_t)-1)
rb_sys_fail("clock");
uc = (unsigned_clock_t)c;
tt.count = (int32_t)(uc % 1000000000);
tt.giga_count = uc / 1000000000;
denominators[num_denominators++] = CLOCKS_PER_SEC;
goto success;
}
#ifdef __APPLE__
#define RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC ID2SYM(id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC)
if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
const mach_timebase_info_data_t *info = get_mach_timebase_info();
uint64_t t = mach_absolute_time();
tt.count = (int32_t)(t % 1000000000);
tt.giga_count = t / 1000000000;
numerators[num_numerators++] = info->numer;
denominators[num_denominators++] = info->denom;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
}
else {
#if defined(HAVE_CLOCK_GETTIME)
struct timespec ts;
clockid_t c;
c = NUM2CLOCKID(clk_id);
ret = clock_gettime(c, &ts);
if (ret == -1)
rb_sys_fail("clock_gettime");
tt.count = (int32_t)ts.tv_nsec;
tt.giga_count = ts.tv_sec;
denominators[num_denominators++] = 1000000000;
goto success;
#endif
}
/* EINVAL emulates clock_gettime behavior when clock_id is invalid. */
rb_syserr_fail(EINVAL, 0);
success:
return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.clock_gettime;F;@@;@@;T;;9;0;@@;{ ;IC; "pReturns a time returned by POSIX clock_gettime() function.
p Process.clock_gettime(Process::CLOCK_MONOTONIC)
#=> 896053.968060096
+clock_id+ specifies a kind of clock.
It is specified as a constant which begins with Process::CLOCK_
such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.
The supported constants depends on OS and version.
Ruby provides following types of +clock_id+ if available.
[CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
[CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_REALTIME_FAST] FreeBSD 8.1
[CLOCK_REALTIME_PRECISE] FreeBSD 8.1
[CLOCK_REALTIME_COARSE] Linux 2.6.32
[CLOCK_REALTIME_ALARM] Linux 3.0
[CLOCK_MONOTONIC_FAST] FreeBSD 8.1
[CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1
[CLOCK_MONOTONIC_COARSE] Linux 2.6.32
[CLOCK_MONOTONIC_RAW] Linux 2.6.28, macOS 10.12
[CLOCK_MONOTONIC_RAW_APPROX] macOS 10.12
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_RAW] macOS 10.12
[CLOCK_UPTIME_RAW_APPROX] macOS 10.12
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
[CLOCK_TAI] Linux 3.10
Note that SUS stands for Single Unix Specification.
SUS contains POSIX and clock_gettime is defined in the POSIX part.
SUS defines CLOCK_REALTIME mandatory but
CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
Also, several symbols are accepted as +clock_id+.
There are emulations for clock_gettime().
For example, Process::CLOCK_REALTIME is defined as
+:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available.
Emulations for +CLOCK_REALTIME+:
[:GETTIMEOFDAY_BASED_CLOCK_REALTIME]
Use gettimeofday() defined by SUS.
(SUSv4 obsoleted it, though.)
The resolution is 1 microsecond.
[:TIME_BASED_CLOCK_REALTIME]
Use time() defined by ISO C.
The resolution is 1 second.
Emulations for +CLOCK_MONOTONIC+:
[:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC]
Use mach_absolute_time(), available on Darwin.
The resolution is CPU dependent.
[:TIMES_BASED_CLOCK_MONOTONIC]
Use the result value of times() defined by POSIX.
POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)".
For example, GNU/Linux returns a value based on jiffies and it is monotonic.
However, 4.4BSD uses gettimeofday() and it is not monotonic.
(FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.)
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and
cannot represent over 497 days.
Emulations for +CLOCK_PROCESS_CPUTIME_ID+:
[:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use getrusage() defined by SUS.
getrusage() is used with RUSAGE_SELF to obtain the time only for
the calling process (excluding the time for child processes).
The result is addition of user time (ru_utime) and system time (ru_stime).
The resolution is 1 microsecond.
[:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use times() defined by POSIX.
The result is addition of user time (tms_utime) and system time (tms_stime).
tms_cutime and tms_cstime are ignored to exclude the time for child processes.
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100, the resolution is 10 millisecond.
[:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use clock() defined by ISO C.
The resolution is 1/CLOCKS_PER_SEC.
CLOCKS_PER_SEC is the C-level macro defined by time.h.
SUS defines CLOCKS_PER_SEC is 1000000.
Non-Unix systems may define it a different value, though.
If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond.
If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
[:float_second] number of seconds as a float (default)
[:float_millisecond] number of milliseconds as a float
[:float_microsecond] number of microseconds as a float
[:second] number of seconds as an integer
[:millisecond] number of milliseconds as an integer
[:microsecond] number of microseconds as an integer
[:nanosecond] number of nanoseconds as an integer
The underlying function, clock_gettime(), returns a number of nanoseconds.
Float object (IEEE 754 double) is not enough to represent
the return value for CLOCK_REALTIME.
If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+.
The origin (zero) of the returned value varies.
For example, system start up time, process start up time, the Epoch, etc.
The origin in CLOCK_REALTIME is defined as the Epoch
(1970-01-01 00:00:00 UTC).
But some systems count leap seconds and others doesn't.
So the result can be interpreted differently across systems.
Time.now is recommended over CLOCK_REALTIME.;T;[o;=
;3I"
overload;F;40;;9;50;)I"%clock_gettime(clock_id [, unit]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @@; [ ; I"@return [Numeric];T; 0; @@;!F;6i ;>0;[[I"clock_id[, unit];T0; @@; [ ; I"Returns a time returned by POSIX clock_gettime() function.
p Process.clock_gettime(Process::CLOCK_MONOTONIC)
#=> 896053.968060096
+clock_id+ specifies a kind of clock.
It is specified as a constant which begins with Process::CLOCK_
such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.
The supported constants depends on OS and version.
Ruby provides following types of +clock_id+ if available.
[CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
[CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1
[CLOCK_REALTIME_FAST] FreeBSD 8.1
[CLOCK_REALTIME_PRECISE] FreeBSD 8.1
[CLOCK_REALTIME_COARSE] Linux 2.6.32
[CLOCK_REALTIME_ALARM] Linux 3.0
[CLOCK_MONOTONIC_FAST] FreeBSD 8.1
[CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1
[CLOCK_MONOTONIC_COARSE] Linux 2.6.32
[CLOCK_MONOTONIC_RAW] Linux 2.6.28, macOS 10.12
[CLOCK_MONOTONIC_RAW_APPROX] macOS 10.12
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_RAW] macOS 10.12
[CLOCK_UPTIME_RAW_APPROX] macOS 10.12
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
[CLOCK_TAI] Linux 3.10
Note that SUS stands for Single Unix Specification.
SUS contains POSIX and clock_gettime is defined in the POSIX part.
SUS defines CLOCK_REALTIME mandatory but
CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
Also, several symbols are accepted as +clock_id+.
There are emulations for clock_gettime().
For example, Process::CLOCK_REALTIME is defined as
+:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available.
Emulations for +CLOCK_REALTIME+:
[:GETTIMEOFDAY_BASED_CLOCK_REALTIME]
Use gettimeofday() defined by SUS.
(SUSv4 obsoleted it, though.)
The resolution is 1 microsecond.
[:TIME_BASED_CLOCK_REALTIME]
Use time() defined by ISO C.
The resolution is 1 second.
Emulations for +CLOCK_MONOTONIC+:
[:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC]
Use mach_absolute_time(), available on Darwin.
The resolution is CPU dependent.
[:TIMES_BASED_CLOCK_MONOTONIC]
Use the result value of times() defined by POSIX.
POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)".
For example, GNU/Linux returns a value based on jiffies and it is monotonic.
However, 4.4BSD uses gettimeofday() and it is not monotonic.
(FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.)
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and
cannot represent over 497 days.
Emulations for +CLOCK_PROCESS_CPUTIME_ID+:
[:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use getrusage() defined by SUS.
getrusage() is used with RUSAGE_SELF to obtain the time only for
the calling process (excluding the time for child processes).
The result is addition of user time (ru_utime) and system time (ru_stime).
The resolution is 1 microsecond.
[:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use times() defined by POSIX.
The result is addition of user time (tms_utime) and system time (tms_stime).
tms_cutime and tms_cstime are ignored to exclude the time for child processes.
The resolution is the clock tick.
"getconf CLK_TCK" command shows the clock ticks per second.
(The clock ticks per second is defined by HZ macro in older systems.)
If it is 100, the resolution is 10 millisecond.
[:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID]
Use clock() defined by ISO C.
The resolution is 1/CLOCKS_PER_SEC.
CLOCKS_PER_SEC is the C-level macro defined by time.h.
SUS defines CLOCKS_PER_SEC is 1000000.
Non-Unix systems may define it a different value, though.
If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond.
If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
[:float_second] number of seconds as a float (default)
[:float_millisecond] number of milliseconds as a float
[:float_microsecond] number of microseconds as a float
[:second] number of seconds as an integer
[:millisecond] number of milliseconds as an integer
[:microsecond] number of microseconds as an integer
[:nanosecond] number of nanoseconds as an integer
The underlying function, clock_gettime(), returns a number of nanoseconds.
Float object (IEEE 754 double) is not enough to represent
the return value for CLOCK_REALTIME.
If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+.
The origin (zero) of the returned value varies.
For example, system start up time, process start up time, the Epoch, etc.
The origin in CLOCK_REALTIME is defined as the Epoch
(1970-01-01 00:00:00 UTC).
But some systems count leap seconds and others doesn't.
So the result can be interpreted differently across systems.
Time.now is recommended over CLOCK_REALTIME.
@overload clock_gettime(clock_id [, unit])
@return [Numeric];T; 0; @@;!F;"o;#;$T;%i ;&id ;6i ;'@{+;(@@;)@@;*To; ; F;
;;;;I"Process#clock_getres;F;[[@c0;[[@]i+ ;T;:clock_getres;0;[ ;{ ;IC; "Returns the time resolution returned by POSIX clock_getres() function.
+clock_id+ specifies a kind of clock.
See the document of +Process.clock_gettime+ for details.
+clock_id+ can be a symbol as +Process.clock_gettime+.
However the result may not be accurate.
For example, Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)
returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
+Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+.
The default value, +:float_second+, is also same as
+Process.clock_gettime+.
+Process.clock_getres+ also accepts +:hertz+ as +unit+.
+:hertz+ means a the reciprocal of +:float_second+.
+:hertz+ can be used to obtain the exact value of
the clock ticks per second for times() function and
CLOCKS_PER_SEC for clock() function.
Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns the clock ticks per second.
Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns CLOCKS_PER_SEC.
p Process.clock_getres(Process::CLOCK_MONOTONIC)
#=> 1.0e-09
;T;[o;=
;3I"
overload;F;40;;:;50;)I"$clock_getres(clock_id [, unit]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @@; [ ; I"@return [Numeric];T; 0; @@;!F;6i ;>0;[[I"clock_id[, unit];T0; @@; [ ; I" Returns the time resolution returned by POSIX clock_getres() function.
+clock_id+ specifies a kind of clock.
See the document of +Process.clock_gettime+ for details.
+clock_id+ can be a symbol as +Process.clock_gettime+.
However the result may not be accurate.
For example, Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)
returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
+Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+.
The default value, +:float_second+, is also same as
+Process.clock_gettime+.
+Process.clock_getres+ also accepts +:hertz+ as +unit+.
+:hertz+ means a the reciprocal of +:float_second+.
+:hertz+ can be used to obtain the exact value of
the clock ticks per second for times() function and
CLOCKS_PER_SEC for clock() function.
Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns the clock ticks per second.
Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns CLOCKS_PER_SEC.
p Process.clock_getres(Process::CLOCK_MONOTONIC)
#=> 1.0e-09
@overload clock_getres(clock_id [, unit])
@return [Numeric];T; 0; @@;!F;>0;'@{+;(I" static VALUE
rb_clock_getres(int argc, VALUE *argv, VALUE _)
{
struct timetick tt;
timetick_int_t numerators[2];
timetick_int_t denominators[2];
int num_numerators = 0;
int num_denominators = 0;
VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil;
VALUE clk_id = argv[0];
if (SYMBOL_P(clk_id)) {
#ifdef RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME
if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
tt.giga_count = 0;
tt.count = 1000;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
#ifdef RUBY_TIME_BASED_CLOCK_REALTIME
if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) {
tt.giga_count = 1;
tt.count = 0;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
#ifdef RUBY_TIMES_BASED_CLOCK_MONOTONIC
if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
tt.count = 1;
tt.giga_count = 0;
denominators[num_denominators++] = get_clk_tck();
goto success;
}
#endif
#ifdef RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID
if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
tt.giga_count = 0;
tt.count = 1000;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
#ifdef RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID
if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
tt.count = 1;
tt.giga_count = 0;
denominators[num_denominators++] = get_clk_tck();
goto success;
}
#endif
#ifdef RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
tt.count = 1;
tt.giga_count = 0;
denominators[num_denominators++] = CLOCKS_PER_SEC;
goto success;
}
#endif
#ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC
if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
const mach_timebase_info_data_t *info = get_mach_timebase_info();
tt.count = 1;
tt.giga_count = 0;
numerators[num_numerators++] = info->numer;
denominators[num_denominators++] = info->denom;
denominators[num_denominators++] = 1000000000;
goto success;
}
#endif
}
else {
#if defined(HAVE_CLOCK_GETRES)
struct timespec ts;
clockid_t c = NUM2CLOCKID(clk_id);
int ret = clock_getres(c, &ts);
if (ret == -1)
rb_sys_fail("clock_getres");
tt.count = (int32_t)ts.tv_nsec;
tt.giga_count = ts.tv_sec;
denominators[num_denominators++] = 1000000000;
goto success;
#endif
}
/* EINVAL emulates clock_getres behavior when clock_id is invalid. */
rb_syserr_fail(EINVAL, 0);
success:
if (unit == ID2SYM(id_hertz)) {
return timetick2dblnum_reciprocal(&tt, numerators, num_numerators, denominators, num_denominators);
}
else {
return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
}
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process.clock_getres;F;@@;@@;T;;:;0;@@;{ ;IC; "Returns the time resolution returned by POSIX clock_getres() function.
+clock_id+ specifies a kind of clock.
See the document of +Process.clock_gettime+ for details.
+clock_id+ can be a symbol as +Process.clock_gettime+.
However the result may not be accurate.
For example, Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)
returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
+Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+.
The default value, +:float_second+, is also same as
+Process.clock_gettime+.
+Process.clock_getres+ also accepts +:hertz+ as +unit+.
+:hertz+ means a the reciprocal of +:float_second+.
+:hertz+ can be used to obtain the exact value of
the clock ticks per second for times() function and
CLOCKS_PER_SEC for clock() function.
Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns the clock ticks per second.
Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns CLOCKS_PER_SEC.
p Process.clock_getres(Process::CLOCK_MONOTONIC)
#=> 1.0e-09;T;[o;=
;3I"
overload;F;40;;:;50;)I"$clock_getres(clock_id [, unit]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Numeric;T; @A; [ ; I"@return [Numeric];T; 0; @A;!F;6i ;>0;[[I"clock_id[, unit];T0; @A; [ ; I" Returns the time resolution returned by POSIX clock_getres() function.
+clock_id+ specifies a kind of clock.
See the document of +Process.clock_gettime+ for details.
+clock_id+ can be a symbol as +Process.clock_gettime+.
However the result may not be accurate.
For example, Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)
returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse.
If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+unit+ specifies a type of the return value.
+Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+.
The default value, +:float_second+, is also same as
+Process.clock_gettime+.
+Process.clock_getres+ also accepts +:hertz+ as +unit+.
+:hertz+ means a the reciprocal of +:float_second+.
+:hertz+ can be used to obtain the exact value of
the clock ticks per second for times() function and
CLOCKS_PER_SEC for clock() function.
Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns the clock ticks per second.
Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)
returns CLOCKS_PER_SEC.
p Process.clock_getres(Process::CLOCK_MONOTONIC)
#=> 1.0e-09
@overload clock_getres(clock_id [, unit])
@return [Numeric];T; 0; @A;!F;"o;#;$T;%i ;&i) ;6i ;'@{+;(@ A;)@A;*To; ;IC;[o; ; F;
;;;;I"Process::UID#rid;F;[ ;[[@]i;T;:rid;0;[ ;{ ;IC; "JReturns the (real) user ID of this process.
Process.uid #=> 501
;T;[o;=
;3I"
overload;F;40;;
;50;)I"uid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @Ao;=
;3I"
overload;F;40;; ;50;)I"Process::UID.rid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @Ao;=
;3I"
overload;F;40;; ;50;)I"Process::Sys.getuid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @A; [ ; I"Returns the (real) user ID of this process.
Process.uid #=> 501
@overload uid
@return [Integer]
@overload Process::UID.rid
@return [Integer]
@overload Process::Sys.getuid
@return [Integer];T; 0; @A;!F;>0;'@A;(I"cstatic VALUE
proc_getuid(VALUE obj)
{
rb_uid_t uid = getuid();
return UIDT2NUM(uid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::UID.rid;F;@ A;@ A;T;;;;0;@ A;{ ;IC; "JReturns the (real) user ID of this process.
Process.uid #=> 501;T;[o;=
;3I"
overload;F;40;;
;50;)I"uid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @OA; [ ; I"@return [Integer];T; 0; @OA;!F;6i ;>0;[ ; @OAo;=
;3I"
overload;F;40;; ;50;)I"Process::UID.rid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @OA; [ ; I"@return [Integer];T; 0; @OA;!F;6i ;>0;[ ; @OAo;=
;3I"
overload;F;40;; ;50;)I"Process::Sys.getuid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @OA; [ ; I"@return [Integer];T; 0; @OA;!F;6i ;>0;[ ; @OA; [ ; @6<; 0; @OA;!F;"o;#;$T;%i;&i;6i ;'@A;(@MA;)@NA;*To; ; F;
;;;;I"Process::UID#eid;F;[ ;[[@]i;T;:eid;0;[ ;{ ;IC; "OReturns the effective user ID for this process.
Process.euid #=> 501
;T;[o;=
;3I"
overload;F;40;;;50;)I" euid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}A; [ ; I"@return [Integer];T; 0; @}A;!F;6i ;>0;[ ; @}Ao;=
;3I"
overload;F;40;;;50;)I"Process::UID.eid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}A; [ ; I"@return [Integer];T; 0; @}A;!F;6i ;>0;[ ; @}Ao;=
;3I"
overload;F;40;;;50;)I"Process::Sys.geteuid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}A; [ ; I"@return [Integer];T; 0; @}A;!F;6i ;>0;[ ; @}A; [ ; I"Returns the effective user ID for this process.
Process.euid #=> 501
@overload euid
@return [Integer]
@overload Process::UID.eid
@return [Integer]
@overload Process::Sys.geteuid
@return [Integer];T; 0; @}A;!F;>0;'@A;(I"gstatic VALUE
proc_geteuid(VALUE obj)
{
rb_uid_t euid = geteuid();
return UIDT2NUM(euid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::UID.eid;F;@A;@A;T;;<;0;@A;{ ;IC; "OReturns the effective user ID for this process.
Process.euid #=> 501;T;[o;=
;3I"
overload;F;40;;;50;)I" euid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @Ao;=
;3I"
overload;F;40;;;50;)I"Process::UID.eid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @Ao;=
;3I"
overload;F;40;;;50;)I"Process::Sys.geteuid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[ ; @A; [ ; @f=; 0; @A;!F;"o;#;$T;%iz;&i;6i ;'@A;(@A;)@A;*To; ; F;
;;;;I""Process::UID#change_privilege;F;[[I"id;T0;[[@]i;T;:change_privilege;0;[ ;{ ;IC; "%Change the current process's real and effective user ID to that
specified by _user_. Returns the new user ID. Not
available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.change_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [31, 31]
;T;[o;=
;3I"
overload;F;40;:"Process::UID.change_privilege;50;)I"(Process::UID.change_privilege(user);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[[I" user;T0; @A; [ ; I"hChange the current process's real and effective user ID to that
specified by _user_. Returns the new user ID. Not
available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.change_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [31, 31]
@overload Process::UID.change_privilege(user)
@return [Integer];T; 0; @A;!F;>0;'@A;(I"kstatic VALUE
p_uid_change_privilege(VALUE obj, VALUE id)
{
rb_uid_t uid;
check_uid_switch();
uid = OBJ2UID(id);
if (geteuid() == 0) { /* root-user */
#if defined(HAVE_SETRESUID)
if (setresuid(uid, uid, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
#elif defined(HAVE_SETUID)
if (setuid(uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
if (getuid() == uid) {
if (SAVED_USER_ID == uid) {
if (setreuid(-1, uid) < 0) rb_sys_fail(0);
}
else {
if (uid == 0) { /* (r,e,s) == (root, root, x) */
if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0);
if (setreuid(SAVED_USER_ID, 0) < 0) rb_sys_fail(0);
SAVED_USER_ID = 0; /* (r,e,s) == (x, root, root) */
if (setreuid(uid, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
else {
if (setreuid(0, -1) < 0) rb_sys_fail(0);
SAVED_USER_ID = 0;
if (setreuid(uid, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
}
}
else {
if (setreuid(uid, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
#elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID)
if (getuid() == uid) {
if (SAVED_USER_ID == uid) {
if (seteuid(uid) < 0) rb_sys_fail(0);
}
else {
if (uid == 0) {
if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0);
SAVED_USER_ID = 0;
if (setruid(0) < 0) rb_sys_fail(0);
}
else {
if (setruid(0) < 0) rb_sys_fail(0);
SAVED_USER_ID = 0;
if (seteuid(uid) < 0) rb_sys_fail(0);
if (setruid(uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
}
}
else {
if (seteuid(uid) < 0) rb_sys_fail(0);
if (setruid(uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
#else
(void)uid;
rb_notimplement();
#endif
}
else { /* unprivileged user */
#if defined(HAVE_SETRESUID)
if (setresuid((getuid() == uid)? (rb_uid_t)-1: uid,
(geteuid() == uid)? (rb_uid_t)-1: uid,
(SAVED_USER_ID == uid)? (rb_uid_t)-1: uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
if (SAVED_USER_ID == uid) {
if (setreuid((getuid() == uid)? (rb_uid_t)-1: uid,
(geteuid() == uid)? (rb_uid_t)-1: uid) < 0)
rb_sys_fail(0);
}
else if (getuid() != uid) {
if (setreuid(uid, (geteuid() == uid)? (rb_uid_t)-1: uid) < 0)
rb_sys_fail(0);
SAVED_USER_ID = uid;
}
else if (/* getuid() == uid && */ geteuid() != uid) {
if (setreuid(geteuid(), uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
if (setreuid(uid, -1) < 0) rb_sys_fail(0);
}
else { /* getuid() == uid && geteuid() == uid */
if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0);
if (setreuid(SAVED_USER_ID, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
if (setreuid(uid, -1) < 0) rb_sys_fail(0);
}
#elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID)
if (SAVED_USER_ID == uid) {
if (geteuid() != uid && seteuid(uid) < 0) rb_sys_fail(0);
if (getuid() != uid && setruid(uid) < 0) rb_sys_fail(0);
}
else if (/* SAVED_USER_ID != uid && */ geteuid() == uid) {
if (getuid() != uid) {
if (setruid(uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
else {
if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
if (setruid(uid) < 0) rb_sys_fail(0);
}
}
else if (/* geteuid() != uid && */ getuid() == uid) {
if (seteuid(uid) < 0) rb_sys_fail(0);
if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
if (setruid(uid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_44BSD_SETUID
if (getuid() == uid) {
/* (r,e,s)==(uid,?,?) ==> (uid,uid,uid) */
if (setuid(uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_SETEUID
if (getuid() == uid && SAVED_USER_ID == uid) {
if (seteuid(uid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_SETUID
if (getuid() == uid && SAVED_USER_ID == uid) {
if (setuid(uid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#else
rb_notimplement();
#endif
}
return id;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I""Process::UID.change_privilege;F;@A;@A;T;;=;0;@A;{ ;IC; "%Change the current process's real and effective user ID to that
specified by _user_. Returns the new user ID. Not
available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.change_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [31, 31];T;[o;=
;3I"
overload;F;40;;>;50;)I"(Process::UID.change_privilege(user);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @A; [ ; I"@return [Integer];T; 0; @A;!F;6i ;>0;[[I" user;T0; @A; [ ; I"iChange the current process's real and effective user ID to that
specified by _user_. Returns the new user ID. Not
available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.change_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [31, 31]
@overload Process::UID.change_privilege(user)
@return [Integer];T; 0; @A;!F;"o;#;$T;%i;&i;6i ;'@A;(@A;)@A;*To; ; F;
;;;;I"!Process::UID#grant_privilege;F;[[I"id;T0;[[@]i;T;:grant_privilege;0;[ ;{ ;IC; ";Set the effective user ID, and if possible, the saved user ID of
the process to the given _user_. Returns the new
effective user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.grant_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [0, 31]
;T;[o;=
;3I"
overload;F;40;:!Process::UID.grant_privilege;50;)I"'Process::UID.grant_privilege(user);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @B; [ ; I"@return [Integer];T; 0; @B;!F;6i ;>0;[[I" user;T0; @Bo;=
;3I"
overload;F;40;:Process::UID.eid=;50;)I"Process::UID.eid= user;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @B; [ ; I"@return [Integer];T; 0; @B;!F;6i ;>0;[[I" user;T0; @B; [ ; I"Set the effective user ID, and if possible, the saved user ID of
the process to the given _user_. Returns the new
effective user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.grant_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [0, 31]
@overload Process::UID.grant_privilege(user)
@return [Integer]
@overload Process::UID.eid= user
@return [Integer];T; 0; @B;!F;>0;'@A;(I"qstatic VALUE
p_uid_grant_privilege(VALUE obj, VALUE id)
{
rb_seteuid_core(OBJ2UID(id));
return id;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"!Process::UID.grant_privilege;F;@B;@B;T;;?;0;@B;{ ;IC; ";Set the effective user ID, and if possible, the saved user ID of
the process to the given _user_. Returns the new
effective user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.grant_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [0, 31];T;[o;=
;3I"
overload;F;40;;@;50;)I"'Process::UID.grant_privilege(user);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @AB; [ ; I"@return [Integer];T; 0; @AB;!F;6i ;>0;[[I" user;T0; @ABo;=
;3I"
overload;F;40;;A;50;)I"Process::UID.eid= user;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @AB; [ ; I"@return [Integer];T; 0; @AB;!F;6i ;>0;[[I" user;T0; @AB; [ ; I"Set the effective user ID, and if possible, the saved user ID of
the process to the given _user_. Returns the new
effective user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 0]
Process::UID.grant_privilege(31) #=> 31
[Process.uid, Process.euid] #=> [0, 31]
@overload Process::UID.grant_privilege(user)
@return [Integer]
@overload Process::UID.eid= user
@return [Integer];T; 0; @AB;!F;"o;#;$T;%i;&i;6i ;'@A;(@?B;)@@B;*To; ; F;
;;;;I" Process::UID#re_exchange;F;[ ;[[@]i ;T;:re_exchange;0;[ ;{ ;IC; "Exchange real and effective user IDs and return the new effective
user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 31]
Process::UID.re_exchange #=> 0
[Process.uid, Process.euid] #=> [31, 0]
;T;[o;=
;3I"
overload;F;40;: Process::UID.re_exchange;50;)I" Process::UID.re_exchange;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @gB; [ ; I"@return [Integer];T; 0; @gB;!F;6i ;>0;[ ; @gB; [ ; I"$Exchange real and effective user IDs and return the new effective
user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 31]
Process::UID.re_exchange #=> 0
[Process.uid, Process.euid] #=> [31, 0]
@overload Process::UID.re_exchange
@return [Integer];T; 0; @gB;!F;>0;'@A;(I"static VALUE
p_uid_exchange(VALUE obj)
{
rb_uid_t uid;
#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID))
rb_uid_t euid;
#endif
check_uid_switch();
uid = getuid();
#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID))
euid = geteuid();
#endif
#if defined(HAVE_SETRESUID)
if (setresuid(euid, uid, uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
if (setreuid(euid,uid) < 0) rb_sys_fail(0);
SAVED_USER_ID = uid;
#else
rb_notimplement();
#endif
return UIDT2NUM(uid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" Process::UID.re_exchange;F;@iB;@jB;T;;B;0;@lB;{ ;IC; "Exchange real and effective user IDs and return the new effective
user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 31]
Process::UID.re_exchange #=> 0
[Process.uid, Process.euid] #=> [31, 0];T;[o;=
;3I"
overload;F;40;;C;50;)I" Process::UID.re_exchange;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @B; [ ; I"@return [Integer];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"%Exchange real and effective user IDs and return the new effective
user ID. Not available on all platforms.
[Process.uid, Process.euid] #=> [0, 31]
Process::UID.re_exchange #=> 0
[Process.uid, Process.euid] #=> [31, 0]
@overload Process::UID.re_exchange
@return [Integer];T; 0; @B;!F;"o;#;$T;%i ;&i ;6i ;'@A;(@B;)@B;*To; ; F;
;;;;I""Process::UID#re_exchangeable?;F;[ ;[[@]i ;T;:re_exchangeable?;0;[ ;{ ;IC; "mReturns +true+ if the real and effective user IDs of a
process may be exchanged on the current platform.
;T;[o;=
;3I"
overload;F;40;:"Process::UID.re_exchangeable?;50;)I""Process::UID.re_exchangeable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @B; [ ; I"@return [Boolean];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"Returns +true+ if the real and effective user IDs of a
process may be exchanged on the current platform.
@overload Process::UID.re_exchangeable?
@return [Boolean];T; 0; @B;!F;>0;'@A;(I"static VALUE
p_uid_exchangeable(VALUE _)
{
#if defined(HAVE_SETRESUID)
return Qtrue;
#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)
return Qtrue;
#else
return Qfalse;
#endif
};T;)I"static VALUE;T;*To; ; T;
;F;;;I""Process::UID.re_exchangeable?;F;@B;@B;T;;D;0;@B;{ ;IC; "mReturns +true+ if the real and effective user IDs of a
process may be exchanged on the current platform.;T;[o;=
;3I"
overload;F;40;;E;50;)I""Process::UID.re_exchangeable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @B; [ ; I"@return [Boolean];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"Returns +true+ if the real and effective user IDs of a
process may be exchanged on the current platform.
@overload Process::UID.re_exchangeable?
@return [Boolean];T; 0; @B;!F;"o;#;$T;%iw ;&i} ;6i ;'@A;(@B;)@B;*To; ; F;
;;;;I" Process::UID#sid_available?;F;[ ;[[@]i ;T;:sid_available?;0;[ ;{ ;IC; "LReturns +true+ if the current platform has saved user
ID functionality.
;T;[o;=
;3I"
overload;F;40;: Process::UID.sid_available?;50;)I" Process::UID.sid_available?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @B; [ ; I"@return [Boolean];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"Returns +true+ if the current platform has saved user
ID functionality.
@overload Process::UID.sid_available?
@return [Boolean];T; 0; @B;!F;>0;'@A;(I"static VALUE
p_uid_have_saved_id(VALUE _)
{
#if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS)
return Qtrue;
#else
return Qfalse;
#endif
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" Process::UID.sid_available?;F;@B;@B;T;;F;0;@B;{ ;IC; "LReturns +true+ if the current platform has saved user
ID functionality.;T;[o;=
;3I"
overload;F;40;;G;50;)I" Process::UID.sid_available?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @B; [ ; I"@return [Boolean];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"Returns +true+ if the current platform has saved user
ID functionality.
@overload Process::UID.sid_available?
@return [Boolean];T; 0; @B;!F;"o;#;$T;%i ;&i ;6i ;'@A;(@B;)@B;*To; ; F;
;;;;I"Process::UID#switch;F;[ ;[[@]iL ;T;: switch;0;[ ;{ ;IC; "
;T;[ ; [ ; I" ;F; 0; @B;!F;>0;'@A;(I"sstatic VALUE
p_uid_switch(VALUE obj)
{
rb_uid_t uid, euid;
check_uid_switch();
uid = getuid();
euid = geteuid();
if (uid == euid) {
rb_syserr_fail(EPERM, 0);
}
p_uid_exchange(obj);
if (rb_block_given_p()) {
under_uid_switch = 1;
return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, obj);
}
else {
return UIDT2NUM(euid);
}
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::UID.switch;F;@B;@B;T;;H;0;@B;{ ;IC; " ;T;[ ; [ ; @|; 0; @C;6i ;'@A;(@B;)@ C;*To; ; F;
;;;;I"Process::UID#from_name;F;[[I"id;T0;[[@]i;T;:from_name;0;[ ;{ ;IC; "Get the user ID by the _name_.
If the user is not found, +ArgumentError+ will be raised.
Process::UID.from_name("root") #=> 0
Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError)
;T;[o;=
;3I"
overload;F;40;:Process::UID.from_name;50;)I"!Process::UID.from_name(name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @C;!F;6i ;>0;[[I" name;T0; @C; [ ; I"Get the user ID by the _name_.
If the user is not found, +ArgumentError+ will be raised.
Process::UID.from_name("root") #=> 0
Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError)
@overload Process::UID.from_name(name)
;T; 0; @C;!F;>0;'@A;(I"]static VALUE
p_uid_from_name(VALUE self, VALUE id)
{
return UIDT2NUM(OBJ2UID(id));
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::UID.from_name;F;@ C;@ C;T;;I;0;@C;{ ;IC; "Get the user ID by the _name_.
If the user is not found, +ArgumentError+ will be raised.
Process::UID.from_name("root") #=> 0
Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError);T;[o;=
;3I"
overload;F;40;;J;50;)I"!Process::UID.from_name(name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ C;!F;6i ;>0;[[I" name;T0; @ C; [ ; I"Get the user ID by the _name_.
If the user is not found, +ArgumentError+ will be raised.
Process::UID.from_name("root") #=> 0
Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError)
@overload Process::UID.from_name(name);T; 0; @ C;!F;"o;#;$T;%i;&i;6i ;'@A;(@ C;)@ C;*T;A@A;BIC;[ ;A@A;CIC;[ ;A@A;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@]iK";F;:UID;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @A;6i ;'@{+;I"Process::UID;Fo; ;IC;[o; ; F;
;;;;I"Process::GID#rid;F;[ ;[[@]iO;T;;;;0;[ ;{ ;IC; "LReturns the (real) group ID for this process.
Process.gid #=> 500
;T;[o;=
;3I"
overload;F;40;;;50;)I"gid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @CC; [ ; I"@return [Integer];T; 0; @CC;!F;6i ;>0;[ ; @CCo;=
;3I"
overload;F;40;;;50;)I"Process::GID.rid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @CC; [ ; I"@return [Integer];T; 0; @CC;!F;6i ;>0;[ ; @CCo;=
;3I"
overload;F;40;;;50;)I"Process::Sys.getgid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @CC; [ ; I"@return [Integer];T; 0; @CC;!F;6i ;>0;[ ; @CC; [ ; I"Returns the (real) group ID for this process.
Process.gid #=> 500
@overload gid
@return [Integer]
@overload Process::GID.rid
@return [Integer]
@overload Process::Sys.getgid
@return [Integer];T; 0; @CC;!F;>0;'@AC;(I"cstatic VALUE
proc_getgid(VALUE obj)
{
rb_gid_t gid = getgid();
return GIDT2NUM(gid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::GID.rid;F;@EC;@FC;T;;;;0;@HC;{ ;IC; "LReturns the (real) group ID for this process.
Process.gid #=> 500;T;[o;=
;3I"
overload;F;40;;;50;)I"gid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @wC; [ ; I"@return [Integer];T; 0; @wC;!F;6i ;>0;[ ; @wCo;=
;3I"
overload;F;40;;;50;)I"Process::GID.rid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @wC; [ ; I"@return [Integer];T; 0; @wC;!F;6i ;>0;[ ; @wCo;=
;3I"
overload;F;40;;;50;)I"Process::Sys.getgid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @wC; [ ; I"@return [Integer];T; 0; @wC;!F;6i ;>0;[ ; @wC; [ ; @<; 0; @wC;!F;"o;#;$T;%iD;&iN;6i ;'@AC;(@uC;)@vC;*To; ; F;
;;;;I"Process::GID#eid;F;[ ;[[@]i ;T;;<;0;[ ;{ ;IC; "pReturns the effective group ID for this process. Not available on
all platforms.
Process.egid #=> 500
;T;[o;=
;3I"
overload;F;40;;;50;)I" egid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @Co;=
;3I"
overload;F;40;;;50;)I"Process::GID.eid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @Co;=
;3I"
overload;F;40;;;50;)I"Process::Sys.geteid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @C; [ ; I"Returns the effective group ID for this process. Not available on
all platforms.
Process.egid #=> 500
@overload egid
@return [Integer]
@overload Process::GID.eid
@return [Integer]
@overload Process::Sys.geteid
@return [Integer];T; 0; @C;!F;>0;'@AC;(I"hstatic VALUE
proc_getegid(VALUE obj)
{
rb_gid_t egid = getegid();
return GIDT2NUM(egid);
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::GID.eid;F;@C;@C;T;;<;0;@C;{ ;IC; "pReturns the effective group ID for this process. Not available on
all platforms.
Process.egid #=> 500;T;[o;=
;3I"
overload;F;40;;;50;)I" egid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @Co;=
;3I"
overload;F;40;;;50;)I"Process::GID.eid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @Co;=
;3I"
overload;F;40;;;50;)I"Process::Sys.geteid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @C; [ ; I"@return [Integer];T; 0; @C;!F;6i ;>0;[ ; @C; [ ; @=; 0; @C;!F;"o;#;$T;%i;&i ;6i ;'@AC;(@C;)@C;*To; ; F;
;;;;I""Process::GID#change_privilege;F;[[I"id;T0;[[@]i;T;;=;0;[ ;{ ;IC; "(Change the current process's real and effective group ID to that
specified by _group_. Returns the new group ID. Not
available on all platforms.
[Process.gid, Process.egid] #=> [0, 0]
Process::GID.change_privilege(33) #=> 33
[Process.gid, Process.egid] #=> [33, 33]
;T;[o;=
;3I"
overload;F;40;:"Process::GID.change_privilege;50;)I")Process::GID.change_privilege(group);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @D; [ ; I"@return [Integer];T; 0; @D;!F;6i ;>0;[[I"
group;T0; @D; [ ; I"lChange the current process's real and effective group ID to that
specified by _group_. Returns the new group ID. Not
available on all platforms.
[Process.gid, Process.egid] #=> [0, 0]
Process::GID.change_privilege(33) #=> 33
[Process.gid, Process.egid] #=> [33, 33]
@overload Process::GID.change_privilege(group)
@return [Integer];T; 0; @D;!F;>0;'@AC;(I"static VALUE
p_gid_change_privilege(VALUE obj, VALUE id)
{
rb_gid_t gid;
check_gid_switch();
gid = OBJ2GID(id);
if (geteuid() == 0) { /* root-user */
#if defined(HAVE_SETRESGID)
if (setresgid(gid, gid, gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
#elif defined HAVE_SETGID
if (setgid(gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)
if (getgid() == gid) {
if (SAVED_GROUP_ID == gid) {
if (setregid(-1, gid) < 0) rb_sys_fail(0);
}
else {
if (gid == 0) { /* (r,e,s) == (root, y, x) */
if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0);
if (setregid(SAVED_GROUP_ID, 0) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = 0; /* (r,e,s) == (x, root, root) */
if (setregid(gid, gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
else { /* (r,e,s) == (z, y, x) */
if (setregid(0, 0) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = 0;
if (setregid(gid, gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
}
}
else {
if (setregid(gid, gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
#elif defined(HAVE_SETRGID) && defined (HAVE_SETEGID)
if (getgid() == gid) {
if (SAVED_GROUP_ID == gid) {
if (setegid(gid) < 0) rb_sys_fail(0);
}
else {
if (gid == 0) {
if (setegid(gid) < 0) rb_sys_fail(0);
if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = 0;
if (setrgid(0) < 0) rb_sys_fail(0);
}
else {
if (setrgid(0) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = 0;
if (setegid(gid) < 0) rb_sys_fail(0);
if (setrgid(gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
}
}
else {
if (setegid(gid) < 0) rb_sys_fail(0);
if (setrgid(gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
#else
rb_notimplement();
#endif
}
else { /* unprivileged user */
#if defined(HAVE_SETRESGID)
if (setresgid((getgid() == gid)? (rb_gid_t)-1: gid,
(getegid() == gid)? (rb_gid_t)-1: gid,
(SAVED_GROUP_ID == gid)? (rb_gid_t)-1: gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)
if (SAVED_GROUP_ID == gid) {
if (setregid((getgid() == gid)? (rb_uid_t)-1: gid,
(getegid() == gid)? (rb_uid_t)-1: gid) < 0)
rb_sys_fail(0);
}
else if (getgid() != gid) {
if (setregid(gid, (getegid() == gid)? (rb_uid_t)-1: gid) < 0)
rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
else if (/* getgid() == gid && */ getegid() != gid) {
if (setregid(getegid(), gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
if (setregid(gid, -1) < 0) rb_sys_fail(0);
}
else { /* getgid() == gid && getegid() == gid */
if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0);
if (setregid(SAVED_GROUP_ID, gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
if (setregid(gid, -1) < 0) rb_sys_fail(0);
}
#elif defined(HAVE_SETRGID) && defined(HAVE_SETEGID)
if (SAVED_GROUP_ID == gid) {
if (getegid() != gid && setegid(gid) < 0) rb_sys_fail(0);
if (getgid() != gid && setrgid(gid) < 0) rb_sys_fail(0);
}
else if (/* SAVED_GROUP_ID != gid && */ getegid() == gid) {
if (getgid() != gid) {
if (setrgid(gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
else {
if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
if (setrgid(gid) < 0) rb_sys_fail(0);
}
}
else if (/* getegid() != gid && */ getgid() == gid) {
if (setegid(gid) < 0) rb_sys_fail(0);
if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
if (setrgid(gid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_44BSD_SETGID
if (getgid() == gid) {
/* (r,e,s)==(gid,?,?) ==> (gid,gid,gid) */
if (setgid(gid) < 0) rb_sys_fail(0);
SAVED_GROUP_ID = gid;
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_SETEGID
if (getgid() == gid && SAVED_GROUP_ID == gid) {
if (setegid(gid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#elif defined HAVE_SETGID
if (getgid() == gid && SAVED_GROUP_ID == gid) {
if (setgid(gid) < 0) rb_sys_fail(0);
}
else {
rb_syserr_fail(EPERM, 0);
}
#else
(void)gid;
rb_notimplement();
#endif
}
return id;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I""Process::GID.change_privilege;F;@ D;@ D;T;;=;0;@D;{ ;IC; "(Change the current process's real and effective group ID to that
specified by _group_. Returns the new group ID. Not
available on all platforms.
[Process.gid, Process.egid] #=> [0, 0]
Process::GID.change_privilege(33) #=> 33
[Process.gid, Process.egid] #=> [33, 33];T;[o;=
;3I"
overload;F;40;;L;50;)I")Process::GID.change_privilege(group);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @%D; [ ; I"@return [Integer];T; 0; @%D;!F;6i ;>0;[[I"
group;T0; @%D; [ ; I"mChange the current process's real and effective group ID to that
specified by _group_. Returns the new group ID. Not
available on all platforms.
[Process.gid, Process.egid] #=> [0, 0]
Process::GID.change_privilege(33) #=> 33
[Process.gid, Process.egid] #=> [33, 33]
@overload Process::GID.change_privilege(group)
@return [Integer];T; 0; @%D;!F;"o;#;$T;%i;&i;6i ;'@AC;(@#D;)@$D;*To; ; F;
;;;;I"!Process::GID#grant_privilege;F;[[I"id;T0;[[@]io ;T;;?;0;[ ;{ ;IC; "?Set the effective group ID, and if possible, the saved group ID of
the process to the given _group_. Returns the new
effective group ID. Not available on all platforms.
[Process.gid, Process.egid] #=> [0, 0]
Process::GID.grant_privilege(31) #=> 33
[Process.gid, Process.egid] #=> [0, 33]
;T;[o;=
;3I"
overload;F;40;:!Process::GID.grant_privilege;50;)I"(Process::GID.grant_privilege(group);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @-1 for either means to leave that ID unchanged. Not
available on all platforms.
;T;[o;=
;3I"
overload;F;40;:Process::Sys.setreuid;50;)I"$Process::Sys.setreuid(rid, eid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @3H; [ ; I"@return [nil];T; 0; @3H;!F;6i ;>0;[[I"rid;T0[I"eid;T0; @3H; [ ; I"
Sets the (user) real and/or effective user IDs of the current
process to _rid_ and _eid_, respectively. A value of
-1 for either means to leave that ID unchanged. Not
available on all platforms.
@overload Process::Sys.setreuid(rid, eid)
@return [nil];T; 0; @3H;!F;>0;'@kE;(I"static VALUE
p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid)
{
rb_uid_t ruid, euid;
PREPARE_GETPWNAM;
check_uid_switch();
ruid = OBJ2UID1(rid);
euid = OBJ2UID1(eid);
FINISH_GETPWNAM;
if (setreuid(ruid, euid) != 0) rb_sys_fail(0);
return Qnil;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::Sys.setreuid;F;@5H;@:H;T;;c;0;@-1 for either means to leave that ID unchanged. Not
available on all platforms.
@overload Process::Sys.setreuid(rid, eid)
@return [nil];T; 0; @UH;!F;"o;#;$T;%iw;&i;6i ;'@kE;(@SH;)@TH;*To; ; F;
;;;;I"Process::Sys#setregid;F;[[I"rid;T0[I"eid;T0;[[@]i;T;:
setregid;0;[ ;{ ;IC; "Sets the (group) real and/or effective group IDs of the current
process to rid and eid, respectively. A value of
-1 for either means to leave that ID unchanged. Not
available on all platforms.
;T;[o;=
;3I"
overload;F;40;:Process::Sys.setregid;50;)I"$Process::Sys.setregid(rid, eid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @nH; [ ; I"@return [nil];T; 0; @nH;!F;6i ;>0;[[I"rid;T0[I"eid;T0; @nH; [ ; I"Sets the (group) real and/or effective group IDs of the current
process to rid and eid, respectively. A value of
-1 for either means to leave that ID unchanged. Not
available on all platforms.
@overload Process::Sys.setregid(rid, eid)
@return [nil];T; 0; @nH;!F;>0;'@kE;(I"static VALUE
p_sys_setregid(VALUE obj, VALUE rid, VALUE eid)
{
rb_gid_t rgid, egid;
check_gid_switch();
rgid = OBJ2GID(rid);
egid = OBJ2GID(eid);
if (setregid(rgid, egid) != 0) rb_sys_fail(0);
return Qnil;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::Sys.setregid;F;@pH;@uH;T;;e;0;@wH;{ ;IC; "Sets the (group) real and/or effective group IDs of the current
process to rid and eid, respectively. A value of
-1 for either means to leave that ID unchanged. Not
available on all platforms.;T;[o;=
;3I"
overload;F;40;;f;50;)I"$Process::Sys.setregid(rid, eid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @H; [ ; I"@return [nil];T; 0; @H;!F;6i ;>0;[[I"rid;T0[I"eid;T0; @H; [ ; I" Sets the (group) real and/or effective group IDs of the current
process to rid and eid, respectively. A value of
-1 for either means to leave that ID unchanged. Not
available on all platforms.
@overload Process::Sys.setregid(rid, eid)
@return [nil];T; 0; @H;!F;"o;#;$T;%i;&i;6i ;'@kE;(@H;)@H;*To; ; F;
;;;;I"Process::Sys#setresuid;F;[[I"rid;T0[I"eid;T0[I"sid;T0;[[@]i;T;:setresuid;0;[ ;{ ;IC; "Sets the (user) real, effective, and saved user IDs of the
current process to _rid_, _eid_, and _sid_ respectively. A
value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
;T;[o;=
;3I"
overload;F;40;:Process::Sys.setresuid;50;)I"*Process::Sys.setresuid(rid, eid, sid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @H; [ ; I"@return [nil];T; 0; @H;!F;6i ;>0;[[I"rid;T0[I"eid;T0[I"sid;T0; @H; [ ; I" Sets the (user) real, effective, and saved user IDs of the
current process to _rid_, _eid_, and _sid_ respectively. A
value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
@overload Process::Sys.setresuid(rid, eid, sid)
@return [nil];T; 0; @H;!F;>0;'@kE;(I"Gstatic VALUE
p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
{
rb_uid_t ruid, euid, suid;
PREPARE_GETPWNAM;
check_uid_switch();
ruid = OBJ2UID1(rid);
euid = OBJ2UID1(eid);
suid = OBJ2UID1(sid);
FINISH_GETPWNAM;
if (setresuid(ruid, euid, suid) != 0) rb_sys_fail(0);
return Qnil;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::Sys.setresuid;F;@H;@H;T;;g;0;@H;{ ;IC; "Sets the (user) real, effective, and saved user IDs of the
current process to _rid_, _eid_, and _sid_ respectively. A
value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.;T;[o;=
;3I"
overload;F;40;;h;50;)I"*Process::Sys.setresuid(rid, eid, sid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @H; [ ; I"@return [nil];T; 0; @H;!F;6i ;>0;[[I"rid;T0[I"eid;T0[I"sid;T0; @H; [ ; I"!Sets the (user) real, effective, and saved user IDs of the
current process to _rid_, _eid_, and _sid_ respectively. A
value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
@overload Process::Sys.setresuid(rid, eid, sid)
@return [nil];T; 0; @H;!F;"o;#;$T;%i;&i;6i ;'@kE;(@H;)@H;*To; ; F;
;;;;I"Process::Sys#setresgid;F;[[I"rid;T0[I"eid;T0[I"sid;T0;[[@]i;T;:setresgid;0;[ ;{ ;IC; "Sets the (group) real, effective, and saved user IDs of the
current process to rid, eid, and sid
respectively. A value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
;T;[o;=
;3I"
overload;F;40;:Process::Sys.setresgid;50;)I"*Process::Sys.setresgid(rid, eid, sid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @H; [ ; I"@return [nil];T; 0; @H;!F;6i ;>0;[[I"rid;T0[I"eid;T0[I"sid;T0; @H; [ ; I"5Sets the (group) real, effective, and saved user IDs of the
current process to rid, eid, and sid
respectively. A value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
@overload Process::Sys.setresgid(rid, eid, sid)
@return [nil];T; 0; @H;!F;>0;'@kE;(I"static VALUE
p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
{
rb_gid_t rgid, egid, sgid;
check_gid_switch();
rgid = OBJ2GID(rid);
egid = OBJ2GID(eid);
sgid = OBJ2GID(sid);
if (setresgid(rgid, egid, sgid) != 0) rb_sys_fail(0);
return Qnil;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::Sys.setresgid;F;@H;@H;T;;i;0;@H;{ ;IC; "Sets the (group) real, effective, and saved user IDs of the
current process to rid, eid, and sid
respectively. A value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.;T;[o;=
;3I"
overload;F;40;;j;50;)I"*Process::Sys.setresgid(rid, eid, sid);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @I; [ ; I"@return [nil];T; 0; @I;!F;6i ;>0;[[I"rid;T0[I"eid;T0[I"sid;T0; @I; [ ; I"7Sets the (group) real, effective, and saved user IDs of the
current process to rid, eid, and sid
respectively. A value of -1 for any value means to
leave that ID unchanged. Not available on all platforms.
@overload Process::Sys.setresgid(rid, eid, sid)
@return [nil];T; 0; @I;!F;"o;#;$T;%i
;&i;6i ;'@kE;(@I;)@I;*To; ; F;
;;;;I"Process::Sys#issetugid;F;[ ;[[@]i5;T;:issetugid;0;[ ;{ ;IC; "Returns +true+ if the process was created as a result
of an execve(2) system call which had either of the setuid or
setgid bits set (and extra privileges were given as a result) or
if it has changed any of its real, effective or saved user or
group IDs since it began execution.
;T;[o;=
;3I"
overload;F;40;:Process::Sys.issetugid;50;)I"Process::Sys.issetugid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @+I; [ ; I"@return [Boolean];T; 0; @+I;!F;6i ;>0;[ ; @+I; [ ; I"LReturns +true+ if the process was created as a result
of an execve(2) system call which had either of the setuid or
setgid bits set (and extra privileges were given as a result) or
if it has changed any of its real, effective or saved user or
group IDs since it began execution.
@overload Process::Sys.issetugid
@return [Boolean];T; 0; @+I;!F;>0;'@kE;(I"}static VALUE
p_sys_issetugid(VALUE obj)
{
if (issetugid()) {
return Qtrue;
}
else {
return Qfalse;
}
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"Process::Sys.issetugid;F;@-I;@.I;T;;k;0;@0I;{ ;IC; "Returns +true+ if the process was created as a result
of an execve(2) system call which had either of the setuid or
setgid bits set (and extra privileges were given as a result) or
if it has changed any of its real, effective or saved user or
group IDs since it began execution.;T;[o;=
;3I"
overload;F;40;;l;50;)I"Process::Sys.issetugid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @EI; [ ; I"@return [Boolean];T; 0; @EI;!F;6i ;>0;[ ; @EI; [ ; I"NReturns +true+ if the process was created as a result
of an execve(2) system call which had either of the setuid or
setgid bits set (and extra privileges were given as a result) or
if it has changed any of its real, effective or saved user or
group IDs since it began execution.
@overload Process::Sys.issetugid
@return [Boolean];T; 0; @EI;!F;"o;#;$T;%i);&i2;6i ;'@kE;(@CI;)@DI;*T;A@kE;BIC;[ ;A@kE;CIC;[ ;A@kE;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@]ig";F;:Sys;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @kE;6i ;'@{+;I"Process::Sys;F;A@{+;BIC;[ ;A@{+;CIC;[ ;A@{+;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@]i[@]i ;T;;;;K;;;[ ;{ ;IC; "The module contains several groups of functionality for handling OS processes:
* Low-level property introspection and management of the current process, like
Process.argv0, Process.pid;
* Low-level introspection of other processes, like Process.getpgid, Process.getpriority;
* Management of the current process: Process.abort, Process.exit, Process.daemon, etc.
(for convenience, most of those are also available as global functions
and module functions of Kernel);
* Creation and management of child processes: Process.fork, Process.spawn, and
related methods;
* Management of low-level system clock: Process.times and Process.clock_gettime,
which could be important for proper benchmarking and other elapsed
time measurement tasks.;T;[ ; [ ; I"
The module contains several groups of functionality for handling OS processes:
* Low-level property introspection and management of the current process, like
Process.argv0, Process.pid;
* Low-level introspection of other processes, like Process.getpgid, Process.getpriority;
* Management of the current process: Process.abort, Process.exit, Process.daemon, etc.
(for convenience, most of those are also available as global functions
and module functions of Kernel);
* Creation and management of child processes: Process.fork, Process.spawn, and
related methods;
* Management of low-level system clock: Process.times and Process.clock_gettime,
which could be important for proper benchmarking and other elapsed
time measurement tasks.
;T; 0; @{+;!F;"o;#;$T;%i;&i;6i ;'@;I" Process;Fo;;[[@+iS ;F;: ARGV;;;;;[ ;{ ;IC; "ARGV contains the command line arguments used to run ruby.
A library like OptionParser can be used to process command-line
arguments.
;T;[ ; [ ; I"ARGV contains the command line arguments used to run ruby.
A library like OptionParser can be used to process command-line
arguments.
;T; 0; @{I;!F;"o;#;$T;%iM ;&iQ ;'@;I" ARGV;F;I" rb_argv;To; ;IC;[o;
;IC;[ o; ; F;
;;;;I""Racc::Parser#_racc_do_parse_c;F;[[I"arg;T0[I"
sysdebug;T0;[[I" ext/racc/cparse/cparse.c;Ti;T;:_racc_do_parse_c;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;(I"static VALUE
racc_cparse(VALUE parser, VALUE arg, VALUE sysdebug)
{
VALUE vparams;
struct cparse_params *v;
vparams = TypedData_Make_Struct(CparseParams, struct cparse_params,
&cparse_params_type, v);
D_puts("starting cparse");
v->sys_debug = RTEST(sysdebug);
vparams = initialize_params(vparams, parser, arg, Qnil, Qnil);
v->lex_is_iterator = FALSE;
parse_main(v, Qnil, Qnil, 0);
RB_GC_GUARD(vparams);
return v->retval;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!Racc::Parser#_racc_yyparse_c;F;[ [I"
lexer;T0[I" lexmid;T0[I"arg;T0[I"
sysdebug;T0;[[@Ii;T;:_racc_yyparse_c;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;(I"static VALUE
racc_yyparse(VALUE parser, VALUE lexer, VALUE lexmid, VALUE arg, VALUE sysdebug)
{
VALUE vparams;
struct cparse_params *v;
vparams = TypedData_Make_Struct(CparseParams, struct cparse_params,
&cparse_params_type, v);
v->sys_debug = RTEST(sysdebug);
D_puts("start C yyparse");
vparams = initialize_params(vparams, parser, arg, lexer, lexmid);
v->lex_is_iterator = TRUE;
D_puts("params initialized");
parse_main(v, Qnil, Qnil, 0);
call_lexer(v);
if (!v->fin) {
rb_raise(rb_eArgError, "%s() is finished before EndOfToken",
rb_id2name(v->lexmid));
}
RB_GC_GUARD(vparams);
return v->retval;
};T;)I"static VALUE;T;*To;;[[@IiE;F;: Racc_Runtime_Core_Version_C;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;I".Racc::Parser::Racc_Runtime_Core_Version_C;F;I" rb_str_new2(RACC_VERSION);To;;[[@IiG;F;:Racc_Runtime_Core_Id_C;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;I")Racc::Parser::Racc_Runtime_Core_Id_C;F;I"Prb_str_new2("$originalId: cparse.c,v 1.8 2006/07/06 11:39:46 aamine Exp $");T;A@I;BIC;[ ;A@I;CIC;[ ;A@I;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@IiA;F;: Parser;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;I"Racc::Parser;F;So;L ;M0;N0;O0;;T;'@;Q@];R;Fo;
;IC;[ ;A@I;BIC;[ ;A@I;CIC;[ ;A@I;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@IiJ;F;:CparseParams;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;I"Racc::CparseParams;F;So;L ;M0;N0;O0;;T;'@;Q@];R;F;A@I;BIC;[ ;A@I;CIC;[ ;A@I;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Ii@;F;: Racc;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@;I" Racc;Fo; ;IC;[#o; ;IC;[o; ; F;
;F;;;I" Syslog::Constants.included;F;[[I" target;T0;[[I"ext/syslog/syslog.c;Ti;T;:
included;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;(I"}static VALUE mSyslogMacros_included(VALUE mod, VALUE target)
{
rb_extend_object(target, mSyslogMacros);
return mod;
};T;)I"Astatic VALUE mSyslogMacros_included(VALUE mod, VALUE target);T;*T;A@I;BIC;[ ;A@I;CIC;[o; ;IC;[ ;A@
J;BIC;[ ;A@
J;CIC;[ ;A@
J;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@ Ji;F;: Option;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @
J;'@I;I"Syslog::Option;Fo; ;IC;[ ;A@J;BIC;[ ;A@J;CIC;[ ;A@J;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@ Ji;F;:
Facility;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @J;'@I;I"Syslog::Facility;Fo; ;IC;[ ;A@,J;BIC;[ ;A@,J;CIC;[ ;A@,J;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@ Ji;F;:
Level;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @,J;'@I;I"Syslog::Level;F;A@I;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@ Ji;F;:Constants;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @I;'@I;I"Syslog::Constants;F@
J@J@,Jo; ;IC;[o; ; F;
;;;;I" Syslog::Macros#LOG_MASK;F;[ ;[ ;F;:
LOG_MASK;;K;[ ;{ ;IC; "Syslog macros
;T;[ ; [ ; I"Syslog macros;T; 0; @LJ;!F;"o;#;$T;%i?;&i?;'@JJ;*To; ; F;
;;;;I" Syslog::Macros#LOG_UPTO;F;[[I"pri;T0;[[@ Ji;T;:
LOG_UPTO;0;[ ;{ ;IC; "[Generates a mask value for priority levels at or below the level specified.
See #mask=
;T;[o;=
;3I"
overload;F;40;;|;50;)I" LOG_UPTO(priority_level);T;IC; " ;T;[ ; [ ; I" ;T; 0; @WJ;!F;6i ;>0;[[I"priority_level;T0; @WJ; [ ; I"{Generates a mask value for priority levels at or below the level specified.
See #mask=
@overload LOG_UPTO(priority_level);T; 0; @WJ;!F;"o;#;$T;%i;&i;'@JJ;(I"nstatic VALUE mSyslogMacros_LOG_UPTO(VALUE mod, VALUE pri)
{
return INT2FIX(LOG_UPTO(NUM2INT(pri)));
};T;)I">static VALUE mSyslogMacros_LOG_UPTO(VALUE mod, VALUE pri);T;*To; ; F;
;F;;;I" Syslog::Macros.included;F;[[I" target;T0;[[@ Ji;T;;v;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @qJ;'@JJ;(I"}static VALUE mSyslogMacros_included(VALUE mod, VALUE target)
{
rb_extend_object(target, mSyslogMacros);
return mod;
};T;)I"Astatic VALUE mSyslogMacros_included(VALUE mod, VALUE target);T;*T;A@JJ;BIC;[ ;A@JJ;CIC;[ ;A@JJ;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@ Ji;F;: Macros;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @JJ;6i ;'@I;I"Syslog::Macros;Fo; ; F;
;;;;I"Syslog#open;F;[[@c0;[[@ Ji;T;;;0;[ ;{ ;IC; "t:yields: syslog
Open the syslog facility.
Raises a runtime exception if it is already open.
Can be called with or without a code block. If called with a block, the
Syslog object created is passed to the block.
If the syslog is already open, raises a RuntimeError.
+ident+ is a String which identifies the calling program.
+options+ is the logical OR of any of the following:
LOG_CONS:: If there is an error while sending to the system logger,
write directly to the console instead.
LOG_NDELAY:: Open the connection now, rather than waiting for the first
message to be written.
LOG_NOWAIT:: Don't wait for any child processes created while logging
messages. (Has no effect on Linux.)
LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before
opening the connection. (This is the default.)
LOG_PERROR:: Print the message to stderr as well as sending it to syslog.
(Not in POSIX.1-2001.)
LOG_PID:: Include the current process ID with each message.
+facility+ describes the type of program opening the syslog, and is
the logical OR of any of the following which are defined for the host OS:
LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV
instead.
LOG_AUTHPRIV:: Security or authorization messages which should be kept
private.
LOG_CONSOLE:: System console message.
LOG_CRON:: System task scheduler (cron or at).
LOG_DAEMON:: A system daemon which has no facility value of its own.
LOG_FTP:: An FTP server.
LOG_KERN:: A kernel message (not sendable by user processes, so not of
much use to Ruby, but listed here for completeness).
LOG_LPR:: Line printer subsystem.
LOG_MAIL:: Mail delivery or transport subsystem.
LOG_NEWS:: Usenet news system.
LOG_NTP:: Network Time Protocol server.
LOG_SECURITY:: General security message.
LOG_SYSLOG:: Messages generated internally by syslog.
LOG_USER:: Generic user-level message.
LOG_UUCP:: UUCP subsystem.
LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities.
Example:
Syslog.open("webrick", Syslog::LOG_PID,
Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3)
;T;[o;=
;3I"
overload;F;40;;;50;)I"#open(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @J;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @J; [ ; I":yields: syslog
Open the syslog facility.
Raises a runtime exception if it is already open.
Can be called with or without a code block. If called with a block, the
Syslog object created is passed to the block.
If the syslog is already open, raises a RuntimeError.
+ident+ is a String which identifies the calling program.
+options+ is the logical OR of any of the following:
LOG_CONS:: If there is an error while sending to the system logger,
write directly to the console instead.
LOG_NDELAY:: Open the connection now, rather than waiting for the first
message to be written.
LOG_NOWAIT:: Don't wait for any child processes created while logging
messages. (Has no effect on Linux.)
LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before
opening the connection. (This is the default.)
LOG_PERROR:: Print the message to stderr as well as sending it to syslog.
(Not in POSIX.1-2001.)
LOG_PID:: Include the current process ID with each message.
+facility+ describes the type of program opening the syslog, and is
the logical OR of any of the following which are defined for the host OS:
LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV
instead.
LOG_AUTHPRIV:: Security or authorization messages which should be kept
private.
LOG_CONSOLE:: System console message.
LOG_CRON:: System task scheduler (cron or at).
LOG_DAEMON:: A system daemon which has no facility value of its own.
LOG_FTP:: An FTP server.
LOG_KERN:: A kernel message (not sendable by user processes, so not of
much use to Ruby, but listed here for completeness).
LOG_LPR:: Line printer subsystem.
LOG_MAIL:: Mail delivery or transport subsystem.
LOG_NEWS:: Usenet news system.
LOG_NTP:: Network Time Protocol server.
LOG_SECURITY:: General security message.
LOG_SYSLOG:: Messages generated internally by syslog.
LOG_USER:: Generic user-level message.
LOG_UUCP:: UUCP subsystem.
LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities.
Example:
Syslog.open("webrick", Syslog::LOG_PID,
Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3)
@overload open(ident, options, facility)
;T; 0; @J;!F;>0;'@I;(I"static VALUE mSyslog_open(int argc, VALUE *argv, VALUE self)
{
VALUE ident, opt, fac;
const char *ident_ptr;
if (syslog_opened) {
rb_raise(rb_eRuntimeError, "syslog already open");
}
rb_scan_args(argc, argv, "03", &ident, &opt, &fac);
if (NIL_P(ident)) {
ident = rb_gv_get("$0");
}
ident_ptr = StringValueCStr(ident);
syslog_ident = strdup(ident_ptr);
if (NIL_P(opt)) {
syslog_options = LOG_PID | LOG_CONS;
} else {
syslog_options = NUM2INT(opt);
}
if (NIL_P(fac)) {
syslog_facility = LOG_USER;
} else {
syslog_facility = NUM2INT(fac);
}
openlog(syslog_ident, syslog_options, syslog_facility);
syslog_opened = 1;
setlogmask(syslog_mask = setlogmask(0));
/* be like File.new.open {...} */
if (rb_block_given_p()) {
rb_ensure(rb_yield, self, mSyslog_close, self);
}
return self;
};T;)I"Astatic VALUE mSyslog_open(int argc, VALUE *argv, VALUE self);T;*To; ; T;
;F;;;I"Syslog.open;F;@J;@J;T;;;0;@J;{ ;IC; "t:yields: syslog
Open the syslog facility.
Raises a runtime exception if it is already open.
Can be called with or without a code block. If called with a block, the
Syslog object created is passed to the block.
If the syslog is already open, raises a RuntimeError.
+ident+ is a String which identifies the calling program.
+options+ is the logical OR of any of the following:
LOG_CONS:: If there is an error while sending to the system logger,
write directly to the console instead.
LOG_NDELAY:: Open the connection now, rather than waiting for the first
message to be written.
LOG_NOWAIT:: Don't wait for any child processes created while logging
messages. (Has no effect on Linux.)
LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before
opening the connection. (This is the default.)
LOG_PERROR:: Print the message to stderr as well as sending it to syslog.
(Not in POSIX.1-2001.)
LOG_PID:: Include the current process ID with each message.
+facility+ describes the type of program opening the syslog, and is
the logical OR of any of the following which are defined for the host OS:
LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV
instead.
LOG_AUTHPRIV:: Security or authorization messages which should be kept
private.
LOG_CONSOLE:: System console message.
LOG_CRON:: System task scheduler (cron or at).
LOG_DAEMON:: A system daemon which has no facility value of its own.
LOG_FTP:: An FTP server.
LOG_KERN:: A kernel message (not sendable by user processes, so not of
much use to Ruby, but listed here for completeness).
LOG_LPR:: Line printer subsystem.
LOG_MAIL:: Mail delivery or transport subsystem.
LOG_NEWS:: Usenet news system.
LOG_NTP:: Network Time Protocol server.
LOG_SECURITY:: General security message.
LOG_SYSLOG:: Messages generated internally by syslog.
LOG_USER:: Generic user-level message.
LOG_UUCP:: UUCP subsystem.
LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities.
Example:
Syslog.open("webrick", Syslog::LOG_PID,
Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3);T;[o;=
;3I"
overload;F;40;;;50;)I"#open(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @J;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @J; [ ; I":yields: syslog
Open the syslog facility.
Raises a runtime exception if it is already open.
Can be called with or without a code block. If called with a block, the
Syslog object created is passed to the block.
If the syslog is already open, raises a RuntimeError.
+ident+ is a String which identifies the calling program.
+options+ is the logical OR of any of the following:
LOG_CONS:: If there is an error while sending to the system logger,
write directly to the console instead.
LOG_NDELAY:: Open the connection now, rather than waiting for the first
message to be written.
LOG_NOWAIT:: Don't wait for any child processes created while logging
messages. (Has no effect on Linux.)
LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before
opening the connection. (This is the default.)
LOG_PERROR:: Print the message to stderr as well as sending it to syslog.
(Not in POSIX.1-2001.)
LOG_PID:: Include the current process ID with each message.
+facility+ describes the type of program opening the syslog, and is
the logical OR of any of the following which are defined for the host OS:
LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV
instead.
LOG_AUTHPRIV:: Security or authorization messages which should be kept
private.
LOG_CONSOLE:: System console message.
LOG_CRON:: System task scheduler (cron or at).
LOG_DAEMON:: A system daemon which has no facility value of its own.
LOG_FTP:: An FTP server.
LOG_KERN:: A kernel message (not sendable by user processes, so not of
much use to Ruby, but listed here for completeness).
LOG_LPR:: Line printer subsystem.
LOG_MAIL:: Mail delivery or transport subsystem.
LOG_NEWS:: Usenet news system.
LOG_NTP:: Network Time Protocol server.
LOG_SECURITY:: General security message.
LOG_SYSLOG:: Messages generated internally by syslog.
LOG_USER:: Generic user-level message.
LOG_UUCP:: UUCP subsystem.
LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities.
Example:
Syslog.open("webrick", Syslog::LOG_PID,
Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3)
@overload open(ident, options, facility);T; 0; @J;!F;"o;#;$T;%iM;&i;6i ;'@I;(@J;)@J;*To; ; F;
;;;;I"Syslog#reopen;F;[[@c0;[[@ Ji;T;: reopen;0;[ ;{ ;IC; "`:yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().
;T;[o;=
;3I"
overload;F;40;;~;50;)I"%reopen(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @J;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @J; [ ; I":yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().
@overload reopen(ident, options, facility)
;T; 0; @J;!F;>0;'@I;(I"static VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self)
{
mSyslog_close(self);
return mSyslog_open(argc, argv, self);
};T;)I"Cstatic VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self);T;*To; ; T;
;F;;;I"Syslog.reopen;F;@J;@J;T;;~;0;@J;{ ;IC; "`:yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().;T;[o;=
;3I"
overload;F;40;;~;50;)I"%reopen(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @J;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @J; [ ; I":yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().
@overload reopen(ident, options, facility);T; 0; @J;!F;"o;#;$T;%i;&i;6i ;'@I;(@J;)@J;*To; ; F;
;;;;I"Syslog#open!;F;[[@c0;[[@ Ji;T;:
open!;0;[ ;{ ;IC; "`:yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().
;T;[o;=
;3I"
overload;F;40;;~;50;)I"%reopen(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @J;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @J; [ ; I":yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().
@overload reopen(ident, options, facility)
;T; 0; @J;!F;>0;'@I;(I"static VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self)
{
mSyslog_close(self);
return mSyslog_open(argc, argv, self);
};T;)I"Cstatic VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self);T;*To; ; T;
;F;;;I"Syslog.open!;F;@J;@J;T;;;0;@J;{ ;IC; "`:yields: syslog
Closes and then reopens the syslog.
Arguments are the same as for open().;T;[o;=
;3I"
overload;F;40;;~;50;)I"%reopen(ident, options, facility);T;IC; " ;T;[ ; [ ; I" ;T; 0; @K;!F;6i ;>0;[[I"
ident;T0[I" options;T0[I"
facility;T0; @K; [ ; @J; 0; @K;!F;"o;#;$T;%i;&i;6i ;'@I;(@ K;)@
K;*To; ; F;
;;;;I"Syslog#opened?;F;[ ;[[@ Ji;T;: opened?;0;[ ;{ ;IC; "(Returns true if the syslog is open.
;T;[o;=
;3I"
overload;F;40;;;50;)I" opened?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @#K;!F;6i ;>0;[ ; @#Ko;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @#K; [ ; I"NReturns true if the syslog is open.
@overload opened?
@return [Boolean] ;T; 0; @#K;!F;>0;'@I;(I"[static VALUE mSyslog_isopen(VALUE self)
{
return syslog_opened ? Qtrue : Qfalse;
};T;)I",static VALUE mSyslog_isopen(VALUE self);T;*To; ; T;
;F;;;I"Syslog.opened?;F;@%K;@&K;T;;;0;@(K;{ ;IC; "(Returns true if the syslog is open.;T;[o;=
;3I"
overload;F;40;;;50;)I" opened?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @=K;!F;6i ;>0;[ ; @=Ko;2
;3I" return;F;4@|;0;5[@~; @=K; [ ; I"# and
the parent directory #.
If you don't want +.+ and +..+ and
want directories, consider Pathname#children.
;T;[ ; [ ; I"Return the entries (files and subdirectories) in the directory, each as a
Pathname object.
The results contains just the names in the directory, without any trailing
slashes or recursive look-up.
pp Pathname.new('/usr/local').entries
#=> [## and
the parent directory #.
If you don't want +.+ and +..+ and
want directories, consider Pathname#children.
;T; 0; @S;!F;"o;#;$T;%i;&i;'@HL;(I"static VALUE
path_entries(VALUE self)
{
VALUE klass, str, ary;
long i;
klass = rb_obj_class(self);
str = get_strpath(self);
ary = rb_funcall(rb_cDir, id_entries, 1, str);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
elt = rb_class_new_instance(1, &elt, klass);
rb_ary_store(ary, i, elt);
}
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#mkdir;F;[[@c0;[[@- i;T;:
mkdir;0;[ ;{ ;IC; "5Create the referenced directory.
See Dir.mkdir.
;T;[ ; [ ; I"6Create the referenced directory.
See Dir.mkdir.
;T; 0; @S;!F;"o;#;$T;%i;&i;'@HL;(I"#static VALUE
path_mkdir(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE vmode;
if (rb_scan_args(argc, argv, "01", &vmode) == 0)
return rb_funcall(rb_cDir, id_mkdir, 1, str);
else
return rb_funcall(rb_cDir, id_mkdir, 2, str, vmode);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#rmdir;F;[ ;[[@- i;T;:
rmdir;0;[ ;{ ;IC; "5Remove the referenced directory.
See Dir.rmdir.
;T;[ ; [ ; I"6Remove the referenced directory.
See Dir.rmdir.
;T; 0; @ S;!F;"o;#;$T;%i;&i;'@HL;(I"lstatic VALUE
path_rmdir(VALUE self)
{
return rb_funcall(rb_cDir, id_rmdir, 1, get_strpath(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#opendir;F;[ ;[[@- i;T;: opendir;0;[ ;{ ;IC; "3Opens the referenced directory.
See Dir.open.
;T;[ ; [ ; I"4Opens the referenced directory.
See Dir.open.
;T; 0; @-S;!F;"o;#;$T;%i;&i;'@HL;(I"static VALUE
path_opendir(VALUE self)
{
VALUE args[1];
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, id_open, 1, args, 0, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#each_entry;F;[ ;[[@- i;T;;N;0;[ ;{ ;IC; "vIterates over the entries (files and subdirectories) in the directory,
yielding a Pathname object for each entry.
;T;[ ; [ ; I"wIterates over the entries (files and subdirectories) in the directory,
yielding a Pathname object for each entry.
;T; 0; @;S;!F;"o;#;$T;%i;&i;'@HL;(I"static VALUE
path_each_entry(VALUE self)
{
VALUE args[1];
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, id_foreach, 1, args, each_entry_i, rb_obj_class(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#unlink;F;[ ;[[@- i ;T;: unlink;0;[ ;{ ;IC; "dRemoves a file or directory, using File.unlink if +self+ is a file, or
Dir.unlink as necessary.
;T;[ ; [ ; I"eRemoves a file or directory, using File.unlink if +self+ is a file, or
Dir.unlink as necessary.
;T; 0; @IS;!F;"o;#;$T;%i;&i ;'@HL;(I"static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, id_ENOTDIR);
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Pathname#delete;F;[ ;[[@- i ;T;: delete;0;[ ;{ ;IC; "dRemoves a file or directory, using File.unlink if +self+ is a file, or
Dir.unlink as necessary.
;T;[ ; [ ; @SS; 0; @WS;!F;"o;#;$T;%i;&i ;'@HL;(I"static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, id_ENOTDIR);
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
};T;)I"static VALUE;T;*T;A@HL;BIC;[ ;A@HL;CIC;[ ;A@HL;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@- i;F;;;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @HL;6i ;'@;I"
Pathname;F;So;L ;M0;N0;O0;;T;'@;Q@];R;F@$ o;
;IC;[o; ;IC;[ o; ; F;
;;;;I"CGI::Escape#escapeHTML;F;[[I"str;T0;[[I" ext/cgi/escape/escape.c;Ti1;T;:escapeHTML;0;[ ;{ ;IC; "!Returns HTML-escaped string.
;T;[o;=
;3I"
overload;F;40;;;50;)I"escapeHTML(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @xS; [ ; I"@return [String];T; 0; @xS;!F;6i ;>0;[[I" string;T0; @xS; [ ; I"TReturns HTML-escaped string.
@overload escapeHTML(string)
@return [String];T; 0; @xS;!F;"o;#;$T;%i*;&i/;'@vS;(I"static VALUE
cgiesc_escape_html(VALUE self, VALUE str)
{
StringValue(str);
if (rb_enc_str_asciicompat_p(str)) {
return optimized_escape_html(str);
}
else {
return rb_call_super(1, &str);
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I" CGI::Escape#unescapeHTML;F;[[I"str;T0;[[@SiE;T;:unescapeHTML;0;[ ;{ ;IC; "#Returns HTML-unescaped string.
;T;[o;=
;3I"
overload;F;40;;;50;)I"unescapeHTML(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @S; [ ; I"@return [String];T; 0; @S;!F;6i ;>0;[[I" string;T0; @S; [ ; I"XReturns HTML-unescaped string.
@overload unescapeHTML(string)
@return [String];T; 0; @S;!F;"o;#;$T;%i>;&iC;'@vS;(I"static VALUE
cgiesc_unescape_html(VALUE self, VALUE str)
{
StringValue(str);
if (rb_enc_str_asciicompat_p(str)) {
return optimized_unescape_html(str);
}
else {
return rb_call_super(1, &str);
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"CGI::Escape#escape;F;[[I"str;T0;[[@SiY;T;: escape;0;[ ;{ ;IC; " Returns URL-escaped string.
;T;[o;=
;3I"
overload;F;40;;;50;)I"escape(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @S; [ ; I"@return [String];T; 0; @S;!F;6i ;>0;[[I" string;T0; @S; [ ; I"OReturns URL-escaped string.
@overload escape(string)
@return [String];T; 0; @S;!F;"o;#;$T;%iR;&iW;'@vS;(I"static VALUE
cgiesc_escape(VALUE self, VALUE str)
{
StringValue(str);
if (rb_enc_str_asciicompat_p(str)) {
return optimized_escape(str);
}
else {
return rb_call_super(1, &str);
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I"CGI::Escape#unescape;F;[[@c0;[[@Siu;T;:
unescape;0;[ ;{ ;IC; ""Returns URL-unescaped string.
;T;[o;=
;3I"
overload;F;40;;;50;)I"0unescape(string, encoding=@@accept_charset);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @S; [ ; I"@return [String];T; 0; @S;!F;6i ;>0;[[I" string;T0[I"
encoding;TI"@@accept_charset;T; @S; [ ; I"nReturns URL-unescaped string.
@overload unescape(string, encoding=@@accept_charset)
@return [String];T; 0; @S;!F;"o;#;$T;%in;&is;'@vS;(I"Nstatic VALUE
cgiesc_unescape(int argc, VALUE *argv, VALUE self)
{
VALUE str = (rb_check_arity(argc, 1, 2), argv[0]);
StringValue(str);
if (rb_enc_str_asciicompat_p(str)) {
VALUE enc = accept_charset(argc-1, argv+1, self);
return optimized_unescape(str, enc);
}
else {
return rb_call_super(argc, argv);
}
};T;)I"static VALUE;T;*T;A@vS;BIC;[ ;A@vS;CIC;[ ;A@vS;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Si;F;: Escape;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @vS;6i ;'@tS;I"CGI::Escape;Fo; ;IC;[ ;A@T;BIC;[ ;A@T;CIC;[ ;A@T;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Si;F;: Util;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @T;'@tS;I"CGI::Util;F;A@tS;BIC;[ ;A@tS;CIC;[ ;A@tS;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Si;F;:CGI;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @tS;'@;I"CGI;F;So;L ;M0;N0;O0;;T;'@;Q@];R;Fo; ;IC;[-o;
;IC;[ ;A@)T;BIC;[ ;A@)T;CIC;[ ;A@)T;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[ [I" ext/openssl/ossl_x509attr.c;Ti5[I" ext/openssl/ossl_hmac.c;TiQ[I" ext/openssl/ossl_config.c;TiS[I" ext/openssl/ossl_engine.c;Ti[I" ext/openssl/ossl_pkey.c;Ti[I" ext/openssl/ossl_x509cert.c;Ti[I"#ext/openssl/ossl_ssl_session.c;Ti9[I" ext/openssl/ossl_rand.c;Ti[I" ext/openssl/ossl_x509ext.c;Ti[I" ext/openssl/ossl_cipher.c;Ti9[I"ext/openssl/ossl_ssl.c;Ti [I"ext/openssl/ossl.c;Ti[I" ext/openssl/ossl_x509name.c;Ti[I" ext/openssl/ossl_x509crl.c;Ti[I"ext/openssl/ossl_kdf.c;Ti[I" ext/openssl/ossl_ocsp.c;Ti[I" ext/openssl/ossl_pkcs7.c;Ti[I" ext/openssl/ossl_x509req.c;Ti[I" ext/openssl/ossl_pkcs12.c;Ti[I" ext/openssl/ossl_digest.c;Ti>[I"!ext/openssl/ossl_x509store.c;Ti[I"#ext/openssl/ossl_x509revoked.c;Ti[I"ext/openssl/ossl_bn.c;TiK[I" ext/openssl/ossl_asn1.c;TiY[I" ext/openssl/ossl_ns_spki.c;Ti[I" ext/openssl/ossl_pkey_ec.c;Tix;F;:OpenSSLError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @)T;'@'T;I"OpenSSL::OpenSSLError;F;S@o; ;IC;[o;
;IC;[ ;A@oT;BIC;[ ;A@oT;CIC;[ ;A@oT;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@4Ti9;F;:AttributeError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @oT;'@mT;I""OpenSSL::X509::AttributeError;F;S@)To;
;IC;[ o; ; F;
;;;;I"(OpenSSL::X509::Attribute#initialize;F;[[@c0;[[@4Tij;T;;;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"new(oid [, value]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @T;!F;6i ;>0;[[I"oid[, value];T0; @T; [ ; I""
@overload new(oid [, value]);T; 0; @T;!F;"o;#;$T;%if;&ig;'@T;(I"bstatic VALUE
ossl_x509attr_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE oid, value;
X509_ATTRIBUTE *attr, *x;
const unsigned char *p;
GetX509Attr(self, attr);
if(rb_scan_args(argc, argv, "11", &oid, &value) == 1){
oid = ossl_to_der_if_possible(oid);
StringValue(oid);
p = (unsigned char *)RSTRING_PTR(oid);
x = d2i_X509_ATTRIBUTE(&attr, &p, RSTRING_LEN(oid));
DATA_PTR(self) = attr;
if(!x){
ossl_raise(eX509AttrError, NULL);
}
return self;
}
rb_funcall(self, rb_intern("oid="), 1, oid);
rb_funcall(self, rb_intern("value="), 1, value);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"-OpenSSL::X509::Attribute#initialize_copy;F;[[I"
other;T0;[[@4Ti~;T;;j;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @T;'@T;(I"static VALUE
ossl_x509attr_initialize_copy(VALUE self, VALUE other)
{
X509_ATTRIBUTE *attr, *attr_other, *attr_new;
rb_check_frozen(self);
GetX509Attr(self, attr);
GetX509Attr(other, attr_other);
attr_new = X509_ATTRIBUTE_dup(attr_other);
if (!attr_new)
ossl_raise(eX509AttrError, "X509_ATTRIBUTE_dup");
SetX509Attr(self, attr_new);
X509_ATTRIBUTE_free(attr);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""OpenSSL::X509::Attribute#oid=;F;[[I"oid;T0;[[@4Ti;T;: oid=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"oid=(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @T; [ ; I"@return [String];T; 0; @T;!F;6i ;>0;[[I" string;T0; @T; [ ; I"/
@overload oid=(string)
@return [String];T; 0; @T;!F;"o;#;$T;%i;&i;'@T;(I"static VALUE
ossl_x509attr_set_oid(VALUE self, VALUE oid)
{
X509_ATTRIBUTE *attr;
ASN1_OBJECT *obj;
char *s;
GetX509Attr(self, attr);
s = StringValueCStr(oid);
obj = OBJ_txt2obj(s, 0);
if(!obj) ossl_raise(eX509AttrError, NULL);
if (!X509_ATTRIBUTE_set1_object(attr, obj)) {
ASN1_OBJECT_free(obj);
ossl_raise(eX509AttrError, "X509_ATTRIBUTE_set1_object");
}
ASN1_OBJECT_free(obj);
return oid;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!OpenSSL::X509::Attribute#oid;F;[ ;[[@4Ti;T;:oid;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"oid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @T; [ ; I"@return [String];T; 0; @T;!F;6i ;>0;[ ; @T; [ ; I"&
@overload oid
@return [String];T; 0; @T;!F;"o;#;$T;%i;&i;'@T;(I"static VALUE
ossl_x509attr_get_oid(VALUE self)
{
X509_ATTRIBUTE *attr;
ASN1_OBJECT *oid;
BIO *out;
VALUE ret;
int nid;
GetX509Attr(self, attr);
oid = X509_ATTRIBUTE_get0_object(attr);
if ((nid = OBJ_obj2nid(oid)) != NID_undef)
ret = rb_str_new2(OBJ_nid2sn(nid));
else{
if (!(out = BIO_new(BIO_s_mem())))
ossl_raise(eX509AttrError, NULL);
i2a_ASN1_OBJECT(out, oid);
ret = ossl_membio2str(out);
}
return ret;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::X509::Attribute#value=;F;[[I"
value;T0;[[@4Ti;T;: value=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"value=(asn1);T;IC; " ;T;[ ; [ ; I" ;T; 0; @T;!F;6i ;>0;[[I" asn1;T0; @T; [ ; I"
@overload value=(asn1);T; 0; @T;!F;"o;#;$T;%i;&i;'@T;(I"static VALUE
ossl_x509attr_set_value(VALUE self, VALUE value)
{
X509_ATTRIBUTE *attr;
VALUE asn1_value;
int i, asn1_tag;
OSSL_Check_Kind(value, cASN1Data);
asn1_tag = NUM2INT(rb_attr_get(value, rb_intern("@tag")));
asn1_value = rb_attr_get(value, rb_intern("@value"));
if (asn1_tag != V_ASN1_SET)
ossl_raise(eASN1Error, "argument must be ASN1::Set");
if (!RB_TYPE_P(asn1_value, T_ARRAY))
ossl_raise(eASN1Error, "ASN1::Set has non-array value");
GetX509Attr(self, attr);
if (X509_ATTRIBUTE_count(attr)) { /* populated, reset first */
ASN1_OBJECT *obj = X509_ATTRIBUTE_get0_object(attr);
X509_ATTRIBUTE *new_attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, 0, NULL, -1);
if (!new_attr)
ossl_raise(eX509AttrError, NULL);
SetX509Attr(self, new_attr);
X509_ATTRIBUTE_free(attr);
attr = new_attr;
}
for (i = 0; i < RARRAY_LEN(asn1_value); i++) {
ASN1_TYPE *a1type = ossl_asn1_get_asn1type(RARRAY_AREF(asn1_value, i));
if (!X509_ATTRIBUTE_set1_data(attr, ASN1_TYPE_get(a1type),
a1type->value.ptr, -1)) {
ASN1_TYPE_free(a1type);
ossl_raise(eX509AttrError, NULL);
}
ASN1_TYPE_free(a1type);
}
return value;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::X509::Attribute#value;F;[ ;[[@4Ti;T;;;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"
value;T;IC; " ;T;[ ; [ ; I" ;T; 0; @T;!F;6i ;>0;[ ; @T; [ ; I"
@overload value;T; 0; @T;!F;"o;#;$T;%i;&i;'@T;(I"hstatic VALUE
ossl_x509attr_get_value(VALUE self)
{
X509_ATTRIBUTE *attr;
STACK_OF(ASN1_TYPE) *sk;
VALUE str;
int i, count, len;
unsigned char *p;
GetX509Attr(self, attr);
/* there is no X509_ATTRIBUTE_get0_set() :( */
if (!(sk = sk_ASN1_TYPE_new_null()))
ossl_raise(eX509AttrError, "sk_new");
count = X509_ATTRIBUTE_count(attr);
for (i = 0; i < count; i++)
sk_ASN1_TYPE_push(sk, X509_ATTRIBUTE_get0_type(attr, i));
if ((len = i2d_ASN1_SET_ANY(sk, NULL)) <= 0) {
sk_ASN1_TYPE_free(sk);
ossl_raise(eX509AttrError, NULL);
}
str = rb_str_new(0, len);
p = (unsigned char *)RSTRING_PTR(str);
if (i2d_ASN1_SET_ANY(sk, &p) <= 0) {
sk_ASN1_TYPE_free(sk);
ossl_raise(eX509AttrError, NULL);
}
ossl_str_adjust(str, p);
sk_ASN1_TYPE_free(sk);
return rb_funcall(mASN1, rb_intern("decode"), 1, str);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::X509::Attribute#to_der;F;[ ;[[@4Ti;T;: to_der;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" to_der;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @U; [ ; I"@return [String];T; 0; @U;!F;6i ;>0;[ ; @U; [ ; I")
@overload to_der
@return [String];T; 0; @U;!F;"o;#;$T;%i;&i;'@T;(I"static VALUE
ossl_x509attr_to_der(VALUE self)
{
X509_ATTRIBUTE *attr;
VALUE str;
int len;
unsigned char *p;
GetX509Attr(self, attr);
if((len = i2d_X509_ATTRIBUTE(attr, NULL)) <= 0)
ossl_raise(eX509AttrError, NULL);
str = rb_str_new(0, len);
p = (unsigned char *)RSTRING_PTR(str);
if(i2d_X509_ATTRIBUTE(attr, &p) <= 0)
ossl_raise(eX509AttrError, NULL);
ossl_str_adjust(str, p);
return str;
};T;)I"static VALUE;T;*T;A@T;BIC;[ ;A@T;CIC;[ ;A@T;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@4Ti;;F;:Attribute;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @T;6i ;'@mT;I" OpenSSL::X509::Attribute;F;So;L ;M0;N0;O0;;T;'@;Q@];R;Fo;
;IC;[ ;A@>U;BIC;[ ;A@>U;CIC;[ ;A@>U;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@>Ti;F;:CertificateError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @>U;'@mT;I"$OpenSSL::X509::CertificateError;F;S@)To;
;IC;["o; ; F;
;;;;I"*OpenSSL::X509::Certificate#initialize;F;[[@c0;[[@>Tiw;T;;;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"new;T;IC; " ;T;[ ; [ ; I" ;T; 0; @QU;!F;6i ;>0;[ ; @QUo;=
;3I"
overload;F;40;;;50;)I"new(string);T;IC; " ;T;[ ; [ ; I" ;T; 0; @QU;!F;6i ;>0;[[I" string;T0; @QU; [ ; I")
@overload new
@overload new(string);T; 0; @QU;!F;"o;#;$T;%ir;'@OU;(I"8static VALUE
ossl_x509_initialize(int argc, VALUE *argv, VALUE self)
{
BIO *in;
X509 *x509, *x = DATA_PTR(self);
VALUE arg;
if (rb_scan_args(argc, argv, "01", &arg) == 0) {
/* create just empty X509Cert */
return self;
}
arg = ossl_to_der_if_possible(arg);
in = ossl_obj2bio(&arg);
x509 = PEM_read_bio_X509(in, &x, NULL, NULL);
DATA_PTR(self) = x;
if (!x509) {
OSSL_BIO_reset(in);
x509 = d2i_X509_bio(in, &x);
DATA_PTR(self) = x;
}
BIO_free(in);
if (!x509) ossl_raise(eX509CertError, NULL);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"/OpenSSL::X509::Certificate#initialize_copy;F;[[I"
other;T0;[[@>Ti;T;;j;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @rU;'@OU;(I"Hstatic VALUE
ossl_x509_copy(VALUE self, VALUE other)
{
X509 *a, *b, *x509;
rb_check_frozen(self);
if (self == other) return self;
GetX509(self, a);
GetX509(other, b);
x509 = X509_dup(b);
if (!x509) ossl_raise(eX509CertError, NULL);
DATA_PTR(self) = x509;
X509_free(a);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::X509::Certificate#to_der;F;[ ;[[@>Ti;T;;;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" to_der;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @U; [ ; I"@return [String];T; 0; @U;!F;6i ;>0;[ ; @U; [ ; I")
@overload to_der
@return [String];T; 0; @U;!F;"o;#;$T;%i;&i;'@OU;(I"static VALUE
ossl_x509_to_der(VALUE self)
{
X509 *x509;
VALUE str;
long len;
unsigned char *p;
GetX509(self, x509);
if ((len = i2d_X509(x509, NULL)) <= 0)
ossl_raise(eX509CertError, NULL);
str = rb_str_new(0, len);
p = (unsigned char *)RSTRING_PTR(str);
if (i2d_X509(x509, &p) <= 0)
ossl_raise(eX509CertError, NULL);
ossl_str_adjust(str, p);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::X509::Certificate#to_pem;F;[ ;[[@>Ti;T;: to_pem;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" to_pem;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @U; [ ; I"@return [String];T; 0; @U;!F;6i ;>0;[ ; @U; [ ; I")
@overload to_pem
@return [String];T; 0; o; ; F;
;;;;I"$OpenSSL::X509::Certificate#to_s;F;[ ;[[@>Ti5;F;;u;;K;[ ;{ ;@U;'@OU;(I"Ystatic VALUE
ossl_x509_to_pem(VALUE self)
{
X509 *x509;
BIO *out;
VALUE str;
GetX509(self, x509);
out = BIO_new(BIO_s_mem());
if (!out) ossl_raise(eX509CertError, NULL);
if (!PEM_write_bio_X509(out, x509)) {
BIO_free(out);
ossl_raise(eX509CertError, NULL);
}
str = ossl_membio2str(out);
return str;
};T;)I"static VALUE;T;!F;"o;#;$T;%i;&i;'@OU;(I"Ystatic VALUE
ossl_x509_to_pem(VALUE self)
{
X509 *x509;
BIO *out;
VALUE str;
GetX509(self, x509);
out = BIO_new(BIO_s_mem());
if (!out) ossl_raise(eX509CertError, NULL);
if (!PEM_write_bio_X509(out, x509)) {
BIO_free(out);
ossl_raise(eX509CertError, NULL);
}
str = ossl_membio2str(out);
return str;
};T;)@U;*T@Uo; ; F;
;;;;I"'OpenSSL::X509::Certificate#to_text;F;[ ;[[@>Ti;T;: to_text;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" to_text;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @U; [ ; I"@return [String];T; 0; @U;!F;6i ;>0;[ ; @U; [ ; I"*
@overload to_text
@return [String];T; 0; @U;!F;"o;#;$T;%i;&i;'@OU;(I"Sstatic VALUE
ossl_x509_to_text(VALUE self)
{
X509 *x509;
BIO *out;
VALUE str;
GetX509(self, x509);
out = BIO_new(BIO_s_mem());
if (!out) ossl_raise(eX509CertError, NULL);
if (!X509_print(out, x509)) {
BIO_free(out);
ossl_raise(eX509CertError, NULL);
}
str = ossl_membio2str(out);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'OpenSSL::X509::Certificate#version;F;[ ;[[@>Ti;T;: version;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" version;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @U; [ ; I"@return [Integer];T; 0; @U;!F;6i ;>0;[ ; @U; [ ; I"+
@overload version
@return [Integer];T; 0; @U;!F;"o;#;$T;%i;&i;'@OU;(I"static VALUE
ossl_x509_get_version(VALUE self)
{
X509 *x509;
GetX509(self, x509);
return LONG2NUM(X509_get_version(x509));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"(OpenSSL::X509::Certificate#version=;F;[[I" version;T0;[[@>Ti;T;:
version=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"version=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @U; [ ; I"@return [Integer];T; 0; @U;!F;6i ;>0;[[I" integer;T0; @U; [ ; I"5
@overload version=(integer)
@return [Integer];T; 0; @U;!F;"o;#;$T;%i
;&i;'@OU;(I"Dstatic VALUE
ossl_x509_set_version(VALUE self, VALUE version)
{
X509 *x509;
long ver;
if ((ver = NUM2LONG(version)) < 0) {
ossl_raise(eX509CertError, "version must be >= 0!");
}
GetX509(self, x509);
if (!X509_set_version(x509, ver)) {
ossl_raise(eX509CertError, NULL);
}
return version;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"3OpenSSL::X509::Certificate#signature_algorithm;F;[ ;[[@>TiC;T;:signature_algorithm;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"signature_algorithm;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @V; [ ; I"@return [String];T; 0; @V;!F;6i ;>0;[ ; @V; [ ; I"6
@overload signature_algorithm
@return [String];T; 0; @V;!F;"o;#;$T;%i?;&iA;'@OU;(I"static VALUE
ossl_x509_get_signature_algorithm(VALUE self)
{
X509 *x509;
BIO *out;
VALUE str;
GetX509(self, x509);
out = BIO_new(BIO_s_mem());
if (!out) ossl_raise(eX509CertError, NULL);
if (!i2a_ASN1_OBJECT(out, X509_get0_tbs_sigalg(x509)->algorithm)) {
BIO_free(out);
ossl_raise(eX509CertError, NULL);
}
str = ossl_membio2str(out);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::X509::Certificate#serial;F;[ ;[[@>Ti&;T;: serial;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" serial;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.V; [ ; I"@return [Integer];T; 0; @.V;!F;6i ;>0;[ ; @.V; [ ; I"*
@overload serial
@return [Integer];T; 0; @.V;!F;"o;#;$T;%i";&i$;'@OU;(I"static VALUE
ossl_x509_get_serial(VALUE self)
{
X509 *x509;
GetX509(self, x509);
return asn1integer_to_num(X509_get_serialNumber(x509));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'OpenSSL::X509::Certificate#serial=;F;[[I"num;T0;[[@>Ti4;T;: serial=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"serial=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @IV; [ ; I"@return [Integer];T; 0; @IV;!F;6i ;>0;[[I" integer;T0; @IV; [ ; I"4
@overload serial=(integer)
@return [Integer];T; 0; @IV;!F;"o;#;$T;%i0;&i2;'@OU;(I"static VALUE
ossl_x509_set_serial(VALUE self, VALUE num)
{
X509 *x509;
GetX509(self, x509);
X509_set_serialNumber(x509, num_to_asn1integer(num, X509_get_serialNumber(x509)));
return num;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'OpenSSL::X509::Certificate#subject;F;[ ;[[@>Ti[;T;: subject;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" subject;T;IC; " ;T;[ ; [ ; I" ;T; 0; @hV;!F;6i ;>0;[ ; @hV; [ ; I"
@overload subject;T; 0; @hV;!F;"o;#;$T;%iW;&iX;'@OU;(I" static VALUE
ossl_x509_get_subject(VALUE self)
{
X509 *x509;
X509_NAME *name;
GetX509(self, x509);
if (!(name = X509_get_subject_name(x509))) { /* NO DUP - don't free! */
ossl_raise(eX509CertError, NULL);
}
return ossl_x509name_new(name);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"(OpenSSL::X509::Certificate#subject=;F;[[I" subject;T0;[[@>Tim;T;:
subject=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"subject=(name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @~V;!F;6i ;>0;[[I" name;T0; @~V; [ ; I"
@overload subject=(name);T; 0; @~V;!F;"o;#;$T;%ii;&ij;'@OU;(I"static VALUE
ossl_x509_set_subject(VALUE self, VALUE subject)
{
X509 *x509;
GetX509(self, x509);
if (!X509_set_subject_name(x509, GetX509NamePtr(subject))) { /* DUPs name */
ossl_raise(eX509CertError, NULL);
}
return subject;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::X509::Certificate#issuer;F;[ ;[[@>Ti~;T;: issuer;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I" issuer;T;IC; " ;T;[ ; [ ; I" ;T; 0; @V;!F;6i ;>0;[ ; @V; [ ; I"
@overload issuer;T; 0; @V;!F;"o;#;$T;%iz;&i{;'@OU;(I"static VALUE
ossl_x509_get_issuer(VALUE self)
{
X509 *x509;
X509_NAME *name;
GetX509(self, x509);
if(!(name = X509_get_issuer_name(x509))) { /* NO DUP - don't free! */
ossl_raise(eX509CertError, NULL);
}
return ossl_x509name_new(name);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'OpenSSL::X509::Certificate#issuer=;F;[[I" issuer;T0;[[@>Ti;T;: issuer=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"issuer=(name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @V;!F;6i ;>0;[[I" name;T0; @V; [ ; I"
@overload issuer=(name);T; 0; @V;!F;"o;#;$T;%i;&i;'@OU;(I"static VALUE
ossl_x509_set_issuer(VALUE self, VALUE issuer)
{
X509 *x509;
GetX509(self, x509);
if (!X509_set_issuer_name(x509, GetX509NamePtr(issuer))) { /* DUPs name */
ossl_raise(eX509CertError, NULL);
}
return issuer;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::X509::Certificate#not_before;F;[ ;[[@>Ti;T;:not_before;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"not_before;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @V; [ ; I"@return [Time];T; 0; @V;!F;6i ;>0;[ ; @V; [ ; I"+
@overload not_before
@return [Time];T; 0; @V;!F;"o;#;$T;%i;&i;'@OU;(I"static VALUE
ossl_x509_get_not_before(VALUE self)
{
X509 *x509;
const ASN1_TIME *asn1time;
GetX509(self, x509);
if (!(asn1time = X509_get0_notBefore(x509))) {
ossl_raise(eX509CertError, NULL);
}
return asn1time_to_time(asn1time);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"+OpenSSL::X509::Certificate#not_before=;F;[[I" time;T0;[[@>Ti;T;:not_before=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"not_before=(time);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @V; [ ; I"@return [Time];T; 0; @V;!F;6i ;>0;[[I" time;T0; @V; [ ; I"2
@overload not_before=(time)
@return [Time];T; 0; @V;!F;"o;#;$T;%i;&i;'@OU;(I"jstatic VALUE
ossl_x509_set_not_before(VALUE self, VALUE time)
{
X509 *x509;
ASN1_TIME *asn1time;
GetX509(self, x509);
asn1time = ossl_x509_time_adjust(NULL, time);
if (!X509_set1_notBefore(x509, asn1time)) {
ASN1_TIME_free(asn1time);
ossl_raise(eX509CertError, "X509_set_notBefore");
}
ASN1_TIME_free(asn1time);
return time;
};T;)I"static VALUE;T;*To; ; F;
;;;;I")OpenSSL::X509::Certificate#not_after;F;[ ;[[@>Ti;T;:not_after;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"not_after;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @W; [ ; I"@return [Time];T; 0; @W;!F;6i ;>0;[ ; @W; [ ; I"*
@overload not_after
@return [Time];T; 0; @W;!F;"o;#;$T;%i;&i;'@OU;(I" static VALUE
ossl_x509_get_not_after(VALUE self)
{
X509 *x509;
const ASN1_TIME *asn1time;
GetX509(self, x509);
if (!(asn1time = X509_get0_notAfter(x509))) {
ossl_raise(eX509CertError, NULL);
}
return asn1time_to_time(asn1time);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::X509::Certificate#not_after=;F;[[I" time;T0;[[@>Ti;T;:not_after=;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"not_after=(time);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @ W; [ ; I"@return [Time];T; 0; @ W;!F;6i ;>0;[[I" time;T0; @ W; [ ; I"1
@overload not_after=(time)
@return [Time];T; 0; @ W;!F;"o;#;$T;%i;&i;'@OU;(I"gstatic VALUE
ossl_x509_set_not_after(VALUE self, VALUE time)
{
X509 *x509;
ASN1_TIME *asn1time;
GetX509(self, x509);
asn1time = ossl_x509_time_adjust(NULL, time);
if (!X509_set1_notAfter(x509, asn1time)) {
ASN1_TIME_free(asn1time);
ossl_raise(eX509CertError, "X509_set_notAfter");
}
ASN1_TIME_free(asn1time);
return time;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::X509::Certificate#public_key;F;[ ;[[@>Ti;T;:public_key;0;[ ;{ ;IC; "
;T;[o;=
;3I"
overload;F;40;;;50;)I"public_key;T;IC; " ;T;[ ; [ ; I" ;T; 0; @<=>
method, returning true if it returns 0. Also returns true if
_obj_ and _other_ are the same object.
;T;[o;=
;3I"
overload;F;40;;`;50;)I"==(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @Z[; [ ; I"@return [Boolean];T; 0; @Z[;!F;6i ;>0;[[I"
other;T0; @Z[; [ ; I"Compares two objects based on the receiver's <=>
method, returning true if it returns 0. Also returns true if
_obj_ and _other_ are the same object.
@overload ==(other)
@return [Boolean];T; 0; @Z[;!F;"o;#;$T;%iG;&iM;'@X[;(I"static VALUE
cmp_equal(VALUE x, VALUE y)
{
VALUE c;
if (x == y) return Qtrue;
c = rb_exec_recursive_paired_outer(cmp_eq_recursive, x, y, y);
if (NIL_P(c)) return Qfalse;
if (rb_cmpint(c, x, y) == 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#>;F;[[I"y;T0;[[@a[ik;T;:>;0;[ ;{ ;IC; "Compares two objects based on the receiver's <=>
method, returning true if it returns a value greater than 0.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
>(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @z[; [ ; I"@return [Boolean];T; 0; @z[;!F;6i ;>0;[[I"
other;T0; @z[; [ ; I"Compares two objects based on the receiver's <=>
method, returning true if it returns a value greater than 0.
@overload >(other)
@return [Boolean];T; 0; @z[;!F;"o;#;$T;%ic;&ih;'@X[;(I"istatic VALUE
cmp_gt(VALUE x, VALUE y)
{
if (cmpint(x, y) > 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#>=;F;[[I"y;T0;[[@a[iz;T;:>=;0;[ ;{ ;IC; "Compares two objects based on the receiver's <=>
method, returning true if it returns a value greater than or equal to 0.
;T;[o;=
;3I"
overload;F;40;;;50;)I">=(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @[; [ ; I"@return [Boolean];T; 0; @[;!F;6i ;>0;[[I"
other;T0; @[; [ ; I"Compares two objects based on the receiver's <=>
method, returning true if it returns a value greater than or equal to 0.
@overload >=(other)
@return [Boolean];T; 0; @[;!F;"o;#;$T;%ir;&iw;'@X[;(I"jstatic VALUE
cmp_ge(VALUE x, VALUE y)
{
if (cmpint(x, y) >= 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#<;F;[[I"y;T0;[[@a[i;T;:<;0;[ ;{ ;IC; "|Compares two objects based on the receiver's <=>
method, returning true if it returns a value less than 0.
;T;[o;=
;3I"
overload;F;40;; ;50;)I"
<(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @[; [ ; I"@return [Boolean];T; 0; @[;!F;6i ;>0;[[I"
other;T0; @[; [ ; I"Compares two objects based on the receiver's <=>
method, returning true if it returns a value less than 0.
@overload <(other)
@return [Boolean];T; 0; @[;!F;"o;#;$T;%i|;&i;'@X[;(I"istatic VALUE
cmp_lt(VALUE x, VALUE y)
{
if (cmpint(x, y) < 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#<=;F;[[I"y;T0;[[@a[i;T;:<=;0;[ ;{ ;IC; "Compares two objects based on the receiver's <=>
method, returning true if it returns a value less than or equal to 0.
;T;[o;=
;3I"
overload;F;40;;
;50;)I"<=(other);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @[; [ ; I"@return [Boolean];T; 0; @[;!F;6i ;>0;[[I"
other;T0; @[; [ ; I"Compares two objects based on the receiver's <=>
method, returning true if it returns a value less than or equal to 0.
@overload <=(other)
@return [Boolean];T; 0; @[;!F;"o;#;$T;%i;&i;'@X[;(I"jstatic VALUE
cmp_le(VALUE x, VALUE y)
{
if (cmpint(x, y) <= 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#between?;F;[[I"min;T0[I"max;T0;[[@a[i;T;:
between?;0;[ ;{ ;IC; "QReturns false if _obj_ <=> _min_ is less
than zero or if _obj_ <=> _max_ is greater than zero,
true otherwise.
3.between?(1, 5) #=> true
6.between?(1, 5) #=> false
'cat'.between?('ant', 'dog') #=> true
'gnu'.between?('ant', 'dog') #=> false;T;[o;=
;3I"
overload;F;40;; ;50;)I"between?(min, max);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @[; [ ; I"@return [Boolean];T; 0; @[;!F;6i ;>0;[[I"min;T0[I"max;T0; @[; [ ; I"Returns false if _obj_ <=> _min_ is less
than zero or if _obj_ <=> _max_ is greater than zero,
true otherwise.
3.between?(1, 5) #=> true
6.between?(1, 5) #=> false
'cat'.between?('ant', 'dog') #=> true
'gnu'.between?('ant', 'dog') #=> false
@overload between?(min, max)
@return [Boolean];T; 0; @[;!F;"o;#;$T;%i;&i;6i ;'@X[;(I"static VALUE
cmp_between(VALUE x, VALUE min, VALUE max)
{
if (cmpint(x, min) < 0) return Qfalse;
if (cmpint(x, max) > 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"Comparable#clamp;F;[[@c0;[[@a[i;T;:
clamp;0;[ ;{ ;IC; "!In (min, max) form, returns _min_ if _obj_
<=> _min_ is less than zero, _max_ if _obj_
<=> _max_ is greater than zero, and _obj_
otherwise.
12.clamp(0, 100) #=> 12
523.clamp(0, 100) #=> 100
-3.123.clamp(0, 100) #=> 0
'd'.clamp('a', 'f') #=> 'd'
'z'.clamp('a', 'f') #=> 'f'
In (range) form, returns _range.begin_ if _obj_
<=> _range.begin_ is less than zero, _range.end_
if _obj_ <=> _range.end_ is greater than zero, and
_obj_ otherwise.
12.clamp(0..100) #=> 12
523.clamp(0..100) #=> 100
-3.123.clamp(0..100) #=> 0
'd'.clamp('a'..'f') #=> 'd'
'z'.clamp('a'..'f') #=> 'f'
If _range.begin_ is +nil+, it is considered smaller than _obj_,
and if _range.end_ is +nil+, it is considered greater than
_obj_.
-20.clamp(0..) #=> 0
523.clamp(..100) #=> 100
When _range.end_ is excluded and not +nil+, an exception is
raised.
100.clamp(0...100) # ArgumentError
;T;[o;=
;3I"
overload;F;40;; ;50;)I"clamp(min, max);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @\; [ ; I"@return [Object];T; 0; @\;!F;6i ;>0;[[I"min;T0[I"max;T0; @\o;=
;3I"
overload;F;40;; ;50;)I"clamp(range);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @\; [ ; I"@return [Object];T; 0; @\;!F;6i ;>0;[[I"
range;T0; @\; [ ; I"zIn (min, max) form, returns _min_ if _obj_
<=> _min_ is less than zero, _max_ if _obj_
<=> _max_ is greater than zero, and _obj_
otherwise.
12.clamp(0, 100) #=> 12
523.clamp(0, 100) #=> 100
-3.123.clamp(0, 100) #=> 0
'd'.clamp('a', 'f') #=> 'd'
'z'.clamp('a', 'f') #=> 'f'
In (range) form, returns _range.begin_ if _obj_
<=> _range.begin_ is less than zero, _range.end_
if _obj_ <=> _range.end_ is greater than zero, and
_obj_ otherwise.
12.clamp(0..100) #=> 12
523.clamp(0..100) #=> 100
-3.123.clamp(0..100) #=> 0
'd'.clamp('a'..'f') #=> 'd'
'z'.clamp('a'..'f') #=> 'f'
If _range.begin_ is +nil+, it is considered smaller than _obj_,
and if _range.end_ is +nil+, it is considered greater than
_obj_.
-20.clamp(0..) #=> 0
523.clamp(..100) #=> 100
When _range.end_ is excluded and not +nil+, an exception is
raised.
100.clamp(0...100) # ArgumentError
@overload clamp(min, max)
@return [Object]
@overload clamp(range)
@return [Object];T; 0; @\;!F;"o;#;$T;%i;&i;'@X[;(I"static VALUE
cmp_clamp(int argc, VALUE *argv, VALUE x)
{
VALUE min, max;
int c, excl = 0;
if (rb_scan_args(argc, argv, "11", &min, &max) == 1) {
VALUE range = min;
if (!rb_range_values(range, &min, &max, &excl)) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Range)",
rb_builtin_class_name(range));
}
if (!NIL_P(max)) {
if (excl) rb_raise(rb_eArgError, "cannot clamp with an exclusive range");
if (!NIL_P(min) && cmpint(min, max) > 0) goto arg_error;
}
}
else if (cmpint(min, max) > 0) {
arg_error:
rb_raise(rb_eArgError, "min argument must be smaller than max argument");
}
if (!NIL_P(min)) {
c = cmpint(x, min);
if (c == 0) return x;
if (c < 0) return min;
}
if (!NIL_P(max)) {
c = cmpint(x, max);
if (c > 0) return max;
}
return x;
};T;)I"static VALUE;T;*T;A@X[;BIC;[ ;A@X[;CIC;[ ;A@X[;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@a[i+;F;;;;K;;;[ ;{ ;IC; "The Comparable mixin is used by classes whose objects may be
ordered. The class must define the <=> operator,
which compares the receiver against another object, returning a
value less than 0, returning 0, or returning a value greater than 0,
depending on whether the receiver is less than, equal to,
or greater than the other object. If the other object is not
comparable then the <=> operator should return +nil+.
Comparable uses <=> to implement the conventional
comparison operators (<, <=,
==, >=, and >) and the
method between?.
class SizeMatters
include Comparable
attr :str
def <=>(other)
str.size <=> other.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end
s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]
;T;[ ; [ ; I"The Comparable mixin is used by classes whose objects may be
ordered. The class must define the <=> operator,
which compares the receiver against another object, returning a
value less than 0, returning 0, or returning a value greater than 0,
depending on whether the receiver is less than, equal to,
or greater than the other object. If the other object is not
comparable then the <=> operator should return +nil+.
Comparable uses <=> to implement the conventional
comparison operators (<, <=,
==, >=, and >) and the
method between?.
class SizeMatters
include Comparable
attr :str
def <=>(other)
str.size <=> other.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end
s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]
;T; 0; @X[;!F;"o;#;$T;%i;&i";'@;I"Comparable;F;R0;A@Y;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{@Z;;I[ ;[[@LTi[@LTi;T;: Name;;K;;;[ ;{ ;IC; "UAn X.509 name represents a hostname, email address or other entity
associated with a public key.
You can create a Name by parsing a distinguished name String or by
supplying the distinguished name as an Array.
name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example'
name = OpenSSL::X509::Name.new [['CN', 'nobody'], ['DC', 'example']];T;[ ; [ ; I"W
An X.509 name represents a hostname, email address or other entity
associated with a public key.
You can create a Name by parsing a distinguished name String or by
supplying the distinguished name as an Array.
name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example'
name = OpenSSL::X509::Name.new [['CN', 'nobody'], ['DC', 'example']]
;T; 0; @Y;!F;"o;#;$T;%i;&i;6i ;'o;L ;M@;NI"OpenSSL::X509;T;O0;: X509;'@'T;Q@mT;R0;I"OpenSSL::X509::Name;F;S@]o;
;IC;[ ;A@k\;BIC;[ ;A@k\;CIC;[ ;A@k\;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@LTi;F;:NameError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @k\;'@mT;I" OpenSSL::X509::NameError;F;S@)To;
;IC;[ ;A@|\;BIC;[ ;A@|\;CIC;[ ;A@|\;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@NTi;F;:
CRLError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @|\;'@mT;I" OpenSSL::X509::CRLError;F;S@)To;
;IC;[ o; ; F;
;;;;I""OpenSSL::X509::CRL#initialize;F;[[@c0;[[@NTia;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I" static VALUE
ossl_x509crl_initialize(int argc, VALUE *argv, VALUE self)
{
BIO *in;
X509_CRL *crl, *x = DATA_PTR(self);
VALUE arg;
if (rb_scan_args(argc, argv, "01", &arg) == 0) {
return self;
}
arg = ossl_to_der_if_possible(arg);
in = ossl_obj2bio(&arg);
crl = PEM_read_bio_X509_CRL(in, &x, NULL, NULL);
DATA_PTR(self) = x;
if (!crl) {
OSSL_BIO_reset(in);
crl = d2i_X509_CRL_bio(in, &x);
DATA_PTR(self) = x;
}
BIO_free(in);
if (!crl) ossl_raise(eX509CRLError, NULL);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'OpenSSL::X509::CRL#initialize_copy;F;[[I"
other;T0;[[@NTiz;T;;j;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"Wstatic VALUE
ossl_x509crl_copy(VALUE self, VALUE other)
{
X509_CRL *a, *b, *crl;
rb_check_frozen(self);
if (self == other) return self;
GetX509CRL(self, a);
GetX509CRL(other, b);
if (!(crl = X509_CRL_dup(b))) {
ossl_raise(eX509CRLError, NULL);
}
X509_CRL_free(a);
DATA_PTR(self) = crl;
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::X509::CRL#version;F;[ ;[[@NTi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"static VALUE
ossl_x509crl_get_version(VALUE self)
{
X509_CRL *crl;
long ver;
GetX509CRL(self, crl);
ver = X509_CRL_get_version(crl);
return LONG2NUM(ver);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::X509::CRL#version=;F;[[I" version;T0;[[@NTi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"Mstatic VALUE
ossl_x509crl_set_version(VALUE self, VALUE version)
{
X509_CRL *crl;
long ver;
if ((ver = NUM2LONG(version)) < 0) {
ossl_raise(eX509CRLError, "version must be >= 0!");
}
GetX509CRL(self, crl);
if (!X509_CRL_set_version(crl, ver)) {
ossl_raise(eX509CRLError, NULL);
}
return version;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"+OpenSSL::X509::CRL#signature_algorithm;F;[ ;[[@NTi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"static VALUE
ossl_x509crl_get_signature_algorithm(VALUE self)
{
X509_CRL *crl;
const X509_ALGOR *alg;
BIO *out;
GetX509CRL(self, crl);
if (!(out = BIO_new(BIO_s_mem()))) {
ossl_raise(eX509CRLError, NULL);
}
X509_CRL_get0_signature(crl, NULL, &alg);
if (!i2a_ASN1_OBJECT(out, alg->algorithm)) {
BIO_free(out);
ossl_raise(eX509CRLError, NULL);
}
return ossl_membio2str(out);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::X509::CRL#issuer;F;[ ;[[@NTi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"static VALUE
ossl_x509crl_get_issuer(VALUE self)
{
X509_CRL *crl;
GetX509CRL(self, crl);
return ossl_x509name_new(X509_CRL_get_issuer(crl)); /* NO DUP - don't free */
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::X509::CRL#issuer=;F;[[I" issuer;T0;[[@NTi;T;;;0;[ ;{ ;IC; "NO DUP - don't free
;T;[ ; [ ; I"NO DUP - don't free;T; 0; @\;!F;"o;#;$T;%i;&i;'@\;(I"static VALUE
ossl_x509crl_set_issuer(VALUE self, VALUE issuer)
{
X509_CRL *crl;
GetX509CRL(self, crl);
if (!X509_CRL_set_issuer_name(crl, GetX509NamePtr(issuer))) { /* DUPs name */
ossl_raise(eX509CRLError, NULL);
}
return issuer;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::X509::CRL#last_update;F;[ ;[[@NTi;T;:last_update;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"static VALUE
ossl_x509crl_get_last_update(VALUE self)
{
X509_CRL *crl;
const ASN1_TIME *time;
GetX509CRL(self, crl);
time = X509_CRL_get0_lastUpdate(crl);
if (!time)
return Qnil;
return asn1time_to_time(time);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::X509::CRL#last_update=;F;[[I" time;T0;[[@NTi;T;:last_update=;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @\;'@\;(I"{static VALUE
ossl_x509crl_set_last_update(VALUE self, VALUE time)
{
X509_CRL *crl;
ASN1_TIME *asn1time;
GetX509CRL(self, crl);
asn1time = ossl_x509_time_adjust(NULL, time);
if (!X509_CRL_set1_lastUpdate(crl, asn1time)) {
ASN1_TIME_free(asn1time);
ossl_raise(eX509CRLError, "X509_CRL_set_lastUpdate");
}
ASN1_TIME_free(asn1time);
return time;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::X509::CRL#next_update;F;[ ;[[@NTi;T;:next_update;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @];'@\;(I"static VALUE
ossl_x509crl_get_next_update(VALUE self)
{
X509_CRL *crl;
const ASN1_TIME *time;
GetX509CRL(self, crl);
time = X509_CRL_get0_nextUpdate(crl);
if (!time)
return Qnil;
return asn1time_to_time(time);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::X509::CRL#next_update=;F;[[I" time;T0;[[@NTi;T;:next_update=;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @];'@\;(I"{static VALUE
ossl_x509crl_set_next_update(VALUE self, VALUE time)
{
X509_CRL *crl;
ASN1_TIME *asn1time;
GetX509CRL(self, crl);
asn1time = ossl_x509_time_adjust(NULL, time);
if (!X509_CRL_set1_nextUpdate(crl, asn1time)) {
ASN1_TIME_free(asn1time);
ossl_raise(eX509CRLError, "X509_CRL_set_nextUpdate");
}
ASN1_TIME_free(asn1time);
return time;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::X509::CRL#revoked;F;[ ;[[@NTi
;T;: revoked;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ ];'@\;(I"static VALUE
ossl_x509crl_get_revoked(VALUE self)
{
X509_CRL *crl;
int i, num;
X509_REVOKED *rev;
VALUE ary, revoked;
GetX509CRL(self, crl);
num = sk_X509_REVOKED_num(X509_CRL_get_REVOKED(crl));
if (num < 0) {
OSSL_Debug("num < 0???");
return rb_ary_new();
}
ary = rb_ary_new2(num);
for(i=0; iEtc which begins with PC_.
The return value is an integer or nil.
nil means indefinite limit. (fpathconf() returns -1 but errno is not set.)
require 'etc'
IO.pipe {|r, w|
p w.pathconf(Etc::PC_PIPE_BUF) #=> 4096
}
;T;[ ; [ ; I"[Returns pathname configuration variable using fpathconf().
_name_ should be a constant under Etc which begins with PC_.
The return value is an integer or nil.
nil means indefinite limit. (fpathconf() returns -1 but errno is not set.)
require 'etc'
IO.pipe {|r, w|
p w.pathconf(Etc::PC_PIPE_BUF) #=> 4096
}
;T; 0; @t;!F;"o;#;$T;%iu;&i;'@t;(I"bstatic VALUE
io_pathconf(VALUE io, VALUE arg)
{
int name;
long ret;
rb_io_t *fptr;
name = NUM2INT(arg);
GetOpenFile(io, fptr);
errno = 0;
ret = fpathconf(fptr->fd, name);
if (ret == -1) {
if (errno == 0) /* no limit */
return Qnil;
rb_sys_fail("fpathconf");
}
return LONG2NUM(ret);
};T;)I"static VALUE;T;*T@to; ;IC;[ ;A@t;BIC;[ ;A@t;CIC;[ ;A@t;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3[@HTi ;F;:WaitWritable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @t;'@t;I"IO::WaitWritable;Fo;
;IC;[ ;A@ u;BIC;[ ;A@ u;CIC;[@t;A@ u;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;:EAGAINWaitReadable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ u;'@t;I"IO::EAGAINWaitReadable;F;So;L ;M0;N0;O0;: EAGAIN;'@;Q0;R;Fo;
;IC;[ ;A@u;BIC;[ ;A@u;CIC;[@t;A@u;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;:EAGAINWaitWritable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @u;'@t;I"IO::EAGAINWaitWritable;F;So;L ;M0;N0;O0;;;'@;Q0;R;Fo;
;IC;[ ;A@-u;BIC;[ ;A@-u;CIC;[@t;A@-u;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;: EWOULDBLOCKWaitReadable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @-u;'@t;I" IO::EWOULDBLOCKWaitReadable;F;So;L ;M0;N0;O0;:EWOULDBLOCK;'@;Q0;R;Fo;
;IC;[ ;A@?u;BIC;[ ;A@?u;CIC;[@t;A@?u;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;: EWOULDBLOCKWaitWritable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @?u;'@t;I" IO::EWOULDBLOCKWaitWritable;F;So;L ;M0;N0;O0;;;'@;Q0;R;Fo;
;IC;[ ;A@Qu;BIC;[ ;A@Qu;CIC;[@t;A@Qu;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;: EINPROGRESSWaitReadable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @Qu;'@t;I" IO::EINPROGRESSWaitReadable;F;So;L ;M0;N0;O0;:EINPROGRESS;'@;Q0;R;Fo;
;IC;[ ;A@cu;BIC;[ ;A@cu;CIC;[@t;A@cu;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@i3;F;: EINPROGRESSWaitWritable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @cu;'@t;I" IO::EINPROGRESSWaitWritable;F;So;L ;M0;N0;O0;;;'@;Q0;R;Fo; ; F;
;F;;;I" IO.new;F;[[@c0;[[@i ;T;;;0;[ ;{ ;IC; " :nodoc:
;T;[ ; [ ; I" :nodoc:;T; 0; @uu;!F;"o;#;$T;%i ;&i ;'@t;(I"Estatic VALUE
rb_io_s_new(int argc, VALUE *argv, VALUE klass)
{
if (rb_block_given_p()) {
VALUE cname = rb_obj_as_string(klass);
rb_warn("%"PRIsVALUE"::new() does not take block; use %"PRIsVALUE"::open() instead",
cname, cname);
}
return rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I" IO.open;F;[[@c0;[[@iu;T;;;0;[ ;{ ;IC; "call-seq:
IO.open(fd, mode="r" [, opt]) -> io
IO.open(fd, mode="r" [, opt]) {|io| block } -> obj
With no associated block, IO.open is a synonym for IO.new. If
the optional code block is given, it will be passed +io+ as an argument,
and the IO object will automatically be closed when the block terminates.
In this instance, IO.open returns the value of the block.
See IO.new for a description of the +fd+, +mode+ and +opt+ parameters.
;T;[ ; [ ; I"
call-seq:
IO.open(fd, mode="r" [, opt]) -> io
IO.open(fd, mode="r" [, opt]) {|io| block } -> obj
With no associated block, IO.open is a synonym for IO.new. If
the optional code block is given, it will be passed +io+ as an argument,
and the IO object will automatically be closed when the block terminates.
In this instance, IO.open returns the value of the block.
See IO.new for a description of the +fd+, +mode+ and +opt+ parameters.
;T; 0; @u;!F;"o;#;$T;%if;&iq;'@t;(I"static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE io = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.sysopen;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "tOpens the given path, returning the underlying file descriptor as a
Integer.
IO.sysopen("testfile") #=> 3
;T;[o;=
;3I"
overload;F;40;;;50;)I""sysopen(path, [mode, [perm]]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @u; [ ; I"@return [Integer];T; 0; @u;!F;6i ;>0;[[I" path;T0[I"[mode, [perm]];T0; @u; [ ; I"Opens the given path, returning the underlying file descriptor as a
Integer.
IO.sysopen("testfile") #=> 3
@overload sysopen(path, [mode, [perm]])
@return [Integer];T; 0; @u;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_s_sysopen(int argc, VALUE *argv, VALUE _)
{
VALUE fname, vmode, vperm;
VALUE intmode;
int oflags, fd;
mode_t perm;
rb_scan_args(argc, argv, "12", &fname, &vmode, &vperm);
FilePathValue(fname);
if (NIL_P(vmode))
oflags = O_RDONLY;
else if (!NIL_P(intmode = rb_check_to_integer(vmode, "to_int")))
oflags = NUM2INT(intmode);
else {
SafeStringValue(vmode);
oflags = rb_io_modestr_oflags(StringValueCStr(vmode));
}
if (NIL_P(vperm)) perm = 0666;
else perm = NUM2MODET(vperm);
RB_GC_GUARD(fname) = rb_str_new4(fname);
fd = rb_sysopen(fname, oflags, perm);
return INT2NUM(fd);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.for_fd;F;[[@c0;[[@i ;T;: for_fd;0;[ ;{ ;IC; "Synonym for IO.new.
;T;[o;=
;3I"
overload;F;40;;;50;)I" for_fd(fd, mode [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @u; [ ; I"@return [IO];T; 0; @u;!F;6i ;>0;[[I"fd;T0[I"mode[, opt];T0; @u; [ ; I"MSynonym for IO.new.
@overload for_fd(fd, mode [, opt])
@return [IO];T; 0; @u;!F;"o;#;$T;%i ;&i ;'@t;(I"static VALUE
rb_io_s_for_fd(int argc, VALUE *argv, VALUE klass)
{
VALUE io = rb_obj_alloc(klass);
rb_io_initialize(argc, argv, io);
return io;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"
IO.popen;F;[[@c0;[[@i;T;:
popen;0;[ ;{ ;IC; "E Runs the specified command as a subprocess; the subprocess's
standard input and output will be connected to the returned
IO object.
The PID of the started process can be obtained by IO#pid method.
_cmd_ is a string or an array as follows.
cmd:
"-" : fork
commandline : command line string which is passed to a shell
[env, cmdname, arg1, ..., opts] : command name and zero or more arguments (no shell)
[env, [cmdname, argv0], arg1, ..., opts] : command name, argv[0] and zero or more arguments (no shell)
(env and opts are optional.)
If _cmd_ is a +String+ ``-'',
then a new instance of Ruby is started as the subprocess.
If cmd is an +Array+ of +String+,
then it will be used as the subprocess's +argv+ bypassing a shell.
The array can contain a hash at first for environments and
a hash at last for options similar to #spawn.
The default mode for the new file object is ``r'',
but mode may be set to any of the modes listed in the description for class IO.
The last argument opt qualifies mode.
# set IO encoding
IO.popen("nkf -e filename", :external_encoding=>"EUC-JP") {|nkf_io|
euc_jp_string = nkf_io.read
}
# merge standard output and standard error using
# spawn option. See the document of Kernel.spawn.
IO.popen(["ls", "/", :err=>[:child, :out]]) {|ls_io|
ls_result_with_error = ls_io.read
}
# spawn options can be mixed with IO options
IO.popen(["ls", "/"], :err=>[:child, :out]) {|ls_io|
ls_result_with_error = ls_io.read
}
Raises exceptions which IO.pipe and Kernel.spawn raise.
If a block is given, Ruby will run the command as a child connected
to Ruby with a pipe. Ruby's end of the pipe will be passed as a
parameter to the block.
At the end of block, Ruby closes the pipe and sets $?.
In this case IO.popen returns the value of the block.
If a block is given with a _cmd_ of ``-'',
the block will be run in two separate processes: once in the parent,
and once in a child. The parent process will be passed the pipe
object as a parameter to the block, the child version of the block
will be passed +nil+, and the child's standard in and
standard out will be connected to the parent through the pipe. Not
available on all platforms.
f = IO.popen("uname")
p f.readlines
f.close
puts "Parent is #{Process.pid}"
IO.popen("date") {|f| puts f.gets }
IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f.inspect}"}
p $?
IO.popen(%w"sed -e s|^|-'',
then a new instance of Ruby is started as the subprocess.
If cmd is an +Array+ of +String+,
then it will be used as the subprocess's +argv+ bypassing a shell.
The array can contain a hash at first for environments and
a hash at last for options similar to #spawn.
The default mode for the new file object is ``r'',
but mode may be set to any of the modes listed in the description for class IO.
The last argument opt qualifies mode.
# set IO encoding
IO.popen("nkf -e filename", :external_encoding=>"EUC-JP") {|nkf_io|
euc_jp_string = nkf_io.read
}
# merge standard output and standard error using
# spawn option. See the document of Kernel.spawn.
IO.popen(["ls", "/", :err=>[:child, :out]]) {|ls_io|
ls_result_with_error = ls_io.read
}
# spawn options can be mixed with IO options
IO.popen(["ls", "/"], :err=>[:child, :out]) {|ls_io|
ls_result_with_error = ls_io.read
}
Raises exceptions which IO.pipe and Kernel.spawn raise.
If a block is given, Ruby will run the command as a child connected
to Ruby with a pipe. Ruby's end of the pipe will be passed as a
parameter to the block.
At the end of block, Ruby closes the pipe and sets $?.
In this case IO.popen returns the value of the block.
If a block is given with a _cmd_ of ``-'',
the block will be run in two separate processes: once in the parent,
and once in a child. The parent process will be passed the pipe
object as a parameter to the block, the child version of the block
will be passed +nil+, and the child's standard in and
standard out will be connected to the parent through the pipe. Not
available on all platforms.
f = IO.popen("uname")
p f.readlines
f.close
puts "Parent is #{Process.pid}"
IO.popen("date") {|f| puts f.gets }
IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f.inspect}"}
p $?
IO.popen(%w"sed -e s|^|\n, \r, and \r\n
will be removed from the end of each line.
See also IO.read for details about open_args.
;T;[o;=
;3I"
overload;F;40;;;50;)I"8readlines(name, sep=$/ [, getline_args, open_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @iv; [ ; I"@return [Array];T; 0; @iv;!F;6i ;>0;[[I" name;T0[I"sep;TI""$/[, getline_args, open_args];T; @ivo;=
;3I"
overload;F;40;;;50;)I"7readlines(name, limit [, getline_args, open_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @iv; [ ; I"@return [Array];T; 0; @iv;!F;6i ;>0;[[I" name;T0[I"%limit[, getline_args, open_args];T0; @ivo;=
;3I"
overload;F;40;;;50;)I"\n, \r, and \r\n
will be removed from the end of each line.
See also IO.read for details about open_args.
@overload readlines(name, sep=$/ [, getline_args, open_args])
@return [Array]
@overload readlines(name, limit [, getline_args, open_args])
@return [Array]
@overload readlines(name, sep, limit [, getline_args, open_args])
@return [Array];T; 0; @iv;!F;"o;#;$T;%i(;&i(;'@t;(I" static VALUE
rb_io_s_readlines(int argc, VALUE *argv, VALUE io)
{
VALUE opt;
struct foreach_arg arg;
struct getline_arg garg;
argc = rb_scan_args(argc, argv, "13:", NULL, NULL, NULL, NULL, &opt);
extract_getline_args(argc-1, argv+1, &garg);
open_key_args(io, argc, argv, opt, &arg);
if (NIL_P(arg.io)) return Qnil;
extract_getline_opts(opt, &garg);
check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
return rb_ensure(io_s_readlines, (VALUE)&garg, rb_io_close, arg.io);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I" IO.read;F;[[@c0;[[@iF);T;;;0;[ ;{ ;IC; "Opens the file, optionally seeks to the given +offset+, then returns
+length+ bytes (defaulting to the rest of the file). #read ensures
the file is closed before returning.
If +name+ starts with a pipe character ("|"), a subprocess is
created in the same way as Kernel#open, and its output is returned.
=== Options
The options hash accepts the following keys:
:encoding::
string or encoding
Specifies the encoding of the read string. +:encoding+ will be ignored
if +length+ is specified. See Encoding.aliases for possible encodings.
:mode::
string or integer
Specifies the mode argument for open(). It must start
with an "r", otherwise it will cause an error.
See IO.new for the list of possible modes.
:open_args::
array
Specifies arguments for open() as an array. This key can not be used
in combination with either +:encoding+ or +:mode+.
Examples:
IO.read("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
IO.read("testfile", 20) #=> "This is line one\nThi"
IO.read("testfile", 20, 10) #=> "ne one\nThis is line "
IO.read("binfile", mode: "rb") #=> "\xF7\x00\x00\x0E\x12"
;T;[o;=
;3I"
overload;F;40;;;50;)I"-read(name, [length [, offset]] [, opt] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @v; [ ; I"@return [String];T; 0; @v;!F;6i ;>0;[[I" name;T0[I" [length [, offset]][, opt];T0; @v; [ ; I"Opens the file, optionally seeks to the given +offset+, then returns
+length+ bytes (defaulting to the rest of the file). #read ensures
the file is closed before returning.
If +name+ starts with a pipe character ("|"), a subprocess is
created in the same way as Kernel#open, and its output is returned.
=== Options
The options hash accepts the following keys:
:encoding::
string or encoding
Specifies the encoding of the read string. +:encoding+ will be ignored
if +length+ is specified. See Encoding.aliases for possible encodings.
:mode::
string or integer
Specifies the mode argument for open(). It must start
with an "r", otherwise it will cause an error.
See IO.new for the list of possible modes.
:open_args::
array
Specifies arguments for open() as an array. This key can not be used
in combination with either +:encoding+ or +:mode+.
Examples:
IO.read("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
IO.read("testfile", 20) #=> "This is line one\nThi"
IO.read("testfile", 20, 10) #=> "ne one\nThis is line "
IO.read("binfile", mode: "rb") #=> "\xF7\x00\x00\x0E\x12"
@overload read(name, [length [, offset]] [, opt] )
@return [String];T; 0; @v;!F;"o;#;$T;%i );&iC);'@t;(I"ystatic VALUE
rb_io_s_read(int argc, VALUE *argv, VALUE io)
{
VALUE opt, offset;
struct foreach_arg arg;
argc = rb_scan_args(argc, argv, "13:", NULL, NULL, &offset, NULL, &opt);
open_key_args(io, argc, argv, opt, &arg);
if (NIL_P(arg.io)) return Qnil;
if (!NIL_P(offset)) {
struct seek_arg sarg;
int state = 0;
sarg.io = arg.io;
sarg.offset = offset;
sarg.mode = SEEK_SET;
rb_protect(seek_before_access, (VALUE)&sarg, &state);
if (state) {
rb_io_close(arg.io);
rb_jump_tag(state);
}
if (arg.argc == 2) arg.argc = 1;
}
return rb_ensure(io_s_read, (VALUE)&arg, rb_io_close, arg.io);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.binread;F;[[@c0;[[@im);T;;;0;[ ;{ ;IC; "Opens the file, optionally seeks to the given offset, then
returns length bytes (defaulting to the rest of the file).
#binread ensures the file is closed before returning. The open mode
would be "rb:ASCII-8BIT".
IO.binread("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
IO.binread("testfile", 20) #=> "This is line one\nThi"
IO.binread("testfile", 20, 10) #=> "ne one\nThis is line "
;T;[o;=
;3I"
overload;F;40;;;50;)I"(binread(name, [length [, offset]] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @v; [ ; I"@return [String];T; 0; @v;!F;6i ;>0;[[I" name;T0[I"[length [, offset]];T0; @v; [ ; I"$Opens the file, optionally seeks to the given offset, then
returns length bytes (defaulting to the rest of the file).
#binread ensures the file is closed before returning. The open mode
would be "rb:ASCII-8BIT".
IO.binread("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
IO.binread("testfile", 20) #=> "This is line one\nThi"
IO.binread("testfile", 20, 10) #=> "ne one\nThis is line "
@overload binread(name, [length [, offset]] )
@return [String];T; 0; @v;!F;"o;#;$T;%i_);&ij);'@t;(I"static VALUE
rb_io_s_binread(int argc, VALUE *argv, VALUE io)
{
VALUE offset;
struct foreach_arg arg;
enum {
fmode = FMODE_READABLE|FMODE_BINMODE,
oflags = O_RDONLY
#ifdef O_BINARY
|O_BINARY
#endif
};
convconfig_t convconfig = {NULL, NULL, 0, Qnil};
rb_scan_args(argc, argv, "12", NULL, NULL, &offset);
FilePathValue(argv[0]);
convconfig.enc = rb_ascii8bit_encoding();
arg.io = rb_io_open_generic(io, argv[0], oflags, fmode, &convconfig, 0);
if (NIL_P(arg.io)) return Qnil;
arg.argv = argv+1;
arg.argc = (argc > 1) ? 1 : 0;
if (!NIL_P(offset)) {
struct seek_arg sarg;
int state = 0;
sarg.io = arg.io;
sarg.offset = offset;
sarg.mode = SEEK_SET;
rb_protect(seek_before_access, (VALUE)&sarg, &state);
if (state) {
rb_io_close(arg.io);
rb_jump_tag(state);
}
}
return rb_ensure(io_s_read, (VALUE)&arg, rb_io_close, arg.io);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"
IO.write;F;[[@c0;[[@i);T;;;0;[ ;{ ;IC; "sOpens the file, optionally seeks to the given offset, writes
string, then returns the length written. #write ensures the
file is closed before returning. If offset is not given in
write mode, the file is truncated. Otherwise, it is not truncated.
IO.write("testfile", "0123456789", 20) #=> 10
# File could contain: "This is line one\nThi0123456789two\nThis is line three\nAnd so on...\n"
IO.write("testfile", "0123456789") #=> 10
# File would now read: "0123456789"
If the last argument is a hash, it specifies options for the internal
open(). It accepts the following keys:
:encoding::
string or encoding
Specifies the encoding of the read string.
See Encoding.aliases for possible encodings.
:mode::
string or integer
Specifies the mode argument for open(). It must start
with "w", "a", or "r+", otherwise it will cause an error.
See IO.new for the list of possible modes.
:perm::
integer
Specifies the perm argument for open().
:open_args::
array
Specifies arguments for open() as an array.
This key can not be used in combination with other keys.
;T;[o;=
;3I"
overload;F;40;;;50;)I"#write(name, string [, offset]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @v; [ ; I"@return [Integer];T; 0; @v;!F;6i ;>0;[[I" name;T0[I"string[, offset];T0; @vo;=
;3I"
overload;F;40;;;50;)I"+write(name, string [, offset] [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @v; [ ; I"@return [Integer];T; 0; @v;!F;6i ;>0;[[I" name;T0[I" string[, offset][, opt];T0; @v; [ ; I"Opens the file, optionally seeks to the given offset, writes
string, then returns the length written. #write ensures the
file is closed before returning. If offset is not given in
write mode, the file is truncated. Otherwise, it is not truncated.
IO.write("testfile", "0123456789", 20) #=> 10
# File could contain: "This is line one\nThi0123456789two\nThis is line three\nAnd so on...\n"
IO.write("testfile", "0123456789") #=> 10
# File would now read: "0123456789"
If the last argument is a hash, it specifies options for the internal
open(). It accepts the following keys:
:encoding::
string or encoding
Specifies the encoding of the read string.
See Encoding.aliases for possible encodings.
:mode::
string or integer
Specifies the mode argument for open(). It must start
with "w", "a", or "r+", otherwise it will cause an error.
See IO.new for the list of possible modes.
:perm::
integer
Specifies the perm argument for open().
:open_args::
array
Specifies arguments for open() as an array.
This key can not be used in combination with other keys.
@overload write(name, string [, offset])
@return [Integer]
@overload write(name, string [, offset] [, opt])
@return [Integer];T; 0; @v;!F;"o;#;$T;%i);&i);'@t;(I"nstatic VALUE
rb_io_s_write(int argc, VALUE *argv, VALUE io)
{
return io_s_write(argc, argv, io, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.binwrite;F;[[@c0;[[@i*;T;;;0;[ ;{ ;IC; "tSame as IO.write except opening the file in binary mode and
ASCII-8BIT encoding ("wb:ASCII-8BIT").
;T;[o;=
;3I"
overload;F;40;;;50;)I"&binwrite(name, string, [offset] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ w; [ ; I"@return [Integer];T; 0; @ w;!F;6i ;>0;[[I" name;T0[I" string;T0[I"
[offset];T0; @ wo;=
;3I"
overload;F;40;;;50;)I"1binwrite(name, string, [offset], open_args );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ w; [ ; I"@return [Integer];T; 0; @ w;!F;6i ;>0;[ [I" name;T0[I" string;T0[I"
[offset];T0[I"open_args;T0; @ w; [ ; I"Same as IO.write except opening the file in binary mode and
ASCII-8BIT encoding ("wb:ASCII-8BIT").
@overload binwrite(name, string, [offset] )
@return [Integer]
@overload binwrite(name, string, [offset], open_args )
@return [Integer];T; 0; @ w;!F;"o;#;$T;%i);&i *;'@t;(I"qstatic VALUE
rb_io_s_binwrite(int argc, VALUE *argv, VALUE io)
{
return io_s_write(argc, argv, io, 1);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.select;F;[[@c0;[[@iN%;T;;;0;[ ;{ ;IC; "Calls select(2) system call.
It monitors given arrays of IO objects, waits until one or more of
IO objects are ready for reading, are ready for writing, and have
pending exceptions respectively, and returns an array that contains
arrays of those IO objects. It will return +nil+ if optional
timeout value is given and no IO object is ready in
timeout seconds.
IO.select peeks the buffer of IO objects for testing readability.
If the IO buffer is not empty, IO.select immediately notifies
readability. This "peek" only happens for IO objects. It does not
happen for IO-like objects such as OpenSSL::SSL::SSLSocket.
The best way to use IO.select is invoking it after nonblocking
methods such as #read_nonblock, #write_nonblock, etc. The methods
raise an exception which is extended by IO::WaitReadable or
IO::WaitWritable. The modules notify how the caller should wait
with IO.select. If IO::WaitReadable is raised, the caller should
wait for reading. If IO::WaitWritable is raised, the caller should
wait for writing.
So, blocking read (#readpartial) can be emulated using
#read_nonblock and IO.select as follows:
begin
result = io_like.read_nonblock(maxlen)
rescue IO::WaitReadable
IO.select([io_like])
retry
rescue IO::WaitWritable
IO.select(nil, [io_like])
retry
end
Especially, the combination of nonblocking methods and IO.select is
preferred for IO like objects such as OpenSSL::SSL::SSLSocket. It
has #to_io method to return underlying IO object. IO.select calls
#to_io to obtain the file descriptor to wait.
This means that readability notified by IO.select doesn't mean
readability from OpenSSL::SSL::SSLSocket object.
The most likely situation is that OpenSSL::SSL::SSLSocket buffers
some data. IO.select doesn't see the buffer. So IO.select can
block when OpenSSL::SSL::SSLSocket#readpartial doesn't block.
However, several more complicated situations exist.
SSL is a protocol which is sequence of records.
The record consists of multiple bytes.
So, the remote side of SSL sends a partial record, IO.select
notifies readability but OpenSSL::SSL::SSLSocket cannot decrypt a
byte and OpenSSL::SSL::SSLSocket#readpartial will block.
Also, the remote side can request SSL renegotiation which forces
the local SSL engine to write some data.
This means OpenSSL::SSL::SSLSocket#readpartial may invoke #write
system call and it can block.
In such a situation, OpenSSL::SSL::SSLSocket#read_nonblock raises
IO::WaitWritable instead of blocking.
So, the caller should wait for ready for writability as above
example.
The combination of nonblocking methods and IO.select is also useful
for streams such as tty, pipe socket socket when multiple processes
read from a stream.
Finally, Linux kernel developers don't guarantee that
readability of select(2) means readability of following read(2) even
for a single process.
See select(2) manual on GNU/Linux system.
Invoking IO.select before IO#readpartial works well as usual.
However it is not the best way to use IO.select.
The writability notified by select(2) doesn't show
how many bytes are writable.
IO#write method blocks until given whole string is written.
So, IO#write(two or more bytes) can block after
writability is notified by IO.select. IO#write_nonblock is required
to avoid the blocking.
Blocking write (#write) can be emulated using #write_nonblock and
IO.select as follows: IO::WaitReadable should also be rescued for
SSL renegotiation in OpenSSL::SSL::SSLSocket.
while 0 < string.bytesize
begin
written = io_like.write_nonblock(string)
rescue IO::WaitReadable
IO.select([io_like])
retry
rescue IO::WaitWritable
IO.select(nil, [io_like])
retry
end
string = string.byteslice(written..-1)
end
=== Parameters
read_array:: an array of IO objects that wait until ready for read
write_array:: an array of IO objects that wait until ready for write
error_array:: an array of IO objects that wait for exceptions
timeout:: a numeric value in second
=== Example
rp, wp = IO.pipe
mesg = "ping "
100.times {
# IO.select follows IO#read. Not the best way to use IO.select.
rs, ws, = IO.select([rp], [wp])
if r = rs[0]
ret = r.read(5)
print ret
case ret
when /ping/
mesg = "pong\n"
when /pong/
mesg = "ping "
end
end
if w = ws[0]
w.write(mesg)
end
}
produces:
ping pong
ping pong
ping pong
(snipped)
ping
;T;[o;=
;3I"
overload;F;40;;;50;)I"Cselect(read_array [, write_array [, error_array [, timeout]]]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;TI"nil;T; @Vw; [ ; I"@return [Array, nil];T; 0; @Vw;!F;6i ;>0;[[I":read_array[, write_array [, error_array [, timeout]]];T0; @Vw; [ ; @
; 0; @Vw;!F;"o;#;$T;%i$;&iK%;'@t;(I"
static VALUE
rb_f_select(int argc, VALUE *argv, VALUE obj)
{
VALUE timeout;
struct select_args args;
struct timeval timerec;
int i;
rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout);
if (NIL_P(timeout)) {
args.timeout = 0;
}
else {
timerec = rb_time_interval(timeout);
args.timeout = &timerec;
}
for (i = 0; i < numberof(args.fdsets); ++i)
rb_fd_init(&args.fdsets[i]);
return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I" IO.pipe;F;[[@c0;[[@i!(;T;: pipe;0;[ ;{ ;IC; "0IO.pipe(...) {|read_io, write_io| ... }
Creates a pair of pipe endpoints (connected to each other) and
returns them as a two-element array of IO objects:
[ read_io, write_io ].
If a block is given, the block is called and
returns the value of the block.
read_io and write_io are sent to the block as arguments.
If read_io and write_io are not closed when the block exits, they are closed.
i.e. closing read_io and/or write_io doesn't cause an error.
Not available on all platforms.
If an encoding (encoding name or encoding object) is specified as an optional argument,
read string from pipe is tagged with the encoding specified.
If the argument is a colon separated two encoding names "A:B",
the read string is converted from encoding A (external encoding)
to encoding B (internal encoding), then tagged with B.
If two optional arguments are specified, those must be
encoding objects or encoding names,
and the first one is the external encoding,
and the second one is the internal encoding.
If the external encoding and the internal encoding is specified,
optional hash argument specify the conversion option.
In the example below, the two processes close the ends of the pipe
that they are not using. This is not just a cosmetic nicety. The
read end of a pipe will not generate an end of file condition if
there are any writers with the pipe still open. In the case of the
parent process, the rd.read will never return if it
does not first issue a wr.close.
rd, wr = IO.pipe
if fork
wr.close
puts "Parent got: <#{rd.read}>"
rd.close
Process.wait
else
rd.close
puts "Sending message to parent"
wr.write "Hi Dad"
wr.close
end
produces:
Sending message to parent
Parent got: ;T;[ o;= ;3I" overload;F;40;;;50;)I" pipe;T;IC; " ;T;[o;2 ;3I" return;F;4I" ;T;0;5[I" Array;T; @tw; [ ; I"@return [Array];T; 0; @tw;!F;6i ;>0;[ ; @two;= ;3I" overload;F;40;;;50;)I"pipe(ext_enc);T;IC; " ;T;[o;2 ;3I" return;F;4I" ;T;0;5[I" Array;T; @tw; [ ; I"@return [Array];T; 0; @tw;!F;6i ;>0;[[I" ext_enc;T0; @two;= ;3I" overload;F;40;;;50;)I"$pipe("ext_enc:int_enc" [, opt]);T;IC; " ;T;[o;2 ;3I" return;F;4I" ;T;0;5[I" Array;T; @tw; [ ; I"@return [Array];T; 0; @tw;!F;6i ;>0;[[""ext_enc:"int_enc"[, opt]; @two;= ;3I" overload;F;40;;;50;)I"#pipe(ext_enc, int_enc [, opt]);T;IC; " ;T;[o;2 ;3I" return;F;4I" ;T;0;5[I" Array;T; @tw; [ ; I"@return [Array];T; 0; @tw;!F;6i ;>0;[[I" ext_enc;T0[I"int_enc[, opt];T0; @tw; [ ; I" IO.pipe(...) {|read_io, write_io| ... } Creates a pair of pipe endpoints (connected to each other) and returns them as a two-element array of IO objects:
[ read_io, write_io ].
If a block is given, the block is called and
returns the value of the block.
read_io and write_io are sent to the block as arguments.
If read_io and write_io are not closed when the block exits, they are closed.
i.e. closing read_io and/or write_io doesn't cause an error.
Not available on all platforms.
If an encoding (encoding name or encoding object) is specified as an optional argument,
read string from pipe is tagged with the encoding specified.
If the argument is a colon separated two encoding names "A:B",
the read string is converted from encoding A (external encoding)
to encoding B (internal encoding), then tagged with B.
If two optional arguments are specified, those must be
encoding objects or encoding names,
and the first one is the external encoding,
and the second one is the internal encoding.
If the external encoding and the internal encoding is specified,
optional hash argument specify the conversion option.
In the example below, the two processes close the ends of the pipe
that they are not using. This is not just a cosmetic nicety. The
read end of a pipe will not generate an end of file condition if
there are any writers with the pipe still open. In the case of the
parent process, the rd.read will never return if it
does not first issue a wr.close.
rd, wr = IO.pipe
if fork
wr.close
puts "Parent got: <#{rd.read}>"
rd.close
Process.wait
else
rd.close
puts "Sending message to parent"
wr.write "Hi Dad"
wr.close
end
produces:
Sending message to parent
Parent got: @overload pipe @return [Array] @overload pipe(ext_enc) @return [Array] @overload pipe("ext_enc:int_enc" [, opt]) @return [Array] @overload pipe(ext_enc, int_enc [, opt]) @return [Array];T; 0; @tw;!F;"o;#;$T;%i';&i!(;'@t;(I"static VALUE rb_io_s_pipe(int argc, VALUE *argv, VALUE klass) { int pipes[2], state; VALUE r, w, args[3], v1, v2; VALUE opt; rb_io_t *fptr, *fptr2; struct io_encoding_set_args ies_args; int fmode = 0; VALUE ret; argc = rb_scan_args(argc, argv, "02:", &v1, &v2, &opt); if (rb_pipe(pipes) < 0) rb_sys_fail(0); args[0] = klass; args[1] = INT2NUM(pipes[0]); args[2] = INT2FIX(O_RDONLY); r = rb_protect(io_new_instance, (VALUE)args, &state); if (state) { close(pipes[0]); close(pipes[1]); rb_jump_tag(state); } GetOpenFile(r, fptr); ies_args.fptr = fptr; ies_args.v1 = v1; ies_args.v2 = v2; ies_args.opt = opt; rb_protect(io_encoding_set_v, (VALUE)&ies_args, &state); if (state) { close(pipes[1]); io_close(r); rb_jump_tag(state); } args[1] = INT2NUM(pipes[1]); args[2] = INT2FIX(O_WRONLY); w = rb_protect(io_new_instance, (VALUE)args, &state); if (state) { close(pipes[1]); if (!NIL_P(r)) rb_io_close(r); rb_jump_tag(state); } GetOpenFile(w, fptr2); rb_io_synchronized(fptr2); extract_binmode(opt, &fmode); if ((fmode & FMODE_BINMODE) && v1 == Qnil) { rb_io_ascii8bit_binmode(r); rb_io_ascii8bit_binmode(w); } #if DEFAULT_TEXTMODE if ((fptr->mode & FMODE_TEXTMODE) && (fmode & FMODE_BINMODE)) { fptr->mode &= ~FMODE_TEXTMODE; setmode(fptr->fd, O_BINARY); } #if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32) if (fptr->encs.ecflags & ECONV_DEFAULT_NEWLINE_DECORATOR) { fptr->encs.ecflags |= ECONV_UNIVERSAL_NEWLINE_DECORATOR; } #endif #endif fptr->mode |= fmode; #if DEFAULT_TEXTMODE if ((fptr2->mode & FMODE_TEXTMODE) && (fmode & FMODE_BINMODE)) { fptr2->mode &= ~FMODE_TEXTMODE; setmode(fptr2->fd, O_BINARY); } #endif fptr2->mode |= fmode; ret = rb_assoc_new(r, w); if (rb_block_given_p()) { VALUE rw[2]; rw[0] = r; rw[1] = w; return rb_ensure(rb_yield, ret, pipe_pair_close, (VALUE)rw); } return ret; };T;)I"static VALUE;T;*To; ; F; ;F;;;I"IO.try_convert;F;[[I"io;T0;[[@i;T;:try_convert;0;[ ;{ ;IC; "Try to convert obj into an IO, using to_io method. Returns converted IO or +nil+ if obj cannot be converted for any reason. IO.try_convert(STDOUT) #=> STDOUT IO.try_convert("STDOUT") #=> nil require 'zlib' f = open("/tmp/zz.gz") #=> #
z = Zlib::GzipReader.open(f) #=> #
IO.try_convert(z) #=> #
;T;[o;=
;3I"
overload;F;40;;;50;)I"try_convert(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;TI"nil;T; @w; [ ; I"@return [IO, nil];T; 0; @w;!F;6i ;>0;[[I"obj;T0; @w; [ ; I"Try to convert obj into an IO, using to_io method.
Returns converted IO or +nil+ if obj cannot be converted
for any reason.
IO.try_convert(STDOUT) #=> STDOUT
IO.try_convert("STDOUT") #=> nil
require 'zlib'
f = open("/tmp/zz.gz") #=> #
z = Zlib::GzipReader.open(f) #=> #
IO.try_convert(z) #=> #
@overload try_convert(obj)
@return [IO, nil];T; 0; @w;!F;"o;#;$T;%i;&i;'@t;(I"_static VALUE
rb_io_s_try_convert(VALUE dummy, VALUE io)
{
return rb_io_check_io(io);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.copy_stream;F;[[@c0;[[@i-;T;:copy_stream;0;[ ;{ ;IC; "UIO.copy_stream copies src to dst.
src and dst is either a filename or an IO-like object.
IO-like object for src should have #readpartial or #read
method. IO-like object for dst should have #write method.
(Specialized mechanisms, such as sendfile system call, may be used
on appropriate situation.)
This method returns the number of bytes copied.
If optional arguments are not given,
the start position of the copy is
the beginning of the filename or
the current file offset of the IO.
The end position of the copy is the end of file.
If copy_length is given,
No more than copy_length bytes are copied.
If src_offset is given,
it specifies the start position of the copy.
When src_offset is specified and
src is an IO,
IO.copy_stream doesn't move the current file offset.
;T;[o;=
;3I"
overload;F;40;;;50;)I"copy_stream(src, dst);T;IC; " ;T;[ ; [ ; I" ;T; 0; @w;!F;6i ;>0;[[I"src;T0[I"dst;T0; @wo;=
;3I"
overload;F;40;;;50;)I"'copy_stream(src, dst, copy_length);T;IC; " ;T;[ ; [ ; I" ;T; 0; @w;!F;6i ;>0;[[I"src;T0[I"dst;T0[I"copy_length;T0; @wo;=
;3I"
overload;F;40;;;50;)I"3copy_stream(src, dst, copy_length, src_offset);T;IC; " ;T;[ ; [ ; I" ;T; 0; @w;!F;6i ;>0;[ [I"src;T0[I"dst;T0[I"copy_length;T0[I"src_offset;T0; @w; [ ; I"IO.copy_stream copies src to dst.
src and dst is either a filename or an IO-like object.
IO-like object for src should have #readpartial or #read
method. IO-like object for dst should have #write method.
(Specialized mechanisms, such as sendfile system call, may be used
on appropriate situation.)
This method returns the number of bytes copied.
If optional arguments are not given,
the start position of the copy is
the beginning of the filename or
the current file offset of the IO.
The end position of the copy is the end of file.
If copy_length is given,
No more than copy_length bytes are copied.
If src_offset is given,
it specifies the start position of the copy.
When src_offset is specified and
src is an IO,
IO.copy_stream doesn't move the current file offset.
@overload copy_stream(src, dst)
@overload copy_stream(src, dst, copy_length)
@overload copy_stream(src, dst, copy_length, src_offset);T; 0; @w;!F;"o;#;$T;%in-;&i-;'@t;(I"static VALUE
rb_io_s_copy_stream(int argc, VALUE *argv, VALUE io)
{
VALUE src, dst, length, src_offset;
struct copy_stream_struct st;
MEMZERO(&st, struct copy_stream_struct, 1);
rb_scan_args(argc, argv, "22", &src, &dst, &length, &src_offset);
st.src = src;
st.dst = dst;
if (NIL_P(length))
st.copy_length = (off_t)-1;
else
st.copy_length = NUM2OFFT(length);
if (NIL_P(src_offset))
st.src_offset = (off_t)-1;
else
st.src_offset = NUM2OFFT(src_offset);
rb_ensure(copy_stream_body, (VALUE)&st, copy_stream_finalize, (VALUE)&st);
return OFFT2NUM(st.total);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#initialize;F;[[@c0;[[@i< ;T;;;0;[ ;{ ;IC; "Returns a new IO object (a stream) for the given integer file descriptor
+fd+ and +mode+ string. +opt+ may be used to specify parts of +mode+ in a
more readable fashion. See also IO.sysopen and IO.for_fd.
IO.new is called by various File and IO opening methods such as IO::open,
Kernel#open, and File::open.
=== Open Mode
When +mode+ is an integer it must be combination of the modes defined in
File::Constants (+File::RDONLY+,
f2.readlines[0] #=> "This is line one\n"
;T;[o;=
;3I"
overload;F;40;;~;50;)I"reopen(other_IO);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @Gx; [ ; I"@return [IO];T; 0; @Gx;!F;6i ;>0;[[I"
other_IO;T0; @Gxo;=
;3I"
overload;F;40;;~;50;)I" reopen(path, mode [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @Gx; [ ; I"@return [IO];T; 0; @Gx;!F;6i ;>0;[[I" path;T0[I"mode[, opt];T0; @Gx; [ ; I"Reassociates ios with the I/O stream given in
other_IO or to a new stream opened on path. This may
dynamically change the actual class of this stream.
The +mode+ and +opt+ parameters accept the same values as IO.open.
f1 = File.new("testfile")
f2 = File.new("testfile")
f2.readlines[0] #=> "This is line one\n"
f2.reopen(f1) #=> #
f2.readlines[0] #=> "This is line one\n"
@overload reopen(other_IO)
@return [IO]
@overload reopen(path, mode [, opt])
@return [IO];T; 0; @Gx;!F;"o;#;$T;%i ;&i ;'@t;(I" static VALUE
rb_io_reopen(int argc, VALUE *argv, VALUE file)
{
VALUE fname, nmode, opt;
int oflags;
rb_io_t *fptr;
if (rb_scan_args(argc, argv, "11:", &fname, &nmode, &opt) == 1) {
VALUE tmp = rb_io_check_io(fname);
if (!NIL_P(tmp)) {
return io_reopen(file, tmp);
}
}
FilePathValue(fname);
rb_io_taint_check(file);
fptr = RFILE(file)->fptr;
if (!fptr) {
fptr = RFILE(file)->fptr = ZALLOC(rb_io_t);
}
if (!NIL_P(nmode) || !NIL_P(opt)) {
int fmode;
convconfig_t convconfig;
rb_io_extract_modeenc(&nmode, 0, opt, &oflags, &fmode, &convconfig);
if (IS_PREP_STDIO(fptr) &&
((fptr->mode & FMODE_READWRITE) & (fmode & FMODE_READWRITE)) !=
(fptr->mode & FMODE_READWRITE)) {
rb_raise(rb_eArgError,
"%s can't change access mode from \"%s\" to \"%s\"",
PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->mode),
rb_io_fmode_modestr(fmode));
}
fptr->mode = fmode;
fptr->encs = convconfig;
}
else {
oflags = rb_io_fmode_oflags(fptr->mode);
}
fptr->pathv = fname;
if (fptr->fd < 0) {
fptr->fd = rb_sysopen(fptr->pathv, oflags, 0666);
fptr->stdio_file = 0;
return file;
}
if (fptr->mode & FMODE_WRITABLE) {
if (io_fflush(fptr) < 0)
rb_sys_fail(0);
}
fptr->rbuf.off = fptr->rbuf.len = 0;
if (fptr->stdio_file) {
int e = rb_freopen(rb_str_encode_ospath(fptr->pathv),
rb_io_oflags_modestr(oflags),
fptr->stdio_file);
if (e) rb_syserr_fail_path(e, fptr->pathv);
fptr->fd = fileno(fptr->stdio_file);
rb_fd_fix_cloexec(fptr->fd);
#ifdef USE_SETVBUF
if (setvbuf(fptr->stdio_file, NULL, _IOFBF, 0) != 0)
rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr->pathv);
#endif
if (fptr->stdio_file == stderr) {
if (setvbuf(fptr->stdio_file, NULL, _IONBF, BUFSIZ) != 0)
rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr->pathv);
}
else if (fptr->stdio_file == stdout && isatty(fptr->fd)) {
if (setvbuf(fptr->stdio_file, NULL, _IOLBF, BUFSIZ) != 0)
rb_warn("setvbuf() can't be honoured for %"PRIsVALUE, fptr->pathv);
}
}
else {
int tmpfd = rb_sysopen(fptr->pathv, oflags, 0666);
int err = 0;
if (rb_cloexec_dup2(tmpfd, fptr->fd) < 0)
err = errno;
(void)close(tmpfd);
if (err) {
rb_syserr_fail_path(err, fptr->pathv);
}
}
return file;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#print;F;[[@c0;[[@i ;T;;;0;[ ;{ ;IC; "&Writes the given object(s) to ios. Returns +nil+.
The stream must be opened for writing.
Each given object that isn't a string will be converted by calling
its 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;
};T;)I"
VALUE;T;*To; ; F;
;;;;I" IO#putc;F;[[I"ch;T0;[[@i ;T;;;0;[ ;{ ;IC; "If obj is Numeric, write the character whose code is the
least-significant byte of obj. If obj is String,
write the first character of obj to ios. Otherwise,
raise TypeError.
$stdout.putc "A"
$stdout.putc 65
produces:
AA
;T;[o;=
;3I"
overload;F;40;;;50;)I"putc(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Object;T; @x; [ ; I"@return [Object];T; 0; @x;!F;6i ;>0;[[I"obj;T0; @x; [ ; I"AIf obj is Numeric, write the character whose code is the
least-significant byte of obj. If obj is String,
write the first character of obj to ios. Otherwise,
raise TypeError.
$stdout.putc "A"
$stdout.putc 65
produces:
AA
@overload putc(obj)
@return [Object];T; 0; @x;!F;"o;#;$T;%i ;&i ;'@t;(I"static VALUE
rb_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;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#puts;F;[[@c0;[[@iF ;T;;;0;[ ;{ ;IC; "UWrites the given object(s) to ios.
Writes a newline after any that do not already end
with a newline sequence. Returns +nil+.
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 a string or array will be converted
by calling its +to_s+ method.
If called without arguments, outputs a single newline.
$stdout.puts("this", "is", ["a", "test"])
produces:
this
is
a
test
Note that +puts+ always uses newlines and is not affected
by the output record separator (ios, converting parameters under
control of the format string. See Kernel#sprintf for details.
;T;[o;=
;3I"
overload;F;40;;;50;)I"'printf(format_string [, obj, ...]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @x; [ ; I"@return [nil];T; 0; @x;!F;6i ;>0;[[I" format_string[, obj, ...];T0; @x; [ ; I"Formats and writes to ios, converting parameters under
control of the format string. See Kernel#sprintf for details.
@overload printf(format_string [, obj, ...])
@return [nil];T; 0; @x;!F;"o;#;$T;%iL ;&iQ ;'@t;(I"VALUE
rb_io_printf(int argc, const VALUE *argv, VALUE out)
{
rb_io_write(out, rb_f_sprintf(argc, argv));
return Qnil;
};T;)I"
VALUE;T;*To; ; F;
;;;;I" IO#each;F;[[@c0;[[@i;T;; ;0;[ ;{ ;IC; "ios.each_line(sep=$/ [, getline_args]) {|line| block } -> ios
ios.each_line(limit [, getline_args]) {|line| block } -> ios
ios.each_line(sep, limit [, getline_args]) {|line| block } -> ios
ios.each_line(...) -> an_enumerator
Executes the block for every line in ios, where lines are
separated by sep. ios must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each {|line| puts "#{f.lineno}: #{line}" }
produces:
1: This is line one
2: This is line two
3: This is line three
4: And so on...
See IO.readlines for details about getline_args.
;T;[ o;=
;3I"
overload;F;40;; ;50;)I""each(sep=$/ [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @ yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @ y; [ ; I" @yield [line]
@return [IO];T; 0; @ y;!F;6i ;>0;[[I"sep;TI"$/[, getline_args];T; @ yo;=
;3I"
overload;F;40;; ;50;)I"!each(limit [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @ yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @ y; [ ; I" @yield [line]
@return [IO];T; 0; @ y;!F;6i ;>0;[[I"limit[, getline_args];T0; @ yo;=
;3I"
overload;F;40;; ;50;)I"&each(sep, limit [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @ yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @ y; [ ; I" @yield [line]
@return [IO];T; 0; @ y;!F;6i ;>0;[[I"sep;T0[I"limit[, getline_args];T0; @ yo;=
;3I"
overload;F;40;; ;50;)I"each(...);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ y;!F;6i ;>0;[[I"...;T0; @ y; [ ; I" ios.each_line(sep=$/ [, getline_args]) {|line| block } -> ios
ios.each_line(limit [, getline_args]) {|line| block } -> ios
ios.each_line(sep, limit [, getline_args]) {|line| block } -> ios
ios.each_line(...) -> an_enumerator
Executes the block for every line in ios, where lines are
separated by sep. ios must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each {|line| puts "#{f.lineno}: #{line}" }
produces:
1: This is line one
2: This is line two
3: This is line three
4: And so on...
See IO.readlines for details about getline_args.
@overload each(sep=$/ [, getline_args])
@yield [line]
@return [IO]
@overload each(limit [, getline_args])
@yield [line]
@return [IO]
@overload each(sep, limit [, getline_args])
@yield [line]
@return [IO]
@overload each(...);T; 0; @ y;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_each_line(int argc, VALUE *argv, VALUE io)
{
VALUE str;
struct getline_arg args;
RETURN_ENUMERATOR(io, argc, argv);
prepare_getline_args(argc, argv, &args, io);
if (args.limit == 0)
rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
while (!NIL_P(str = rb_io_getline_1(args.rs, args.limit, args.chomp, io))) {
rb_yield(str);
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#each_line;F;[[@c0;[[@i;T;;!;0;[ ;{ ;IC; "ios.each_line(sep=$/ [, getline_args]) {|line| block } -> ios
ios.each_line(limit [, getline_args]) {|line| block } -> ios
ios.each_line(sep, limit [, getline_args]) {|line| block } -> ios
ios.each_line(...) -> an_enumerator
Executes the block for every line in ios, where lines are
separated by sep. ios must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each {|line| puts "#{f.lineno}: #{line}" }
produces:
1: This is line one
2: This is line two
3: This is line three
4: And so on...
See IO.readlines for details about getline_args.
;T;[ o;=
;3I"
overload;F;40;; ;50;)I""each(sep=$/ [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @Xyo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @Xy; [ ; I" @yield [line]
@return [IO];T; 0; @Xy;!F;6i ;>0;[[I"sep;TI"$/[, getline_args];T; @Xyo;=
;3I"
overload;F;40;; ;50;)I"!each(limit [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @Xyo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @Xy; [ ; I" @yield [line]
@return [IO];T; 0; @Xy;!F;6i ;>0;[[I"limit[, getline_args];T0; @Xyo;=
;3I"
overload;F;40;; ;50;)I"&each(sep, limit [, getline_args]);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" line;T; @Xyo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @Xy; [ ; I" @yield [line]
@return [IO];T; 0; @Xy;!F;6i ;>0;[[I"sep;T0[I"limit[, getline_args];T0; @Xyo;=
;3I"
overload;F;40;; ;50;)I"each(...);T;IC; " ;T;[ ; [ ; I" ;T; 0; @Xy;!F;6i ;>0;[[I"...;T0; @Xy; [ ; @Ty; 0; @Xy;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_each_line(int argc, VALUE *argv, VALUE io)
{
VALUE str;
struct getline_arg args;
RETURN_ENUMERATOR(io, argc, argv);
prepare_getline_args(argc, argv, &args, io);
if (args.limit == 0)
rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
while (!NIL_P(str = rb_io_getline_1(args.rs, args.limit, args.chomp, io))) {
rb_yield(str);
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#each_byte;F;[ ;[[@i ;T;;;0;[ ;{ ;IC; "vCalls the given block once for each byte (0..255) in ios,
passing the byte as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
checksum = 0
f.each_byte {|x| checksum ^= x } #=> #
checksum #=> 12
;T;[o;=
;3I"
overload;F;40;;;50;)I"each_byte;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I" byte;T; @yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @y; [ ; I" @yield [byte]
@return [IO];T; 0; @y;!F;6i ;>0;[ ; @yo;=
;3I"
overload;F;40;;;50;)I"each_byte;T;IC; " ;T;[ ; [ ; I" ;T; 0; @y;!F;6i ;>0;[ ; @y; [ ; I"Calls the given block once for each byte (0..255) in ios,
passing the byte as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
checksum = 0
f.each_byte {|x| checksum ^= x } #=> #
checksum #=> 12
@overload each_byte
@yield [byte]
@return [IO]
@overload each_byte;T; 0; @y;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_each_byte(VALUE io)
{
rb_io_t *fptr;
RETURN_ENUMERATOR(io, 0, 0);
GetOpenFile(io, fptr);
do {
while (fptr->rbuf.len > 0) {
char *p = fptr->rbuf.ptr + fptr->rbuf.off++;
fptr->rbuf.len--;
rb_yield(INT2FIX(*p & 0xff));
errno = 0;
}
rb_io_check_byte_readable(fptr);
READ_CHECK(fptr);
} while (io_fillbuf(fptr) >= 0);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#each_char;F;[ ;[[@i;T;; ;0;[ ;{ ;IC; "9Calls the given block once for each character in ios,
passing the character as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each_char {|c| print c, ' ' } #=> #
;T;[o;=
;3I"
overload;F;40;; ;50;)I"each_char;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"c;T; @yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @y; [ ; I" @yield [c]
@return [IO];T; 0; @y;!F;6i ;>0;[ ; @yo;=
;3I"
overload;F;40;; ;50;)I"each_char;T;IC; " ;T;[ ; [ ; I" ;T; 0; @y;!F;6i ;>0;[ ; @y; [ ; I"Calls the given block once for each character in ios,
passing the character as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each_char {|c| print c, ' ' } #=> #
@overload each_char
@yield [c]
@return [IO]
@overload each_char;T; 0; @y;!F;"o;#;$T;%i;&i;'@t;(I"Sstatic VALUE
rb_io_each_char(VALUE io)
{
rb_io_t *fptr;
rb_encoding *enc;
VALUE c;
RETURN_ENUMERATOR(io, 0, 0);
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
enc = io_input_encoding(fptr);
READ_CHECK(fptr);
while (!NIL_P(c = io_getc(fptr, enc))) {
rb_yield(c);
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#each_codepoint;F;[ ;[[@i;T;:each_codepoint;0;[ ;{ ;IC; "Passes the Integer ordinal of each character in ios,
passing the codepoint as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
;T;[ o;=
;3I"
overload;F;40;;;50;)I"each_codepoint;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"c;T; @yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @y; [ ; I" @yield [c]
@return [IO];T; 0; @y;!F;6i ;>0;[ ; @yo;=
;3I"
overload;F;40;:codepoints;50;)I"codepoints;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"c;T; @yo;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @y; [ ; I" @yield [c]
@return [IO];T; 0; @y;!F;6i ;>0;[ ; @yo;=
;3I"
overload;F;40;;;50;)I"each_codepoint;T;IC; " ;T;[ ; [ ; I" ;T; 0; @y;!F;6i ;>0;[ ; @yo;=
;3I"
overload;F;40;;;50;)I"codepoints;T;IC; " ;T;[ ; [ ; I" ;T; 0; @y;!F;6i ;>0;[ ; @y; [ ; I"vPasses the Integer ordinal of each character in ios,
passing the codepoint as an argument. The stream must be opened for
reading or an IOError will be raised.
If no block is given, an enumerator is returned instead.
@overload each_codepoint
@yield [c]
@return [IO]
@overload codepoints
@yield [c]
@return [IO]
@overload each_codepoint
@overload codepoints;T; 0; @y;!F;"o;#;$T;%i;&i;'@t;(I"
static VALUE
rb_io_each_codepoint(VALUE io)
{
rb_io_t *fptr;
rb_encoding *enc;
unsigned int c;
int r, n;
RETURN_ENUMERATOR(io, 0, 0);
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
READ_CHECK(fptr);
if (NEED_READCONV(fptr)) {
SET_BINARY_MODE(fptr);
r = 1; /* no invalid char yet */
for (;;) {
make_readconv(fptr, 0);
for (;;) {
if (fptr->cbuf.len) {
if (fptr->encs.enc)
r = rb_enc_precise_mbclen(fptr->cbuf.ptr+fptr->cbuf.off,
fptr->cbuf.ptr+fptr->cbuf.off+fptr->cbuf.len,
fptr->encs.enc);
else
r = ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1);
if (!MBCLEN_NEEDMORE_P(r))
break;
if (fptr->cbuf.len == fptr->cbuf.capa) {
rb_raise(rb_eIOError, "too long character");
}
}
if (more_char(fptr) == MORE_CHAR_FINISHED) {
clear_readconv(fptr);
if (!MBCLEN_CHARFOUND_P(r)) {
enc = fptr->encs.enc;
goto invalid;
}
return io;
}
}
if (MBCLEN_INVALID_P(r)) {
enc = fptr->encs.enc;
goto invalid;
}
n = MBCLEN_CHARFOUND_LEN(r);
if (fptr->encs.enc) {
c = rb_enc_codepoint(fptr->cbuf.ptr+fptr->cbuf.off,
fptr->cbuf.ptr+fptr->cbuf.off+fptr->cbuf.len,
fptr->encs.enc);
}
else {
c = (unsigned char)fptr->cbuf.ptr[fptr->cbuf.off];
}
fptr->cbuf.off += n;
fptr->cbuf.len -= n;
rb_yield(UINT2NUM(c));
}
}
NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
enc = io_input_encoding(fptr);
while (io_fillbuf(fptr) >= 0) {
r = rb_enc_precise_mbclen(fptr->rbuf.ptr+fptr->rbuf.off,
fptr->rbuf.ptr+fptr->rbuf.off+fptr->rbuf.len, enc);
if (MBCLEN_CHARFOUND_P(r) &&
(n = MBCLEN_CHARFOUND_LEN(r)) <= fptr->rbuf.len) {
c = rb_enc_codepoint(fptr->rbuf.ptr+fptr->rbuf.off,
fptr->rbuf.ptr+fptr->rbuf.off+fptr->rbuf.len, enc);
fptr->rbuf.off += n;
fptr->rbuf.len -= n;
rb_yield(UINT2NUM(c));
}
else if (MBCLEN_INVALID_P(r)) {
invalid:
rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(enc));
}
else if (MBCLEN_NEEDMORE_P(r)) {
char cbuf[8], *p = cbuf;
int more = MBCLEN_NEEDMORE_LEN(r);
if (more > numberof(cbuf)) goto invalid;
more += n = fptr->rbuf.len;
if (more > numberof(cbuf)) goto invalid;
while ((n = (int)read_buffered_data(p, more, fptr)) > 0 &&
(p += n, (more -= n) > 0)) {
if (io_fillbuf(fptr) < 0) goto invalid;
if ((n = fptr->rbuf.len) > more) n = more;
}
r = rb_enc_precise_mbclen(cbuf, p, enc);
if (!MBCLEN_CHARFOUND_P(r)) goto invalid;
c = rb_enc_codepoint(cbuf, p, enc);
rb_yield(UINT2NUM(c));
}
else {
continue;
}
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#lines;F;[[@c0;[[@i;T;;";0;[ ;{ ;IC; "/This is a deprecated alias for #each_line.
;T;[ ; [ ; I"0This is a deprecated alias for #each_line.
;T; 0; @Az;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_lines(int argc, VALUE *argv, VALUE io)
{
rb_warn_deprecated("IO#lines", "#each_line");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_line")), argc, argv);
return rb_io_each_line(argc, argv, io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#bytes;F;[ ;[[@i;T;; ;0;[ ;{ ;IC; "/This is a deprecated alias for #each_byte.
;T;[ ; [ ; I"0This is a deprecated alias for #each_byte.
;T; 0; @Pz;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_bytes(VALUE io)
{
rb_warn_deprecated("IO#bytes", "#each_byte");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_byte")), 0, 0);
return rb_io_each_byte(io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#chars;F;[ ;[[@i;T;:
chars;0;[ ;{ ;IC; "/This is a deprecated alias for #each_char.
;T;[ ; [ ; I"0This is a deprecated alias for #each_char.
;T; 0; @^z;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_chars(VALUE io)
{
rb_warn_deprecated("IO#chars", "#each_char");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_char")), 0, 0);
return rb_io_each_char(io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#codepoints;F;[ ;[[@i3;T;;;0;[ ;{ ;IC; "4This is a deprecated alias for #each_codepoint.
;T;[ ; [ ; I"5This is a deprecated alias for #each_codepoint.
;T; 0; @lz;!F;"o;#;$T;%i/;&i0;'@t;(I"static VALUE
rb_io_codepoints(VALUE io)
{
rb_warn_deprecated("IO#codepoints", "#each_codepoint");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_codepoint")), 0, 0);
return rb_io_each_codepoint(io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#syswrite;F;[[I"str;T0;[[@i;T;:
syswrite;0;[ ;{ ;IC; ""Writes the given string to ios using a low-level write.
Returns the number of bytes written. Do not mix with other methods
that write to ios or you may get unpredictable results.
Raises SystemCallError on error.
f = File.new("out", "w")
f.syswrite("ABCDEF") #=> 6
;T;[o;=
;3I"
overload;F;40;;;50;)I"syswrite(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @zz; [ ; I"@return [Integer];T; 0; @zz;!F;6i ;>0;[[I" string;T0; @zz; [ ; I"SWrites the given string to ios using a low-level write.
Returns the number of bytes written. Do not mix with other methods
that write to ios or you may get unpredictable results.
Raises SystemCallError on error.
f = File.new("out", "w")
f.syswrite("ABCDEF") #=> 6
@overload syswrite(string)
@return [Integer];T; 0; @zz;!F;"o;#;$T;%i;&i;'@t;(I"Gstatic VALUE
rb_io_syswrite(VALUE io, VALUE str)
{
VALUE tmp;
rb_io_t *fptr;
long n, len;
const char *ptr;
if (!RB_TYPE_P(str, T_STRING))
str = rb_obj_as_string(str);
io = GetWriteIO(io);
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
if (fptr->wbuf.len) {
rb_warn("syswrite for buffered IO");
}
tmp = rb_str_tmp_frozen_acquire(str);
RSTRING_GETMEM(tmp, ptr, len);
n = rb_write_internal(fptr->fd, ptr, len);
if (n < 0) rb_sys_fail_path(fptr->pathv);
rb_str_tmp_frozen_release(str, tmp);
return LONG2FIX(n);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#sysread;F;[[@c0;[[@i;T;: sysread;0;[ ;{ ;IC; " Reads maxlen bytes from ios using a low-level
read and returns them as a string. Do not mix with other methods
that read from ios or you may get unpredictable results.
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
Raises SystemCallError on error and EOFError at end of file.
f = File.new("testfile")
f.sysread(16) #=> "This is line one"
;T;[o;=
;3I"
overload;F;40;;;50;)I" sysread(maxlen[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @z; [ ; I"@return [String];T; 0; @z;!F;6i ;>0;[[I"maxlen[, outbuf];T0; @z; [ ; I"XReads maxlen bytes from ios using a low-level
read and returns them as a string. Do not mix with other methods
that read from ios or you may get unpredictable results.
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
Raises SystemCallError on error and EOFError at end of file.
f = File.new("testfile")
f.sysread(16) #=> "This is line one"
@overload sysread(maxlen[, outbuf])
@return [String];T; 0; @z;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_sysread(int argc, VALUE *argv, VALUE io)
{
VALUE len, str;
rb_io_t *fptr;
long n, ilen;
struct io_internal_read_struct iis;
int shrinkable;
rb_scan_args(argc, argv, "11", &len, &str);
ilen = NUM2LONG(len);
shrinkable = io_setstrbuf(&str, ilen);
if (ilen == 0) return str;
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
if (READ_DATA_BUFFERED(fptr)) {
rb_raise(rb_eIOError, "sysread for buffered IO");
}
/*
* FIXME: removing rb_thread_wait_fd() here changes sysread semantics
* on non-blocking IOs. However, it's still currently possible
* for sysread to raise Errno::EAGAIN if another thread read()s
* the IO after we return from rb_thread_wait_fd() but before
* we call read()
*/
rb_thread_wait_fd(fptr->fd);
rb_io_check_closed(fptr);
io_setstrbuf(&str, ilen);
iis.fd = fptr->fd;
iis.nonblock = 1; /* for historical reasons, maybe (see above) */
iis.buf = RSTRING_PTR(str);
iis.capa = ilen;
n = read_internal_locktmp(str, &iis);
if (n < 0) {
rb_sys_fail_path(fptr->pathv);
}
io_set_read_length(str, n, shrinkable);
if (n == 0 && ilen > 0) {
rb_eof_error();
}
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#pread;F;[[@c0;[[@iu;T;:
pread;0;[ ;{ ;IC; "Reads maxlen bytes from ios using the pread system call
and returns them as a string without modifying the underlying
descriptor offset. This is advantageous compared to combining IO#seek
and IO#read in that it is atomic, allowing multiple threads/process to
share the same IO object for reading the file at various locations.
This bypasses any userspace buffering of the IO layer.
If the optional outbuf argument is present, it must
reference a String, which will receive the data.
Raises SystemCallError on error, EOFError at end of file and
NotImplementedError if platform does not implement the system call.
File.write("testfile", "This is line one\nThis is line two\n")
File.open("testfile") do |f|
p f.read # => "This is line one\nThis is line two\n"
p f.pread(12, 0) # => "This is line"
p f.pread(9, 8) # => "line one\n"
end
;T;[o;=
;3I"
overload;F;40;;;50;)I"$pread(maxlen, offset[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @z; [ ; I"@return [String];T; 0; @z;!F;6i ;>0;[[I" maxlen;T0[I"offset[, outbuf];T0; @z; [ ; I"Reads maxlen bytes from ios using the pread system call
and returns them as a string without modifying the underlying
descriptor offset. This is advantageous compared to combining IO#seek
and IO#read in that it is atomic, allowing multiple threads/process to
share the same IO object for reading the file at various locations.
This bypasses any userspace buffering of the IO layer.
If the optional outbuf argument is present, it must
reference a String, which will receive the data.
Raises SystemCallError on error, EOFError at end of file and
NotImplementedError if platform does not implement the system call.
File.write("testfile", "This is line one\nThis is line two\n")
File.open("testfile") do |f|
p f.read # => "This is line one\nThis is line two\n"
p f.pread(12, 0) # => "This is line"
p f.pread(9, 8) # => "line one\n"
end
@overload pread(maxlen, offset[, outbuf])
@return [String];T; 0; @z;!F;"o;#;$T;%i_;&is;'@t;(I"?static VALUE
rb_io_pread(int argc, VALUE *argv, VALUE io)
{
VALUE len, offset, str;
rb_io_t *fptr;
ssize_t n;
struct prdwr_internal_arg arg;
int shrinkable;
rb_scan_args(argc, argv, "21", &len, &offset, &str);
arg.count = NUM2SIZET(len);
arg.offset = NUM2OFFT(offset);
shrinkable = io_setstrbuf(&str, (long)arg.count);
if (arg.count == 0) return str;
arg.buf = RSTRING_PTR(str);
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
arg.fd = fptr->fd;
rb_io_check_closed(fptr);
rb_str_locktmp(str);
n = (ssize_t)rb_ensure(pread_internal_call, (VALUE)&arg, rb_str_unlocktmp, str);
if (n < 0) {
rb_sys_fail_path(fptr->pathv);
}
io_set_read_length(str, n, shrinkable);
if (n == 0 && arg.count > 0) {
rb_eof_error();
}
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#pwrite;F;[[I"str;T0[I" offset;T0;[[@i;T;: pwrite;0;[ ;{ ;IC; "WWrites the given string to ios at offset using pwrite()
system call. This is advantageous to combining IO#seek and IO#write
in that it is atomic, allowing multiple threads/process to share the
same IO object for reading the file at various locations.
This bypasses any userspace buffering of the IO layer.
Returns the number of bytes written.
Raises SystemCallError on error and NotImplementedError
if platform does not implement the system call.
File.open("out", "w") do |f|
f.pwrite("ABCDEF", 3) #=> 6
end
File.read("out") #=> "\u0000\u0000\u0000ABCDEF"
;T;[o;=
;3I"
overload;F;40;;;50;)I"pwrite(string, offset);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @z; [ ; I"@return [Integer];T; 0; @z;!F;6i ;>0;[[I" string;T0[I" offset;T0; @z; [ ; I"Writes the given string to ios at offset using pwrite()
system call. This is advantageous to combining IO#seek and IO#write
in that it is atomic, allowing multiple threads/process to share the
same IO object for reading the file at various locations.
This bypasses any userspace buffering of the IO layer.
Returns the number of bytes written.
Raises SystemCallError on error and NotImplementedError
if platform does not implement the system call.
File.open("out", "w") do |f|
f.pwrite("ABCDEF", 3) #=> 6
end
File.read("out") #=> "\u0000\u0000\u0000ABCDEF"
@overload pwrite(string, offset)
@return [Integer];T; 0; @z;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_pwrite(VALUE io, VALUE str, VALUE offset)
{
rb_io_t *fptr;
ssize_t n;
struct prdwr_internal_arg arg;
VALUE tmp;
if (!RB_TYPE_P(str, T_STRING))
str = rb_obj_as_string(str);
arg.offset = NUM2OFFT(offset);
io = GetWriteIO(io);
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
arg.fd = fptr->fd;
tmp = rb_str_tmp_frozen_acquire(str);
arg.buf = RSTRING_PTR(tmp);
arg.count = (size_t)RSTRING_LEN(tmp);
n = (ssize_t)rb_thread_io_blocking_region(internal_pwrite_func, &arg, fptr->fd);
if (n < 0) rb_sys_fail_path(fptr->pathv);
rb_str_tmp_frozen_release(str, tmp);
return SSIZET2NUM(n);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#fileno;F;[ ;[[@i ;T;: fileno;0;[ ;{ ;IC; "Returns an integer representing the numeric file descriptor for
ios.
$stdin.fileno #=> 0
$stdout.fileno #=> 1
;T;[o;=
;3I"
overload;F;40;;;50;)I" fileno;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @z; [ ; I"@return [Integer];T; 0; @z;!F;6i ;>0;[ ; @zo;=
;3I"
overload;F;40;;;50;)I" to_i;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @z; [ ; I"@return [Integer];T; 0; @z;!F;6i ;>0;[ ; @z; [ ; I"Returns an integer representing the numeric file descriptor for
ios.
$stdin.fileno #=> 0
$stdout.fileno #=> 1
@overload fileno
@return [Integer]
@overload to_i
@return [Integer];T; 0; o; ; F;
;;;;I" IO#to_i;F;[ ;[[@i3;F;;;;K;[ ;{ ;@{;'@t;(I"static VALUE
rb_io_fileno(VALUE io)
{
rb_io_t *fptr = RFILE(io)->fptr;
int fd;
rb_io_check_closed(fptr);
fd = fptr->fd;
return INT2FIX(fd);
};T;)I"static VALUE;T;!F;"o;#;$T;%i ;&i
;'@t;(I"static VALUE
rb_io_fileno(VALUE io)
{
rb_io_t *fptr = RFILE(io)->fptr;
int fd;
rb_io_check_closed(fptr);
fd = fptr->fd;
return INT2FIX(fd);
};T;)@'{;*T@ {o; ; F;
;;;;I"
IO#to_io;F;[ ;[[@if ;T;;;0;[ ;{ ;IC; "Returns ios.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
to_io;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @*{; [ ; I"@return [IO];T; 0; @*{;!F;6i ;>0;[ ; @*{; [ ; I";Returns ios.
@overload to_io
@return [IO];T; 0; @*{;!F;"o;#;$T;%i_ ;&ic ;'@t;(I":static VALUE
rb_io_to_io(VALUE io)
{
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#fsync;F;[ ;[[@i;T;:
fsync;0;[ ;{ ;IC; "fImmediately writes all buffered data in ios to disk.
Note that #fsync differs from using IO#sync=. The latter ensures
that data is flushed from Ruby's buffers, but does not guarantee
that the underlying operating system actually writes it to disk.
NotImplementedError is raised
if the underlying operating system does not support fsync(2).
;T;[o;=
;3I"
overload;F;40;;;50;)I"
fsync;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;TI"nil;T; @E{; [ ; I"@return [0, nil];T; 0; @E{;!F;6i ;>0;[ ; @E{; [ ; I"Immediately writes all buffered data in ios to disk.
Note that #fsync differs from using IO#sync=. The latter ensures
that data is flushed from Ruby's buffers, but does not guarantee
that the underlying operating system actually writes it to disk.
NotImplementedError is raised
if the underlying operating system does not support fsync(2).
@overload fsync
@return [0, nil];T; 0; @E{;!F;"o;#;$T;%i;&i;'@t;(I"'static VALUE
rb_io_fsync(VALUE io)
{
rb_io_t *fptr;
io = GetWriteIO(io);
GetOpenFile(io, fptr);
if (io_fflush(fptr) < 0)
rb_sys_fail(0);
if ((int)rb_thread_io_blocking_region(nogvl_fsync, fptr, fptr->fd) < 0)
rb_sys_fail_path(fptr->pathv);
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#fdatasync;F;[ ;[[@i;T;:fdatasync;0;[ ;{ ;IC; "Immediately writes all buffered data in ios to disk.
If the underlying operating system does not support fdatasync(2),
IO#fsync is called instead (which might raise a
NotImplementedError).
;T;[o;=
;3I"
overload;F;40;;;50;)I"fdatasync;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;TI"nil;T; @a{; [ ; I"@return [0, nil];T; 0; @a{;!F;6i ;>0;[ ; @a{; [ ; I"Immediately writes all buffered data in ios to disk.
If the underlying operating system does not support fdatasync(2),
IO#fsync is called instead (which might raise a
NotImplementedError).
@overload fdatasync
@return [0, nil];T; 0; @a{;!F;"o;#;$T;%i;&i;'@t;(I"?static VALUE
rb_io_fdatasync(VALUE io)
{
rb_io_t *fptr;
io = GetWriteIO(io);
GetOpenFile(io, fptr);
if (io_fflush(fptr) < 0)
rb_sys_fail(0);
if ((int)rb_thread_io_blocking_region(nogvl_fdatasync, fptr, fptr->fd) == 0)
return INT2FIX(0);
/* fall back */
return rb_io_fsync(io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#sync;F;[ ;[[@i;T;;;0;[ ;{ ;IC; "Returns the current ``sync mode'' of ios. When sync mode is
true, all output is immediately flushed to the underlying operating
system and is not buffered by Ruby internally. See also
IO#fsync.
f = File.new("testfile")
f.sync #=> false
;T;[o;=
;3I"
overload;F;40;;;50;)I" sync;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @}{; [ ; I"@return [Boolean];T; 0; @}{;!F;6i ;>0;[ ; @}{; [ ; I""Returns the current ``sync mode'' of ios. When sync mode is
true, all output is immediately flushed to the underlying operating
system and is not buffered by Ruby internally. See also
IO#fsync.
f = File.new("testfile")
f.sync #=> false
@overload sync
@return [Boolean];T; 0; @}{;!F;"o;#;$T;%iz;&i;'@t;(I"static VALUE
rb_io_sync(VALUE io)
{
rb_io_t *fptr;
io = GetWriteIO(io);
GetOpenFile(io, fptr);
return (fptr->mode & FMODE_SYNC) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#sync=;F;[[I" sync;T0;[[@i;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @{;'@t;(I"bstatic VALUE
rb_io_set_sync(VALUE io, VALUE sync)
{
rb_notimplement();
UNREACHABLE;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#lineno;F;[ ;[[@iH;T;;;0;[ ;{ ;IC; ">Returns the current line number in ios. The stream must be
opened for reading. #lineno counts the number of times #gets is called
rather than the number of newlines encountered. The two values will
differ if #gets is called with a separator other than newline.
Methods that use
b = f.getbyte #=> 0x38
f.ungetbyte(b) #=> nil
f.getbyte #=> 0x38
;T;[o;=
;3I"
overload;F;40;; ;50;)I"ungetbyte(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @w}; [ ; I"@return [nil];T; 0; @w};!F;6i ;>0;[[I" string;T0; @w}o;=
;3I"
overload;F;40;; ;50;)I"ungetbyte(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @w}; [ ; I"@return [nil];T; 0; @w};!F;6i ;>0;[[I" integer;T0; @w}; [ ; I"QPushes back bytes (passed as a parameter) onto ios,
such that a subsequent buffered read will return it. Only one byte
may be pushed back before a subsequent read operation (that is,
you will be able to read only the last of several bytes that have been pushed
back). Has no effect with unbuffered reads (such as IO#sysread).
f = File.new("testfile") #=> #
b = f.getbyte #=> 0x38
f.ungetbyte(b) #=> nil
f.getbyte #=> 0x38
@overload ungetbyte(string)
@return [nil]
@overload ungetbyte(integer)
@return [nil];T; 0; @w};!F;"o;#;$T;%i;&i;'@t;(I"VALUE
rb_io_ungetbyte(VALUE io, VALUE b)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
switch (TYPE(b)) {
case T_NIL:
return Qnil;
case T_FIXNUM:
case T_BIGNUM: ;
VALUE v = rb_int_modulo(b, INT2FIX(256));
unsigned char c = NUM2INT(v) & 0xFF;
b = rb_str_new((const char *)&c, 1);
break;
default:
SafeStringValue(b);
}
io_ungetbyte(b, fptr);
return Qnil;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"IO#ungetc;F;[[I"c;T0;[[@i;T;; ;0;[ ;{ ;IC; "Pushes back one character (passed as a parameter) onto ios,
such that a subsequent buffered character read will return it. Only one character
may be pushed back before a subsequent read operation (that is,
you will be able to read only the last of several characters that have been pushed
back). Has no effect with unbuffered reads (such as IO#sysread).
f = File.new("testfile") #=> #
c = f.getc #=> "8"
f.ungetc(c) #=> nil
f.getc #=> "8"
;T;[o;=
;3I"
overload;F;40;; ;50;)I"ungetc(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @}; [ ; I"@return [nil];T; 0; @};!F;6i ;>0;[[I" string;T0; @}; [ ; I";Pushes back one character (passed as a parameter) onto ios,
such that a subsequent buffered character read will return it. Only one character
may be pushed back before a subsequent read operation (that is,
you will be able to read only the last of several characters that have been pushed
back). Has no effect with unbuffered reads (such as IO#sysread).
f = File.new("testfile") #=> #
c = f.getc #=> "8"
f.ungetc(c) #=> nil
f.getc #=> "8"
@overload ungetc(string)
@return [nil];T; 0; @};!F;"o;#;$T;%i;&i;'@t;(I"VALUE
rb_io_ungetc(VALUE io, VALUE c)
{
rb_io_t *fptr;
long len;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
if (NIL_P(c)) return Qnil;
if (FIXNUM_P(c)) {
c = rb_enc_uint_chr(FIX2UINT(c), io_read_encoding(fptr));
}
else if (RB_TYPE_P(c, T_BIGNUM)) {
c = rb_enc_uint_chr(NUM2UINT(c), io_read_encoding(fptr));
}
else {
SafeStringValue(c);
}
if (NEED_READCONV(fptr)) {
SET_BINARY_MODE(fptr);
len = RSTRING_LEN(c);
#if SIZEOF_LONG > SIZEOF_INT
if (len > INT_MAX)
rb_raise(rb_eIOError, "ungetc failed");
#endif
make_readconv(fptr, (int)len);
if (fptr->cbuf.capa - fptr->cbuf.len < len)
rb_raise(rb_eIOError, "ungetc failed");
if (fptr->cbuf.off < len) {
MEMMOVE(fptr->cbuf.ptr+fptr->cbuf.capa-fptr->cbuf.len,
fptr->cbuf.ptr+fptr->cbuf.off,
char, fptr->cbuf.len);
fptr->cbuf.off = fptr->cbuf.capa-fptr->cbuf.len;
}
fptr->cbuf.off -= (int)len;
fptr->cbuf.len += (int)len;
MEMMOVE(fptr->cbuf.ptr+fptr->cbuf.off, RSTRING_PTR(c), char, len);
}
else {
NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
io_ungetbyte(c, fptr);
}
return Qnil;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"
IO#<<;F;[[I"str;T0;[[@i2;T;;;0;[ ;{ ;IC; "String Output---Writes obj to ios.
obj will be converted to a string using
File.write("nobom.txt", "abc")
ios = File.open("nobom.txt", "rb")
ios.set_encoding_by_bom #=> nil
;T;[o;=
;3I"
overload;F;40;;;50;)I"set_encoding_by_bom;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Encoding;TI"nil;T; @; [ ; I" @return [Encoding, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Checks if +ios+ starts with a BOM, and then consumes it and sets
the external encoding. Returns the result encoding if found, or
nil. If +ios+ is not binmode or its encoding has been set
already, an exception will be raised.
File.write("bom.txt", "\u{FEFF}abc")
ios = File.open("bom.txt", "rb")
ios.set_encoding_by_bom #=> #
File.write("nobom.txt", "abc")
ios = File.open("nobom.txt", "rb")
ios.set_encoding_by_bom #=> nil
@overload set_encoding_by_bom
@return [Encoding, nil];T; 0; @;!F;"o;#;$T;%iw ;&i ;'@t;(I"bstatic VALUE
rb_io_set_encoding_by_bom(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (!(fptr->mode & FMODE_BINMODE)) {
rb_raise(rb_eArgError, "ASCII incompatible encoding needs binmode");
}
if (fptr->encs.enc2) {
rb_raise(rb_eArgError, "encoding conversion is set");
}
else if (fptr->encs.enc && fptr->encs.enc != rb_ascii8bit_encoding()) {
rb_raise(rb_eArgError, "encoding is set to %s already",
rb_enc_name(fptr->encs.enc));
}
if (!io_set_encoding_by_bom(io)) return Qnil;
return rb_enc_from_encoding(fptr->encs.enc);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#autoclose?;F;[ ;[[@i ;T;:autoclose?;0;[ ;{ ;IC; "~Returns +true+ if the underlying file descriptor of _ios_ will be
closed automatically at its finalization, otherwise +false+.;T;[o;=
;3I"
overload;F;40;;;50;)I"autoclose?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ρ; [ ; I"@return [Boolean];T; 0; @ρ;!F;6i ;>0;[ ; @ρ; [ ; I"Returns +true+ if the underlying file descriptor of _ios_ will be
closed automatically at its finalization, otherwise +false+.
@overload autoclose?
@return [Boolean];T; 0; @ρ;!F;"o;#;$T;%i ;&i ;6i ;'@t;(I"static VALUE
rb_io_autoclose_p(VALUE io)
{
rb_io_t *fptr = RFILE(io)->fptr;
rb_io_check_closed(fptr);
return (fptr->mode & FMODE_PREP) ? Qfalse : Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#autoclose=;F;[[I"autoclose;T0;[[@i!;T;:autoclose=;0;[ ;{ ;IC; "Sets auto-close flag.
f = open("/dev/null")
IO.for_fd(f.fileno)
# ...
f.gets # may cause Errno::EBADF
f = open("/dev/null")
IO.for_fd(f.fileno).autoclose = false
# ...
f.gets # won't cause Errno::EBADF
;T;[o;=
;3I"
overload;F;40;;;50;)I"autoclose=(bool);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" bool;T0; @; [ ; I"Sets auto-close flag.
f = open("/dev/null")
IO.for_fd(f.fileno)
# ...
f.gets # may cause Errno::EBADF
f = open("/dev/null")
IO.for_fd(f.fileno).autoclose = false
# ...
f.gets # won't cause Errno::EBADF
@overload autoclose=(bool)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i ;&i!;'@t;(I"static VALUE
rb_io_set_autoclose(VALUE io, VALUE autoclose)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (!RTEST(autoclose))
fptr->mode |= FMODE_PREP;
else
fptr->mode &= ~FMODE_PREP;
return autoclose;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.thread_fd_close;F;[[I"fd;T0;[[I"1ext/-test-/thread_fd_close/thread_fd_close.c;Ti;T;:thread_fd_close;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ ;'@t;(I"pstatic VALUE
thread_fd_close(VALUE ign, VALUE fd)
{
rb_thread_fd_close(NUM2INT(fd));
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.wait_for_single_fd;F;[[I"fd;T0[I" events;T0[I" timeout;T0;[[@i ;T;:wait_for_single_fd;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"{static VALUE
wait_for_single_fd(VALUE ign, VALUE fd, VALUE events, VALUE timeout)
{
struct timeval tv;
struct timeval *tvp = NULL;
int rc;
if (!NIL_P(timeout)) {
tv = rb_time_timeval(timeout);
tvp = &tv;
}
rc = rb_wait_for_single_fd(NUM2INT(fd), NUM2INT(events), tvp);
if (rc == -1)
rb_sys_fail("rb_wait_for_single_fd");
return INT2NUM(rc);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.kqueue_test_wait;F;[ ;[[@i ;T;:kqueue_test_wait;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @*;'@t;(I"static VALUE
kqueue_test_wait(VALUE klass)
{
int kqfd = -1;
int p[2] = { -1, -1 };
struct timeval tv = { 0, 0 };
const struct timespec ts = { 1, 0 };
struct kevent kev;
const char *msg;
VALUE ret = Qfalse;
int e = 0;
int n;
msg = "pipe";
if (rb_cloexec_pipe(p) < 0) goto err;
msg = "kqueue";
kqfd = kqueue();
if (kqfd < 0) goto err;
n = rb_wait_for_single_fd(kqfd, RB_WAITFD_IN, &tv);
if (n != 0) {
msg = "spurious wakeup";
errno = 0;
goto err;
}
msg = "write";
if (write(p[1], "", 1) < 0) goto err;
EV_SET(&kev, p[0], EVFILT_READ, EV_ADD, 0, 0, 0);
msg = "kevent";
n = kevent(kqfd, &kev, 1, &kev, 1, &ts);
if (n < 0) goto err;
msg = NULL;
if (n == 1) {
n = rb_wait_for_single_fd(kqfd, RB_WAITFD_IN, &tv);
ret = INT2NUM(n);
}
else {
rb_warn("kevent did not return readiness");
}
err:
if (msg) e = errno;
if (p[0] >= 0) close(p[0]);
if (p[1] >= 0) close(p[1]);
if (kqfd >= 0) close(kqfd);
if (msg) {
if (e) rb_syserr_fail(e, msg);
rb_raise(rb_eRuntimeError, "%s", msg);
}
return ret;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#console_info;F;[ ;[[I")ext/-test-/win32/console/attribute.c;Ti;T;:console_info;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @6;'@t;(I"static VALUE
console_info(VALUE io)
{
HANDLE h = io_handle(io);
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (!GetConsoleScreenBufferInfo(h, &csbi))
rb_syserr_fail(rb_w32_map_errno(GetLastError()), "not console");
return rb_struct_new(rb_cConsoleScreenBufferInfo,
INT2FIX(csbi.dwSize.X),
INT2FIX(csbi.dwSize.Y),
INT2FIX(csbi.dwCursorPosition.X),
INT2FIX(csbi.dwCursorPosition.Y),
INT2FIX(csbi.wAttributes));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#console_attribute;F;[[I" attr;T0;[[@;i$;T;:console_attribute;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @C;'@t;(I"static VALUE
console_set_attribute(VALUE io, VALUE attr)
{
HANDLE h = io_handle(io);
SetConsoleTextAttribute(h, (WORD)NUM2INT(attr));
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#raw;F;[[@c0;[[I" ext/io/console/console.c;Ti;T;:raw;0;[ ;{ ;IC; "ZYields +self+ within raw mode, and returns the result of the block.
STDIN.raw(&:gets)
will read and return a line without echo back and line editing.
The parameter +min+ specifies the minimum number of bytes that
should be received when a read operation is performed. (default: 1)
The parameter +time+ specifies the timeout in _seconds_ with a
precision of 1/10 of a second. (default: 0)
If the parameter +intr+ is +true+, enables break, interrupt, quit,
and suspend special characters.
Refer to the manual page of termios for further details.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"(raw(min: nil, time: nil, intr: nil);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"io;T; @Q; [ ; I"@yield [io];T; 0; @Q;!F;6i ;>0;[[I" min:;TI"nil;T[I"
time:;TI"nil;T[I"
intr:;TI"nil;T; @Q; [ ; I"Yields +self+ within raw mode, and returns the result of the block.
STDIN.raw(&:gets)
will read and return a line without echo back and line editing.
The parameter +min+ specifies the minimum number of bytes that
should be received when a read operation is performed. (default: 1)
The parameter +time+ specifies the timeout in _seconds_ with a
precision of 1/10 of a second. (default: 0)
If the parameter +intr+ is +true+, enables break, interrupt, quit,
and suspend special characters.
Refer to the manual page of termios for further details.
You must require 'io/console' to use this method.
@overload raw(min: nil, time: nil, intr: nil)
@yield [io];T; 0; @Q;!F;"o;#;$T;%ii;&i~;'@t;(I"static VALUE
console_raw(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(&argc, argv, 0, 0, &opts);
return ttymode(io, rb_yield, io, set_rawmode, optp);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#raw!;F;[[@c0;[[@Wi;T;: raw!;0;[ ;{ ;IC; "Enables raw mode, and returns +io+.
If the terminal mode needs to be back, use ];T; 0; @ۄ;!F;6i ;>0;[ ; @ۄo;=
;3I"
overload;F;40;;;50;)I"console(sym, *args);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ۄ;!F;6i ;>0;[[I"sym;T0[I"
*args;T0; @ۄ; [ ; I"2Returns an File instance opened console.
If +sym+ is given, it will be sent to the opened console with
+args+ and the result will be returned instead of the console IO
itself.
You must require 'io/console' to use this method.
@overload console
@return [#]
@overload console(sym, *args);T; 0; @ۄ;!F;"o;#;$T;%iy;&i;'@t;(I"5static VALUE
console_dev(int argc, VALUE *argv, VALUE klass)
{
VALUE con = 0;
rb_io_t *fptr;
VALUE sym = 0;
rb_check_arity(argc, 0, UNLIMITED_ARGUMENTS);
if (argc) {
Check_Type(sym = argv[0], T_SYMBOL);
}
if (klass == rb_cIO) klass = rb_cFile;
if (rb_const_defined(klass, id_console)) {
con = rb_const_get(klass, id_console);
if (!RB_TYPE_P(con, T_FILE) ||
(!(fptr = RFILE(con)->fptr) || GetReadFD(fptr) == -1)) {
rb_const_remove(klass, id_console);
con = 0;
}
}
if (sym) {
if (sym == ID2SYM(id_close) && argc == 1) {
if (con) {
rb_io_close(con);
rb_const_remove(klass, id_console);
con = 0;
}
return Qnil;
}
}
if (!con) {
VALUE args[2];
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H || defined HAVE_SGTTY_H
# define CONSOLE_DEVICE "/dev/tty"
#elif defined _WIN32
# define CONSOLE_DEVICE "con$"
# define CONSOLE_DEVICE_FOR_READING "conin$"
# define CONSOLE_DEVICE_FOR_WRITING "conout$"
#endif
#ifndef CONSOLE_DEVICE_FOR_READING
# define CONSOLE_DEVICE_FOR_READING CONSOLE_DEVICE
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
VALUE out;
rb_io_t *ofptr;
#endif
int fd;
#ifdef CONSOLE_DEVICE_FOR_WRITING
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_WRITING, O_RDWR, 0);
if (fd < 0) return Qnil;
rb_update_max_fd(fd);
args[1] = INT2FIX(O_WRONLY);
args[0] = INT2NUM(fd);
out = rb_class_new_instance(2, args, klass);
#endif
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_READING, O_RDWR, 0);
if (fd < 0) {
#ifdef CONSOLE_DEVICE_FOR_WRITING
rb_io_close(out);
#endif
return Qnil;
}
rb_update_max_fd(fd);
args[1] = INT2FIX(O_RDWR);
args[0] = INT2NUM(fd);
con = rb_class_new_instance(2, args, klass);
GetOpenFile(con, fptr);
fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE));
#ifdef CONSOLE_DEVICE_FOR_WRITING
GetOpenFile(out, ofptr);
ofptr->pathv = fptr->pathv;
fptr->tied_io_for_writing = out;
ofptr->mode |= FMODE_SYNC;
#endif
fptr->mode |= FMODE_SYNC;
rb_const_set(klass, id_console, con);
}
if (sym) {
return rb_f_send(argc, argv, con);
}
return con;
};T;)I"static VALUE;T;*To; ;IC;[
o; ; F;
;;;;I" IO::generic_readable#getch;F;[[@c0;[[@Wi;T;;;0;[ ;{ ;IC; "See IO#getch.
;T;[o;=
;3I"
overload;F;40;;;50;)I"*getch(min: nil, time: nil, intr: nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" min:;TI"nil;T[I"
time:;TI"nil;T[I"
intr:;TI"nil;T; @; [ ; I"WSee IO#getch.
@overload getch(min: nil, time: nil, intr: nil)
@return [String];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"pstatic VALUE
io_getch(int argc, VALUE *argv, VALUE io)
{
return rb_funcallv(io, id_getc, argc, argv);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!IO::generic_readable#getpass;F;[[@c0;[[@Wi";T;;;0;[ ;{ ;IC; "See IO#getpass.
;T;[o;=
;3I"
overload;F;40;;;50;)I"getpass(prompt=nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @*; [ ; I"@return [String];T; 0; @*;!F;6i ;>0;[[I" prompt;TI"nil;T; @*; [ ; I"GSee IO#getpass.
@overload getpass(prompt=nil)
@return [String];T; 0; @*;!F;"o;#;$T;%i ;&i ;'@;(I"static VALUE
io_getpass(int argc, VALUE *argv, VALUE io)
{
VALUE str;
rb_check_arity(argc, 0, 1);
prompt(argc, argv, io);
str = str_chomp(rb_funcallv(io, id_gets, 0, 0));
puts_call(io);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""IO::generic_readable#readchar;F;[ ;[[I" ext/stringio/stringio.c;Ti;T;;;0;[ ;{ ;IC; "See IO#readchar.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
readchar;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @I; [ ; I"@return [String];T; 0; @I;!F;6i ;>0;[ ; @I; [ ; I"=See IO#readchar.
@overload readchar
@return [String];T; 0; @I;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
strio_readchar(VALUE self)
{
VALUE c = rb_funcallv(self, rb_intern("getc"), 0, 0);
if (NIL_P(c)) rb_eof_error();
return c;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""IO::generic_readable#readbyte;F;[ ;[[@Ni;T;;;0;[ ;{ ;IC; "See IO#readbyte.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
readbyte;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Fixnum;T; @e; [ ; I"@return [Fixnum];T; 0; @e;!F;6i ;>0;[ ; @e; [ ; I"=See IO#readbyte.
@overload readbyte
@return [Fixnum];T; 0; @e;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
strio_readbyte(VALUE self)
{
VALUE c = rb_funcallv(self, rb_intern("getbyte"), 0, 0);
if (NIL_P(c)) rb_eof_error();
return c;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""IO::generic_readable#readline;F;[[@c0;[[@Ni-;T;;;0;[ ;{ ;IC; "See IO#readline.
;T;[o;=
;3I"
overload;F;40;;;50;)I"#readline(sep=$/, chomp: false);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I"sep;TI"$/;T[I" chomp:;TI"
false;T; @o;=
;3I"
overload;F;40;;;50;)I""readline(limit, chomp: false);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @; [ ; I"@return [String, nil];T; 0; @;!F;6i ;>0;[[I"
limit;T0[I" chomp:;TI"
false;T; @o;=
;3I"
overload;F;40;;;50;)I"'readline(sep, limit, chomp: false);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @; [ ; I"@return [String, nil];T; 0; @;!F;6i ;>0;[[I"sep;T0[I"
limit;T0[I" chomp:;TI"
false;T; @; [ ; I"See IO#readline.
@overload readline(sep=$/, chomp: false)
@return [String]
@overload readline(limit, chomp: false)
@return [String, nil]
@overload readline(sep, limit, chomp: false)
@return [String, nil];T; 0; @;!F;"o;#;$T;%i%;&i-;'@;(I"static VALUE
strio_readline(int argc, VALUE *argv, VALUE self)
{
VALUE line = rb_funcallv_kw(self, rb_intern("gets"), argc, argv, RB_PASS_CALLED_KEYWORDS);
if (NIL_P(line)) rb_eof_error();
return line;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!IO::generic_readable#sysread;F;[[@c0;[[@NiB;T;;;0;[ ;{ ;IC; "uSimilar to #read, but raises +EOFError+ at end of string instead of
returning +nil+, as well as IO#sysread does.
;T;[o;=
;3I"
overload;F;40;;;50;)I" sysread(integer[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ʅ; [ ; I"@return [String];T; 0; @ʅ;!F;6i ;>0;[[I"integer[, outbuf];T0; @ʅo;=
;3I"
overload;F;40;;;50;)I"#readpartial(integer[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ʅ; [ ; I"@return [String];T; 0; @ʅ;!F;6i ;>0;[[I"integer[, outbuf];T0; @ʅ; [ ; I"Similar to #read, but raises +EOFError+ at end of string instead of
returning +nil+, as well as IO#sysread does.
@overload sysread(integer[, outbuf])
@return [String]
@overload readpartial(integer[, outbuf])
@return [String];T; 0; @ʅ;!F;"o;#;$T;%i:;&iA;'@;(I"static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
VALUE val = rb_funcallv_kw(self, rb_intern("read"), argc, argv, RB_PASS_CALLED_KEYWORDS);
if (NIL_P(val)) {
rb_eof_error();
}
return val;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"%IO::generic_readable#readpartial;F;[[@c0;[[@NiB;T;;;0;[ ;{ ;IC; "uSimilar to #read, but raises +EOFError+ at end of string instead of
returning +nil+, as well as IO#sysread does.
;T;[o;=
;3I"
overload;F;40;;;50;)I" sysread(integer[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I"integer[, outbuf];T0; @o;=
;3I"
overload;F;40;;;50;)I"#readpartial(integer[, outbuf]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I"integer[, outbuf];T0; @; [ ; @; 0; @;!F;"o;#;$T;%i:;&iA;'@;(I"static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
VALUE val = rb_funcallv_kw(self, rb_intern("read"), argc, argv, RB_PASS_CALLED_KEYWORDS);
if (NIL_P(val)) {
rb_eof_error();
}
return val;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"'IO::generic_readable#read_nonblock;F;[[@c0;[[@NiS;T;:read_nonblock;0;[ ;{ ;IC; "pSimilar to #read, but raises +EOFError+ at end of string unless the
+exception: false+ option is passed in.
;T;[o;=
;3I"
overload;F;40;;;50;)I".read_nonblock(integer[, outbuf [, opts]]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @#; [ ; I"@return [String];T; 0; @#;!F;6i ;>0;[[I" integer[, outbuf [, opts]];T0; @#; [ ; I"Similar to #read, but raises +EOFError+ at end of string unless the
+exception: false+ option is passed in.
@overload read_nonblock(integer[, outbuf [, opts]])
@return [String];T; 0; @#;!F;"o;#;$T;%iL;&iQ;'@;(I"static VALUE
strio_read_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE opts = Qnil, val;
rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);
if (!NIL_P(opts)) {
argc--;
}
val = strio_read(argc, argv, self);
if (NIL_P(val)) {
if (!NIL_P(opts) &&
rb_hash_lookup2(opts, sym_exception, Qundef) == Qfalse)
return Qnil;
else
rb_eof_error();
}
return val;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Wil[@NiZ;F;:generic_readable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;6i ;'@t;I"IO::generic_readable;Fo;
;IC;[ o; ; F;
;;;;I"$IO::ConsoleMode#initialize_copy;F;[[I" obj2;T0;[[@Wi;T;;j;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @S;'@Q;(I"static VALUE
conmode_init_copy(VALUE obj, VALUE obj2)
{
conmode *t = rb_check_typeddata(obj, &conmode_type);
conmode *t2 = rb_check_typeddata(obj2, &conmode_type);
*t = *t2;
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO::ConsoleMode#echo=;F;[[I"f;T0;[[@Wi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @a;'@Q;(I"static VALUE
conmode_set_echo(VALUE obj, VALUE f)
{
conmode *t = rb_check_typeddata(obj, &conmode_type);
if (RTEST(f))
set_echo(t, NULL);
else
set_noecho(t, NULL);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO::ConsoleMode#raw!;F;[[@c0;[[@Wi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @o;'@Q;(I"static VALUE
conmode_set_raw(int argc, VALUE *argv, VALUE obj)
{
conmode *t = rb_check_typeddata(obj, &conmode_type);
rawmode_arg_t opts, *optp = rawmode_opt(&argc, argv, 0, 0, &opts);
set_rawmode(t, optp);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO::ConsoleMode#raw;F;[[@c0;[[@Wi;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @|;'@Q;(I"!static VALUE
conmode_raw_new(int argc, VALUE *argv, VALUE obj)
{
conmode *r = rb_check_typeddata(obj, &conmode_type);
conmode t = *r;
rawmode_arg_t opts, *optp = rawmode_opt(&argc, argv, 0, 0, &opts);
set_rawmode(&t, optp);
return conmode_new(rb_obj_class(obj), &t);
};T;)I"static VALUE;T;*T;A@Q;BIC;[ ;A@Q;CIC;[ ;A@Q;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Wit;F;:ConsoleMode;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @Q;'@t;I"IO::ConsoleMode;F;S@]o; ; F;
;;;;I"
IO#nread;F;[ ;[[I"ext/io/wait/wait.c;TiT;T;:
nread;0;[ ;{ ;IC; "iReturns number of bytes that can be read without blocking.
Returns zero if no information available.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
nread;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns number of bytes that can be read without blocking.
Returns zero if no information available.
@overload nread
@return [Integer];T; 0; @;!F;"o;#;$T;%iL;&iQ;'@t;(I"static VALUE
io_nread(VALUE io)
{
rb_io_t *fptr;
int len;
ioctl_arg n;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
len = rb_io_read_pending(fptr);
if (len > 0) return INT2FIX(len);
if (!FIONREAD_POSSIBLE_P(fptr->fd)) return INT2FIX(0);
if (ioctl(fptr->fd, FIONREAD, &n)) return INT2FIX(0);
if (n > 0) return ioctl_arg2num(n);
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#ready?;F;[ ;[[@il;T;: ready?;0;[ ;{ ;IC; "@Returns true if input available without blocking, or false.;T;[o;=
;3I"
overload;F;40;;;50;)I" ready?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"gReturns true if input available without blocking, or false.
@overload ready?
@return [Boolean];T; 0; @;!F;"o;#;$T;%ie;ⅈ6i ;'@t;(I"static VALUE
io_ready_p(VALUE io)
{
rb_io_t *fptr;
struct timeval tv = {0, 0};
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
if (rb_io_read_pending(fptr)) return Qtrue;
if (wait_for_single_fd(fptr, RB_WAITFD_IN, &tv))
return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#wait;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "Waits until IO is readable or writable without blocking and returns
+self+, or +nil+ when times out.
Returns +true+ immediately when buffered data is available.
Optional parameter +mode+ is one of +:read+, +:write+, or
+:read_write+.
;T;[o;=
;3I"
overload;F;40;;;50;)I"&wait(timeout = nil, mode = :read);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;TI"nil;T; @φ; [ ; I"@return [true, nil];T; 0; @φ;!F;6i ;>0;[[I" timeout;TI"nil;T[I" mode;TI"
:read;T; @φ; [ ; I"-Waits until IO is readable or writable without blocking and returns
+self+, or +nil+ when times out.
Returns +true+ immediately when buffered data is available.
Optional parameter +mode+ is one of +:read+, +:write+, or
+:read_write+.
@overload wait(timeout = nil, mode = :read)
@return [true, nil];T; 0; @φ;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
io_wait_readwrite(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv = NULL;
int event = 0;
int i;
GetOpenFile(io, fptr);
for (i = 0; i < argc; ++i) {
if (SYMBOL_P(argv[i])) {
event |= wait_mode_sym(argv[i]);
}
else {
*(tv = &timerec) = rb_time_interval(argv[i]);
}
}
/* rb_time_interval() and might_mode() might convert the argument */
rb_io_check_closed(fptr);
if (!event) event = RB_WAITFD_IN;
if ((event & RB_WAITFD_IN) && rb_io_read_pending(fptr))
return Qtrue;
if (wait_for_single_fd(fptr, event, tv))
return io;
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#wait_readable;F;[[@c0;[[@i;T;:wait_readable;0;[ ;{ ;IC; "Waits until IO is readable without blocking and returns +self+, or
+nil+ when times out.
Returns +true+ immediately when buffered data is available.
;T;[o;=
;3I"
overload;F;40;;;50;)I"wait_readable;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;TI"nil;T; @; [ ; I"@return [true, nil];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I"wait_readable(timeout);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;TI"nil;T; @; [ ; I"@return [true, nil];T; 0; @;!F;6i ;>0;[[I" timeout;T0; @; [ ; I"Waits until IO is readable without blocking and returns +self+, or
+nil+ when times out.
Returns +true+ immediately when buffered data is available.
@overload wait_readable
@return [true, nil]
@overload wait_readable(timeout)
@return [true, nil];T; 0; @;!F;"o;#;$T;%iz;&i};'@t;(I"zstatic VALUE
io_wait_readable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
tv = get_timeout(argc, argv, &timerec);
if (rb_io_read_pending(fptr)) return Qtrue;
if (wait_for_single_fd(fptr, RB_WAITFD_IN, tv)) {
return io;
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#wait_writable;F;[[@c0;[[@i;T;:wait_writable;0;[ ;{ ;IC; "\Waits until IO is writable without blocking and returns +self+ or
+nil+ when times out.
;T;[o;=
;3I"
overload;F;40;;;50;)I"wait_writable;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I"wait_writable(timeout);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @ ; [ ; I"@return [nil];T; 0; @ ;!F;6i ;>0;[[I" timeout;T0; @ ; [ ; I"Waits until IO is writable without blocking and returns +self+ or
+nil+ when times out.
@overload wait_writable
@overload wait_writable(timeout)
@return [nil];T; 0; @ ;!F;"o;#;$T;%i;&i;'@t;(I"Kstatic VALUE
io_wait_writable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
tv = get_timeout(argc, argv, &timerec);
if (wait_for_single_fd(fptr, RB_WAITFD_OUT, tv)) {
return io;
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#nonblock?;F;[ ;[[I" ext/io/nonblock/nonblock.c;Ti,;T;:nonblock?;0;[ ;{ ;IC; "0;[ ; @E; [ ; I"fReturns +true+ if an IO object is in non-blocking mode.
@overload nonblock?
@return [Boolean];T; 0; @E;!F;"o;#;$T;%i&;&i*;6i ;'@t;(I"static VALUE
rb_io_nonblock_p(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (io_nonblock_mode(fptr->fd) & O_NONBLOCK)
return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#nonblock=;F;[[I"nb;T0;[[@JiS;T;:nonblock=;0;[ ;{ ;IC; "eEnables non-blocking mode on a stream when set to
+true+, and blocking mode when set to +false+.
;T;[o;=
;3I"
overload;F;40;;;50;)I"nonblock=(boolean);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @a; [ ; I"@return [Boolean];T; 0; @a;!F;6i ;>0;[[I" boolean;T0; @a; [ ; I"Enables non-blocking mode on a stream when set to
+true+, and blocking mode when set to +false+.
@overload nonblock=(boolean)
@return [Boolean];T; 0; @a;!F;"o;#;$T;%iL;&iQ;'@t;(I"static VALUE
rb_io_nonblock_set(VALUE io, VALUE nb)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (RTEST(nb))
rb_io_set_nonblock(fptr);
else
io_nonblock_set(fptr->fd, io_nonblock_mode(fptr->fd), RTEST(nb));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#nonblock;F;[[@c0;[[@Jir;T;:
nonblock;0;[ ;{ ;IC; "Yields +self+ in non-blocking mode.
When +false+ is given as an argument, +self+ is yielded in blocking mode.
The original mode is restored after the block is executed.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
nonblock;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"io;T; @o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @; [ ; I" @yield [io]
@return [IO];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I"nonblock(boolean);T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"io;T; @o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @; [ ; I" @yield [io]
@return [IO];T; 0; @;!F;6i ;>0;[[I" boolean;T0; @; [ ; I"Yields +self+ in non-blocking mode.
When +false+ is given as an argument, +self+ is yielded in blocking mode.
The original mode is restored after the block is executed.
@overload nonblock
@yield [io]
@return [IO]
@overload nonblock(boolean)
@yield [io]
@return [IO];T; 0; @;!F;"o;#;$T;%ih;&is;'@t;(I"static VALUE
rb_io_nonblock_block(int argc, VALUE *argv, VALUE io)
{
int nb = 1;
rb_io_t *fptr;
int f, restore[2];
GetOpenFile(io, fptr);
if (argc > 0) {
VALUE v;
rb_scan_args(argc, argv, "01", &v);
nb = RTEST(v);
}
f = io_nonblock_mode(fptr->fd);
restore[0] = fptr->fd;
restore[1] = f;
if (!io_nonblock_set(fptr->fd, f, nb))
return rb_yield(io);
return rb_ensure(rb_yield, io, io_nonblock_restore, (VALUE)restore);
};T;)I"static VALUE;T;*To; ;IC;[ o; ; F;
;;;;I" IO::generic_writable#<<;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@;*To; ; F;
;;;;I" IO::generic_writable#print;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@;*To; ; F;
;;;;I" IO::generic_writable#printf;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ɇ;'@;*To; ; F;
;;;;I" IO::generic_writable#puts;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @҇;'@;*To; ; F;
;;;;I""IO::generic_writable#syswrite;F;[ ;[ ;F;;;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ۇ;'@;*To; ; F;
;;;;I"(IO::generic_writable#write_nonblock;F;[[@c0;[[@Nil;T;:write_nonblock;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@;(I"static VALUE
strio_syswrite_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE str;
rb_scan_args(argc, argv, "10:", &str, NULL);
return strio_syswrite(self, str);
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Nid;F;:generic_writable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;I"IO::generic_writable;Fo; ; F;
;;;;I" IO#stat;F;[ ;[[@Gi@;T;;;0;[ ;{ ;IC; "Returns status information for ios as an object of type
File::Stat.
f = File.new("testfile")
s = f.stat
"%o" % s.mode #=> "100644"
s.blksize #=> 4096
s.atime #=> Wed Apr 09 08:53:54 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I" stat;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns status information for ios as an object of type
File::Stat.
f = File.new("testfile")
s = f.stat
"%o" % s.mode #=> "100644"
s.blksize #=> 4096
s.atime #=> Wed Apr 09 08:53:54 CDT 2003
@overload stat;T; 0; @ ;!F;"o;#;$T;%i1;&i<;'@t;(I"static VALUE
rb_io_stat(VALUE obj)
{
rb_io_t *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fptr->fd, &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return rb_stat_new(&st);
};T;)I"static VALUE;T;*T;A@t;BIC;[ ;A@t;CIC;[@ o; ;IC;[ o;;[[@Gi;F;: RDONLY;;;;;[ ;{ ;IC; "open for reading only
;T;[ ; [ ; I"open for reading only;T; 0; @;!F;"o;#;$T;%i;&i;'@;I" File::Constants::RDONLY;F;I"INT2FIX(O_RDONLY);To;;[[@Gi;F;: WRONLY;;;;;[ ;{ ;IC; "open for writing only
;T;[ ; [ ; I"open for writing only;T; 0; @&;!F;"o;#;$T;%i;&i;'@;I" File::Constants::WRONLY;F;I"INT2FIX(O_WRONLY);To;;[[@Gi;F;: RDWR;;;;;[ ;{ ;IC; "!open for reading and writing
;T;[ ; [ ; I"!open for reading and writing;T; 0; @2;!F;"o;#;$T;%i;&i;'@;I"File::Constants::RDWR;F;I"INT2FIX(O_RDWR);To;;[[@Gi;F;: APPEND;;;;;[ ;{ ;IC; "append on each write
;T;[ ; [ ; I"append on each write;T; 0; @>;!F;"o;#;$T;%i;&i;'@;I" File::Constants::APPEND;F;I"INT2FIX(O_APPEND);To;;[[@Gi;F;:
CREAT;;;;;[ ;{ ;IC; "%create file if it does not exist
;T;[ ; [ ; I"%create file if it does not exist;T; 0; @J;!F;"o;#;$T;%i;&i;'@;I"File::Constants::CREAT;F;I"INT2FIX(O_CREAT);To;;[[@Gi;F;: EXCL;;;;;[ ;{ ;IC; "'error if CREAT and the file exists
;T;[ ; [ ; I"'error if CREAT and the file exists;T; 0; @V;!F;"o;#;$T;%i;&i;'@;I"File::Constants::EXCL;F;I"INT2FIX(O_EXCL);To;;[[@Gi;F;:
NONBLOCK;;;;;[ ;{ ;IC; "9do not block on open or for data to become available
;T;[ ; [ ; I"9do not block on open or for data to become available;T; 0; @b;!F;"o;#;$T;%i;&i;'@;I" File::Constants::NONBLOCK;F;I"INT2FIX(O_NONBLOCK);To;;[[@Gi;F;:
TRUNC;;;;;[ ;{ ;IC; "truncate size to 0
;T;[ ; [ ; I"truncate size to 0;T; 0; @n;!F;"o;#;$T;%i;&i;'@;I"File::Constants::TRUNC;F;I"INT2FIX(O_TRUNC);To;;[[@Gi;F;: NOCTTY;;;;;[ ;{ ;IC; ":not to make opened IO the controlling terminal device
;T;[ ; [ ; I":not to make opened IO the controlling terminal device;T; 0; @z;!F;"o;#;$T;%i;&i;'@;I" File::Constants::NOCTTY;F;I"INT2FIX(O_NOCTTY);To;;[[@Gi;F;;p;;;;;[ ;{ ;IC; "!disable line code conversion
;T;[ ; [ ; I"!disable line code conversion;T; 0; @;!F;"o;#;$T;%i;&i;'@;I" File::Constants::BINARY;F;I"INT2FIX(O_BINARY);To;;[[@Gi;F;:SHARE_DELETE;;;;;[ ;{ ;IC; "can delete opened file
;T;[ ; [ ; I"can delete opened file;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;I""File::Constants::SHARE_DELETE;F;I" INT2FIX(O_SHARE_DELETE);To;;[[@Gi;F;: SYNC;;;;;[ ;{ ;IC; ".any write operation perform synchronously
;T;[ ; [ ; I".any write operation perform synchronously;T; 0; @;!F;"o;#;$T;%i;&i;'@;I"File::Constants::SYNC;F;I"INT2FIX(O_SYNC);To;;[[@Gi;F;:
DSYNC;;;;;[ ;{ ;IC; "Dany write operation perform synchronously except some meta data
;T;[ ; [ ; I"Dany write operation perform synchronously except some meta data;T; 0; @;!F;"o;#;$T;%i;&i;'@;I"File::Constants::DSYNC;F;I"INT2FIX(O_DSYNC);To;;[[@Gi ;F;:
RSYNC;;;;;[ ;{ ;IC; "Gany read operation perform synchronously. used with SYNC or DSYNC.
;T;[ ; [ ; I"Gany read operation perform synchronously. used with SYNC or DSYNC.;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;I"File::Constants::RSYNC;F;I"INT2FIX(O_RSYNC);To;;[[@Gi;F;:
NOFOLLOW;;;;;[ ;{ ;IC; "FreeBSD, Linux
;T;[ ; [ ; I"FreeBSD, Linux;T; 0; @;!F;"o;#;$T;%i;&i;'@;I" File::Constants::NOFOLLOW;F;I"INT2FIX(O_NOFOLLOW);To;;[[@Gi;F;: NOATIME;;;;;[ ;{ ;IC; "
Linux
;T;[ ; [ ; I"
Linux;T; 0; @Έ;!F;"o;#;$T;%i;&i;'@;I" File::Constants::NOATIME;F;I"INT2FIX(O_NOATIME);To;;[[@Gi;F;: DIRECT;;;;;[ ;{ ;IC; "DTry to minimize cache effects of the I/O to and from this file.
;T;[ ; [ ; I"DTry to minimize cache effects of the I/O to and from this file.;T; 0; @ڈ;!F;"o;#;$T;%i;&i;'@;I" File::Constants::DIRECT;F;I"INT2FIX(O_DIRECT);To;;[[@Gi ;F;: TMPFILE;;;;;[ ;{ ;IC; "%Create an unnamed temporary file
;T;[ ; [ ; I"%Create an unnamed temporary file;T; 0; @;!F;"o;#;$T;%i;&i;'@;I" File::Constants::TMPFILE;F;I"INT2FIX(O_TMPFILE);To;;[[@Gi ;F;: LOCK_SH;;;;;[ ;{ ;IC; " shared lock. see File#flock
;T;[ ; [ ; I" shared lock. see File#flock;T; 0; @;!F;"o;#;$T;%i ;&i ;'@;I" File::Constants::LOCK_SH;F;I"INT2FIX(LOCK_SH);To;;[[@Gi";F;: LOCK_EX;;;;;[ ;{ ;IC; "#exclusive lock. see File#flock
;T;[ ; [ ; I"#exclusive lock. see File#flock;T; 0; @;!F;"o;#;$T;%i!;&i!;'@;I" File::Constants::LOCK_EX;F;I"INT2FIX(LOCK_EX);To;;[[@Gi$;F;: LOCK_UN;;;;;[ ;{ ;IC; "unlock. see File#flock
;T;[ ; [ ; I"unlock. see File#flock;T; 0; @
;!F;"o;#;$T;%i#;&i#;'@;I" File::Constants::LOCK_UN;F;I"INT2FIX(LOCK_UN);To;;[[@Gi&;F;: LOCK_NB;;;;;[ ;{ ;IC; "Dnon-blocking lock. used with LOCK_SH or LOCK_EX. see File#flock
;T;[ ; [ ; I"Dnon-blocking lock. used with LOCK_SH or LOCK_EX. see File#flock;T; 0; @;!F;"o;#;$T;%i%;&i%;'@;I" File::Constants::LOCK_NB;F;I"INT2FIX(LOCK_NB);To;;[[@Gi);F;: NULL;;;;;[ ;{ ;IC; " Name of the null device
;T;[ ; [ ; I" Name of the null device;T; 0; @";!F;"o;#;$T;%i(;&i(;'@;I"File::Constants::NULL;F;I"&rb_fstring_cstr(ruby_null_device);T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Gi[@Gi;T;;z;;K;;;[ ;{ ;IC; "^File::Constants provides file-related constants. All possible
file constants are listed in the documentation but they may not all
be present on your platform.
If the underlying platform doesn't define a constant the corresponding
Ruby constant is not defined.
Your platform documentations (e.g. man open(2)) may describe more
detailed information.
;T;[ ; [ ; I"`
File::Constants provides file-related constants. All possible
file constants are listed in the documentation but they may not all
be present on your platform.
If the underlying platform doesn't define a constant the corresponding
Ruby constant is not defined.
Your platform documentations (e.g. man open(2)) may describe more
detailed information.
;T; 0; @;!F;"o;#;$T;%i;&i;'o;
;IC;[Wo; ; F;
;F;;;I"File.open;F;[[@c0;[[@iu;T;;;0;[ ;{ ;IC; "call-seq:
IO.open(fd, mode="r" [, opt]) -> io
IO.open(fd, mode="r" [, opt]) {|io| block } -> obj
With no associated block, IO.open is a synonym for IO.new. If
the optional code block is given, it will be passed +io+ as an argument,
and the IO object will automatically be closed when the block terminates.
In this instance, IO.open returns the value of the block.
See IO.new for a description of the +fd+, +mode+ and +opt+ parameters.
;T;[ ; [ ; @u; 0; @A;!F;"o;#;$T;%if;&iq;'@?;(I"static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE io = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#initialize;F;[[@c0;[[@i ;T;;;0;[ ;{ ;IC; "~Opens the file named by +filename+ according to the given +mode+ and
returns a new File object.
See IO.new for a description of +mode+ and +opt+.
If a file is being created, permission bits may be given in +perm+. These
mode and permission bits are platform dependent; on Unix systems, see
open(2) and chmod(2) man pages for details.
The new File object is buffered mode (or non-sync mode), unless
+filename+ is a tty.
See IO#flush, IO#fsync, IO#fdatasync, and IO#sync= about sync mode.
=== Examples
f = File.new("testfile", "r")
f = File.new("newfile", "w+")
f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
;T;[o;=
;3I"
overload;F;40;;;50;)I"$new(filename, mode="r" [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" File;T; @O; [ ; I"@return [File];T; 0; @O;!F;6i ;>0;[[I"
filename;T0[I" mode;TI""r"[, opt];T; @Oo;=
;3I"
overload;F;40;;;50;)I",new(filename [, mode [, perm]] [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" File;T; @O; [ ; I"@return [File];T; 0; @O;!F;6i ;>0;[[I"%filename[, mode [, perm]][, opt];T0; @O; [ ; I"Opens the file named by +filename+ according to the given +mode+ and
returns a new File object.
See IO.new for a description of +mode+ and +opt+.
If a file is being created, permission bits may be given in +perm+. These
mode and permission bits are platform dependent; on Unix systems, see
open(2) and chmod(2) man pages for details.
The new File object is buffered mode (or non-sync mode), unless
+filename+ is a tty.
See IO#flush, IO#fsync, IO#fdatasync, and IO#sync= about sync mode.
=== Examples
f = File.new("testfile", "r")
f = File.new("newfile", "w+")
f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
@overload new(filename, mode="r" [, opt])
@return [File]
@overload new(filename [, mode [, perm]] [, opt])
@return [File];T; 0; @O;!F;"o;#;$T;%i ;&i ;'@?;(I"ostatic VALUE
rb_file_initialize(int argc, VALUE *argv, VALUE io)
{
if (RFILE(io)->fptr) {
rb_raise(rb_eRuntimeError, "reinitializing File");
}
if (0 < argc && argc < 3) {
VALUE fd = rb_check_to_int(argv[0]);
if (!NIL_P(fd)) {
argv[0] = fd;
return rb_io_initialize(argc, argv, io);
}
}
rb_open_file(argc, argv, io);
return io;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.fnmatch;F;[[@c0;[[I"
dir.c;Ti ;T;;;0;[ ;{ ;IC; "Returns true if +path+ matches against +pattern+. The pattern is not a
regular expression; instead it follows rules similar to shell filename
globbing. It may contain the following metacharacters:
"
;T;[o;=
;3I"
overload;F;40;;v;50;)I" inspect;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ ; [ ; I"@return [String];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Produce a nicely formatted description of stat.
File.stat("/etc/passwd").inspect
#=> "#"
@overload inspect
@return [String];T; 0; @ ;!F;"o;#;$T;%i;&i ;'@;(I"static VALUE
rb_stat_inspect(VALUE self)
{
VALUE str;
size_t i;
static const struct {
const char *name;
VALUE (*func)(VALUE);
} member[] = {
{"dev", rb_stat_dev},
{"ino", rb_stat_ino},
{"mode", rb_stat_mode},
{"nlink", rb_stat_nlink},
{"uid", rb_stat_uid},
{"gid", rb_stat_gid},
{"rdev", rb_stat_rdev},
{"size", rb_stat_size},
{"blksize", rb_stat_blksize},
{"blocks", rb_stat_blocks},
{"atime", rb_stat_atime},
{"mtime", rb_stat_mtime},
{"ctime", rb_stat_ctime},
#if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC)
{"birthtime", rb_stat_birthtime},
#endif
};
struct stat* st;
TypedData_Get_Struct(self, struct stat, &stat_data_type, st);
if (!st) {
return rb_sprintf("#<%s: uninitialized>", rb_obj_classname(self));
}
str = rb_str_buf_new2("#<");
rb_str_buf_cat2(str, rb_obj_classname(self));
rb_str_buf_cat2(str, " ");
for (i = 0; i < sizeof(member)/sizeof(member[0]); i++) {
VALUE v;
if (i > 0) {
rb_str_buf_cat2(str, ", ");
}
rb_str_buf_cat2(str, member[i].name);
rb_str_buf_cat2(str, "=");
v = (*member[i].func)(self);
if (i == 2) { /* mode */
rb_str_catf(str, "0%lo", (unsigned long)NUM2ULONG(v));
}
else if (i == 0 || i == 6) { /* dev/rdev */
rb_str_catf(str, "0x%"PRI_DEVT_PREFIX"x", NUM2DEVT(v));
}
else {
rb_str_append(str, rb_inspect(v));
}
}
rb_str_buf_cat2(str, ">");
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#ftype;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "RIdentifies the type of stat. The return string is one of:
``/~oracle/bin"
;T;[o;=
;3I"
overload;F;40;;;50;)I"-absolute_path(file_name [, dir_string] );T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" file_name[, dir_string];T0; @; [ ; I"Converts a pathname to an absolute pathname. Relative paths are
referenced from the current working directory of the process unless
dir_string is given, in which case it will be used as the
starting point. If the given pathname starts with a ``/~oracle/bin"
@overload absolute_path(file_name [, dir_string] );T; 0; @;!F;"o;#;$T;%i2;&i;;'@?;(I"pstatic VALUE
s_absolute_path(int c, const VALUE * v, VALUE _)
{
return rb_file_s_absolute_path(c, v);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.absolute_path?;F;[[I"
fname;T0;[[@GiO;T;:absolute_path?;0;[ ;{ ;IC; "Returns 0;[[I"str;T0; @; [ ; I"n::seed is equivalent to ::add where _entropy_ is length of _str_.
@overload seed(str)
@return [String];T; 0; @;!F;>0;'@;(I"static VALUE
ossl_rand_seed(VALUE self, VALUE str)
{
StringValue(str);
RAND_seed(RSTRING_PTR(str), RSTRING_LENINT(str));
return str;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"OpenSSL::Random.seed;F;@;@ş;T;;];0;@ǟ;{ ;IC; "F::seed is equivalent to ::add where _entropy_ is length of _str_.;T;[o;=
;3I"
overload;F;40;;];50;)I"seed(str);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ޟ; [ ; I"@return [String];T; 0; @ޟ;!F;6i ;>0;[[I"str;T0; @ޟ; [ ; I"o::seed is equivalent to ::add where _entropy_ is length of _str_.
@overload seed(str)
@return [String];T; 0; @ޟ;!F;"o;#;$T;%i;&i;6i ;'@;(@ܟ;)@ݟ;*To; ; F;
;;;;I" OpenSSL::Random#random_add;F;[[I"str;T0[I" entropy;T0;[[@BTi9;T;:random_add;0;[ ;{ ;IC; " Mixes the bytes from _str_ into the Pseudo Random Number Generator(PRNG)
state.
Thus, if the data from _str_ are unpredictable to an adversary, this
increases the uncertainty about the state and makes the PRNG output less
predictable.
The _entropy_ argument is (the lower bound of) an estimate of how much
randomness is contained in _str_, measured in bytes.
=== Example
pid = $$
now = Time.now
ary = [now.to_i, now.nsec, 1000, pid]
OpenSSL::Random.add(ary.join, 0.0)
OpenSSL::Random.seed(ary.join)
;T;[o;=
;3I"
overload;F;40;:add;50;)I"add(str, entropy);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[[I"str;T0[I" entropy;T0; @; [ ; I".Mixes the bytes from _str_ into the Pseudo Random Number Generator(PRNG)
state.
Thus, if the data from _str_ are unpredictable to an adversary, this
increases the uncertainty about the state and makes the PRNG output less
predictable.
The _entropy_ argument is (the lower bound of) an estimate of how much
randomness is contained in _str_, measured in bytes.
=== Example
pid = $$
now = Time.now
ary = [now.to_i, now.nsec, 1000, pid]
OpenSSL::Random.add(ary.join, 0.0)
OpenSSL::Random.seed(ary.join)
@overload add(str, entropy)
@return [self];T; 0; @;!F;>0;'@;(I"static VALUE
ossl_rand_add(VALUE self, VALUE str, VALUE entropy)
{
StringValue(str);
RAND_add(RSTRING_PTR(str), RSTRING_LENINT(str), NUM2DBL(entropy));
return self;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" OpenSSL::Random.random_add;F;@;@;T;;;0;@;{ ;IC; " Mixes the bytes from _str_ into the Pseudo Random Number Generator(PRNG)
state.
Thus, if the data from _str_ are unpredictable to an adversary, this
increases the uncertainty about the state and makes the PRNG output less
predictable.
The _entropy_ argument is (the lower bound of) an estimate of how much
randomness is contained in _str_, measured in bytes.
=== Example
pid = $$
now = Time.now
ary = [now.to_i, now.nsec, 1000, pid]
OpenSSL::Random.add(ary.join, 0.0)
OpenSSL::Random.seed(ary.join);T;[o;=
;3I"
overload;F;40;;;50;)I"add(str, entropy);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[[I"str;T0[I" entropy;T0; @; [ ; I"/Mixes the bytes from _str_ into the Pseudo Random Number Generator(PRNG)
state.
Thus, if the data from _str_ are unpredictable to an adversary, this
increases the uncertainty about the state and makes the PRNG output less
predictable.
The _entropy_ argument is (the lower bound of) an estimate of how much
randomness is contained in _str_, measured in bytes.
=== Example
pid = $$
now = Time.now
ary = [now.to_i, now.nsec, 1000, pid]
OpenSSL::Random.add(ary.join, 0.0)
OpenSSL::Random.seed(ary.join)
@overload add(str, entropy)
@return [self];T; 0; @;!F;"o;#;$T;%i#;&i7;6i ;'@;(@;)@;*To; ; F;
;;;;I"%OpenSSL::Random#load_random_file;F;[[I"
filename;T0;[[@BTiH;T;:load_random_file;0;[ ;{ ;IC; ";Reads bytes from _filename_ and adds them to the PRNG.
;T;[o;=
;3I"
overload;F;40;;;50;)I" load_random_file(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @0; [ ; I"@return [true];T; 0; @0;!F;6i ;>0;[[I"
filename;T0; @0; [ ; I"rReads bytes from _filename_ and adds them to the PRNG.
@overload load_random_file(filename)
@return [true];T; 0; @0;!F;>0;'@;(I"static VALUE
ossl_rand_load_file(VALUE self, VALUE filename)
{
if(!RAND_load_file(StringValueCStr(filename), -1)) {
ossl_raise(eRandomError, NULL);
}
return Qtrue;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"%OpenSSL::Random.load_random_file;F;@2;@5;T;;;0;@7;{ ;IC; ";Reads bytes from _filename_ and adds them to the PRNG.;T;[o;=
;3I"
overload;F;40;;;50;)I" load_random_file(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @N; [ ; I"@return [true];T; 0; @N;!F;6i ;>0;[[I"
filename;T0; @N; [ ; I"sReads bytes from _filename_ and adds them to the PRNG.
@overload load_random_file(filename)
@return [true];T; 0; @N;!F;"o;#;$T;%iB;&iF;6i ;'@;(@L;)@M;*To; ; F;
;;;;I"&OpenSSL::Random#write_random_file;F;[[I"
filename;T0;[[@BTiY;T;:write_random_file;0;[ ;{ ;IC; "Writes a number of random generated bytes (currently 1024) to _filename_
which can be used to initialize the PRNG by calling ::load_random_file in a
later session.
;T;[o;=
;3I"
overload;F;40;;;50;)I" write_random_file(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @e; [ ; I"@return [true];T; 0; @e;!F;6i ;>0;[[I"
filename;T0; @e; [ ; I"Writes a number of random generated bytes (currently 1024) to _filename_
which can be used to initialize the PRNG by calling ::load_random_file in a
later session.
@overload write_random_file(filename)
@return [true];T; 0; @e;!F;>0;'@;(I"static VALUE
ossl_rand_write_file(VALUE self, VALUE filename)
{
if (RAND_write_file(StringValueCStr(filename)) == -1) {
ossl_raise(eRandomError, NULL);
}
return Qtrue;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"&OpenSSL::Random.write_random_file;F;@g;@j;T;;;0;@l;{ ;IC; "Writes a number of random generated bytes (currently 1024) to _filename_
which can be used to initialize the PRNG by calling ::load_random_file in a
later session.;T;[o;=
;3I"
overload;F;40;;;50;)I" write_random_file(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @; [ ; I"@return [true];T; 0; @;!F;6i ;>0;[[I"
filename;T0; @; [ ; I"Writes a number of random generated bytes (currently 1024) to _filename_
which can be used to initialize the PRNG by calling ::load_random_file in a
later session.
@overload write_random_file(filename)
@return [true];T; 0; @;!F;"o;#;$T;%iQ;&iW;6i ;'@;(@;)@;*To; ; F;
;;;;I"!OpenSSL::Random#random_bytes;F;[[I"len;T0;[[@BTin;T;:random_bytes;0;[ ;{ ;IC; "random_bytes(length) -> string
Generates a String with _length_ number of cryptographically strong
pseudo-random bytes.
=== Example
OpenSSL::Random.random_bytes(12)
#=> "..."
;T;[ ; [ ; I"random_bytes(length) -> string
Generates a String with _length_ number of cryptographically strong
pseudo-random bytes.
=== Example
OpenSSL::Random.random_bytes(12)
#=> "...";T; 0; @;!F;>0;'@;(I"pstatic VALUE
ossl_rand_bytes(VALUE self, VALUE len)
{
VALUE str;
int n = NUM2INT(len);
int ret;
str = rb_str_new(0, n);
ret = RAND_bytes((unsigned char *)RSTRING_PTR(str), n);
if (ret == 0) {
ossl_raise(eRandomError, "RAND_bytes");
} else if (ret == -1) {
ossl_raise(eRandomError, "RAND_bytes is not supported");
}
return str;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"!OpenSSL::Random.random_bytes;F;@;@;T;;;0;@;{ ;IC; "random_bytes(length) -> string
Generates a String with _length_ number of cryptographically strong
pseudo-random bytes.
=== Example
OpenSSL::Random.random_bytes(12)
#=> "...";T;[ ; [ ; I"random_bytes(length) -> string
Generates a String with _length_ number of cryptographically strong
pseudo-random bytes.
=== Example
OpenSSL::Random.random_bytes(12)
#=> "..."
;T; 0; @;!F;"o;#;$T;%ib;&il;6i ;'@;(@;)@;*To; ; F;
;;;;I"!OpenSSL::Random#pseudo_bytes;F;[[I"len;T0;[[@BTi;T;:pseudo_bytes;0;[ ;{ ;IC; ".pseudo_bytes(length) -> string
Generates a String with _length_ number of pseudo-random bytes.
Pseudo-random byte sequences generated by ::pseudo_bytes will be unique if
they are of sufficient length, but are not necessarily unpredictable.
=== Example
OpenSSL::Random.pseudo_bytes(12)
#=> "..."
;T;[ ; [ ; I".pseudo_bytes(length) -> string
Generates a String with _length_ number of pseudo-random bytes.
Pseudo-random byte sequences generated by ::pseudo_bytes will be unique if
they are of sufficient length, but are not necessarily unpredictable.
=== Example
OpenSSL::Random.pseudo_bytes(12)
#=> "...";T; 0; @;!F;>0;'@;(I"static VALUE
ossl_rand_pseudo_bytes(VALUE self, VALUE len)
{
VALUE str;
int n = NUM2INT(len);
str = rb_str_new(0, n);
if (RAND_pseudo_bytes((unsigned char *)RSTRING_PTR(str), n) < 1) {
ossl_raise(eRandomError, NULL);
}
return str;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"!OpenSSL::Random.pseudo_bytes;F;@;@;T;;;0;@;{ ;IC; ".pseudo_bytes(length) -> string
Generates a String with _length_ number of pseudo-random bytes.
Pseudo-random byte sequences generated by ::pseudo_bytes will be unique if
they are of sufficient length, but are not necessarily unpredictable.
=== Example
OpenSSL::Random.pseudo_bytes(12)
#=> "...";T;[ ; [ ; I"0pseudo_bytes(length) -> string
Generates a String with _length_ number of pseudo-random bytes.
Pseudo-random byte sequences generated by ::pseudo_bytes will be unique if
they are of sufficient length, but are not necessarily unpredictable.
=== Example
OpenSSL::Random.pseudo_bytes(12)
#=> "..."
;T; 0; @;!F;"o;#;$T;%i|;&i;6i ;'@;(@;)@;*To; ; F;
;;;;I"OpenSSL::Random#egd;F;[[I"
filename;T0;[[@BTi;T;:egd;0;[ ;{ ;IC; ":Same as ::egd_bytes but queries 255 bytes by default.
;T;[o;=
;3I"
overload;F;40;;;50;)I"egd(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @Ƞ; [ ; I"@return [true];T; 0; @Ƞ;!F;6i ;>0;[[I"
filename;T0; @Ƞ; [ ; I"dSame as ::egd_bytes but queries 255 bytes by default.
@overload egd(filename)
@return [true];T; 0; @Ƞ;!F;>0;'@;(I"static VALUE
ossl_rand_egd(VALUE self, VALUE filename)
{
if (RAND_egd(StringValueCStr(filename)) == -1) {
ossl_raise(eRandomError, NULL);
}
return Qtrue;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I"OpenSSL::Random.egd;F;@ʠ;@͠;T;;;0;@Ϡ;{ ;IC; ":Same as ::egd_bytes but queries 255 bytes by default.;T;[o;=
;3I"
overload;F;40;;;50;)I"egd(filename);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @; [ ; I"@return [true];T; 0; @;!F;6i ;>0;[[I"
filename;T0; @; [ ; I"eSame as ::egd_bytes but queries 255 bytes by default.
@overload egd(filename)
@return [true];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(@;)@;*To; ; F;
;;;;I" OpenSSL::Random#egd_bytes;F;[[I"
filename;T0[I"len;T0;[[@BTi;T;:egd_bytes;0;[ ;{ ;IC; "Queries the entropy gathering daemon EGD on socket path given by _filename_.
Fetches _length_ number of bytes and uses ::add to seed the OpenSSL built-in
PRNG.
;T;[o;=
;3I"
overload;F;40;;;50;)I" egd_bytes(filename, length);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @; [ ; I"@return [true];T; 0; @;!F;6i ;>0;[[I"
filename;T0[I" length;T0; @; [ ; I"Queries the entropy gathering daemon EGD on socket path given by _filename_.
Fetches _length_ number of bytes and uses ::add to seed the OpenSSL built-in
PRNG.
@overload egd_bytes(filename, length)
@return [true];T; 0; @;!F;>0;'@;(I"static VALUE
ossl_rand_egd_bytes(VALUE self, VALUE filename, VALUE len)
{
int n = NUM2INT(len);
if (RAND_egd_bytes(StringValueCStr(filename), n) == -1) {
ossl_raise(eRandomError, NULL);
}
return Qtrue;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" OpenSSL::Random.egd_bytes;F;@;@;T;;;0;@;{ ;IC; "Queries the entropy gathering daemon EGD on socket path given by _filename_.
Fetches _length_ number of bytes and uses ::add to seed the OpenSSL built-in
PRNG.;T;[o;=
;3I"
overload;F;40;;;50;)I" egd_bytes(filename, length);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" true;T; @ ; [ ; I"@return [true];T; 0; @ ;!F;6i ;>0;[[I"
filename;T0[I" length;T0; @ ; [ ; I"Queries the entropy gathering daemon EGD on socket path given by _filename_.
Fetches _length_ number of bytes and uses ::add to seed the OpenSSL built-in
PRNG.
@overload egd_bytes(filename, length)
@return [true];T; 0; @ ;!F;"o;#;$T;%i;&i;6i ;'@;(@ ;)@ ;*To; ; F;
;;;;I" OpenSSL::Random#status?;F;[ ;[[@BTi;T;: status?;0;[ ;{ ;IC; "SReturn +true+ if the PRNG has been seeded with enough data, +false+ otherwise.
;T;[o;=
;3I"
overload;F;40;;;50;)I" status?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @8;!F;6i ;>0;[ ; @8o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @8; [ ; I"yReturn +true+ if the PRNG has been seeded with enough data, +false+ otherwise.
@overload status?
@return [Boolean] ;T; 0; @8;!F;>0;'@;(I"]static VALUE
ossl_rand_status(VALUE self)
{
return RAND_status() ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" OpenSSL::Random.status?;F;@:;@;;T;;;0;@=;{ ;IC; "SReturn +true+ if the PRNG has been seeded with enough data, +false+ otherwise.;T;[o;=
;3I"
overload;F;40;;;50;)I" status?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @R;!F;6i ;>0;[ ; @Ro;2
;3I" return;F;4@|;0;5[@~; @R; [ ; I"gReturn +true+ if the PRNG has been seeded with enough data, +false+ otherwise.
@overload status?;T; 0; @R;!F;"o;#;$T;%i;&i;6i ;'@;(@P;)@Q;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@BTi;F;: Random;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;6i ;'@'T;I"OpenSSL::Random;Fo;
;IC;[ o;
;IC;[ ;A@v;BIC;[ ;A@v;CIC;[ ;A@v;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@FTi
;F;:CipherError;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @v;'@t;I"!OpenSSL::Cipher::CipherError;F;S@)To; ; F;
;;;;I"$OpenSSL::Cipher#initialize_copy;F;[[I"
other;T0;[[@FTi;T;;j;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"istatic VALUE
ossl_cipher_copy(VALUE self, VALUE other)
{
EVP_CIPHER_CTX *ctx1, *ctx2;
rb_check_frozen(self);
if (self == other) return self;
GetCipherInit(self, ctx1);
if (!ctx1) {
AllocCipher(self, ctx1);
}
GetCipher(other, ctx2);
if (EVP_CIPHER_CTX_copy(ctx1, ctx2) != 1)
ossl_raise(eCipherError, NULL);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#ciphers;F;[ ;[[@FTi;T;;5;0;[ ;{ ;IC; "0;[ ; @; [ ; I"_Returns the names of all available ciphers in an array.
@overload OpenSSL::Cipher.ciphers
;T; 0; @;!F;>0;'@t;(I"static VALUE
ossl_s_ciphers(VALUE self)
{
VALUE ary;
ary = rb_ary_new();
OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
(void(*)(const OBJ_NAME*,void*))add_cipher_name_to_ary,
(void*)ary);
return ary;
};T;)I"static VALUE;T;*To; ; T;
;F;;;I" OpenSSL::Cipher.ciphers;F;@;@;T;;5;0;@;{ ;IC; "0;[ ; @; [ ; I"`Returns the names of all available ciphers in an array.
@overload OpenSSL::Cipher.ciphers;T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@t;(@;)@;*To; ; F;
;;;;I" OpenSSL::Cipher#initialize;F;[[I"str;T0;[[@FTit;T;;;0;[ ;{ ;IC; "The string must be a valid cipher name like "AES-128-CBC" or "3DES".
A list of cipher names is available by calling OpenSSL::Cipher.ciphers.
;T;[o;=
;3I"
overload;F;40;;;50;)I"new(string);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"The string must be a valid cipher name like "AES-128-CBC" or "3DES".
A list of cipher names is available by calling OpenSSL::Cipher.ciphers.
@overload new(string);T; 0; @;!F;"o;#;$T;%il;&iq;'@t;(I"5static VALUE
ossl_cipher_initialize(VALUE self, VALUE str)
{
EVP_CIPHER_CTX *ctx;
const EVP_CIPHER *cipher;
char *name;
name = StringValueCStr(str);
GetCipherInit(self, ctx);
if (ctx) {
ossl_raise(rb_eRuntimeError, "Cipher already initialized!");
}
AllocCipher(self, ctx);
if (!(cipher = EVP_get_cipherbyname(name))) {
ossl_raise(rb_eRuntimeError, "unsupported cipher algorithm (%"PRIsVALUE")", str);
}
if (EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, -1) != 1)
ossl_raise(eCipherError, NULL);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#reset;F;[ ;[[@FTi;T;;;;0;[ ;{ ;IC; "Fully resets the internal state of the Cipher. By using this, the same
Cipher instance may be used several times for encryption or decryption tasks.
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, -1).
;T;[o;=
;3I"
overload;F;40;;;;50;)I"
reset;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @ԡ; [ ; I"@return [self];T; 0; @ԡ;!F;6i ;>0;[ ; @ԡ; [ ; I"Fully resets the internal state of the Cipher. By using this, the same
Cipher instance may be used several times for encryption or decryption tasks.
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, -1).
@overload reset
@return [self];T; 0; @ԡ;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_reset(VALUE self)
{
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
if (EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, -1) != 1)
ossl_raise(eCipherError, NULL);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#encrypt;F;[[@c0;[[@FTi;T;: encrypt;0;[ ;{ ;IC; "Initializes the Cipher for encryption.
Make sure to call Cipher#encrypt or Cipher#decrypt before using any of the
following methods:
* [#key=, #iv=, #random_key, #random_iv, #pkcs5_keyivgen]
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, 1).
;T;[o;=
;3I"
overload;F;40;;;50;)I" encrypt;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[ ; @; [ ; I")Initializes the Cipher for encryption.
Make sure to call Cipher#encrypt or Cipher#decrypt before using any of the
following methods:
* [#key=, #iv=, #random_key, #random_iv, #pkcs5_keyivgen]
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, 1).
@overload encrypt
@return [self];T; 0; @;!F;"o;#;$T;%i;&i ;'@t;(I"~static VALUE
ossl_cipher_encrypt(int argc, VALUE *argv, VALUE self)
{
return ossl_cipher_init(argc, argv, self, 1);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#decrypt;F;[[@c0;[[@FTi;T;: decrypt;0;[ ;{ ;IC; "Initializes the Cipher for decryption.
Make sure to call Cipher#encrypt or Cipher#decrypt before using any of the
following methods:
* [#key=, #iv=, #random_key, #random_iv, #pkcs5_keyivgen]
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, 0).
;T;[o;=
;3I"
overload;F;40;;;50;)I" decrypt;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @ ; [ ; I"@return [self];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I")Initializes the Cipher for decryption.
Make sure to call Cipher#encrypt or Cipher#decrypt before using any of the
following methods:
* [#key=, #iv=, #random_key, #random_iv, #pkcs5_keyivgen]
Internally calls EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, 0).
@overload decrypt
@return [self];T; 0; @ ;!F;"o;#;$T;%i;&i;'@t;(I"~static VALUE
ossl_cipher_decrypt(int argc, VALUE *argv, VALUE self)
{
return ossl_cipher_init(argc, argv, self, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::Cipher#pkcs5_keyivgen;F;[[@c0;[[@FTi.;T;:pkcs5_keyivgen;0;[ ;{ ;IC; "CGenerates and sets the key/IV based on a password.
*WARNING*: This method is only PKCS5 v1.5 compliant when using RC2, RC4-40,
or DES with MD5 or SHA1. Using anything else (like AES) will generate the
key/iv using an OpenSSL specific method. This method is deprecated and
should no longer be used. Use a PKCS5 v2 key generation method from
OpenSSL::PKCS5 instead.
=== Parameters
* _salt_ must be an 8 byte string if provided.
* _iterations_ is an integer with a default of 2048.
* _digest_ is a Digest object that defaults to 'MD5'
A minimum of 1000 iterations is recommended.
;T;[o;=
;3I"
overload;F;40;;;50;)I"Hpkcs5_keyivgen(pass, salt = nil, iterations = 2048, digest = "MD5");T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @'; [ ; I"@return [nil];T; 0; @';!F;6i ;>0;[ [I" pass;T0[I" salt;TI"nil;T[I"iterations;TI" 2048;T[I" digest;TI"
"MD5";T; @'; [ ; I"Generates and sets the key/IV based on a password.
*WARNING*: This method is only PKCS5 v1.5 compliant when using RC2, RC4-40,
or DES with MD5 or SHA1. Using anything else (like AES) will generate the
key/iv using an OpenSSL specific method. This method is deprecated and
should no longer be used. Use a PKCS5 v2 key generation method from
OpenSSL::PKCS5 instead.
=== Parameters
* _salt_ must be an 8 byte string if provided.
* _iterations_ is an integer with a default of 2048.
* _digest_ is a Digest object that defaults to 'MD5'
A minimum of 1000 iterations is recommended.
@overload pkcs5_keyivgen(pass, salt = nil, iterations = 2048, digest = "MD5")
@return [nil];T; 0; @';!F;"o;#;$T;%i;&i,;'@t;(I"static VALUE
ossl_cipher_pkcs5_keyivgen(int argc, VALUE *argv, VALUE self)
{
EVP_CIPHER_CTX *ctx;
const EVP_MD *digest;
VALUE vpass, vsalt, viter, vdigest;
unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH], *salt = NULL;
int iter;
rb_scan_args(argc, argv, "13", &vpass, &vsalt, &viter, &vdigest);
StringValue(vpass);
if(!NIL_P(vsalt)){
StringValue(vsalt);
if(RSTRING_LEN(vsalt) != PKCS5_SALT_LEN)
ossl_raise(eCipherError, "salt must be an 8-octet string");
salt = (unsigned char *)RSTRING_PTR(vsalt);
}
iter = NIL_P(viter) ? 2048 : NUM2INT(viter);
if (iter <= 0)
rb_raise(rb_eArgError, "iterations must be a positive integer");
digest = NIL_P(vdigest) ? EVP_md5() : ossl_evp_get_digestbyname(vdigest);
GetCipher(self, ctx);
EVP_BytesToKey(EVP_CIPHER_CTX_cipher(ctx), digest, salt,
(unsigned char *)RSTRING_PTR(vpass), RSTRING_LENINT(vpass), iter, key, iv);
if (EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, -1) != 1)
ossl_raise(eCipherError, NULL);
OPENSSL_cleanse(key, sizeof key);
OPENSSL_cleanse(iv, sizeof iv);
rb_ivar_set(self, id_key_set, Qtrue);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#update;F;[[@c0;[[@FTiu;T;;8;0;[ ;{ ;IC; "^Encrypts data in a streaming fashion. Hand consecutive blocks of data
to the #update method in order to encrypt it. Returns the encrypted
data chunk. When done, the output of Cipher#final should be additionally
added to the result.
If _buffer_ is given, the encryption/decryption result will be written to
it. _buffer_ will be resized automatically.
;T;[o;=
;3I"
overload;F;40;;8;50;)I" update(data [, buffer]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @N; [ ; I"@return [String];T; 0; @N;!F;6i ;>0;[[I"data[, buffer];T0; @N; [ ; I"Encrypts data in a streaming fashion. Hand consecutive blocks of data
to the #update method in order to encrypt it. Returns the encrypted
data chunk. When done, the output of Cipher#final should be additionally
added to the result.
If _buffer_ is given, the encryption/decryption result will be written to
it. _buffer_ will be resized automatically.
@overload update(data [, buffer])
@return [String];T; 0; @N;!F;"o;#;$T;%ii;&is;'@t;(I"static VALUE
ossl_cipher_update(int argc, VALUE *argv, VALUE self)
{
EVP_CIPHER_CTX *ctx;
unsigned char *in;
long in_len, out_len;
VALUE data, str;
rb_scan_args(argc, argv, "11", &data, &str);
if (!RTEST(rb_attr_get(self, id_key_set)))
ossl_raise(eCipherError, "key not set");
StringValue(data);
in = (unsigned char *)RSTRING_PTR(data);
if ((in_len = RSTRING_LEN(data)) == 0)
ossl_raise(rb_eArgError, "data must not be empty");
GetCipher(self, ctx);
out_len = in_len+EVP_CIPHER_CTX_block_size(ctx);
if (out_len <= 0) {
ossl_raise(rb_eRangeError,
"data too big to make output buffer: %ld bytes", in_len);
}
if (NIL_P(str)) {
str = rb_str_new(0, out_len);
} else {
StringValue(str);
rb_str_resize(str, out_len);
}
if (!ossl_cipher_update_long(ctx, (unsigned char *)RSTRING_PTR(str), &out_len, in, in_len))
ossl_raise(eCipherError, NULL);
assert(out_len < RSTRING_LEN(str));
rb_str_set_len(str, out_len);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#final;F;[ ;[[@FTi;T;:
final;0;[ ;{ ;IC; "Returns the remaining data held in the cipher object. Further calls to
Cipher#update or Cipher#final will return garbage. This call should always
be made as the last call of an encryption or decryption operation, after
having fed the entire plaintext or ciphertext to the Cipher instance.
If an authenticated cipher was used, a CipherError is raised if the tag
could not be authenticated successfully. Only call this method after
setting the authentication tag and passing the entire contents of the
ciphertext into the cipher.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
final;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @l; [ ; I"@return [String];T; 0; @l;!F;6i ;>0;[ ; @l; [ ; I"5Returns the remaining data held in the cipher object. Further calls to
Cipher#update or Cipher#final will return garbage. This call should always
be made as the last call of an encryption or decryption operation, after
having fed the entire plaintext or ciphertext to the Cipher instance.
If an authenticated cipher was used, a CipherError is raised if the tag
could not be authenticated successfully. Only call this method after
setting the authentication tag and passing the entire contents of the
ciphertext into the cipher.
@overload final
@return [String];T; 0; @l;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_final(VALUE self)
{
EVP_CIPHER_CTX *ctx;
int out_len;
VALUE str;
GetCipher(self, ctx);
str = rb_str_new(0, EVP_CIPHER_CTX_block_size(ctx));
if (!EVP_CipherFinal_ex(ctx, (unsigned char *)RSTRING_PTR(str), &out_len))
ossl_raise(eCipherError, NULL);
assert(out_len <= RSTRING_LEN(str));
rb_str_set_len(str, out_len);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#name;F;[ ;[[@FTi;T;;;0;[ ;{ ;IC; "^Returns the name of the cipher which may differ slightly from the original
name provided.
;T;[o;=
;3I"
overload;F;40;;;50;)I" name;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"}Returns the name of the cipher which may differ slightly from the original
name provided.
@overload name
@return [String];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_name(VALUE self)
{
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
return rb_str_new2(EVP_CIPHER_name(EVP_CIPHER_CTX_cipher(ctx)));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#key=;F;[[I"key;T0;[[@FTi;T;: key=;0;[ ;{ ;IC; "[Sets the cipher key. To generate a key, you should either use a secure
random byte string or, if the key is to be derived from a password, you
should rely on PBKDF2 functionality provided by OpenSSL::PKCS5. To
generate a secure random-based key, Cipher#random_key may be used.
Only call this method after calling Cipher#encrypt or Cipher#decrypt.
;T;[o;=
;3I"
overload;F;40;;;50;)I"key=(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"Sets the cipher key. To generate a key, you should either use a secure
random byte string or, if the key is to be derived from a password, you
should rely on PBKDF2 functionality provided by OpenSSL::PKCS5. To
generate a secure random-based key, Cipher#random_key may be used.
Only call this method after calling Cipher#encrypt or Cipher#decrypt.
@overload key=(string)
@return [String];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_set_key(VALUE self, VALUE key)
{
EVP_CIPHER_CTX *ctx;
int key_len;
StringValue(key);
GetCipher(self, ctx);
key_len = EVP_CIPHER_CTX_key_length(ctx);
if (RSTRING_LEN(key) != key_len)
ossl_raise(rb_eArgError, "key must be %d bytes", key_len);
if (EVP_CipherInit_ex(ctx, NULL, NULL, (unsigned char *)RSTRING_PTR(key), NULL, -1) != 1)
ossl_raise(eCipherError, NULL);
rb_ivar_set(self, id_key_set, Qtrue);
return key;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#auth_data=;F;[[I" data;T0;[[@FTi1;T;:auth_data=;0;[ ;{ ;IC; "Sets the cipher's additional authenticated data. This field must be
set when using AEAD cipher modes such as GCM or CCM. If no associated
data shall be used, this method must *still* be called with a value of "".
The contents of this field should be non-sensitive data which will be
added to the ciphertext to generate the authentication tag which validates
the contents of the ciphertext.
The AAD must be set prior to encryption or decryption. In encryption mode,
it must be set after calling Cipher#encrypt and setting Cipher#key= and
Cipher#iv=. When decrypting, the authenticated data must be set after key,
iv and especially *after* the authentication tag has been set. I.e. set it
only after calling Cipher#decrypt, Cipher#key=, Cipher#iv= and
Cipher#auth_tag= first.
;T;[o;=
;3I"
overload;F;40;;;50;)I"auth_data=(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"8Sets the cipher's additional authenticated data. This field must be
set when using AEAD cipher modes such as GCM or CCM. If no associated
data shall be used, this method must *still* be called with a value of "".
The contents of this field should be non-sensitive data which will be
added to the ciphertext to generate the authentication tag which validates
the contents of the ciphertext.
The AAD must be set prior to encryption or decryption. In encryption mode,
it must be set after calling Cipher#encrypt and setting Cipher#key= and
Cipher#iv=. When decrypting, the authenticated data must be set after key,
iv and especially *after* the authentication tag has been set. I.e. set it
only after calling Cipher#decrypt, Cipher#key=, Cipher#iv= and
Cipher#auth_tag= first.
@overload auth_data=(string)
@return [String];T; 0; @;!F;"o;#;$T;%i ;&i/;'@t;(I"Istatic VALUE
ossl_cipher_set_auth_data(VALUE self, VALUE data)
{
EVP_CIPHER_CTX *ctx;
unsigned char *in;
long in_len, out_len;
StringValue(data);
in = (unsigned char *) RSTRING_PTR(data);
in_len = RSTRING_LEN(data);
GetCipher(self, ctx);
if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER))
ossl_raise(eCipherError, "AEAD not supported by this cipher");
if (!ossl_cipher_update_long(ctx, NULL, &out_len, in, in_len))
ossl_raise(eCipherError, "couldn't set additional authenticated data");
return data;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#auth_tag=;F;[[I" vtag;T0;[[@FTi|;T;:auth_tag=;0;[ ;{ ;IC; "Sets the authentication tag to verify the integrity of the ciphertext.
This can be called only when the cipher supports AE. The tag must be set
after calling Cipher#decrypt, Cipher#key= and Cipher#iv=, but before
calling Cipher#final. After all decryption is performed, the tag is
verified automatically in the call to Cipher#final.
For OCB mode, the tag length must be supplied with #auth_tag_len=
beforehand.
;T;[o;=
;3I"
overload;F;40;;;50;)I"auth_tag=(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"Sets the authentication tag to verify the integrity of the ciphertext.
This can be called only when the cipher supports AE. The tag must be set
after calling Cipher#decrypt, Cipher#key= and Cipher#iv=, but before
calling Cipher#final. After all decryption is performed, the tag is
verified automatically in the call to Cipher#final.
For OCB mode, the tag length must be supplied with #auth_tag_len=
beforehand.
@overload auth_tag=(string)
@return [String];T; 0; @;!F;"o;#;$T;%io;&iz;'@t;(I"<static VALUE
ossl_cipher_set_auth_tag(VALUE self, VALUE vtag)
{
EVP_CIPHER_CTX *ctx;
unsigned char *tag;
int tag_len;
StringValue(vtag);
tag = (unsigned char *) RSTRING_PTR(vtag);
tag_len = RSTRING_LENINT(vtag);
GetCipher(self, ctx);
if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER))
ossl_raise(eCipherError, "authentication tag not supported by this cipher");
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len, tag))
ossl_raise(eCipherError, "unable to set AEAD tag");
return vtag;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#auth_tag;F;[[@c0;[[@FTiV;T;:
auth_tag;0;[ ;{ ;IC; "KGets the authentication tag generated by Authenticated Encryption Cipher
modes (GCM for example). This tag may be stored along with the ciphertext,
then set on the decryption cipher to authenticate the contents of the
ciphertext against changes. If the optional integer parameter _tag_len_ is
given, the returned tag will be _tag_len_ bytes long. If the parameter is
omitted, the default length of 16 bytes or the length previously set by
#auth_tag_len= will be used. For maximum security, the longest possible
should be chosen.
The tag may only be retrieved after calling Cipher#final.
;T;[o;=
;3I"
overload;F;40;;;50;)I"auth_tag(tag_len = 16);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" tag_len;TI"16;T; @; [ ; I"Gets the authentication tag generated by Authenticated Encryption Cipher
modes (GCM for example). This tag may be stored along with the ciphertext,
then set on the decryption cipher to authenticate the contents of the
ciphertext against changes. If the optional integer parameter _tag_len_ is
given, the returned tag will be _tag_len_ bytes long. If the parameter is
omitted, the default length of 16 bytes or the length previously set by
#auth_tag_len= will be used. For maximum security, the longest possible
should be chosen.
The tag may only be retrieved after calling Cipher#final.
@overload auth_tag(tag_len = 16)
@return [String];T; 0; @;!F;"o;#;$T;%iG;&iT;'@t;(I"static VALUE
ossl_cipher_get_auth_tag(int argc, VALUE *argv, VALUE self)
{
VALUE vtag_len, ret;
EVP_CIPHER_CTX *ctx;
int tag_len = 16;
rb_scan_args(argc, argv, "01", &vtag_len);
if (NIL_P(vtag_len))
vtag_len = rb_attr_get(self, id_auth_tag_len);
if (!NIL_P(vtag_len))
tag_len = NUM2INT(vtag_len);
GetCipher(self, ctx);
if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER))
ossl_raise(eCipherError, "authentication tag not supported by this cipher");
ret = rb_str_new(NULL, tag_len);
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, tag_len, RSTRING_PTR(ret)))
ossl_raise(eCipherError, "retrieving the authentication tag failed");
return ret;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""OpenSSL::Cipher#auth_tag_len=;F;[[I" vlen;T0;[[@FTi;T;:auth_tag_len=;0;[ ;{ ;IC; ".Sets the length of the authentication tag to be generated or to be given for
AEAD ciphers that requires it as in input parameter. Note that not all AEAD
ciphers support this method.
In OCB mode, the length must be supplied both when encrypting and when
decrypting, and must be before specifying an IV.
;T;[o;=
;3I"
overload;F;40;;;50;)I"auth_tag_len=(Integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ ; [ ; I"@return [Integer];T; 0; @ ;!F;6i ;>0;[[I" Integer;T0; @ ; [ ; I"eSets the length of the authentication tag to be generated or to be given for
AEAD ciphers that requires it as in input parameter. Note that not all AEAD
ciphers support this method.
In OCB mode, the length must be supplied both when encrypting and when
decrypting, and must be before specifying an IV.
@overload auth_tag_len=(Integer)
@return [Integer];T; 0; @ ;!F;"o;#;$T;%i;&i;'@t;(I"$static VALUE
ossl_cipher_set_auth_tag_len(VALUE self, VALUE vlen)
{
int tag_len = NUM2INT(vlen);
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER))
ossl_raise(eCipherError, "AEAD not supported by this cipher");
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len, NULL))
ossl_raise(eCipherError, "unable to set authentication tag length");
/* for #auth_tag */
rb_ivar_set(self, id_auth_tag_len, INT2NUM(tag_len));
return vlen;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::Cipher#authenticated?;F;[ ;[[@FTi;T;:authenticated?;0;[ ;{ ;IC; "RIndicated whether this Cipher instance uses an Authenticated Encryption
mode.;T;[o;=
;3I"
overload;F;40;;;50;)I"authenticated?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @=;!F;6i ;>0;[ ; @=o;2
;3I" return;F;4@|;0;5[@~; @=; [ ; I"mIndicated whether this Cipher instance uses an Authenticated Encryption
mode.
@overload authenticated?;T; 0; @=;!F;"o;#;$T;%i;&i;6i ;'@t;(I"static VALUE
ossl_cipher_is_authenticated(VALUE self)
{
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
return (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#key_len=;F;[[I"key_length;T0;[[@FTi;T;:
key_len=;0;[ ;{ ;IC; ";Sets the key length of the cipher. If the cipher is a fixed length cipher
then attempting to set the key length to any value other than the fixed
value is an error.
Under normal circumstances you do not need to call this method (and probably shouldn't).
See EVP_CIPHER_CTX_set_key_length for further information.
;T;[o;=
;3I"
overload;F;40;;;50;)I"key_len=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @V; [ ; I"@return [Integer];T; 0; @V;!F;6i ;>0;[[I" integer;T0; @V; [ ; I"mSets the key length of the cipher. If the cipher is a fixed length cipher
then attempting to set the key length to any value other than the fixed
value is an error.
Under normal circumstances you do not need to call this method (and probably shouldn't).
See EVP_CIPHER_CTX_set_key_length for further information.
@overload key_len=(integer)
@return [Integer];T; 0; @V;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_set_key_length(VALUE self, VALUE key_length)
{
int len = NUM2INT(key_length);
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
if (EVP_CIPHER_CTX_set_key_length(ctx, len) != 1)
ossl_raise(eCipherError, NULL);
return key_length;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#key_len;F;[ ;[[@FTi;T;: key_len;0;[ ;{ ;IC; "3Returns the key length in bytes of the Cipher.
;T;[o;=
;3I"
overload;F;40;;;50;)I" key_len;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @u; [ ; I"@return [Integer];T; 0; @u;!F;6i ;>0;[ ; @u; [ ; I"[Returns the key length in bytes of the Cipher.
@overload key_len
@return [Integer];T; 0; @u;!F;"o;#;$T;%i;&i ;'@t;(I"static VALUE
ossl_cipher_key_length(VALUE self)
{
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
return INT2NUM(EVP_CIPHER_CTX_key_length(ctx));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#iv=;F;[[I"iv;T0;[[@FTi;T;:iv=;0;[ ;{ ;IC; "Sets the cipher IV. Please note that since you should never be using ECB
mode, an IV is always explicitly required and should be set prior to
encryption. The IV itself can be safely transmitted in public, but it
should be unpredictable to prevent certain kinds of attacks. You may use
Cipher#random_iv to create a secure random IV.
Only call this method after calling Cipher#encrypt or Cipher#decrypt.
;T;[o;=
;3I"
overload;F;40;;;50;)I"iv=(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"Sets the cipher IV. Please note that since you should never be using ECB
mode, an IV is always explicitly required and should be set prior to
encryption. The IV itself can be safely transmitted in public, but it
should be unpredictable to prevent certain kinds of attacks. You may use
Cipher#random_iv to create a secure random IV.
Only call this method after calling Cipher#encrypt or Cipher#decrypt.
@overload iv=(string)
@return [String];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"Gstatic VALUE
ossl_cipher_set_iv(VALUE self, VALUE iv)
{
EVP_CIPHER_CTX *ctx;
int iv_len = 0;
StringValue(iv);
GetCipher(self, ctx);
if (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER)
iv_len = (int)(VALUE)EVP_CIPHER_CTX_get_app_data(ctx);
if (!iv_len)
iv_len = EVP_CIPHER_CTX_iv_length(ctx);
if (RSTRING_LEN(iv) != iv_len)
ossl_raise(rb_eArgError, "iv must be %d bytes", iv_len);
if (EVP_CipherInit_ex(ctx, NULL, NULL, NULL, (unsigned char *)RSTRING_PTR(iv), -1) != 1)
ossl_raise(eCipherError, NULL);
return iv;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#iv_len=;F;[[I"iv_length;T0;[[@FTi;T;: iv_len=;0;[ ;{ ;IC; "Sets the IV/nonce length of the Cipher. Normally block ciphers don't allow
changing the IV length, but some make use of IV for 'nonce'. You may need
this for interoperability with other applications.
;T;[o;=
;3I"
overload;F;40;;;50;)I"iv_len=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I" integer;T0; @; [ ; I"Sets the IV/nonce length of the Cipher. Normally block ciphers don't allow
changing the IV length, but some make use of IV for 'nonce'. You may need
this for interoperability with other applications.
@overload iv_len=(integer)
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_set_iv_length(VALUE self, VALUE iv_length)
{
int len = NUM2INT(iv_length);
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER))
ossl_raise(eCipherError, "cipher does not support AEAD");
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, len, NULL))
ossl_raise(eCipherError, "unable to set IV length");
/*
* EVP_CIPHER_CTX_iv_length() returns the default length. So we need to save
* the length somewhere. Luckily currently we aren't using app_data.
*/
EVP_CIPHER_CTX_set_app_data(ctx, (void *)(VALUE)len);
return iv_length;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"OpenSSL::Cipher#iv_len;F;[ ;[[@FTi;T;: iv_len;0;[ ;{ ;IC; "DReturns the expected length in bytes for an IV for this Cipher.
;T;[o;=
;3I"
overload;F;40;;;50;)I" iv_len;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @Σ; [ ; I"@return [Integer];T; 0; @Σ;!F;6i ;>0;[ ; @Σ; [ ; I"kReturns the expected length in bytes for an IV for this Cipher.
@overload iv_len
@return [Integer];T; 0; @Σ;!F;"o;#;$T;%i ;&i;'@t;(I"Lstatic VALUE
ossl_cipher_iv_length(VALUE self)
{
EVP_CIPHER_CTX *ctx;
int len = 0;
GetCipher(self, ctx);
if (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ctx)) & EVP_CIPH_FLAG_AEAD_CIPHER)
len = (int)(VALUE)EVP_CIPHER_CTX_get_app_data(ctx);
if (!len)
len = EVP_CIPHER_CTX_iv_length(ctx);
return INT2NUM(len);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#block_size;F;[ ;[[@FTi';T;:block_size;0;[ ;{ ;IC; "NReturns the size in bytes of the blocks on which this Cipher operates on.
;T;[o;=
;3I"
overload;F;40;;;50;)I"block_size;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"yReturns the size in bytes of the blocks on which this Cipher operates on.
@overload block_size
@return [Integer];T; 0; @;!F;"o;#;$T;%i!;&i%;'@t;(I"static VALUE
ossl_cipher_block_size(VALUE self)
{
EVP_CIPHER_CTX *ctx;
GetCipher(self, ctx);
return INT2NUM(EVP_CIPHER_CTX_block_size(ctx));
};T;)I"static VALUE;T;*To; ; F;
;;;;I" OpenSSL::Cipher#padding=;F;[[I" padding;T0;[[@FTi;T;:
padding=;0;[ ;{ ;IC; "Enables or disables padding. By default encryption operations are padded using standard block padding and the
padding is checked and removed when decrypting. If the pad parameter is zero then no padding is performed, the
total amount of data encrypted or decrypted must then be a multiple of the block size or an error will occur.
See EVP_CIPHER_CTX_set_padding for further information.
;T;[o;=
;3I"
overload;F;40;;;50;)I"padding=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I" integer;T0; @; [ ; I"Enables or disables padding. By default encryption operations are padded using standard block padding and the
padding is checked and removed when decrypting. If the pad parameter is zero then no padding is performed, the
total amount of data encrypted or decrypted must then be a multiple of the block size or an error will occur.
See EVP_CIPHER_CTX_set_padding for further information.
@overload padding=(integer)
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
ossl_cipher_set_padding(VALUE self, VALUE padding)
{
EVP_CIPHER_CTX *ctx;
int pad = NUM2INT(padding);
GetCipher(self, ctx);
if (EVP_CIPHER_CTX_set_padding(ctx, pad) != 1)
ossl_raise(eCipherError, NULL);
return padding;
};T;)I"static VALUE;T;*T;A@t;BIC;[ ;A@t;CIC;[ ;A@t;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@FTi<[@FTi ;T;: Cipher;;K;;;[ ;{ ;IC; " Provides symmetric algorithms for encryption and decryption. The
algorithms that are available depend on the particular version
of OpenSSL that is installed.
=== Listing all supported algorithms
A list of supported algorithms can be obtained by
puts OpenSSL::Cipher.ciphers
=== Instantiating a Cipher
There are several ways to create a Cipher instance. Generally, a
Cipher algorithm is categorized by its name, the key length in bits
and the cipher mode to be used. The most generic way to create a
Cipher is the following
cipher = OpenSSL::Cipher.new('--')
That is, a string consisting of the hyphenated concatenation of the
individual components name, key length and mode. Either all uppercase
or all lowercase strings may be used, for example:
cipher = OpenSSL::Cipher.new('AES-128-CBC')
For each algorithm supported, there is a class defined under the
Cipher class that goes by the name of the cipher, e.g. to obtain an
instance of AES, you could also use
# these are equivalent
cipher = OpenSSL::Cipher::AES.new(128, :CBC)
cipher = OpenSSL::Cipher::AES.new(128, 'CBC')
cipher = OpenSSL::Cipher::AES.new('128-CBC')
Finally, due to its wide-spread use, there are also extra classes
defined for the different key sizes of AES
cipher = OpenSSL::Cipher::AES128.new(:CBC)
cipher = OpenSSL::Cipher::AES192.new(:CBC)
cipher = OpenSSL::Cipher::AES256.new(:CBC)
=== Choosing either encryption or decryption mode
Encryption and decryption are often very similar operations for
symmetric algorithms, this is reflected by not having to choose
different classes for either operation, both can be done using the
same class. Still, after obtaining a Cipher instance, we need to
tell the instance what it is that we intend to do with it, so we
need to call either
cipher.encrypt
or
cipher.decrypt
on the Cipher instance. This should be the first call after creating
the instance, otherwise configuration that has already been set could
get lost in the process.
=== Choosing a key
Symmetric encryption requires a key that is the same for the encrypting
and for the decrypting party and after initial key establishment should
be kept as private information. There are a lot of ways to create
insecure keys, the most notable is to simply take a password as the key
without processing the password further. A simple and secure way to
create a key for a particular Cipher is
cipher = OpenSSL::AES256.new(:CFB)
cipher.encrypt
key = cipher.random_key # also sets the generated key on the Cipher
If you absolutely need to use passwords as encryption keys, you
should use Password-Based Key Derivation Function 2 (PBKDF2) by
generating the key with the help of the functionality provided by
OpenSSL::PKCS5.pbkdf2_hmac_sha1 or OpenSSL::PKCS5.pbkdf2_hmac.
Although there is Cipher#pkcs5_keyivgen, its use is deprecated and
it should only be used in legacy applications because it does not use
the newer PKCS#5 v2 algorithms.
=== Choosing an IV
The cipher modes CBC, CFB, OFB and CTR all need an "initialization
vector", or short, IV. ECB mode is the only mode that does not require
an IV, but there is almost no legitimate use case for this mode
because of the fact that it does not sufficiently hide plaintext
patterns. Therefore
You should never use ECB mode unless you are absolutely sure that
you absolutely need it
Because of this, you will end up with a mode that explicitly requires
an IV in any case. Although the IV can be seen as public information,
i.e. it may be transmitted in public once generated, it should still
stay unpredictable to prevent certain kinds of attacks. Therefore,
ideally
Always create a secure random IV for every encryption of your
Cipher
A new, random IV should be created for every encryption of data. Think
of the IV as a nonce (number used once) - it's public but random and
unpredictable. A secure random IV can be created as follows
cipher = ...
cipher.encrypt
key = cipher.random_key
iv = cipher.random_iv # also sets the generated IV on the Cipher
Although the key is generally a random value, too, it is a bad choice
as an IV. There are elaborate ways how an attacker can take advantage
of such an IV. As a general rule of thumb, exposing the key directly
or indirectly should be avoided at all cost and exceptions only be
made with good reason.
=== Calling Cipher#final
ECB (which should not be used) and CBC are both block-based modes.
This means that unlike for the other streaming-based modes, they
operate on fixed-size blocks of data, and therefore they require a
"finalization" step to produce or correctly decrypt the last block of
data by appropriately handling some form of padding. Therefore it is
essential to add the output of OpenSSL::Cipher#final to your
encryption/decryption buffer or you will end up with decryption errors
or truncated data.
Although this is not really necessary for streaming-mode ciphers, it is
still recommended to apply the same pattern of adding the output of
Cipher#final there as well - it also enables you to switch between
modes more easily in the future.
=== Encrypting and decrypting some data
data = "Very, very confidential data"
cipher = OpenSSL::Cipher::AES.new(128, :CBC)
cipher.encrypt
key = cipher.random_key
iv = cipher.random_iv
encrypted = cipher.update(data) + cipher.final
...
decipher = OpenSSL::Cipher::AES.new(128, :CBC)
decipher.decrypt
decipher.key = key
decipher.iv = iv
plain = decipher.update(encrypted) + decipher.final
puts data == plain #=> true
=== Authenticated Encryption and Associated Data (AEAD)
If the OpenSSL version used supports it, an Authenticated Encryption
mode (such as GCM or CCM) should always be preferred over any
unauthenticated mode. Currently, OpenSSL supports AE only in combination
with Associated Data (AEAD) where additional associated data is included
in the encryption process to compute a tag at the end of the encryption.
This tag will also be used in the decryption process and by verifying
its validity, the authenticity of a given ciphertext is established.
This is superior to unauthenticated modes in that it allows to detect
if somebody effectively changed the ciphertext after it had been
encrypted. This prevents malicious modifications of the ciphertext that
could otherwise be exploited to modify ciphertexts in ways beneficial to
potential attackers.
An associated data is used where there is additional information, such as
headers or some metadata, that must be also authenticated but not
necessarily need to be encrypted. If no associated data is needed for
encryption and later decryption, the OpenSSL library still requires a
value to be set - "" may be used in case none is available.
An example using the GCM (Galois/Counter Mode). You have 16 bytes _key_,
12 bytes (96 bits) _nonce_ and the associated data _auth_data_. Be sure
not to reuse the _key_ and _nonce_ pair. Reusing an nonce ruins the
security guarantees of GCM mode.
cipher = OpenSSL::Cipher::AES.new(128, :GCM).encrypt
cipher.key = key
cipher.iv = nonce
cipher.auth_data = auth_data
encrypted = cipher.update(data) + cipher.final
tag = cipher.auth_tag # produces 16 bytes tag by default
Now you are the receiver. You know the _key_ and have received _nonce_,
_auth_data_, _encrypted_ and _tag_ through an untrusted network. Note
that GCM accepts an arbitrary length tag between 1 and 16 bytes. You may
additionally need to check that the received tag has the correct length,
or you allow attackers to forge a valid single byte tag for the tampered
ciphertext with a probability of 1/256.
raise "tag is truncated!" unless tag.bytesize == 16
decipher = OpenSSL::Cipher::AES.new(128, :GCM).decrypt
decipher.key = key
decipher.iv = nonce
decipher.auth_tag = tag
decipher.auth_data = auth_data
decrypted = decipher.update(encrypted) + decipher.final
puts data == decrypted #=> true
;T;[ ; [ ; I"
Provides symmetric algorithms for encryption and decryption. The
algorithms that are available depend on the particular version
of OpenSSL that is installed.
=== Listing all supported algorithms
A list of supported algorithms can be obtained by
puts OpenSSL::Cipher.ciphers
=== Instantiating a Cipher
There are several ways to create a Cipher instance. Generally, a
Cipher algorithm is categorized by its name, the key length in bits
and the cipher mode to be used. The most generic way to create a
Cipher is the following
cipher = OpenSSL::Cipher.new('- File::WRONLY|File::CREAT).
See the open(2) man page for more information.
When +mode+ is a string it must be in one of the following forms:
fmode
fmode ":" ext_enc
fmode ":" ext_enc ":" int_enc
fmode ":" "BOM|UTF-*"
+fmode+ is an IO open mode string, +ext_enc+ is the external encoding for
the IO and +int_enc+ is the internal encoding.
==== IO Open Mode
Ruby allows the following open modes:
"r" Read-only, starts at beginning of file (default mode).
"r+" Read-write, starts at beginning of file.
"w" Write-only, truncates existing file
to zero length or creates a new file for writing.
"w+" Read-write, truncates existing file to zero length
or creates a new file for reading and writing.
"a" Write-only, each write call appends data at end of file.
Creates a new file for writing if file does not exist.
"a+" Read-write, each write call appends data at end of file.
Creates a new file for reading and writing if file does
not exist.
The following modes must be used separately, and along with one or more of
the modes seen above.
"b" Binary file mode
Suppresses EOL <-> CRLF conversion on Windows. And
sets external encoding to ASCII-8BIT unless explicitly
specified.
"t" Text file mode
The exclusive access mode ("x") can be used together with "w" to ensure
the file is created. Errno::EEXIST is raised when it already exists.
It may not be supported with all kinds of streams (e.g. pipes).
When the open mode of original IO is read only, the mode cannot be
changed to be writable. Similarly, the open mode cannot be changed from
write only to readable.
When such a change is attempted the error is raised in different locations
according to the platform.
=== IO Encoding
When +ext_enc+ is specified, strings read will be tagged by the encoding
when reading, and strings output will be converted to the specified
encoding when writing.
When +ext_enc+ and +int_enc+ are specified read strings will be converted
from +ext_enc+ to +int_enc+ upon input, and written strings will be
converted from +int_enc+ to +ext_enc+ upon output. See Encoding for
further details of transcoding on input and output.
If "BOM|UTF-8", "BOM|UTF-16LE" or "BOM|UTF16-BE" are used, Ruby checks for
a Unicode BOM in the input document to help determine the encoding. For
UTF-16 encodings the file open mode must be binary. When present, the BOM
is stripped and the external encoding from the BOM is used. When the BOM
is missing the given Unicode encoding is used as +ext_enc+. (The BOM-set
encoding option is case insensitive, so "bom|utf-8" is also valid.)
=== Options
+opt+ can be used instead of +mode+ for improved readability. The
following keys are supported:
:mode ::
Same as +mode+ parameter
:flags ::
Specifies file open flags as integer.
If +mode+ parameter is given, this parameter will be bitwise-ORed.
:\external_encoding ::
External encoding for the IO.
:\internal_encoding ::
Internal encoding for the IO. "-" is a synonym for the default internal
encoding.
If the value is +nil+ no conversion occurs.
:encoding ::
Specifies external and internal encodings as "extern:intern".
:textmode ::
If the value is truth value, same as "t" in argument +mode+.
:binmode ::
If the value is truth value, same as "b" in argument +mode+.
:autoclose ::
If the value is +false+, the +fd+ will be kept open after this IO
instance gets finalized.
Also, +opt+ can have same keys in String#encode for controlling conversion
between the external encoding and the internal encoding.
=== Example 1
fd = IO.sysopen("/dev/tty", "w")
a = IO.new(fd,"w")
$stderr.puts "Hello"
a.puts "World"
Produces:
Hello
World
=== Example 2
require 'fcntl'
fd = STDERR.fcntl(Fcntl::F_DUPFD)
io = IO.new(fd, mode: 'w:UTF-16LE', cr_newline: true)
io.puts "Hello, World!"
fd = STDERR.fcntl(Fcntl::F_DUPFD)
io = IO.new(fd, mode: 'w', cr_newline: true,
external_encoding: Encoding::UTF_16LE)
io.puts "Hello, World!"
Both of above print "Hello, World!" in UTF-16LE to standard error output
with converting EOL generated by #puts to CR.
;T;[o;=
;3I"
overload;F;40;;;50;)I" new(fd [, mode] [, opt]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @x; [ ; I"@return [IO];T; 0; @x;!F;6i ;>0;[[I"fd[, mode][, opt];T0; @x; [ ; I"3Returns a new IO object (a stream) for the given integer file descriptor
+fd+ and +mode+ string. +opt+ may be used to specify parts of +mode+ in a
more readable fashion. See also IO.sysopen and IO.for_fd.
IO.new is called by various File and IO opening methods such as IO::open,
Kernel#open, and File::open.
=== Open Mode
When +mode+ is an integer it must be combination of the modes defined in
File::Constants (+File::RDONLY+, File::WRONLY|File::CREAT).
See the open(2) man page for more information.
When +mode+ is a string it must be in one of the following forms:
fmode
fmode ":" ext_enc
fmode ":" ext_enc ":" int_enc
fmode ":" "BOM|UTF-*"
+fmode+ is an IO open mode string, +ext_enc+ is the external encoding for
the IO and +int_enc+ is the internal encoding.
==== IO Open Mode
Ruby allows the following open modes:
"r" Read-only, starts at beginning of file (default mode).
"r+" Read-write, starts at beginning of file.
"w" Write-only, truncates existing file
to zero length or creates a new file for writing.
"w+" Read-write, truncates existing file to zero length
or creates a new file for reading and writing.
"a" Write-only, each write call appends data at end of file.
Creates a new file for writing if file does not exist.
"a+" Read-write, each write call appends data at end of file.
Creates a new file for reading and writing if file does
not exist.
The following modes must be used separately, and along with one or more of
the modes seen above.
"b" Binary file mode
Suppresses EOL <-> CRLF conversion on Windows. And
sets external encoding to ASCII-8BIT unless explicitly
specified.
"t" Text file mode
The exclusive access mode ("x") can be used together with "w" to ensure
the file is created. Errno::EEXIST is raised when it already exists.
It may not be supported with all kinds of streams (e.g. pipes).
When the open mode of original IO is read only, the mode cannot be
changed to be writable. Similarly, the open mode cannot be changed from
write only to readable.
When such a change is attempted the error is raised in different locations
according to the platform.
=== IO Encoding
When +ext_enc+ is specified, strings read will be tagged by the encoding
when reading, and strings output will be converted to the specified
encoding when writing.
When +ext_enc+ and +int_enc+ are specified read strings will be converted
from +ext_enc+ to +int_enc+ upon input, and written strings will be
converted from +int_enc+ to +ext_enc+ upon output. See Encoding for
further details of transcoding on input and output.
If "BOM|UTF-8", "BOM|UTF-16LE" or "BOM|UTF16-BE" are used, Ruby checks for
a Unicode BOM in the input document to help determine the encoding. For
UTF-16 encodings the file open mode must be binary. When present, the BOM
is stripped and the external encoding from the BOM is used. When the BOM
is missing the given Unicode encoding is used as +ext_enc+. (The BOM-set
encoding option is case insensitive, so "bom|utf-8" is also valid.)
=== Options
+opt+ can be used instead of +mode+ for improved readability. The
following keys are supported:
:mode ::
Same as +mode+ parameter
:flags ::
Specifies file open flags as integer.
If +mode+ parameter is given, this parameter will be bitwise-ORed.
:\external_encoding ::
External encoding for the IO.
:\internal_encoding ::
Internal encoding for the IO. "-" is a synonym for the default internal
encoding.
If the value is +nil+ no conversion occurs.
:encoding ::
Specifies external and internal encodings as "extern:intern".
:textmode ::
If the value is truth value, same as "t" in argument +mode+.
:binmode ::
If the value is truth value, same as "b" in argument +mode+.
:autoclose ::
If the value is +false+, the +fd+ will be kept open after this IO
instance gets finalized.
Also, +opt+ can have same keys in String#encode for controlling conversion
between the external encoding and the internal encoding.
=== Example 1
fd = IO.sysopen("/dev/tty", "w")
a = IO.new(fd,"w")
$stderr.puts "Hello"
a.puts "World"
Produces:
Hello
World
=== Example 2
require 'fcntl'
fd = STDERR.fcntl(Fcntl::F_DUPFD)
io = IO.new(fd, mode: 'w:UTF-16LE', cr_newline: true)
io.puts "Hello, World!"
fd = STDERR.fcntl(Fcntl::F_DUPFD)
io = IO.new(fd, mode: 'w', cr_newline: true,
external_encoding: Encoding::UTF_16LE)
io.puts "Hello, World!"
Both of above print "Hello, World!" in UTF-16LE to standard error output
with converting EOL generated by #puts to CR.
@overload new(fd [, mode] [, opt])
@return [IO];T; 0; @x;!F;"o;#;$T;%i ;&i9 ;'@t;(I"static VALUE
rb_io_initialize(int argc, VALUE *argv, VALUE io)
{
VALUE fnum, vmode;
rb_io_t *fp;
int fd, fmode, oflags = O_RDONLY;
convconfig_t convconfig;
VALUE opt;
#if defined(HAVE_FCNTL) && defined(F_GETFL)
int ofmode;
#else
struct stat st;
#endif
argc = rb_scan_args(argc, argv, "11:", &fnum, &vmode, &opt);
rb_io_extract_modeenc(&vmode, 0, opt, &oflags, &fmode, &convconfig);
fd = NUM2INT(fnum);
if (rb_reserved_fd_p(fd)) {
rb_raise(rb_eArgError, "The given fd is not accessible because RubyVM reserves it");
}
#if defined(HAVE_FCNTL) && defined(F_GETFL)
oflags = fcntl(fd, F_GETFL);
if (oflags == -1) rb_sys_fail(0);
#else
if (fstat(fd, &st) < 0) rb_sys_fail(0);
#endif
rb_update_max_fd(fd);
#if defined(HAVE_FCNTL) && defined(F_GETFL)
ofmode = rb_io_oflags_fmode(oflags);
if (NIL_P(vmode)) {
fmode = ofmode;
}
else if ((~ofmode & fmode) & FMODE_READWRITE) {
VALUE error = INT2FIX(EINVAL);
rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
}
#endif
if (!NIL_P(opt) && rb_hash_aref(opt, sym_autoclose) == Qfalse) {
fmode |= FMODE_PREP;
}
MakeOpenFile(io, fp);
fp->fd = fd;
fp->mode = fmode;
fp->encs = convconfig;
clear_codeconv(fp);
io_check_tty(fp);
if (fileno(stdin) == fd)
fp->stdio_file = stdin;
else if (fileno(stdout) == fd)
fp->stdio_file = stdout;
else if (fileno(stderr) == fd)
fp->stdio_file = stderr;
if (fmode & FMODE_SETENC_BY_BOM) io_set_encoding_by_bom(io);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#initialize_copy;F;[[I"io;T0;[[@i" ;T;;j;0;[ ;{ ;IC; " :nodoc:
;T;[ ; [ ; I" :nodoc:;T; 0; @7x;!F;"o;#;$T;%i! ;&i! ;'@t;(I"static VALUE
rb_io_init_copy(VALUE dest, VALUE io)
{
rb_io_t *fptr, *orig;
int fd;
VALUE write_io;
off_t pos;
io = rb_io_get_io(io);
if (!OBJ_INIT_COPY(dest, io)) return dest;
GetOpenFile(io, orig);
MakeOpenFile(dest, fptr);
rb_io_flush(io);
/* copy rb_io_t structure */
fptr->mode = orig->mode & ~FMODE_PREP;
fptr->encs = orig->encs;
fptr->pid = orig->pid;
fptr->lineno = orig->lineno;
if (!NIL_P(orig->pathv)) fptr->pathv = orig->pathv;
fptr_copy_finalizer(fptr, orig);
fd = ruby_dup(orig->fd);
fptr->fd = fd;
pos = io_tell(orig);
if (0 <= pos)
io_seek(fptr, pos, SEEK_SET);
if (fptr->mode & FMODE_BINMODE) {
rb_io_binmode(dest);
}
write_io = GetWriteIO(io);
if (io != write_io) {
write_io = rb_obj_dup(write_io);
fptr->tied_io_for_writing = write_io;
rb_ivar_set(dest, rb_intern("@tied_io_for_writing"), write_io);
}
return dest;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#reopen;F;[[@c0;[[@i ;T;;~;0;[ ;{ ;IC; "Reassociates ios with the I/O stream given in
other_IO or to a new stream opened on path. This may
dynamically change the actual class of this stream.
The +mode+ and +opt+ parameters accept the same values as IO.open.
f1 = File.new("testfile")
f2 = File.new("testfile")
f2.readlines[0] #=> "This is line one\n"
f2.reopen(f1) #=> #to_s method.
When called without arguments, prints the contents of $_.
If the output field separator ($,) is not +nil+,
it is inserted between objects.
If the output record separator ($\\) is not +nil+,
it is appended to the output.
$stdout.print("This is ", 100, " percent.\n")
produces:
This is 100 percent.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
print;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @vx; [ ; I"@return [nil];T; 0; @vx;!F;6i ;>0;[ ; @vxo;=
;3I"
overload;F;40;;;50;)I"print(obj, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @vx; [ ; I"@return [nil];T; 0; @vx;!F;6i ;>0;[[I"obj;T0[I"...;T0; @vx; [ ; I"rWrites the given object(s) to ios. Returns +nil+.
The stream must be opened for writing.
Each given object that isn't a string will be converted by calling
its to_s method.
When called without arguments, prints the contents of $_.
If the output field separator ($,) is not +nil+,
it is inserted between objects.
If the output record separator ($\\) is not +nil+,
it is appended to the output.
$stdout.print("This is ", 100, " percent.\n")
produces:
This is 100 percent.
@overload print
@return [nil]
@overload print(obj, ...)
@return [nil];T; 0; @vx;!F;"o;#;$T;%i ;&i ;'@t;(I"VALUE
rb_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;
}
for (i=0; i$\\).
;T;[o;=
;3I"
overload;F;40;;;50;)I"puts(obj, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @x; [ ; I"@return [nil];T; 0; @x;!F;6i ;>0;[[I"obj;T0[I"...;T0; @x; [ ; I"Writes the given object(s) to ios.
Writes a newline after any that do not already end
with a newline sequence. Returns +nil+.
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 a string or array will be converted
by calling its +to_s+ method.
If called without arguments, outputs a single newline.
$stdout.puts("this", "is", ["a", "test"])
produces:
this
is
a
test
Note that +puts+ always uses newlines and is not affected
by the output record separator ($\\).
@overload puts(obj, ...)
@return [nil];T; 0; @x;!F;"o;#;$T;%i+ ;&iC ;'@t;(I"VALUE
rb_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$/ like #each, #lines and #readline will
also increment #lineno.
See also the $. variable.
f = File.new("testfile")
f.lineno #=> 0
f.gets #=> "This is line one\n"
f.lineno #=> 1
f.gets #=> "This is line two\n"
f.lineno #=> 2
;T;[o;=
;3I"
overload;F;40;;;50;)I" lineno;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @{; [ ; I"@return [Integer];T; 0; @{;!F;6i ;>0;[ ; @{; [ ; I"eReturns the current line number in ios. The stream must be
opened for reading. #lineno counts the number of times #gets is called
rather than the number of newlines encountered. The two values will
differ if #gets is called with a separator other than newline.
Methods that use $/ like #each, #lines and #readline will
also increment #lineno.
See also the $. variable.
f = File.new("testfile")
f.lineno #=> 0
f.gets #=> "This is line one\n"
f.lineno #=> 1
f.gets #=> "This is line two\n"
f.lineno #=> 2
@overload lineno
@return [Integer];T; 0; @{;!F;"o;#;$T;%i2;&iE;'@t;(I"static VALUE
rb_io_lineno(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
return INT2NUM(fptr->lineno);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#lineno=;F;[[I" lineno;T0;[[@ic;T;;;0;[ ;{ ;IC; "Manually sets the current line number to the given value.
$. is updated only on the next read.
f = File.new("testfile")
f.gets #=> "This is line one\n"
$. #=> 1
f.lineno = 1000
f.lineno #=> 1000
$. #=> 1 # lineno of last read
f.gets #=> "This is line two\n"
$. #=> 1001 # lineno of last read
;T;[o;=
;3I"
overload;F;40;;;50;)I"lineno=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @{; [ ; I"@return [Integer];T; 0; @{;!F;6i ;>0;[[I" integer;T0; @{; [ ; I" Manually sets the current line number to the given value.
$. is updated only on the next read.
f = File.new("testfile")
f.gets #=> "This is line one\n"
$. #=> 1
f.lineno = 1000
f.lineno #=> 1000
$. #=> 1 # lineno of last read
f.gets #=> "This is line two\n"
$. #=> 1001 # lineno of last read
@overload lineno=(integer)
@return [Integer];T; 0; @{;!F;"o;#;$T;%iR;&i`;'@t;(I"static VALUE
rb_io_set_lineno(VALUE io, VALUE lineno)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
fptr->lineno = NUM2INT(lineno);
return lineno;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#readlines;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "oReads all of the lines in ios, and returns them in
an array. Lines are separated by the optional sep. If
sep is +nil+, the rest of the stream is returned
as a single record.
If the first argument is an integer, or an
optional second argument is given, the returning string would not be
longer than the given value in bytes. The stream must be opened for
reading or an IOError will be raised.
f = File.new("testfile")
f.readlines[0] #=> "This is line one\n"
f = File.new("testfile", chomp: true)
f.readlines[0] #=> "This is line one"
See IO.readlines for details about getline_args.
;T;[o;=
;3I"
overload;F;40;;;50;)I"'readlines(sep=$/ [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @{; [ ; I"@return [Array];T; 0; @{;!F;6i ;>0;[[I"sep;TI"$/[, getline_args];T; @{o;=
;3I"
overload;F;40;;;50;)I"&readlines(limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @{; [ ; I"@return [Array];T; 0; @{;!F;6i ;>0;[[I"limit[, getline_args];T0; @{o;=
;3I"
overload;F;40;;;50;)I"+readlines(sep, limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @{; [ ; I"@return [Array];T; 0; @{;!F;6i ;>0;[[I"sep;T0[I"limit[, getline_args];T0; @{; [ ; I"1Reads all of the lines in ios, and returns them in
an array. Lines are separated by the optional sep. If
sep is +nil+, the rest of the stream is returned
as a single record.
If the first argument is an integer, or an
optional second argument is given, the returning string would not be
longer than the given value in bytes. The stream must be opened for
reading or an IOError will be raised.
f = File.new("testfile")
f.readlines[0] #=> "This is line one\n"
f = File.new("testfile", chomp: true)
f.readlines[0] #=> "This is line one"
See IO.readlines for details about getline_args.
@overload readlines(sep=$/ [, getline_args])
@return [Array]
@overload readlines(limit [, getline_args])
@return [Array]
@overload readlines(sep, limit [, getline_args])
@return [Array];T; 0; @{;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_readlines(int argc, VALUE *argv, VALUE io)
{
struct getline_arg args;
prepare_getline_args(argc, argv, &args, io);
return io_readlines(&args, io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#readpartial;F;[[@c0;[[@is ;T;;;0;[ ;{ ;IC; "v
Reads at most maxlen bytes from the I/O stream.
It blocks only if ios has no data immediately available.
It doesn't block if some data available.
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
It raises EOFError on end of file.
readpartial is designed for streams such as pipe, socket, tty, etc.
It blocks only when no data immediately available.
This means that it blocks only when following all conditions hold.
* the byte buffer in the IO object is empty.
* the content of the stream is empty.
* the stream is not reached to EOF.
When readpartial blocks, it waits data or EOF on the stream.
If some data is reached, readpartial returns with the data.
If EOF is reached, readpartial raises EOFError.
When readpartial doesn't blocks, it returns or raises immediately.
If the byte buffer is not empty, it returns the data in the buffer.
Otherwise if the stream has some content,
it returns the data in the stream.
Otherwise if the stream is reached to EOF, it raises EOFError.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc".
r.readpartial(4096) #=> "abc" "" ""
r.readpartial(4096) # blocks because buffer and pipe is empty.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc"
w.close # "" "abc" EOF
r.readpartial(4096) #=> "abc" "" EOF
r.readpartial(4096) # raises EOFError
r, w = IO.pipe # buffer pipe content
w << "abc\ndef\n" # "" "abc\ndef\n"
r.gets #=> "abc\n" "def\n" ""
w << "ghi\n" # "def\n" "ghi\n"
r.readpartial(4096) #=> "def\n" "" "ghi\n"
r.readpartial(4096) #=> "ghi\n" "" ""
Note that readpartial behaves similar to sysread.
The differences are:
* If the byte buffer is not empty, read from the byte buffer
instead of "sysread for buffered IO (IOError)".
* It doesn't cause Errno::EWOULDBLOCK and Errno::EINTR. When
readpartial meets EWOULDBLOCK and EINTR by read system call,
readpartial retry the system call.
The latter means that readpartial is nonblocking-flag insensitive.
It blocks on the situation IO#sysread causes Errno::EWOULDBLOCK as
if the fd is blocking mode.
;T;[o;=
;3I"
overload;F;40;;;50;)I"readpartial(maxlen);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ |; [ ; I"@return [String];T; 0; @ |;!F;6i ;>0;[[I" maxlen;T0; @ |o;=
;3I"
overload;F;40;;;50;)I" readpartial(maxlen, outbuf);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ |;!F;6i ;>0;[[I" maxlen;T0[I" outbuf;T0; @ |; [ ; I"
Reads at most maxlen bytes from the I/O stream.
It blocks only if ios has no data immediately available.
It doesn't block if some data available.
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
It raises EOFError on end of file.
readpartial is designed for streams such as pipe, socket, tty, etc.
It blocks only when no data immediately available.
This means that it blocks only when following all conditions hold.
* the byte buffer in the IO object is empty.
* the content of the stream is empty.
* the stream is not reached to EOF.
When readpartial blocks, it waits data or EOF on the stream.
If some data is reached, readpartial returns with the data.
If EOF is reached, readpartial raises EOFError.
When readpartial doesn't blocks, it returns or raises immediately.
If the byte buffer is not empty, it returns the data in the buffer.
Otherwise if the stream has some content,
it returns the data in the stream.
Otherwise if the stream is reached to EOF, it raises EOFError.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc".
r.readpartial(4096) #=> "abc" "" ""
r.readpartial(4096) # blocks because buffer and pipe is empty.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc"
w.close # "" "abc" EOF
r.readpartial(4096) #=> "abc" "" EOF
r.readpartial(4096) # raises EOFError
r, w = IO.pipe # buffer pipe content
w << "abc\ndef\n" # "" "abc\ndef\n"
r.gets #=> "abc\n" "def\n" ""
w << "ghi\n" # "def\n" "ghi\n"
r.readpartial(4096) #=> "def\n" "" "ghi\n"
r.readpartial(4096) #=> "ghi\n" "" ""
Note that readpartial behaves similar to sysread.
The differences are:
* If the byte buffer is not empty, read from the byte buffer
instead of "sysread for buffered IO (IOError)".
* It doesn't cause Errno::EWOULDBLOCK and Errno::EINTR. When
readpartial meets EWOULDBLOCK and EINTR by read system call,
readpartial retry the system call.
The latter means that readpartial is nonblocking-flag insensitive.
It blocks on the situation IO#sysread causes Errno::EWOULDBLOCK as
if the fd is blocking mode.
@overload readpartial(maxlen)
@return [String]
@overload readpartial(maxlen, outbuf);T; 0; @ |;!F;"o;#;$T;%i2 ;&ip ;'@t;(I"static VALUE
io_readpartial(int argc, VALUE *argv, VALUE io)
{
VALUE ret;
ret = io_getpartial(argc, argv, io, Qnil, 0);
if (NIL_P(ret))
rb_eof_error();
return ret;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#read;F;[[@c0;[[@i% ;T;;;0;[ ;{ ;IC; "Reads _length_ bytes from the I/O stream.
_length_ must be a non-negative integer or +nil+.
If _length_ is a positive integer, +read+ tries to read
_length_ bytes without any conversion (binary mode).
It returns +nil+ if an EOF is encountered before anything can be read.
Fewer than _length_ bytes are returned if an EOF is encountered during
the read.
In the case of an integer _length_, the resulting string is always
in ASCII-8BIT encoding.
If _length_ is omitted or is +nil+, it reads until EOF
and the encoding conversion is applied, if applicable.
A string is returned even if EOF is encountered before any data is read.
If _length_ is zero, it returns an empty string ("").
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
When this method is called at end of file, it returns +nil+
or "", depending on _length_:
+read+, read(nil), and read(0) return
"",
read(positive_integer) returns +nil+.
f = File.new("testfile")
f.read(16) #=> "This is line one"
# read whole file
open("file") do |f|
data = f.read # This returns a string even if the file is empty.
# ...
end
# iterate over fixed length records
open("fixed-record-file") do |f|
while record = f.read(256)
# ...
end
end
# iterate over variable length records,
# each record is prefixed by its 32-bit length
open("variable-record-file") do |f|
while len = f.read(4)
len = len.unpack("N")[0] # 32-bit length
record = f.read(len) # This returns a string even if len is 0.
end
end
Note that this method behaves like the fread() function in C.
This means it retries to invoke read(2) system calls to read data
with the specified length (or until EOF).
This behavior is preserved even if ios is in non-blocking mode.
(This method is non-blocking flag insensitive as other methods.)
If you need the behavior like a single read(2) system call,
consider #readpartial, #read_nonblock, and #sysread.
;T;[o;=
;3I"
overload;F;40;;;50;)I" read([length [, outbuf]]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @I|; [ ; I"@return [String, nil];T; 0; @I|;!F;6i ;>0;[[I"[length [, outbuf]];T0; @I|; [ ; I"Reads _length_ bytes from the I/O stream.
_length_ must be a non-negative integer or +nil+.
If _length_ is a positive integer, +read+ tries to read
_length_ bytes without any conversion (binary mode).
It returns +nil+ if an EOF is encountered before anything can be read.
Fewer than _length_ bytes are returned if an EOF is encountered during
the read.
In the case of an integer _length_, the resulting string is always
in ASCII-8BIT encoding.
If _length_ is omitted or is +nil+, it reads until EOF
and the encoding conversion is applied, if applicable.
A string is returned even if EOF is encountered before any data is read.
If _length_ is zero, it returns an empty string ("").
If the optional _outbuf_ argument is present,
it must reference a String, which will receive the data.
The _outbuf_ will contain only the received data after the method call
even if it is not empty at the beginning.
When this method is called at end of file, it returns +nil+
or "", depending on _length_:
+read+, read(nil), and read(0) return
"",
read(positive_integer) returns +nil+.
f = File.new("testfile")
f.read(16) #=> "This is line one"
# read whole file
open("file") do |f|
data = f.read # This returns a string even if the file is empty.
# ...
end
# iterate over fixed length records
open("fixed-record-file") do |f|
while record = f.read(256)
# ...
end
end
# iterate over variable length records,
# each record is prefixed by its 32-bit length
open("variable-record-file") do |f|
while len = f.read(4)
len = len.unpack("N")[0] # 32-bit length
record = f.read(len) # This returns a string even if len is 0.
end
end
Note that this method behaves like the fread() function in C.
This means it retries to invoke read(2) system calls to read data
with the specified length (or until EOF).
This behavior is preserved even if ios is in non-blocking mode.
(This method is non-blocking flag insensitive as other methods.)
If you need the behavior like a single read(2) system call,
consider #readpartial, #read_nonblock, and #sysread.
@overload read([length [, outbuf]])
@return [String, nil];T; 0; @I|;!F;"o;#;$T;%i ;&i" ;'@t;(I"bstatic VALUE
io_read(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
long n, len;
VALUE length, str;
int shrinkable;
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
int previous_mode;
#endif
rb_scan_args(argc, argv, "02", &length, &str);
if (NIL_P(length)) {
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
return read_all(fptr, remain_size(fptr), str);
}
len = NUM2LONG(length);
if (len < 0) {
rb_raise(rb_eArgError, "negative length %ld given", len);
}
shrinkable = io_setstrbuf(&str,len);
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
if (len == 0) {
io_set_read_length(str, 0, shrinkable);
return str;
}
READ_CHECK(fptr);
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
previous_mode = set_binary_mode_with_seek_cur(fptr);
#endif
n = io_fread(str, 0, len, fptr);
io_set_read_length(str, n, shrinkable);
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
if (previous_mode == O_TEXT) {
setmode(fptr->fd, O_TEXT);
}
#endif
if (n == 0) return Qnil;
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#write;F;[[@c0;[[@i;T;;;0;[ ;{ ;IC; "uWrites the given strings to ios. The stream must be opened
for writing. Arguments that are not a string will be converted
to a string using to_s. Returns the number of bytes
written in total.
count = $stdout.write("This is", " a test\n")
puts "That was #{count} bytes of data"
produces:
This is a test
That was 15 bytes of data
;T;[o;=
;3I"
overload;F;40;;;50;)I"write(string, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @h|; [ ; I"@return [Integer];T; 0; @h|;!F;6i ;>0;[[I" string;T0[I"...;T0; @h|; [ ; I"Writes the given strings to ios. The stream must be opened
for writing. Arguments that are not a string will be converted
to a string using to_s. Returns the number of bytes
written in total.
count = $stdout.write("This is", " a test\n")
puts "That was #{count} bytes of data"
produces:
This is a test
That was 15 bytes of data
@overload write(string, ...)
@return [Integer];T; 0; @h|;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
io_write_m(int argc, VALUE *argv, VALUE io)
{
if (argc != 1) {
return io_writev(argc, argv, io);
}
else {
VALUE str = argv[0];
return io_write(io, str, 0);
}
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#gets;F;[[@c0;[[@i';T;;;0;[ ;{ ;IC; "xReads the next ``line'' from the I/O stream; lines are separated by
sep. A separator of +nil+ reads the entire
contents, and a zero-length separator reads the input a paragraph at
a time (two successive newlines in the input separate paragraphs).
The stream must be opened for reading or an IOError will be raised.
The line read in will be returned and also assigned to
$_. Returns +nil+ if called at end of file. If the
first argument is an integer, or optional second argument is given,
the returning string would not be longer than the given value in
bytes.
File.new("testfile").gets #=> "This is line one\n"
$_ #=> "This is line one\n"
File.new("testfile").gets(4)#=> "This"
If IO contains multibyte characters byte then gets(1)
returns character entirely:
# Russian characters take 2 bytes
File.write("testfile", "\u{442 435 441 442}")
File.open("testfile") {|f|f.gets(1)} #=> "\u0442"
File.open("testfile") {|f|f.gets(2)} #=> "\u0442"
File.open("testfile") {|f|f.gets(3)} #=> "\u0442\u0435"
File.open("testfile") {|f|f.gets(4)} #=> "\u0442\u0435"
;T;[o;=
;3I"
overload;F;40;;;50;)I""gets(sep=$/ [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @|; [ ; I"@return [String, nil];T; 0; @|;!F;6i ;>0;[[I"sep;TI"$/[, getline_args];T; @|o;=
;3I"
overload;F;40;;;50;)I"!gets(limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @|; [ ; I"@return [String, nil];T; 0; @|;!F;6i ;>0;[[I"limit[, getline_args];T0; @|o;=
;3I"
overload;F;40;;;50;)I"&gets(sep, limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @|; [ ; I"@return [String, nil];T; 0; @|;!F;6i ;>0;[[I"sep;T0[I"limit[, getline_args];T0; @|; [ ; I"=Reads the next ``line'' from the I/O stream; lines are separated by
sep. A separator of +nil+ reads the entire
contents, and a zero-length separator reads the input a paragraph at
a time (two successive newlines in the input separate paragraphs).
The stream must be opened for reading or an IOError will be raised.
The line read in will be returned and also assigned to
$_. Returns +nil+ if called at end of file. If the
first argument is an integer, or optional second argument is given,
the returning string would not be longer than the given value in
bytes.
File.new("testfile").gets #=> "This is line one\n"
$_ #=> "This is line one\n"
File.new("testfile").gets(4)#=> "This"
If IO contains multibyte characters byte then gets(1)
returns character entirely:
# Russian characters take 2 bytes
File.write("testfile", "\u{442 435 441 442}")
File.open("testfile") {|f|f.gets(1)} #=> "\u0442"
File.open("testfile") {|f|f.gets(2)} #=> "\u0442"
File.open("testfile") {|f|f.gets(3)} #=> "\u0442\u0435"
File.open("testfile") {|f|f.gets(4)} #=> "\u0442\u0435"
@overload gets(sep=$/ [, getline_args])
@return [String, nil]
@overload gets(limit [, getline_args])
@return [String, nil]
@overload gets(sep, limit [, getline_args])
@return [String, nil];T; 0; @|;!F;"o;#;$T;%i;&i&;'@t;(I"static VALUE
rb_io_gets_m(int argc, VALUE *argv, VALUE io)
{
VALUE str;
str = rb_io_getline(argc, argv, io);
rb_lastline_set(str);
return str;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#readline;F;[[@c0;[[@iw;T;;;0;[ ;{ ;IC; "IReads a line as with IO#gets, but raises an EOFError on end of file.
;T;[o;=
;3I"
overload;F;40;;;50;)I"&readline(sep=$/ [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @|; [ ; I"@return [String];T; 0; @|;!F;6i ;>0;[[I"sep;TI"$/[, getline_args];T; @|o;=
;3I"
overload;F;40;;;50;)I"%readline(limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @|; [ ; I"@return [String];T; 0; @|;!F;6i ;>0;[[I"limit[, getline_args];T0; @|o;=
;3I"
overload;F;40;;;50;)I"*readline(sep, limit [, getline_args]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @|; [ ; I"@return [String];T; 0; @|;!F;6i ;>0;[[I"sep;T0[I"limit[, getline_args];T0; @|; [ ; I"Reads a line as with IO#gets, but raises an EOFError on end of file.
@overload readline(sep=$/ [, getline_args])
@return [String]
@overload readline(limit [, getline_args])
@return [String]
@overload readline(sep, limit [, getline_args])
@return [String];T; 0; @|;!F;"o;#;$T;%in;&iv;'@t;(I"static VALUE
rb_io_readline(int argc, VALUE *argv, VALUE io)
{
VALUE line = rb_io_gets_m(argc, argv, io);
if (NIL_P(line)) {
rb_eof_error();
}
return line;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#getc;F;[ ;[[@iI;T;;;0;[ ;{ ;IC; "Reads a one-character string from ios. Returns
+nil+ if called at end of file.
f = File.new("testfile")
f.getc #=> "h"
f.getc #=> "e"
;T;[o;=
;3I"
overload;F;40;;;50;)I" getc;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;TI"nil;T; @ }; [ ; I"@return [String, nil];T; 0; @ };!F;6i ;>0;[ ; @ }; [ ; I"Reads a one-character string from ios. Returns
+nil+ if called at end of file.
f = File.new("testfile")
f.getc #=> "h"
f.getc #=> "e"
@overload getc
@return [String, nil];T; 0; @ };!F;"o;#;$T;%i=;&iF;'@t;(I"static VALUE
rb_io_getc(VALUE io)
{
rb_io_t *fptr;
rb_encoding *enc;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
enc = io_input_encoding(fptr);
READ_CHECK(fptr);
return io_getc(fptr, enc);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#getbyte;F;[ ;[[@iz;T;;;0;[ ;{ ;IC; "Gets the next 8-bit byte (0..255) from ios. Returns
+nil+ if called at end of file.
f = File.new("testfile")
f.getbyte #=> 84
f.getbyte #=> 104
;T;[o;=
;3I"
overload;F;40;;;50;)I" getbyte;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @%}; [ ; I"@return [Integer, nil];T; 0; @%};!F;6i ;>0;[ ; @%}; [ ; I"Gets the next 8-bit byte (0..255) from ios. Returns
+nil+ if called at end of file.
f = File.new("testfile")
f.getbyte #=> 84
f.getbyte #=> 104
@overload getbyte
@return [Integer, nil];T; 0; @%};!F;"o;#;$T;%in;&iw;'@t;(I"6VALUE
rb_io_getbyte(VALUE io)
{
rb_io_t *fptr;
int c;
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
READ_CHECK(fptr);
if (fptr->fd == 0 && (fptr->mode & FMODE_TTY) && RB_TYPE_P(rb_stdout, T_FILE)) {
rb_io_t *ofp;
GetOpenFile(rb_stdout, ofp);
if (ofp->mode & FMODE_TTY) {
rb_io_flush(rb_stdout);
}
}
if (io_fillbuf(fptr) < 0) {
return Qnil;
}
fptr->rbuf.off++;
fptr->rbuf.len--;
c = (unsigned char)fptr->rbuf.ptr[fptr->rbuf.off-1];
return INT2FIX(c & 0xff);
};T;)I"
VALUE;T;*To; ; F;
;;;;I"IO#readchar;F;[ ;[[@ic;T;;;0;[ ;{ ;IC; "Reads a one-character string from ios. Raises an
EOFError on end of file.
f = File.new("testfile")
f.readchar #=> "h"
f.readchar #=> "e"
;T;[o;=
;3I"
overload;F;40;;;50;)I"
readchar;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @A}; [ ; I"@return [String];T; 0; @A};!F;6i ;>0;[ ; @A}; [ ; I"Reads a one-character string from ios. Raises an
EOFError on end of file.
f = File.new("testfile")
f.readchar #=> "h"
f.readchar #=> "e"
@overload readchar
@return [String];T; 0; @A};!F;"o;#;$T;%iW;&i`;'@t;(I"static VALUE
rb_io_readchar(VALUE io)
{
VALUE c = rb_io_getc(io);
if (NIL_P(c)) {
rb_eof_error();
}
return c;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#readbyte;F;[ ;[[@i;T;;;0;[ ;{ ;IC; "LReads a byte as with IO#getbyte, but raises an EOFError on end of
file.
;T;[o;=
;3I"
overload;F;40;;;50;)I"
readbyte;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @\}; [ ; I"@return [Integer];T; 0; @\};!F;6i ;>0;[ ; @\}; [ ; I"uReads a byte as with IO#getbyte, but raises an EOFError on end of
file.
@overload readbyte
@return [Integer];T; 0; @\};!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_readbyte(VALUE io)
{
VALUE c = rb_io_getbyte(io);
if (NIL_P(c)) {
rb_eof_error();
}
return c;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#ungetbyte;F;[[I"b;T0;[[@i;T;; ;0;[ ;{ ;IC; "Pushes back bytes (passed as a parameter) onto ios,
such that a subsequent buffered read will return it. Only one byte
may be pushed back before a subsequent read operation (that is,
you will be able to read only the last of several bytes that have been pushed
back). Has no effect with unbuffered reads (such as IO#sysread).
f = File.new("testfile") #=> #to_s.
$stdout << "Hello " << "world!\n"
produces:
Hello world!
;T;[o;=
;3I"
overload;F;40;;;50;)I" <<(obj);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @}; [ ; I"@return [IO];T; 0; @};!F;6i ;>0;[[I"obj;T0; @}; [ ; I"String Output---Writes obj to ios.
obj will be converted to a string using
to_s.
$stdout << "Hello " << "world!\n"
produces:
Hello world!
@overload <<(obj)
@return [IO];T; 0; @};!F;"o;#;$T;%i";&i.;'@t;(I"YVALUE
rb_io_addstr(VALUE io, VALUE str)
{
rb_io_write(io, str);
return io;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"
IO#flush;F;[ ;[[@in;T;;;0;[ ;{ ;IC; "Flushes any buffered data within ios to the underlying
operating system (note that this is Ruby internal buffering only;
the OS may buffer the data as well).
$stdout.print "no newline"
$stdout.flush
produces:
no newline
;T;[o;=
;3I"
overload;F;40;;;50;)I"
flush;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @}; [ ; I"@return [IO];T; 0; @};!F;6i ;>0;[ ; @}; [ ; I"Flushes any buffered data within ios to the underlying
operating system (note that this is Ruby internal buffering only;
the OS may buffer the data as well).
$stdout.print "no newline"
$stdout.flush
produces:
no newline
@overload flush
@return [IO];T; 0; @};!F;"o;#;$T;%i^;&ik;'@t;(I"GVALUE
rb_io_flush(VALUE io)
{
return rb_io_flush_raw(io, 1);
};T;)I"
VALUE;T;*To; ; F;
;;;;I" IO#tell;F;[ ;[[@i;T;; ;0;[ ;{ ;IC; "Returns the current offset (in bytes) of ios.
f = File.new("testfile")
f.pos #=> 0
f.gets #=> "This is line one\n"
f.pos #=> 17
;T;[o;=
;3I"
overload;F;40;; ;50;)I"pos;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}; [ ; I"@return [Integer];T; 0; @};!F;6i ;>0;[ ; @}o;=
;3I"
overload;F;40;; ;50;)I" tell;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}; [ ; I"@return [Integer];T; 0; @};!F;6i ;>0;[ ; @}; [ ; I"Returns the current offset (in bytes) of ios.
f = File.new("testfile")
f.pos #=> 0
f.gets #=> "This is line one\n"
f.pos #=> 17
@overload pos
@return [Integer]
@overload tell
@return [Integer];T; 0; @};!F;"o;#;$T;%it;&i;'@t;(I"static VALUE
rb_io_tell(VALUE io)
{
rb_io_t *fptr;
off_t pos;
GetOpenFile(io, fptr);
pos = io_tell(fptr);
if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv);
pos -= fptr->rbuf.len;
return OFFT2NUM(pos);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#seek;F;[[@c0;[[@i;T;: seek;0;[ ;{ ;IC; "Seeks to a given offset anInteger in the stream according to
the value of whence:
:CUR or IO::SEEK_CUR | Seeks to _amount_ plus current position
----------------------+--------------------------------------------------
:END or IO::SEEK_END | Seeks to _amount_ plus end of stream (you
| probably want a negative value for _amount_)
----------------------+--------------------------------------------------
:SET or IO::SEEK_SET | Seeks to the absolute location given by _amount_
Example:
f = File.new("testfile")
f.seek(-13, IO::SEEK_END) #=> 0
f.readline #=> "And so on...\n"
;T;[o;=
;3I"
overload;F;40;;;50;)I"&seek(amount, whence=IO::SEEK_SET);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @&~; [ ; I"@return [0];T; 0; @&~;!F;6i ;>0;[[I" amount;T0[I" whence;TI"IO::SEEK_SET;T; @&~; [ ; I"Seeks to a given offset anInteger in the stream according to
the value of whence:
:CUR or IO::SEEK_CUR | Seeks to _amount_ plus current position
----------------------+--------------------------------------------------
:END or IO::SEEK_END | Seeks to _amount_ plus end of stream (you
| probably want a negative value for _amount_)
----------------------+--------------------------------------------------
:SET or IO::SEEK_SET | Seeks to the absolute location given by _amount_
Example:
f = File.new("testfile")
f.seek(-13, IO::SEEK_END) #=> 0
f.readline #=> "And so on...\n"
@overload seek(amount, whence=IO::SEEK_SET)
@return [0];T; 0; @&~;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_seek_m(int argc, VALUE *argv, VALUE io)
{
VALUE offset, ptrname;
int whence = SEEK_SET;
if (rb_scan_args(argc, argv, "11", &offset, &ptrname) == 2) {
whence = interpret_seek_whence(ptrname);
}
return rb_io_seek(io, offset, whence);
};T;)I"static VALUE;T;*To;;[[@i4;F;:
SEEK_SET;;;;;[ ;{ ;IC; "(Set I/O position from the beginning
;T;[ ; [ ; I"(Set I/O position from the beginning;T; 0; @G~;!F;"o;#;$T;%i4;&i4;'@t;I"IO::SEEK_SET;F;I"INT2FIX(SEEK_SET);To;;[[@i4;F;:
SEEK_CUR;;;;;[ ;{ ;IC; "/Set I/O position from the current position
;T;[ ; [ ; I"/Set I/O position from the current position;T; 0; @S~;!F;"o;#;$T;%i4;&i4;'@t;I"IO::SEEK_CUR;F;I"INT2FIX(SEEK_CUR);To;;[[@i4;F;:
SEEK_END;;;;;[ ;{ ;IC; ""Set I/O position from the end
;T;[ ; [ ; I""Set I/O position from the end;T; 0; @_~;!F;"o;#;$T;%i4;&i4;'@t;I"IO::SEEK_END;F;I"INT2FIX(SEEK_END);To;;[[@i4;F;:SEEK_DATA;;;;;[ ;{ ;IC; ":Set I/O position to the next location containing data
;T;[ ; [ ; I":Set I/O position to the next location containing data;T; 0; @k~;!F;"o;#;$T;%i4;&i4;'@t;I"IO::SEEK_DATA;F;I"INT2FIX(SEEK_DATA);To;;[[@i4;F;:SEEK_HOLE;;;;;[ ;{ ;IC; "&Set I/O position to the next hole
;T;[ ; [ ; I"&Set I/O position to the next hole;T; 0; @w~;!F;"o;#;$T;%i4;&i4;'@t;I"IO::SEEK_HOLE;F;I"INT2FIX(SEEK_HOLE);To; ; F;
;;;;I"IO#rewind;F;[ ;[[@i;T;;;0;[ ;{ ;IC; "3Positions ios to the beginning of input, resetting
#lineno to zero.
f = File.new("testfile")
f.readline #=> "This is line one\n"
f.rewind #=> 0
f.lineno #=> 0
f.readline #=> "This is line one\n"
Note that it cannot be used with streams such as pipes, ttys, and sockets.
;T;[o;=
;3I"
overload;F;40;;;50;)I" rewind;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @~; [ ; I"@return [0];T; 0; @~;!F;6i ;>0;[ ; @~; [ ; I"TPositions ios to the beginning of input, resetting
#lineno to zero.
f = File.new("testfile")
f.readline #=> "This is line one\n"
f.rewind #=> 0
f.lineno #=> 0
f.readline #=> "This is line one\n"
Note that it cannot be used with streams such as pipes, ttys, and sockets.
@overload rewind
@return [0];T; 0; @~;!F;"o;#;$T;%i;&i;'@t;(I"Lstatic VALUE
rb_io_rewind(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (io_seek(fptr, 0L, 0) < 0 && errno) rb_sys_fail_path(fptr->pathv);
if (io == ARGF.current_file) {
ARGF.lineno -= fptr->lineno;
}
fptr->lineno = 0;
if (fptr->readconv) {
clear_readconv(fptr);
}
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#pos;F;[ ;[[@i;T;; ;0;[ ;{ ;IC; "Returns the current offset (in bytes) of ios.
f = File.new("testfile")
f.pos #=> 0
f.gets #=> "This is line one\n"
f.pos #=> 17
;T;[o;=
;3I"
overload;F;40;; ;50;)I"pos;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @~; [ ; I"@return [Integer];T; 0; @~;!F;6i ;>0;[ ; @~o;=
;3I"
overload;F;40;; ;50;)I" tell;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @~; [ ; I"@return [Integer];T; 0; @~;!F;6i ;>0;[ ; @~; [ ; @"~; 0; @~;!F;"o;#;$T;%it;&i;'@t;(I"static VALUE
rb_io_tell(VALUE io)
{
rb_io_t *fptr;
off_t pos;
GetOpenFile(io, fptr);
pos = io_tell(fptr);
if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv);
pos -= fptr->rbuf.len;
return OFFT2NUM(pos);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#pos=;F;[[I" offset;T0;[[@i;T;: pos=;0;[ ;{ ;IC; "Seeks to the given position (in bytes) in ios.
It is not guaranteed that seeking to the right position when ios
is textmode.
f = File.new("testfile")
f.pos = 17
f.gets #=> "This is line two\n"
;T;[o;=
;3I"
overload;F;40;;;50;)I"pos=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @~; [ ; I"@return [Integer];T; 0; @~;!F;6i ;>0;[[I" integer;T0; @~; [ ; I" Seeks to the given position (in bytes) in ios.
It is not guaranteed that seeking to the right position when ios
is textmode.
f = File.new("testfile")
f.pos = 17
f.gets #=> "This is line two\n"
@overload pos=(integer)
@return [Integer];T; 0; @~;!F;"o;#;$T;%i;&i;'@t;(I" static VALUE
rb_io_set_pos(VALUE io, VALUE offset)
{
rb_io_t *fptr;
off_t pos;
pos = NUM2OFFT(offset);
GetOpenFile(io, fptr);
pos = io_seek(fptr, pos, SEEK_SET);
if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv);
return OFFT2NUM(pos);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#eof;F;[ ;[[@id;T;;;0;[ ;{ ;IC; "Returns true if ios is at end of file that means
there are no more data to read.
The stream must be opened for reading or an IOError will be
raised.
f = File.new("testfile")
dummy = f.readlines
f.eof #=> true
If ios is a stream such as pipe or socket, IO#eof?
blocks until the other end sends some data or closes it.
r, w = IO.pipe
Thread.new { sleep 1; w.close }
r.eof? #=> true after 1 second blocking
r, w = IO.pipe
Thread.new { sleep 1; w.puts "a" }
r.eof? #=> false after 1 second blocking
r, w = IO.pipe
r.eof? # blocks forever
Note that IO#eof? reads data to the input byte buffer. So
IO#sysread may not behave as you intend with IO#eof?, unless you
call IO#rewind first (which is not available for some streams).
;T;[o;=
;3I"
overload;F;40;;;50;)I"eof;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @~; [ ; I"@return [Boolean];T; 0; @~;!F;6i ;>0;[ ; @~o;=
;3I"
overload;F;40;;;50;)I" eof?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @~; [ ; I"@return [Boolean];T; 0; @~;!F;6i ;>0;[ ; @~; [ ; I"VReturns true if ios is at end of file that means
there are no more data to read.
The stream must be opened for reading or an IOError will be
raised.
f = File.new("testfile")
dummy = f.readlines
f.eof #=> true
If ios is a stream such as pipe or socket, IO#eof?
blocks until the other end sends some data or closes it.
r, w = IO.pipe
Thread.new { sleep 1; w.close }
r.eof? #=> true after 1 second blocking
r, w = IO.pipe
Thread.new { sleep 1; w.puts "a" }
r.eof? #=> false after 1 second blocking
r, w = IO.pipe
r.eof? # blocks forever
Note that IO#eof? reads data to the input byte buffer. So
IO#sysread may not behave as you intend with IO#eof?, unless you
call IO#rewind first (which is not available for some streams).
@overload eof
@return [Boolean]
@overload eof?
@return [Boolean];T; 0; @~;!F;"o;#;$T;%iC;&ib;'@t;(I"VALUE
rb_io_eof(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
if (READ_CHAR_PENDING(fptr)) return Qfalse;
if (READ_DATA_PENDING(fptr)) return Qfalse;
READ_CHECK(fptr);
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
if (!NEED_READCONV(fptr) && NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
return eof(fptr->fd) ? Qtrue : Qfalse;
}
#endif
if (io_fillbuf(fptr) < 0) {
return Qtrue;
}
return Qfalse;
};T;)I"
VALUE;T;*To; ; F;
;;;;I" IO#eof?;F;[ ;[[@id;T;;;0;[ ;{ ;IC; "Returns true if ios is at end of file that means
there are no more data to read.
The stream must be opened for reading or an IOError will be
raised.
f = File.new("testfile")
dummy = f.readlines
f.eof #=> true
If ios is a stream such as pipe or socket, IO#eof?
blocks until the other end sends some data or closes it.
r, w = IO.pipe
Thread.new { sleep 1; w.close }
r.eof? #=> true after 1 second blocking
r, w = IO.pipe
Thread.new { sleep 1; w.puts "a" }
r.eof? #=> false after 1 second blocking
r, w = IO.pipe
r.eof? # blocks forever
Note that IO#eof? reads data to the input byte buffer. So
IO#sysread may not behave as you intend with IO#eof?, unless you
call IO#rewind first (which is not available for some streams).;T;[o;=
;3I"
overload;F;40;;;50;)I"eof;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ ; [ ; I"@return [Boolean];T; 0; @ ;!F;6i ;>0;[ ; @ o;=
;3I"
overload;F;40;;;50;)I" eof?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ ; [ ; I"@return [Boolean];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; @; 0; @ ;!F;"o;#;$T;%iC;&ib;6i ;'@t;(I"VALUE
rb_io_eof(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_char_readable(fptr);
if (READ_CHAR_PENDING(fptr)) return Qfalse;
if (READ_DATA_PENDING(fptr)) return Qfalse;
READ_CHECK(fptr);
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
if (!NEED_READCONV(fptr) && NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
return eof(fptr->fd) ? Qtrue : Qfalse;
}
#endif
if (io_fillbuf(fptr) < 0) {
return Qtrue;
}
return Qfalse;
};T;)I"
VALUE;T;*To; ; F;
;;;;I"IO#close_on_exec?;F;[ ;[[@i1;T;:close_on_exec?;0;[ ;{ ;IC; "Returns true if ios will be closed on exec.
f = open("/dev/null")
f.close_on_exec? #=> false
f.close_on_exec = true
f.close_on_exec? #=> true
f.close_on_exec = false
f.close_on_exec? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I"close_on_exec?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @3; [ ; I"@return [Boolean];T; 0; @3;!F;6i ;>0;[ ; @3; [ ; I"HReturns true if ios will be closed on exec.
f = open("/dev/null")
f.close_on_exec? #=> false
f.close_on_exec = true
f.close_on_exec? #=> true
f.close_on_exec = false
f.close_on_exec? #=> false
@overload close_on_exec?
@return [Boolean];T; 0; @3;!F;"o;#;$T;%i#;&i.;6i ;'@t;(I"astatic VALUE
rb_io_close_on_exec_p(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
int fd, ret;
write_io = GetWriteIO(io);
if (io != write_io) {
GetOpenFile(write_io, fptr);
if (fptr && 0 <= (fd = fptr->fd)) {
if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv);
if (!(ret & FD_CLOEXEC)) return Qfalse;
}
}
GetOpenFile(io, fptr);
if (fptr && 0 <= (fd = fptr->fd)) {
if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv);
if (!(ret & FD_CLOEXEC)) return Qfalse;
}
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#close_on_exec=;F;[[I"arg;T0;[[@ia;T;:close_on_exec=;0;[ ;{ ;IC; "FSets a close-on-exec flag.
f = open("/dev/null")
f.close_on_exec = true
system("cat", "/proc/self/fd/#{f.fileno}") # cat: /proc/self/fd/3: No such file or directory
f.closed? #=> false
Ruby sets close-on-exec flags of all file descriptors by default
since Ruby 2.0.0.
So you don't need to set by yourself.
Also, unsetting a close-on-exec flag can cause file descriptor leak
if another thread use fork() and exec() (via system() method for example).
If you really needs file descriptor inheritance to child process,
use spawn()'s argument such as fd=>fd.
;T;[o;=
;3I"
overload;F;40;;;50;)I"close_on_exec=(bool);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @N; [ ; I"@return [Boolean];T; 0; @N;!F;6i ;>0;[[I" bool;T0; @N; [ ; I"{Sets a close-on-exec flag.
f = open("/dev/null")
f.close_on_exec = true
system("cat", "/proc/self/fd/#{f.fileno}") # cat: /proc/self/fd/3: No such file or directory
f.closed? #=> false
Ruby sets close-on-exec flags of all file descriptors by default
since Ruby 2.0.0.
So you don't need to set by yourself.
Also, unsetting a close-on-exec flag can cause file descriptor leak
if another thread use fork() and exec() (via system() method for example).
If you really needs file descriptor inheritance to child process,
use spawn()'s argument such as fd=>fd.
@overload close_on_exec=(bool)
@return [Boolean];T; 0; @N;!F;"o;#;$T;%iM;&i^;'@t;(I"static VALUE
rb_io_set_close_on_exec(VALUE io, VALUE arg)
{
int flag = RTEST(arg) ? FD_CLOEXEC : 0;
rb_io_t *fptr;
VALUE write_io;
int fd, ret;
write_io = GetWriteIO(io);
if (io != write_io) {
GetOpenFile(write_io, fptr);
if (fptr && 0 <= (fd = fptr->fd)) {
if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv);
if ((ret & FD_CLOEXEC) != flag) {
ret = (ret & ~FD_CLOEXEC) | flag;
ret = fcntl(fd, F_SETFD, ret);
if (ret != 0) rb_sys_fail_path(fptr->pathv);
}
}
}
GetOpenFile(io, fptr);
if (fptr && 0 <= (fd = fptr->fd)) {
if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv);
if ((ret & FD_CLOEXEC) != flag) {
ret = (ret & ~FD_CLOEXEC) | flag;
ret = fcntl(fd, F_SETFD, ret);
if (ret != 0) rb_sys_fail_path(fptr->pathv);
}
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#close;F;[ ;[[@i;T;;:;0;[ ;{ ;IC; "Closes ios and flushes any pending writes to the operating
system. The stream is unavailable for any further data operations;
an IOError is raised if such an attempt is made. I/O streams are
automatically closed when they are claimed by the garbage collector.
If ios is opened by IO.popen, #close sets
$?.
Calling this method on closed IO object is just ignored since Ruby 2.3.
;T;[o;=
;3I"
overload;F;40;;:;50;)I"
close;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @m; [ ; I"@return [nil];T; 0; @m;!F;6i ;>0;[ ; @m; [ ; I"Closes ios and flushes any pending writes to the operating
system. The stream is unavailable for any further data operations;
an IOError is raised if such an attempt is made. I/O streams are
automatically closed when they are claimed by the garbage collector.
If ios is opened by IO.popen, #close sets
$?.
Calling this method on closed IO object is just ignored since Ruby 2.3.
@overload close
@return [nil];T; 0; @m;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_close_m(VALUE io)
{
rb_io_t *fptr = rb_io_get_fptr(io);
if (fptr->fd < 0) {
return Qnil;
}
rb_io_close(io);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#closed?;F;[ ;[[@i*;T;;8;0;[ ;{ ;IC; "mReturns true if ios is completely closed (for
duplex streams, both reader and writer), false
otherwise.
f = File.new("testfile")
f.close #=> nil
f.closed? #=> true
f = IO.popen("/bin/sh","r+")
f.close_write #=> nil
f.closed? #=> false
f.close_read #=> nil
f.closed? #=> true;T;[o;=
;3I"
overload;F;40;;8;50;)I" closed?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if ios is completely closed (for
duplex streams, both reader and writer), false
otherwise.
f = File.new("testfile")
f.close #=> nil
f.closed? #=> true
f = IO.popen("/bin/sh","r+")
f.close_write #=> nil
f.closed? #=> false
f.close_read #=> nil
f.closed? #=> true
@overload closed?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i&;6i ;'@t;(I"tstatic VALUE
rb_io_closed(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
rb_io_t *write_fptr;
write_io = GetWriteIO(io);
if (io != write_io) {
write_fptr = RFILE(write_io)->fptr;
if (write_fptr && 0 <= write_fptr->fd) {
return Qfalse;
}
}
fptr = rb_io_get_fptr(io);
return 0 <= fptr->fd ? Qfalse : Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#close_read;F;[ ;[[@iQ;T;:close_read;0;[ ;{ ;IC; "Closes the read end of a duplex I/O stream (i.e., one that contains
both a read and a write stream, such as a pipe). Will raise an
IOError if the stream is not duplexed.
f = IO.popen("/bin/sh","r+")
f.close_read
f.readlines
produces:
prog.rb:3:in `readlines': not opened for reading (IOError)
from prog.rb:3
Calling this method on closed IO object is just ignored since Ruby 2.3.
;T;[o;=
;3I"
overload;F;40;;;50;)I"close_read;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Closes the read end of a duplex I/O stream (i.e., one that contains
both a read and a write stream, such as a pipe). Will raise an
IOError if the stream is not duplexed.
f = IO.popen("/bin/sh","r+")
f.close_read
f.readlines
produces:
prog.rb:3:in `readlines': not opened for reading (IOError)
from prog.rb:3
Calling this method on closed IO object is just ignored since Ruby 2.3.
@overload close_read
@return [nil];T; 0; @;!F;"o;#;$T;%i=;&iN;'@t;(I"cstatic VALUE
rb_io_close_read(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
fptr = rb_io_get_fptr(rb_io_taint_check(io));
if (fptr->fd < 0) return Qnil;
if (is_socket(fptr->fd, fptr->pathv)) {
#ifndef SHUT_RD
# define SHUT_RD 0
#endif
if (shutdown(fptr->fd, SHUT_RD) < 0)
rb_sys_fail_path(fptr->pathv);
fptr->mode &= ~FMODE_READABLE;
if (!(fptr->mode & FMODE_WRITABLE))
return rb_io_close(io);
return Qnil;
}
write_io = GetWriteIO(io);
if (io != write_io) {
rb_io_t *wfptr;
wfptr = rb_io_get_fptr(rb_io_taint_check(write_io));
wfptr->pid = fptr->pid;
fptr->pid = 0;
RFILE(io)->fptr = wfptr;
/* bind to write_io temporarily to get rid of memory/fd leak */
fptr->tied_io_for_writing = 0;
RFILE(write_io)->fptr = fptr;
rb_io_fptr_cleanup(fptr, FALSE);
/* should not finalize fptr because another thread may be reading it */
return Qnil;
}
if ((fptr->mode & (FMODE_DUPLEX|FMODE_WRITABLE)) == FMODE_WRITABLE) {
rb_raise(rb_eIOError, "closing non-duplex IO for reading");
}
return rb_io_close(io);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#close_write;F;[ ;[[@i;T;:close_write;0;[ ;{ ;IC; "Closes the write end of a duplex I/O stream (i.e., one that contains
both a read and a write stream, such as a pipe). Will raise an
IOError if the stream is not duplexed.
f = IO.popen("/bin/sh","r+")
f.close_write
f.print "nowhere"
produces:
prog.rb:3:in `write': not opened for writing (IOError)
from prog.rb:3:in `print'
from prog.rb:3
Calling this method on closed IO object is just ignored since Ruby 2.3.
;T;[o;=
;3I"
overload;F;40;;;50;)I"close_write;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Closes the write end of a duplex I/O stream (i.e., one that contains
both a read and a write stream, such as a pipe). Will raise an
IOError if the stream is not duplexed.
f = IO.popen("/bin/sh","r+")
f.close_write
f.print "nowhere"
produces:
prog.rb:3:in `write': not opened for writing (IOError)
from prog.rb:3:in `print'
from prog.rb:3
Calling this method on closed IO object is just ignored since Ruby 2.3.
@overload close_write
@return [nil];T; 0; @;!F;"o;#;$T;%iz;&i;'@t;(I"7static VALUE
rb_io_close_write(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
write_io = GetWriteIO(io);
fptr = rb_io_get_fptr(rb_io_taint_check(write_io));
if (fptr->fd < 0) return Qnil;
if (is_socket(fptr->fd, fptr->pathv)) {
#ifndef SHUT_WR
# define SHUT_WR 1
#endif
if (shutdown(fptr->fd, SHUT_WR) < 0)
rb_sys_fail_path(fptr->pathv);
fptr->mode &= ~FMODE_WRITABLE;
if (!(fptr->mode & FMODE_READABLE))
return rb_io_close(write_io);
return Qnil;
}
if ((fptr->mode & (FMODE_DUPLEX|FMODE_READABLE)) == FMODE_READABLE) {
rb_raise(rb_eIOError, "closing non-duplex IO for writing");
}
if (io != write_io) {
fptr = rb_io_get_fptr(rb_io_taint_check(io));
fptr->tied_io_for_writing = 0;
}
rb_io_close(write_io);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#isatty;F;[ ;[[@i;T;: isatty;0;[ ;{ ;IC; "Returns true if ios is associated with a
terminal device (tty), false otherwise.
File.new("testfile").isatty #=> false
File.new("/dev/tty").isatty #=> true
;T;[o;=
;3I"
overload;F;40;;;50;)I" isatty;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;: tty?;50;)I" tty?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if ios is associated with a
terminal device (tty), false otherwise.
File.new("testfile").isatty #=> false
File.new("/dev/tty").isatty #=> true
@overload isatty
@return [Boolean]
@overload tty?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i ;&i;'@t;(I"static VALUE
rb_io_isatty(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (isatty(fptr->fd) == 0)
return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#tty?;F;[ ;[[@i;T;;;0;[ ;{ ;IC; "Returns true if ios is associated with a
terminal device (tty), false otherwise.
File.new("testfile").isatty #=> false
File.new("/dev/tty").isatty #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I" isatty;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I" tty?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; @; 0; @;!F;"o;#;$T;%i ;&i;6i ;'@t;(I"static VALUE
rb_io_isatty(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (isatty(fptr->fd) == 0)
return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#binmode;F;[ ;[[@i ;T;: binmode;0;[ ;{ ;IC; "Puts ios into binary mode.
Once a stream is in binary mode, it cannot be reset to nonbinary mode.
- newline conversion disabled
- encoding conversion disabled
- content is treated as ASCII-8BIT
;T;[o;=
;3I"
overload;F;40;;;50;)I" binmode;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @(; [ ; I"@return [IO];T; 0; @(;!F;6i ;>0;[ ; @(; [ ; I"Puts ios into binary mode.
Once a stream is in binary mode, it cannot be reset to nonbinary mode.
- newline conversion disabled
- encoding conversion disabled
- content is treated as ASCII-8BIT
@overload binmode
@return [IO];T; 0; @(;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_binmode_m(VALUE io)
{
VALUE write_io;
rb_io_ascii8bit_binmode(io);
write_io = GetWriteIO(io);
if (write_io != io)
rb_io_ascii8bit_binmode(write_io);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#binmode?;F;[ ;[[@i1;T;:
binmode?;0;[ ;{ ;IC; ":Returns true if ios is binmode.;T;[o;=
;3I"
overload;F;40;;;50;)I"
binmode?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @C; [ ; I"@return [Boolean];T; 0; @C;!F;6i ;>0;[ ; @C; [ ; I"cReturns true if ios is binmode.
@overload binmode?
@return [Boolean];T; 0; @C;!F;"o;#;$T;%i+;&i/;6i ;'@t;(I"static VALUE
rb_io_binmode_p(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
return fptr->mode & FMODE_BINMODE ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#sysseek;F;[[@c0;[[@i;T;: sysseek;0;[ ;{ ;IC; " Seeks to a given offset in the stream according to the value
of whence (see IO#seek for values of whence). Returns
the new offset into the file.
f = File.new("testfile")
f.sysseek(-13, IO::SEEK_END) #=> 53
f.sysread(10) #=> "And so on."
;T;[o;=
;3I"
overload;F;40;;;50;)I")sysseek(offset, whence=IO::SEEK_SET);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @^; [ ; I"@return [Integer];T; 0; @^;!F;6i ;>0;[[I" offset;T0[I" whence;TI"IO::SEEK_SET;T; @^; [ ; I"cSeeks to a given offset in the stream according to the value
of whence (see IO#seek for values of whence). Returns
the new offset into the file.
f = File.new("testfile")
f.sysseek(-13, IO::SEEK_END) #=> 53
f.sysread(10) #=> "And so on."
@overload sysseek(offset, whence=IO::SEEK_SET)
@return [Integer];T; 0; @^;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
rb_io_sysseek(int argc, VALUE *argv, VALUE io)
{
VALUE offset, ptrname;
int whence = SEEK_SET;
rb_io_t *fptr;
off_t pos;
if (rb_scan_args(argc, argv, "11", &offset, &ptrname) == 2) {
whence = interpret_seek_whence(ptrname);
}
pos = NUM2OFFT(offset);
GetOpenFile(io, fptr);
if ((fptr->mode & FMODE_READABLE) &&
(READ_DATA_BUFFERED(fptr) || READ_CHAR_PENDING(fptr))) {
rb_raise(rb_eIOError, "sysseek for buffered IO");
}
if ((fptr->mode & FMODE_WRITABLE) && fptr->wbuf.len) {
rb_warn("sysseek for buffered IO");
}
errno = 0;
pos = lseek(fptr->fd, pos, whence);
if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv);
return OFFT2NUM(pos);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#advise;F;[[@c0;[[@i$;T;: advise;0;[ ;{ ;IC; ";Announce an intention to access data from the current file in a
specific pattern. On platforms that do not support the
posix_fadvise(2) system call, this method is a no-op.
_advice_ is one of the following symbols:
:normal:: No advice to give; the default assumption for an open file.
:sequential:: The data will be accessed sequentially
with lower offsets read before higher ones.
:random:: The data will be accessed in random order.
:willneed:: The data will be accessed in the near future.
:dontneed:: The data will not be accessed in the near future.
:noreuse:: The data will only be accessed once.
The semantics of a piece of advice are platform-dependent. See
man 2 posix_fadvise for details.
"data" means the region of the current file that begins at
_offset_ and extends for _len_ bytes. If _len_ is 0, the region
ends at the last byte of the file. By default, both _offset_ and
_len_ are 0, meaning that the advice applies to the entire file.
If an error occurs, one of the following exceptions will be raised:
IOError:: The IO stream is closed.
Errno::EBADF::
The file descriptor of the current file is invalid.
Errno::EINVAL:: An invalid value for _advice_ was given.
Errno::ESPIPE::
The file descriptor of the current file refers to a FIFO or
pipe. (Linux raises Errno::EINVAL in this case).
TypeError::
Either _advice_ was not a Symbol, or one of the
other arguments was not an Integer.
RangeError:: One of the arguments given was too big/small.
This list is not exhaustive; other Errno:: exceptions are also possible.
;T;[o;=
;3I"
overload;F;40;;;50;)I"$advise(advice, offset=0, len=0);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[[I" advice;T0[I" offset;TI"0;T[I"len;TI"0;T; @; [ ; I"wAnnounce an intention to access data from the current file in a
specific pattern. On platforms that do not support the
posix_fadvise(2) system call, this method is a no-op.
_advice_ is one of the following symbols:
:normal:: No advice to give; the default assumption for an open file.
:sequential:: The data will be accessed sequentially
with lower offsets read before higher ones.
:random:: The data will be accessed in random order.
:willneed:: The data will be accessed in the near future.
:dontneed:: The data will not be accessed in the near future.
:noreuse:: The data will only be accessed once.
The semantics of a piece of advice are platform-dependent. See
man 2 posix_fadvise for details.
"data" means the region of the current file that begins at
_offset_ and extends for _len_ bytes. If _len_ is 0, the region
ends at the last byte of the file. By default, both _offset_ and
_len_ are 0, meaning that the advice applies to the entire file.
If an error occurs, one of the following exceptions will be raised:
IOError:: The IO stream is closed.
Errno::EBADF::
The file descriptor of the current file is invalid.
Errno::EINVAL:: An invalid value for _advice_ was given.
Errno::ESPIPE::
The file descriptor of the current file refers to a FIFO or
pipe. (Linux raises Errno::EINVAL in this case).
TypeError::
Either _advice_ was not a Symbol, or one of the
other arguments was not an Integer.
RangeError:: One of the arguments given was too big/small.
This list is not exhaustive; other Errno:: exceptions are also possible.
@overload advise(advice, offset=0, len=0)
@return [nil];T; 0; @;!F;"o;#;$T;%i$;&i$;'@t;(I"static VALUE
rb_io_advise(int argc, VALUE *argv, VALUE io)
{
VALUE advice, offset, len;
off_t off, l;
rb_io_t *fptr;
rb_scan_args(argc, argv, "12", &advice, &offset, &len);
advice_arg_check(advice);
io = GetWriteIO(io);
GetOpenFile(io, fptr);
off = NIL_P(offset) ? 0 : NUM2OFFT(offset);
l = NIL_P(len) ? 0 : NUM2OFFT(len);
#ifdef HAVE_POSIX_FADVISE
return do_io_advise(fptr, advice, off, l);
#else
((void)off, (void)l); /* Ignore all hint */
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#ioctl;F;[[@c0;[[@i&;T;:
ioctl;0;[ ;{ ;IC; "[Provides a mechanism for issuing low-level commands to control or
query I/O devices. Arguments and results are platform dependent. If
arg is a number, its value is passed directly. If it is a
string, it is interpreted as a binary sequence of bytes. On Unix
platforms, see ioctl(2) for details. Not implemented on
all platforms.
;T;[o;=
;3I"
overload;F;40;;;50;)I" ioctl(integer_cmd, arg);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I"integer_cmd;T0[I"arg;T0; @; [ ; I"Provides a mechanism for issuing low-level commands to control or
query I/O devices. Arguments and results are platform dependent. If
arg is a number, its value is passed directly. If it is a
string, it is interpreted as a binary sequence of bytes. On Unix
platforms, see ioctl(2) for details. Not implemented on
all platforms.
@overload ioctl(integer_cmd, arg)
@return [Integer];T; 0; @;!F;"o;#;$T;%i&;&i&;'@t;(I"static VALUE
rb_io_ioctl(int argc, VALUE *argv, VALUE io)
{
VALUE req, arg;
rb_scan_args(argc, argv, "11", &req, &arg);
return rb_ioctl(io, req, arg);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#fcntl;F;[[@c0;[[@i&;T;:
fcntl;0;[ ;{ ;IC; "Provides a mechanism for issuing low-level commands to control or
query file-oriented I/O streams. Arguments and results are platform
dependent. If arg is a number, its value is passed
directly. If it is a string, it is interpreted as a binary sequence
of bytes (Array#pack might be a useful way to build this string). On
Unix platforms, see fcntl(2) for details. Not
implemented on all platforms.
;T;[o;=
;3I"
overload;F;40;;;50;)I" fcntl(integer_cmd, arg);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @À; [ ; I"@return [Integer];T; 0; @À;!F;6i ;>0;[[I"integer_cmd;T0[I"arg;T0; @À; [ ; I"Provides a mechanism for issuing low-level commands to control or
query file-oriented I/O streams. Arguments and results are platform
dependent. If arg is a number, its value is passed
directly. If it is a string, it is interpreted as a binary sequence
of bytes (Array#pack might be a useful way to build this string). On
Unix platforms, see fcntl(2) for details. Not
implemented on all platforms.
@overload fcntl(integer_cmd, arg)
@return [Integer];T; 0; @À;!F;"o;#;$T;%i&;&i&;'@t;(I"static VALUE
rb_io_fcntl(int argc, VALUE *argv, VALUE io)
{
VALUE req, arg;
rb_scan_args(argc, argv, "11", &req, &arg);
return rb_fcntl(io, req, arg);
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#pid;F;[ ;[[@i/ ;T;;;0;[ ;{ ;IC; "KReturns the process ID of a child process associated with
ios. This will be set by IO.popen.
pipe = IO.popen("-")
if pipe
$stderr.puts "In parent, child pid is #{pipe.pid}"
else
$stderr.puts "In child, pid is #{$$}"
end
produces:
In child, pid is 26209
In parent, child pid is 26209
;T;[o;=
;3I"
overload;F;40;;;50;)I"pid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"oReturns the process ID of a child process associated with
ios. This will be set by IO.popen.
pipe = IO.popen("-")
if pipe
$stderr.puts "In parent, child pid is #{pipe.pid}"
else
$stderr.puts "In child, pid is #{$$}"
end
produces:
In child, pid is 26209
In parent, child pid is 26209
@overload pid
@return [Integer];T; 0; @;!F;"o;#;$T;%i ;&i, ;'@t;(I"static VALUE
rb_io_pid(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (!fptr->pid)
return Qnil;
return PIDT2NUM(fptr->pid);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#inspect;F;[ ;[[@iB ;T;;v;0;[ ;{ ;IC; "/Return a string describing this IO object.
;T;[o;=
;3I"
overload;F;40;;v;50;)I" inspect;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"VReturn a string describing this IO object.
@overload inspect
@return [String];T; 0; @;!F;"o;#;$T;%i; ;&i? ;'@t;(I"static VALUE
rb_io_inspect(VALUE obj)
{
rb_io_t *fptr;
VALUE result;
static const char closed[] = " (closed)";
fptr = RFILE(obj)->fptr;
if (!fptr) return rb_any_to_s(obj);
result = rb_str_new_cstr("#<");
rb_str_append(result, rb_class_name(CLASS_OF(obj)));
rb_str_cat2(result, ":");
if (NIL_P(fptr->pathv)) {
if (fptr->fd < 0) {
rb_str_cat(result, closed+1, strlen(closed)-1);
}
else {
rb_str_catf(result, "fd %d", fptr->fd);
}
}
else {
rb_str_append(result, fptr->pathv);
if (fptr->fd < 0) {
rb_str_cat(result, closed, strlen(closed));
}
}
return rb_str_cat2(result, ">");
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#external_encoding;F;[ ;[[@i-;T;;#;0;[ ;{ ;IC; "Returns the Encoding object that represents the encoding of the file.
If _io_ is in write mode and no encoding is specified, returns +nil+.
;T;[o;=
;3I"
overload;F;40;;#;50;)I"external_encoding;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Encoding;T; @; [ ; I"@return [Encoding];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the Encoding object that represents the encoding of the file.
If _io_ is in write mode and no encoding is specified, returns +nil+.
@overload external_encoding
@return [Encoding];T; 0; @;!F;"o;#;$T;%i-;&i-;'@t;(I"lstatic VALUE
rb_io_external_encoding(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (fptr->encs.enc2) {
return rb_enc_from_encoding(fptr->encs.enc2);
}
if (fptr->mode & FMODE_WRITABLE) {
if (fptr->encs.enc)
return rb_enc_from_encoding(fptr->encs.enc);
return Qnil;
}
return rb_enc_from_encoding(io_read_encoding(fptr));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#internal_encoding;F;[ ;[[@i-;T;:internal_encoding;0;[ ;{ ;IC; "fReturns the Encoding of the internal string if conversion is
specified. Otherwise returns +nil+.
;T;[o;=
;3I"
overload;F;40;;;50;)I"internal_encoding;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Encoding;T; @4; [ ; I"@return [Encoding];T; 0; @4;!F;6i ;>0;[ ; @4; [ ; I"Returns the Encoding of the internal string if conversion is
specified. Otherwise returns +nil+.
@overload internal_encoding
@return [Encoding];T; 0; @4;!F;"o;#;$T;%i-;&i-;'@t;(I"static VALUE
rb_io_internal_encoding(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (!fptr->encs.enc2) return Qnil;
return rb_enc_from_encoding(io_read_encoding(fptr));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#set_encoding;F;[[@c0;[[@i-;T;:set_encoding;0;[ ;{ ;IC; "2If single argument is specified, read string from io is tagged
with the encoding specified. If encoding is a colon separated two
encoding names "A:B", the read string is converted from encoding A
(external encoding) to encoding B (internal encoding), then tagged
with B. If two arguments are specified, those must be encoding
objects or encoding names, and the first one is the external encoding, and the
second one is the internal encoding.
If the external encoding and the internal encoding is specified,
optional hash argument specify the conversion option.
;T;[
o;=
;3I"
overload;F;40;;;50;)I"set_encoding(ext_enc);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @O; [ ; I"@return [IO];T; 0; @O;!F;6i ;>0;[[I" ext_enc;T0; @Oo;=
;3I"
overload;F;40;;;50;)I"$set_encoding("ext_enc:int_enc");T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @O; [ ; I"@return [IO];T; 0; @O;!F;6i ;>0;[[""ext_enc:"
int_enc"; @Oo;=
;3I"
overload;F;40;;;50;)I"#set_encoding(ext_enc, int_enc);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @O; [ ; I"@return [IO];T; 0; @O;!F;6i ;>0;[[I" ext_enc;T0[I" int_enc;T0; @Oo;=
;3I"
overload;F;40;;;50;)I")set_encoding("ext_enc:int_enc", opt);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @O; [ ; I"@return [IO];T; 0; @O;!F;6i ;>0;[[""ext_enc:"
int_enc"[I"opt;T0; @Oo;=
;3I"
overload;F;40;;;50;)I"(set_encoding(ext_enc, int_enc, opt);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @O; [ ; I"@return [IO];T; 0; @O;!F;6i ;>0;[[I" ext_enc;T0[I" int_enc;T0[I"opt;T0; @O; [ ; I"OIf single argument is specified, read string from io is tagged
with the encoding specified. If encoding is a colon separated two
encoding names "A:B", the read string is converted from encoding A
(external encoding) to encoding B (internal encoding), then tagged
with B. If two arguments are specified, those must be encoding
objects or encoding names, and the first one is the external encoding, and the
second one is the internal encoding.
If the external encoding and the internal encoding is specified,
optional hash argument specify the conversion option.
@overload set_encoding(ext_enc)
@return [IO]
@overload set_encoding("ext_enc:int_enc")
@return [IO]
@overload set_encoding(ext_enc, int_enc)
@return [IO]
@overload set_encoding("ext_enc:int_enc", opt)
@return [IO]
@overload set_encoding(ext_enc, int_enc, opt)
@return [IO];T; 0; @O;!F;"o;#;$T;%i-;&i-;'@t;(I"cstatic VALUE
rb_io_set_encoding(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
VALUE v1, v2, opt;
if (!RB_TYPE_P(io, T_FILE)) {
return rb_funcallv(io, id_set_encoding, argc, argv);
}
argc = rb_scan_args(argc, argv, "11:", &v1, &v2, &opt);
GetOpenFile(io, fptr);
io_encoding_set(fptr, v1, v2, opt);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#set_encoding_by_bom;F;[ ;[[@i ;T;:set_encoding_by_bom;0;[ ;{ ;IC; "Checks if +ios+ starts with a BOM, and then consumes it and sets
the external encoding. Returns the result encoding if found, or
nil. If +ios+ is not binmode or its encoding has been set
already, an exception will be raised.
File.write("bom.txt", "\u{FEFF}abc")
ios = File.open("bom.txt", "rb")
ios.set_encoding_by_bom #=> #io.raw { ... }.
See IO#raw for details on the parameters.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I")raw!(min: nil, time: nil, intr: nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"IO;T; @w; [ ; I"@return [IO];T; 0; @w;!F;6i ;>0;[[I" min:;TI"nil;T[I"
time:;TI"nil;T[I"
intr:;TI"nil;T; @w; [ ; I"
Enables raw mode, and returns +io+.
If the terminal mode needs to be back, use io.raw { ... }.
See IO#raw for details on the parameters.
You must require 'io/console' to use this method.
@overload raw!(min: nil, time: nil, intr: nil)
@return [IO];T; 0; @w;!F;"o;#;$T;%i;&i;'@t;(I"jstatic VALUE
console_set_raw(int argc, VALUE *argv, VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
rawmode_arg_t opts, *optp = rawmode_opt(&argc, argv, 0, 0, &opts);
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
set_rawmode(&t, optp);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cooked;F;[ ;[[@Wi;T;: cooked;0;[ ;{ ;IC; "Yields +self+ within cooked mode.
STDIN.cooked(&:gets)
will read and return a line with echo back and line editing.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" cooked;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"io;T; @; [ ; I"@yield [io];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Yields +self+ within cooked mode.
STDIN.cooked(&:gets)
will read and return a line with echo back and line editing.
You must require 'io/console' to use this method.
@overload cooked
@yield [io];T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"jstatic VALUE
console_cooked(VALUE io)
{
return ttymode(io, rb_yield, io, set_cookedmode, NULL);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cooked!;F;[ ;[[@Wi;T;: cooked!;0;[ ;{ ;IC; "Enables cooked mode.
If the terminal mode needs to be back, use io.cooked { ... }.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" cooked!;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Enables cooked mode.
If the terminal mode needs to be back, use io.cooked { ... }.
You must require 'io/console' to use this method.
@overload cooked!;T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
console_set_cooked(VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
set_cookedmode(&t, NULL);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#getch;F;[[@c0;[[@Wi;T;:
getch;0;[ ;{ ;IC; "Reads and returns a character in raw mode.
See IO#raw for details on the parameters.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"*getch(min: nil, time: nil, intr: nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @͂; [ ; I"@return [String];T; 0; @͂;!F;6i ;>0;[[I" min:;TI"nil;T[I"
time:;TI"nil;T[I"
intr:;TI"nil;T; @͂; [ ; I"Reads and returns a character in raw mode.
See IO#raw for details on the parameters.
You must require 'io/console' to use this method.
@overload getch(min: nil, time: nil, intr: nil)
@return [String];T; 0; @͂;!F;"o;#;$T;%i;&i;'@t;(I" static VALUE
console_getch(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(&argc, argv, 0, 0, &opts);
#ifndef _WIN32
return ttymode(io, getc_call, io, set_rawmode, optp);
#else
rb_io_t *fptr;
VALUE str;
wint_t c;
int w, len;
char buf[8];
wint_t wbuf[2];
struct timeval *to = NULL, tv;
GetOpenFile(io, fptr);
if (optp) {
if (optp->vtime) {
to = &tv;
tv.tv_sec = optp->vtime / 10;
tv.tv_usec = (optp->vtime % 10) * 100000;
}
if (optp->vmin != 1) {
rb_warning("min option ignored");
}
if (optp->intr) {
w = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, to);
if (w < 0) rb_eof_error();
if (!(w & RB_WAITFD_IN)) return Qnil;
}
else {
rb_warning("vtime option ignored if intr flag is unset");
}
}
len = (int)(VALUE)rb_thread_call_without_gvl(nogvl_getch, wbuf, RUBY_UBF_IO, 0);
switch (len) {
case 0:
return Qnil;
case 2:
buf[0] = (char)wbuf[0];
c = wbuf[1];
len = 1;
do {
buf[len++] = (unsigned char)c;
} while ((c >>= CHAR_BIT) && len < (int)sizeof(buf));
return rb_str_new(buf, len);
default:
c = wbuf[0];
len = rb_uv_to_utf8(buf, c);
str = rb_utf8_str_new(buf, len);
return rb_str_conv_enc(str, NULL, rb_default_external_encoding());
}
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#echo=;F;[[I"f;T0;[[@WiH;T;:
echo=;0;[ ;{ ;IC; "Enables/disables echo back.
On some platforms, all combinations of this flags and raw/cooked
mode may not be valid.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"echo=(flag);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" flag;T0; @; [ ; I"Enables/disables echo back.
On some platforms, all combinations of this flags and raw/cooked
mode may not be valid.
You must require 'io/console' to use this method.
@overload echo=(flag);T; 0; @;!F;"o;#;$T;%i>;&iE;'@t;(I"Bstatic VALUE
console_set_echo(VALUE io, VALUE f)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
if (RTEST(f))
set_echo(&t, NULL);
else
set_noecho(&t, NULL);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"
IO#echo?;F;[ ;[[@Wib;T;:
echo?;0;[ ;{ ;IC; "_Returns +true+ if echo back is enabled.
You must require 'io/console' to use this method.;T;[o;=
;3I"
overload;F;40;;;50;)I"
echo?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ ; [ ; I"@return [Boolean];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"Returns +true+ if echo back is enabled.
You must require 'io/console' to use this method.
@overload echo?
@return [Boolean];T; 0; @ ;!F;"o;#;$T;%iZ;&i`;6i ;'@t;(I"static VALUE
console_echo_p(VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
return echo_p(&t) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#console_mode;F;[ ;[[@Wi;T;:console_mode;0;[ ;{ ;IC; "kReturns a data represents the current console mode.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"console_mode;T;IC; " ;T;[ ; [ ; I" ;T; 0; @';!F;6i ;>0;[ ; @'; [ ; I"Returns a data represents the current console mode.
You must require 'io/console' to use this method.
@overload console_mode;T; 0; @';!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
console_conmode_get(VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
return conmode_new(cConmode, &t);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#console_mode=;F;[[I" mode;T0;[[@Wi;T;:console_mode=;0;[ ;{ ;IC; "XSets the console mode to +mode+.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"console_mode=(mode);T;IC; " ;T;[ ; [ ; I" ;T; 0; @=;!F;6i ;>0;[[I" mode;T0; @=; [ ; I"xSets the console mode to +mode+.
You must require 'io/console' to use this method.
@overload console_mode=(mode);T; 0; @=;!F;"o;#;$T;%i;&i;'@t;(I"%static VALUE
console_conmode_set(VALUE io, VALUE mode)
{
conmode *t, r;
rb_io_t *fptr;
int fd;
TypedData_Get_Struct(mode, conmode, &conmode_type, t);
r = *t;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!setattr(fd, &r)) rb_sys_fail(0);
return mode;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#noecho;F;[ ;[[@Wi8;T;: noecho;0;[ ;{ ;IC; "Yields +self+ with disabling echo back.
STDIN.noecho(&:gets)
will read and return a line without echo back.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" noecho;T;IC; " ;T;[o;2
;3I"
yield;F;4I" ;T;0;5[I"io;T; @W; [ ; I"@yield [io];T; 0; @W;!F;6i ;>0;[ ; @W; [ ; I"Yields +self+ with disabling echo back.
STDIN.noecho(&:gets)
will read and return a line without echo back.
You must require 'io/console' to use this method.
@overload noecho
@yield [io];T; 0; @W;!F;"o;#;$T;%i,;&i6;'@t;(I"fstatic VALUE
console_noecho(VALUE io)
{
return ttymode(io, rb_yield, io, set_noecho, NULL);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#winsize;F;[ ;[[@Wi;T;: winsize;0;[ ;{ ;IC; "MReturns console size.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" winsize;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @r; [ ; I"@return [Array];T; 0; @r;!F;6i ;>0;[ ; @r; [ ; I"sReturns console size.
You must require 'io/console' to use this method.
@overload winsize
@return [Array];T; 0; @r;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
console_winsize(VALUE io)
{
rb_io_t *fptr;
int fd;
rb_console_size_t ws;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
if (!getwinsize(fd, &ws)) rb_sys_fail(0);
return rb_assoc_new(INT2NUM(winsize_row(&ws)), INT2NUM(winsize_col(&ws)));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#winsize=;F;[[I" size;T0;[[@Wi;T;:
winsize=;0;[ ;{ ;IC; "Tries to set console size. The effect depends on the platform and
the running environment.
You must require 'io/console' to use this method.
;T;[ ; [ ; I"
Tries to set console size. The effect depends on the platform and
the running environment.
You must require 'io/console' to use this method.
;T; 0; @;!F;"o;#;$T;%i;&i ;'@t;(I"static VALUE
console_set_winsize(VALUE io, VALUE size)
{
rb_io_t *fptr;
rb_console_size_t ws;
#if defined _WIN32
HANDLE wh;
int newrow, newcol;
BOOL ret;
#endif
VALUE row, col, xpixel, ypixel;
const VALUE *sz;
int fd;
long sizelen;
GetOpenFile(io, fptr);
size = rb_Array(size);
if ((sizelen = RARRAY_LEN(size)) != 2 && sizelen != 4) {
rb_raise(rb_eArgError,
"wrong number of arguments (given %ld, expected 2 or 4)",
sizelen);
}
sz = RARRAY_CONST_PTR(size);
row = sz[0], col = sz[1], xpixel = ypixel = Qnil;
if (sizelen == 4) xpixel = sz[2], ypixel = sz[3];
fd = GetWriteFD(fptr);
#if defined TIOCSWINSZ
ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0;
#define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
SET(xpixel);
SET(ypixel);
#undef SET
if (!setwinsize(fd, &ws)) rb_sys_fail(0);
#elif defined _WIN32
wh = (HANDLE)rb_w32_get_osfhandle(fd);
#define SET(m) new##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
#undef SET
if (!NIL_P(xpixel)) (void)NUM2UINT(xpixel);
if (!NIL_P(ypixel)) (void)NUM2UINT(ypixel);
if (!GetConsoleScreenBufferInfo(wh, &ws)) {
rb_syserr_fail(LAST_ERROR, "GetConsoleScreenBufferInfo");
}
ws.dwSize.X = newcol;
ret = SetConsoleScreenBufferSize(wh, ws.dwSize);
ws.srWindow.Left = 0;
ws.srWindow.Top = 0;
ws.srWindow.Right = newcol-1;
ws.srWindow.Bottom = newrow-1;
if (!SetConsoleWindowInfo(wh, TRUE, &ws.srWindow)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo");
}
/* retry when shrinking buffer after shrunk window */
if (!ret && !SetConsoleScreenBufferSize(wh, ws.dwSize)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleScreenBufferInfo");
}
/* remove scrollbar if possible */
if (!SetConsoleWindowInfo(wh, TRUE, &ws.srWindow)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo");
}
#endif
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#iflush;F;[ ;[[@Wir;T;: iflush;0;[ ;{ ;IC; "WFlushes input buffer in kernel.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" iflush;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; I"jFlushes input buffer in kernel.
You must require 'io/console' to use this method.
@overload iflush;T; 0; @;!F;"o;#;$T;%ij;&io;'@t;(I"static VALUE
console_iflush(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
if (tcflush(fd, TCIFLUSH)) rb_sys_fail(0);
#endif
(void)fd;
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#oflush;F;[ ;[[@Wi;T;: oflush;0;[ ;{ ;IC; "XFlushes output buffer in kernel.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" oflush;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; I"kFlushes output buffer in kernel.
You must require 'io/console' to use this method.
@overload oflush;T; 0; @;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
console_oflush(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
if (tcflush(fd, TCOFLUSH)) rb_sys_fail(0);
#endif
(void)fd;
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#ioflush;F;[ ;[[@Wi;T;: ioflush;0;[ ;{ ;IC; "cFlushes input and output buffers in kernel.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" ioflush;T;IC; " ;T;[ ; [ ; I" ;T; 0; @Ƀ;!F;6i ;>0;[ ; @Ƀ; [ ; I"wFlushes input and output buffers in kernel.
You must require 'io/console' to use this method.
@overload ioflush;T; 0; @Ƀ;!F;"o;#;$T;%i;&i;'@t;(I"static VALUE
console_ioflush(VALUE io)
{
rb_io_t *fptr;
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
int fd1, fd2;
#endif
GetOpenFile(io, fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
fd1 = GetReadFD(fptr);
fd2 = GetWriteFD(fptr);
if (fd2 != -1 && fd1 != fd2) {
if (tcflush(fd1, TCIFLUSH)) rb_sys_fail(0);
if (tcflush(fd2, TCOFLUSH)) rb_sys_fail(0);
}
else {
if (tcflush(fd1, TCIOFLUSH)) rb_sys_fail(0);
}
#endif
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#beep;F;[ ;[[@Wi;T;: beep;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @߃;'@t;(I"static VALUE
console_beep(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
#ifdef _WIN32
(void)fd;
MessageBeep(0);
#else
if (write(fd, "\a", 1) < 0)
rb_sys_fail(0);
#endif
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#goto;F;[[I"y;T0[I"x;T0;[[@Wi
;T;: goto;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"static VALUE
console_goto(VALUE io, VALUE y, VALUE x)
{
rb_io_write(io, rb_sprintf("\x1b[%d;%dH", NUM2UINT(y)+1, NUM2UINT(x)+1));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor;F;[ ;[[@Wi;T;: cursor;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"static VALUE
console_cursor_pos(VALUE io)
{
static const struct query_args query = {"\033[6n", 0};
VALUE resp = console_vt_response(0, 0, io, &query);
VALUE row, column, term;
unsigned int r, c;
if (!RB_TYPE_P(resp, T_ARRAY) || RARRAY_LEN(resp) != 3) return Qnil;
term = RARRAY_AREF(resp, 2);
if (!RB_TYPE_P(term, T_STRING) || RSTRING_LEN(term) != 1) return Qnil;
if (RSTRING_PTR(term)[0] != 'R') return Qnil;
row = RARRAY_AREF(resp, 0);
column = RARRAY_AREF(resp, 1);
rb_ary_resize(resp, 2);
r = NUM2UINT(row) - 1;
c = NUM2UINT(column) - 1;
RARRAY_ASET(resp, 0, INT2NUM(r));
RARRAY_ASET(resp, 1, INT2NUM(c));
return resp;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor=;F;[[I" cpos;T0;[[@WiE;T;: cursor=;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"static VALUE
console_cursor_set(VALUE io, VALUE cpos)
{
cpos = rb_convert_type(cpos, T_ARRAY, "Array", "to_ary");
if (RARRAY_LEN(cpos) != 2) rb_raise(rb_eArgError, "expected 2D coordinate");
return console_goto(io, RARRAY_AREF(cpos, 0), RARRAY_AREF(cpos, 1));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor_up;F;[[I"val;T0;[[@WiM;T;:cursor_up;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"kstatic VALUE
console_cursor_up(VALUE io, VALUE val)
{
return console_move(io, -NUM2INT(val), 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor_down;F;[[I"val;T0;[[@WiS;T;:cursor_down;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @#;'@t;(I"mstatic VALUE
console_cursor_down(VALUE io, VALUE val)
{
return console_move(io, +NUM2INT(val), 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor_left;F;[[I"val;T0;[[@WiY;T;:cursor_left;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @1;'@t;(I"mstatic VALUE
console_cursor_left(VALUE io, VALUE val)
{
return console_move(io, 0, -NUM2INT(val));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#cursor_right;F;[[I"val;T0;[[@Wi_;T;:cursor_right;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @?;'@t;(I"nstatic VALUE
console_cursor_right(VALUE io, VALUE val)
{
return console_move(io, 0, +NUM2INT(val));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#goto_column;F;[[I"val;T0;[[@Wi!;T;:goto_column;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @M;'@t;(I"static VALUE
console_goto_column(VALUE io, VALUE val)
{
rb_io_write(io, rb_sprintf("\x1b[%dG", NUM2UINT(val)+1));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#erase_line;F;[[I"val;T0;[[@Wi(;T;:erase_line;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @[;'@t;(I"static VALUE
console_erase_line(VALUE io, VALUE val)
{
int mode = mode_in_range(val, 2, "line erase");
rb_io_write(io, rb_sprintf("\x1b[%dK", mode));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#erase_screen;F;[[I"val;T0;[[@Wi0;T;:erase_screen;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @i;'@t;(I"static VALUE
console_erase_screen(VALUE io, VALUE val)
{
int mode = mode_in_range(val, 3, "screen erase");
rb_io_write(io, rb_sprintf("\x1b[%dJ", mode));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#scroll_forward;F;[[I"val;T0;[[@Wie;T;:scroll_forward;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @w;'@t;(I"ostatic VALUE
console_scroll_forward(VALUE io, VALUE val)
{
return console_scroll(io, +NUM2INT(val));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#scroll_backward;F;[[I"val;T0;[[@Wik;T;:scroll_backward;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"pstatic VALUE
console_scroll_backward(VALUE io, VALUE val)
{
return console_scroll(io, -NUM2INT(val));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#clear_screen;F;[ ;[[@Wiq;T;:clear_screen;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"static VALUE
console_clear_screen(VALUE io)
{
console_erase_screen(io, INT2FIX(2));
console_goto(io, INT2FIX(0), INT2FIX(0));
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#pressed?;F;[[I"k;T0;[[@Wi;T;:
pressed?;0;[ ;{ ;IC; " ;T;[o;2
;3I" return;F;4@|;0;5[@~; @; [ ; @|; 0; @;6i ;'@t;(I"static VALUE
console_key_pressed_p(VALUE io, VALUE k)
{
int vk = -1;
if (FIXNUM_P(k)) {
vk = NUM2UINT(k);
}
else {
const struct vktable *t;
const char *kn;
if (SYMBOL_P(k)) {
k = rb_sym2str(k);
kn = RSTRING_PTR(k);
}
else {
kn = StringValuePtr(k);
}
t = console_win32_vk(kn, RSTRING_LEN(k));
if (!t || (vk = (short)t->vk) == -1) {
rb_raise(rb_eArgError, "unknown virtual key code: % "PRIsVALUE, k);
}
}
return GetKeyState(vk) & 0x80 ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" IO#check_winsize_changed;F;[ ;[[@WiS;T;:check_winsize_changed;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@t;(I"static VALUE
console_check_winsize_changed(VALUE io)
{
rb_io_t *fptr;
HANDLE h;
DWORD num;
GetOpenFile(io, fptr);
h = (HANDLE)rb_w32_get_osfhandle(GetReadFD(fptr));
while (GetNumberOfConsoleInputEvents(h, &num) && num > 0) {
INPUT_RECORD rec;
if (ReadConsoleInput(h, &rec, 1, &num)) {
if (rec.EventType == WINDOW_BUFFER_SIZE_EVENT) {
rb_yield(Qnil);
}
}
}
return io;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"IO#getpass;F;[[@c0;[[@Wi;T;: getpass;0;[ ;{ ;IC; "Reads and returns a line without echo back.
Prints +prompt+ unless it is +nil+.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I"getpass(prompt=nil);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" prompt;TI"nil;T; @; [ ; I"Reads and returns a line without echo back.
Prints +prompt+ unless it is +nil+.
You must require 'io/console' to use this method.
@overload getpass(prompt=nil)
@return [String];T; 0; @;!F;"o;#;$T;%i;&i
;'@t;(I"=static VALUE
console_getpass(int argc, VALUE *argv, VALUE io)
{
VALUE str, wio;
rb_check_arity(argc, 0, 1);
wio = rb_io_get_write_io(io);
if (wio == io && io == rb_stdin) wio = rb_stderr;
prompt(argc, argv, wio);
str = rb_ensure(getpass_call, io, puts_call, wio);
return str_chomp(str);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"IO.console;F;[[@c0;[[@Wi;T;: console;0;[ ;{ ;IC; "Returns an File instance opened console.
If +sym+ is given, it will be sent to the opened console with
+args+ and the result will be returned instead of the console IO
itself.
You must require 'io/console' to use this method.
;T;[o;=
;3I"
overload;F;40;;;50;)I" console;T;IC; " ;T;[o;2
;3I" return;F;4I"];T;0;5[I"#*::
Matches any file. Can be restricted by other values in the glob.
Equivalent to / .* /x in regexp.
*:: Matches all files regular files
c*:: Matches all files beginning with c
*c:: Matches all files ending with c
\*c*:: Matches all files that have c in them
(including at the beginning or end).
To match hidden files (that start with a . set the
File::FNM_DOTMATCH flag.
**::
Matches directories recursively or files expansively.
?::
Matches any one character. Equivalent to /.{1}/ in regexp.
[set]::
Matches any one character in +set+. Behaves exactly like character sets
in Regexp, including set negation ([^a-z]).
\ ::
Escapes the next metacharacter.
{a,b}::
Matches pattern a and pattern b if File::FNM_EXTGLOB flag is enabled.
Behaves like a Regexp union ((?:a|b)).
+flags+ is a bitwise OR of the FNM_XXX constants. The same
glob pattern and flags are used by Dir::glob.
Examples:
File.fnmatch('cat', 'cat') #=> true # match entire string
File.fnmatch('cat', 'category') #=> false # only match partial string
File.fnmatch('c{at,ub}s', 'cats') #=> false # { } isn't supported by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true # { } is supported on FNM_EXTGLOB
File.fnmatch('c?t', 'cat') #=> true # '?' match only 1 character
File.fnmatch('c??t', 'cat') #=> false # ditto
File.fnmatch('c*', 'cats') #=> true # '*' match 0 or more characters
File.fnmatch('c*t', 'c/a/b/t') #=> true # ditto
File.fnmatch('ca[a-z]', 'cat') #=> true # inclusive bracket expression
File.fnmatch('ca[^t]', 'cat') #=> false # exclusive bracket expression ('^' or '!')
File.fnmatch('cat', 'CAT') #=> false # case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true # case insensitive
File.fnmatch('cat', 'CAT', File::FNM_SYSCASE) #=> true or false # depends on the system default
File.fnmatch('?', '/', File::FNM_PATHNAME) #=> false # wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('\?', '?') #=> true # escaped wildcard becomes ordinary
File.fnmatch('\a', 'a') #=> true # escaped ordinary remains ordinary
File.fnmatch('\a', '\a', File::FNM_NOESCAPE) #=> true # FNM_NOESCAPE makes '\' ordinary
File.fnmatch('[\?]', '?') #=> true # can escape inside bracket expression
File.fnmatch('*', '.profile') #=> false # wildcard doesn't match leading
File.fnmatch('*', '.profile', File::FNM_DOTMATCH) #=> true # period by default.
File.fnmatch('.*', '.profile') #=> true
rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
File.fnmatch(rbfiles, 'main.rb') #=> false
File.fnmatch(rbfiles, './main.rb') #=> false
File.fnmatch(rbfiles, 'lib/song.rb') #=> true
File.fnmatch('**.rb', 'main.rb') #=> true
File.fnmatch('**.rb', './main.rb') #=> false
File.fnmatch('**.rb', 'lib/song.rb') #=> true
File.fnmatch('*', 'dave/.profile') #=> true
pattern = '*' '/' '*'
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
pattern = '**' '/' 'foo'
File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
;T;[o;=
;3I"
overload;F;40;;;50;)I"&fnmatch( pattern, path, [flags] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" pattern;T0[I" path;T0[I" [flags];T0; @o;=
;3I"
overload;F;40;;;50;)I"'fnmatch?( pattern, path, [flags] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" pattern;T0[I" path;T0[I" [flags];T0; @; [ ; I".Returns true if +path+ matches against +pattern+. The pattern is not a
regular expression; instead it follows rules similar to shell filename
globbing. It may contain the following metacharacters:
*::
Matches any file. Can be restricted by other values in the glob.
Equivalent to / .* /x in regexp.
*:: Matches all files regular files
c*:: Matches all files beginning with c
*c:: Matches all files ending with c
\*c*:: Matches all files that have c in them
(including at the beginning or end).
To match hidden files (that start with a . set the
File::FNM_DOTMATCH flag.
**::
Matches directories recursively or files expansively.
?::
Matches any one character. Equivalent to /.{1}/ in regexp.
[set]::
Matches any one character in +set+. Behaves exactly like character sets
in Regexp, including set negation ([^a-z]).
\ ::
Escapes the next metacharacter.
{a,b}::
Matches pattern a and pattern b if File::FNM_EXTGLOB flag is enabled.
Behaves like a Regexp union ((?:a|b)).
+flags+ is a bitwise OR of the FNM_XXX constants. The same
glob pattern and flags are used by Dir::glob.
Examples:
File.fnmatch('cat', 'cat') #=> true # match entire string
File.fnmatch('cat', 'category') #=> false # only match partial string
File.fnmatch('c{at,ub}s', 'cats') #=> false # { } isn't supported by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true # { } is supported on FNM_EXTGLOB
File.fnmatch('c?t', 'cat') #=> true # '?' match only 1 character
File.fnmatch('c??t', 'cat') #=> false # ditto
File.fnmatch('c*', 'cats') #=> true # '*' match 0 or more characters
File.fnmatch('c*t', 'c/a/b/t') #=> true # ditto
File.fnmatch('ca[a-z]', 'cat') #=> true # inclusive bracket expression
File.fnmatch('ca[^t]', 'cat') #=> false # exclusive bracket expression ('^' or '!')
File.fnmatch('cat', 'CAT') #=> false # case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true # case insensitive
File.fnmatch('cat', 'CAT', File::FNM_SYSCASE) #=> true or false # depends on the system default
File.fnmatch('?', '/', File::FNM_PATHNAME) #=> false # wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('\?', '?') #=> true # escaped wildcard becomes ordinary
File.fnmatch('\a', 'a') #=> true # escaped ordinary remains ordinary
File.fnmatch('\a', '\a', File::FNM_NOESCAPE) #=> true # FNM_NOESCAPE makes '\' ordinary
File.fnmatch('[\?]', '?') #=> true # can escape inside bracket expression
File.fnmatch('*', '.profile') #=> false # wildcard doesn't match leading
File.fnmatch('*', '.profile', File::FNM_DOTMATCH) #=> true # period by default.
File.fnmatch('.*', '.profile') #=> true
rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
File.fnmatch(rbfiles, 'main.rb') #=> false
File.fnmatch(rbfiles, './main.rb') #=> false
File.fnmatch(rbfiles, 'lib/song.rb') #=> true
File.fnmatch('**.rb', 'main.rb') #=> true
File.fnmatch('**.rb', './main.rb') #=> false
File.fnmatch('**.rb', 'lib/song.rb') #=> true
File.fnmatch('*', 'dave/.profile') #=> true
pattern = '*' '/' '*'
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
pattern = '**' '/' 'foo'
File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
@overload fnmatch( pattern, path, [flags] )
@return [Boolean]
@overload fnmatch?( pattern, path, [flags] )
@return [Boolean];T; 0; @;!F;"o;#;$T;%i0 ;&i ;'@?;(I"static VALUE
file_s_fnmatch(int argc, VALUE *argv, VALUE obj)
{
VALUE pattern, path;
VALUE rflags;
int flags;
if (rb_scan_args(argc, argv, "21", &pattern, &path, &rflags) == 3)
flags = NUM2INT(rflags);
else
flags = 0;
StringValueCStr(pattern);
FilePathStringValue(path);
if (flags & FNM_EXTGLOB) {
struct brace_args args;
args.value = path;
args.flags = flags;
if (ruby_brace_expand(RSTRING_PTR(pattern), flags, fnmatch_brace,
(VALUE)&args, rb_enc_get(pattern), pattern) > 0)
return Qtrue;
}
else {
rb_encoding *enc = rb_enc_compatible(pattern, path);
if (!enc) return Qfalse;
if (fnmatch(RSTRING_PTR(pattern), enc, RSTRING_PTR(path), flags) == 0)
return Qtrue;
}
RB_GC_GUARD(pattern);
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.fnmatch?;F;[[@c0;[[@i ;T;;;0;[ ;{ ;IC; "Returns true if +path+ matches against +pattern+. The pattern is not a
regular expression; instead it follows rules similar to shell filename
globbing. It may contain the following metacharacters:
*::
Matches any file. Can be restricted by other values in the glob.
Equivalent to / .* /x in regexp.
*:: Matches all files regular files
c*:: Matches all files beginning with c
*c:: Matches all files ending with c
\*c*:: Matches all files that have c in them
(including at the beginning or end).
To match hidden files (that start with a . set the
File::FNM_DOTMATCH flag.
**::
Matches directories recursively or files expansively.
?::
Matches any one character. Equivalent to /.{1}/ in regexp.
[set]::
Matches any one character in +set+. Behaves exactly like character sets
in Regexp, including set negation ([^a-z]).
\ ::
Escapes the next metacharacter.
{a,b}::
Matches pattern a and pattern b if File::FNM_EXTGLOB flag is enabled.
Behaves like a Regexp union ((?:a|b)).
+flags+ is a bitwise OR of the FNM_XXX constants. The same
glob pattern and flags are used by Dir::glob.
Examples:
File.fnmatch('cat', 'cat') #=> true # match entire string
File.fnmatch('cat', 'category') #=> false # only match partial string
File.fnmatch('c{at,ub}s', 'cats') #=> false # { } isn't supported by default
File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true # { } is supported on FNM_EXTGLOB
File.fnmatch('c?t', 'cat') #=> true # '?' match only 1 character
File.fnmatch('c??t', 'cat') #=> false # ditto
File.fnmatch('c*', 'cats') #=> true # '*' match 0 or more characters
File.fnmatch('c*t', 'c/a/b/t') #=> true # ditto
File.fnmatch('ca[a-z]', 'cat') #=> true # inclusive bracket expression
File.fnmatch('ca[^t]', 'cat') #=> false # exclusive bracket expression ('^' or '!')
File.fnmatch('cat', 'CAT') #=> false # case sensitive
File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true # case insensitive
File.fnmatch('cat', 'CAT', File::FNM_SYSCASE) #=> true or false # depends on the system default
File.fnmatch('?', '/', File::FNM_PATHNAME) #=> false # wildcard doesn't match '/' on FNM_PATHNAME
File.fnmatch('*', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('[/]', '/', File::FNM_PATHNAME) #=> false # ditto
File.fnmatch('\?', '?') #=> true # escaped wildcard becomes ordinary
File.fnmatch('\a', 'a') #=> true # escaped ordinary remains ordinary
File.fnmatch('\a', '\a', File::FNM_NOESCAPE) #=> true # FNM_NOESCAPE makes '\' ordinary
File.fnmatch('[\?]', '?') #=> true # can escape inside bracket expression
File.fnmatch('*', '.profile') #=> false # wildcard doesn't match leading
File.fnmatch('*', '.profile', File::FNM_DOTMATCH) #=> true # period by default.
File.fnmatch('.*', '.profile') #=> true
rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
File.fnmatch(rbfiles, 'main.rb') #=> false
File.fnmatch(rbfiles, './main.rb') #=> false
File.fnmatch(rbfiles, 'lib/song.rb') #=> true
File.fnmatch('**.rb', 'main.rb') #=> true
File.fnmatch('**.rb', './main.rb') #=> false
File.fnmatch('**.rb', 'lib/song.rb') #=> true
File.fnmatch('*', 'dave/.profile') #=> true
pattern = '*' '/' '*'
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
pattern = '**' '/' 'foo'
File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME) #=> true
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME) #=> false
File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"&fnmatch( pattern, path, [flags] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" pattern;T0[I" path;T0[I" [flags];T0; @o;=
;3I"
overload;F;40;;;50;)I"'fnmatch?( pattern, path, [flags] );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" pattern;T0[I" path;T0[I" [flags];T0; @; [ ; @; 0; @;!F;"o;#;$T;%i0 ;&i ;6i ;'@?;(I"static VALUE
file_s_fnmatch(int argc, VALUE *argv, VALUE obj)
{
VALUE pattern, path;
VALUE rflags;
int flags;
if (rb_scan_args(argc, argv, "21", &pattern, &path, &rflags) == 3)
flags = NUM2INT(rflags);
else
flags = 0;
StringValueCStr(pattern);
FilePathStringValue(path);
if (flags & FNM_EXTGLOB) {
struct brace_args args;
args.value = path;
args.flags = flags;
if (ruby_brace_expand(RSTRING_PTR(pattern), flags, fnmatch_brace,
(VALUE)&args, rb_enc_get(pattern), pattern) > 0)
return Qtrue;
}
else {
rb_encoding *enc = rb_enc_compatible(pattern, path);
if (!enc) return Qfalse;
if (fnmatch(RSTRING_PTR(pattern), enc, RSTRING_PTR(path), flags) == 0)
return Qtrue;
}
RB_GC_GUARD(pattern);
return Qfalse;
};T;)I"static VALUE;T;*To;
;IC;[2o; ; F;
;;;;I"File::Stat#initialize;T;[[I"
fname;T0;[[@Gij;T;;;0;[ ;{ ;IC; "iCreate a File::Stat object for the given file name (raising an
exception if the file doesn't exist).
;T;[o;=
;3I"
overload;F;40;:File::Stat.new;50;)I" File::Stat.new(file_name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Create a File::Stat object for the given file name (raising an
exception if the file doesn't exist).
@overload File::Stat.new(file_name);T; 0; @;!F;"o;#;$T;%ia;&ie;'@;(I"static VALUE
rb_stat_init(VALUE obj, VALUE fname)
{
struct stat st, *nst;
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (STAT(StringValueCStr(fname), &st) == -1) {
rb_sys_fail_path(fname);
}
if (DATA_PTR(obj)) {
xfree(DATA_PTR(obj));
DATA_PTR(obj) = NULL;
}
nst = ALLOC(struct stat);
*nst = st;
DATA_PTR(obj) = nst;
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#initialize_copy;T;[[I" orig;T0;[[@Gi;T;;j;0;[ ;{ ;IC; " :nodoc:
;T;[ ; [ ; I" :nodoc:;T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"Zstatic VALUE
rb_stat_init_copy(VALUE copy, VALUE orig)
{
struct stat *nst;
if (!OBJ_INIT_COPY(copy, orig)) return copy;
if (DATA_PTR(copy)) {
xfree(DATA_PTR(copy));
DATA_PTR(copy) = 0;
}
if (DATA_PTR(orig)) {
nst = ALLOC(struct stat);
*nst = *(struct stat*)DATA_PTR(orig);
DATA_PTR(copy) = nst;
}
return copy;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#<=>;T;[[I"
other;T0;[[@Gi3;T;;c;0;[ ;{ ;IC; "Compares File::Stat objects by comparing their respective modification
times.
+nil+ is returned if +other_stat+ is not a File::Stat object
f1 = File.new("f1", "w")
sleep 1
f2 = File.new("f2", "w")
f1.stat <=> f2.stat #=> -1
;T;[o;=
;3I"
overload;F;40;;c;50;)I"<=>(other_stat);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[ I"-1;TI"0;TI"1;TI"nil;T; @; [ ; I" @return [-1, 0, 1, nil];T; 0; @;!F;6i ;>0;[[I"other_stat;T0; @; [ ; I"'Compares File::Stat objects by comparing their respective modification
times.
+nil+ is returned if +other_stat+ is not a File::Stat object
f1 = File.new("f1", "w")
sleep 1
f2 = File.new("f2", "w")
f1.stat <=> f2.stat #=> -1
@overload <=>(other_stat)
@return [-1, 0, 1, nil];T; 0; @;!F;"o;#;$T;%i$;&i0;'@;(I"$static VALUE
rb_stat_cmp(VALUE self, VALUE other)
{
if (rb_obj_is_kind_of(other, rb_obj_class(self))) {
struct timespec ts1 = stat_mtimespec(get_stat(self));
struct timespec ts2 = stat_mtimespec(get_stat(other));
if (ts1.tv_sec == ts2.tv_sec) {
if (ts1.tv_nsec == ts2.tv_nsec) return INT2FIX(0);
if (ts1.tv_nsec < ts2.tv_nsec) return INT2FIX(-1);
return INT2FIX(1);
}
if (ts1.tv_sec < ts2.tv_sec) return INT2FIX(-1);
return INT2FIX(1);
}
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#dev;T;[ ;[[@GiZ;T;:dev;0;[ ;{ ;IC; "uReturns an integer representing the device on which stat
resides.
File.stat("testfile").dev #=> 774
;T;[o;=
;3I"
overload;F;40;;;50;)I"dev;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @7; [ ; I"@return [Integer];T; 0; @7;!F;6i ;>0;[ ; @7; [ ; I"Returns an integer representing the device on which stat
resides.
File.stat("testfile").dev #=> 774
@overload dev
@return [Integer];T; 0; @7;!F;"o;#;$T;%iP;&iW;'@;(I"Zstatic VALUE
rb_stat_dev(VALUE self)
{
return DEVT2NUM(get_stat(self)->st_dev);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#dev_major;T;[ ;[[@Gik;T;:dev_major;0;[ ;{ ;IC; "Returns the major part of File_Stat#dev or
nil.
File.stat("/dev/fd1").dev_major #=> 2
File.stat("/dev/tty").dev_major #=> 5
;T;[o;=
;3I"
overload;F;40;;;50;)I"dev_major;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @R; [ ; I"@return [Integer];T; 0; @R;!F;6i ;>0;[ ; @R; [ ; I"Returns the major part of File_Stat#dev or
nil.
File.stat("/dev/fd1").dev_major #=> 2
File.stat("/dev/tty").dev_major #=> 5
@overload dev_major
@return [Integer];T; 0; @R;!F;"o;#;$T;%i`;&ih;'@;(I"static VALUE
rb_stat_dev_major(VALUE self)
{
#if defined(major)
return UINT2NUM(major(get_stat(self)->st_dev));
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#dev_minor;T;[ ;[[@Gi;T;:dev_minor;0;[ ;{ ;IC; "Returns the minor part of File_Stat#dev or
nil.
File.stat("/dev/fd1").dev_minor #=> 1
File.stat("/dev/tty").dev_minor #=> 0
;T;[o;=
;3I"
overload;F;40;;;50;)I"dev_minor;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @m; [ ; I"@return [Integer];T; 0; @m;!F;6i ;>0;[ ; @m; [ ; I"Returns the minor part of File_Stat#dev or
nil.
File.stat("/dev/fd1").dev_minor #=> 1
File.stat("/dev/tty").dev_minor #=> 0
@overload dev_minor
@return [Integer];T; 0; @m;!F;"o;#;$T;%iu;&i};'@;(I"static VALUE
rb_stat_dev_minor(VALUE self)
{
#if defined(minor)
return UINT2NUM(minor(get_stat(self)->st_dev));
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#ino;T;[ ;[[@Gi;T;:ino;0;[ ;{ ;IC; "ZReturns the inode number for stat.
File.stat("testfile").ino #=> 1083669
;T;[o;=
;3I"
overload;F;40;;;50;)I"ino;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the inode number for stat.
File.stat("testfile").ino #=> 1083669
@overload ino
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_stat_ino(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_INOHIGH
/* assume INTEGER_PACK_LSWORD_FIRST and st_inohigh is just next of st_ino */
return rb_integer_unpack(&get_stat(self)->st_ino, 2,
SIZEOF_STRUCT_STAT_ST_INO, 0,
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER|
INTEGER_PACK_2COMP);
#elif SIZEOF_STRUCT_STAT_ST_INO > SIZEOF_LONG
return ULL2NUM(get_stat(self)->st_ino);
#else
return ULONG2NUM(get_stat(self)->st_ino);
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#mode;T;[ ;[[@Gi;T;: mode;0;[ ;{ ;IC; "Returns an integer representing the permission bits of
stat. The meaning of the bits is platform dependent; on
Unix systems, see stat(2).
File.chmod(0644, "testfile") #=> 1
s = File.stat("testfile")
sprintf("%o", s.mode) #=> "100644"
;T;[o;=
;3I"
overload;F;40;;;50;)I" mode;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"7Returns an integer representing the permission bits of
stat. The meaning of the bits is platform dependent; on
Unix systems, see stat(2).
File.chmod(0644, "testfile") #=> 1
s = File.stat("testfile")
sprintf("%o", s.mode) #=> "100644"
@overload mode
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"estatic VALUE
rb_stat_mode(VALUE self)
{
return UINT2NUM(ST2UINT(get_stat(self)->st_mode));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#nlink;T;[ ;[[@Gi;T;:
nlink;0;[ ;{ ;IC; "Returns the number of hard links to stat.
File.stat("testfile").nlink #=> 1
File.link("testfile", "testfile.bak") #=> 0
File.stat("testfile").nlink #=> 2
;T;[o;=
;3I"
overload;F;40;;;50;)I"
nlink;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the number of hard links to stat.
File.stat("testfile").nlink #=> 1
File.link("testfile", "testfile.bak") #=> 0
File.stat("testfile").nlink #=> 2
@overload nlink
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"^static VALUE
rb_stat_nlink(VALUE self)
{
return UINT2NUM(get_stat(self)->st_nlink);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#uid;T;[ ;[[@Gi;T;;
;0;[ ;{ ;IC; "eReturns the numeric user id of the owner of stat.
File.stat("testfile").uid #=> 501
;T;[o;=
;3I"
overload;F;40;;
;50;)I"uid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ي; [ ; I"@return [Integer];T; 0; @ي;!F;6i ;>0;[ ; @ي; [ ; I"Returns the numeric user id of the owner of stat.
File.stat("testfile").uid #=> 501
@overload uid
@return [Integer];T; 0; @ي;!F;"o;#;$T;%i;&i;'@;(I"Zstatic VALUE
rb_stat_uid(VALUE self)
{
return UIDT2NUM(get_stat(self)->st_uid);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#gid;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "fReturns the numeric group id of the owner of stat.
File.stat("testfile").gid #=> 500
;T;[o;=
;3I"
overload;F;40;;;50;)I"gid;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the numeric group id of the owner of stat.
File.stat("testfile").gid #=> 500
@overload gid
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"Zstatic VALUE
rb_stat_gid(VALUE self)
{
return GIDT2NUM(get_stat(self)->st_gid);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#rdev;T;[ ;[[@Gi;T;: rdev;0;[ ;{ ;IC; "Returns an integer representing the device type on which
stat resides. Returns nil if the operating
system doesn't support this feature.
File.stat("/dev/fd1").rdev #=> 513
File.stat("/dev/tty").rdev #=> 1280
;T;[o;=
;3I"
overload;F;40;;;50;)I" rdev;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @; [ ; I"@return [Integer, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns an integer representing the device type on which
stat resides. Returns nil if the operating
system doesn't support this feature.
File.stat("/dev/fd1").rdev #=> 513
File.stat("/dev/tty").rdev #=> 1280
@overload rdev
@return [Integer, nil];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_stat_rdev(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_RDEV
return DEVT2NUM(get_stat(self)->st_rdev);
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#rdev_major;T;[ ;[[@Gi
;T;:rdev_major;0;[ ;{ ;IC; "Returns the major part of File_Stat#rdev or
nil.
File.stat("/dev/fd1").rdev_major #=> 2
File.stat("/dev/tty").rdev_major #=> 5
;T;[o;=
;3I"
overload;F;40;; ;50;)I"rdev_major;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @+; [ ; I"@return [Integer];T; 0; @+;!F;6i ;>0;[ ; @+; [ ; I"Returns the major part of File_Stat#rdev or
nil.
File.stat("/dev/fd1").rdev_major #=> 2
File.stat("/dev/tty").rdev_major #=> 5
@overload rdev_major
@return [Integer];T; 0; @+;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
rb_stat_rdev_major(VALUE self)
{
#if defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(major)
return UINT2NUM(major(get_stat(self)->st_rdev));
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#rdev_minor;T;[ ;[[@Gi ;T;:rdev_minor;0;[ ;{ ;IC; "Returns the minor part of File_Stat#rdev or
nil.
File.stat("/dev/fd1").rdev_minor #=> 1
File.stat("/dev/tty").rdev_minor #=> 0
;T;[o;=
;3I"
overload;F;40;; ;50;)I"rdev_minor;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @F; [ ; I"@return [Integer];T; 0; @F;!F;6i ;>0;[ ; @F; [ ; I"Returns the minor part of File_Stat#rdev or
nil.
File.stat("/dev/fd1").rdev_minor #=> 1
File.stat("/dev/tty").rdev_minor #=> 0
@overload rdev_minor
@return [Integer];T; 0; @F;!F;"o;#;$T;%i;&i ;'@;(I"static VALUE
rb_stat_rdev_minor(VALUE self)
{
#if defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(minor)
return UINT2NUM(minor(get_stat(self)->st_rdev));
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#size;T;[ ;[[@Gi2;T;;;0;[ ;{ ;IC; "VReturns the size of stat in bytes.
File.stat("testfile").size #=> 66
;T;[o;=
;3I"
overload;F;40;;;50;)I" size;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @a; [ ; I"@return [Integer];T; 0; @a;!F;6i ;>0;[ ; @a; [ ; I"{Returns the size of stat in bytes.
File.stat("testfile").size #=> 66
@overload size
@return [Integer];T; 0; @a;!F;"o;#;$T;%i);&i/;'@;(I"\static VALUE
rb_stat_size(VALUE self)
{
return OFFT2NUM(get_stat(self)->st_size);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#blksize;T;[ ;[[@GiC;T;: blksize;0;[ ;{ ;IC; "Returns the native file system's block size. Will return nil
on platforms that don't support this information.
File.stat("testfile").blksize #=> 4096
;T;[o;=
;3I"
overload;F;40;; ;50;)I" blksize;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @|; [ ; I"@return [Integer, nil];T; 0; @|;!F;6i ;>0;[ ; @|; [ ; I"Returns the native file system's block size. Will return nil
on platforms that don't support this information.
File.stat("testfile").blksize #=> 4096
@overload blksize
@return [Integer, nil];T; 0; @|;!F;"o;#;$T;%i8;&i@;'@;(I"static VALUE
rb_stat_blksize(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
return ULONG2NUM(get_stat(self)->st_blksize);
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#blocks;T;[ ;[[@GiX;T;: blocks;0;[ ;{ ;IC; "Returns the number of native file system blocks allocated for this
file, or nil if the operating system doesn't
support this feature.
File.stat("testfile").blocks #=> 2
;T;[o;=
;3I"
overload;F;40;; ;50;)I" blocks;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @; [ ; I"@return [Integer, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the number of native file system blocks allocated for this
file, or nil if the operating system doesn't
support this feature.
File.stat("testfile").blocks #=> 2
@overload blocks
@return [Integer, nil];T; 0; @;!F;"o;#;$T;%iM;&iU;'@;(I"
static VALUE
rb_stat_blocks(VALUE self)
{
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
# if SIZEOF_STRUCT_STAT_ST_BLOCKS > SIZEOF_LONG
return ULL2NUM(get_stat(self)->st_blocks);
# else
return ULONG2NUM(get_stat(self)->st_blocks);
# endif
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#atime;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the last access time for this file as an object of class
Time.
File.stat("testfile").atime #=> Wed Dec 31 18:00:00 CST 1969
;T;[o;=
;3I"
overload;F;40;;;50;)I"
atime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @; [ ; I"@return [Time];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the last access time for this file as an object of class
Time.
File.stat("testfile").atime #=> Wed Dec 31 18:00:00 CST 1969
@overload atime
@return [Time];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"Vstatic VALUE
rb_stat_atime(VALUE self)
{
return stat_atime(get_stat(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#mtime;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "uReturns the modification time of stat.
File.stat("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"
mtime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
aTime;T; @ϋ; [ ; I"@return [ aTime];T; 0; @ϋ;!F;6i ;>0;[ ; @ϋ; [ ; I"Returns the modification time of stat.
File.stat("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
@overload mtime
@return [ aTime];T; 0; @ϋ;!F;"o;#;$T;%i;&i;'@;(I"Vstatic VALUE
rb_stat_mtime(VALUE self)
{
return stat_mtime(get_stat(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#ctime;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the change time for stat (that is, the time
directory information about the file was changed, not the file
itself).
Note that on Windows (NTFS), returns creation time (birth time).
File.stat("testfile").ctime #=> Wed Apr 09 08:53:14 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"
ctime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
aTime;T; @; [ ; I"@return [ aTime];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"-Returns the change time for stat (that is, the time
directory information about the file was changed, not the file
itself).
Note that on Windows (NTFS), returns creation time (birth time).
File.stat("testfile").ctime #=> Wed Apr 09 08:53:14 CDT 2003
@overload ctime
@return [ aTime];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"Vstatic VALUE
rb_stat_ctime(VALUE self)
{
return stat_ctime(get_stat(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#birthtime;T;[ ;[[@Gi
;T;;;0;[ ;{ ;IC; "Returns the birth time for stat.
If the platform doesn't have birthtime, raises NotImplementedError.
File.write("testfile", "foo")
sleep 10
File.write("testfile", "bar")
sleep 10
File.chmod(0644, "testfile")
sleep 10
File.read("testfile")
File.stat("testfile").birthtime #=> 2014-02-24 11:19:17 +0900
File.stat("testfile").mtime #=> 2014-02-24 11:19:27 +0900
File.stat("testfile").ctime #=> 2014-02-24 11:19:37 +0900
File.stat("testfile").atime #=> 2014-02-24 11:19:47 +0900
;T;[o;=
;3I"
overload;F;40;;;50;)I"birthtime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
aTime;T; @; [ ; I"@return [ aTime];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"BReturns the birth time for stat.
If the platform doesn't have birthtime, raises NotImplementedError.
File.write("testfile", "foo")
sleep 10
File.write("testfile", "bar")
sleep 10
File.chmod(0644, "testfile")
sleep 10
File.read("testfile")
File.stat("testfile").birthtime #=> 2014-02-24 11:19:17 +0900
File.stat("testfile").mtime #=> 2014-02-24 11:19:27 +0900
File.stat("testfile").ctime #=> 2014-02-24 11:19:37 +0900
File.stat("testfile").atime #=> 2014-02-24 11:19:47 +0900
@overload birthtime
@return [ aTime];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"^static VALUE
rb_stat_birthtime(VALUE self)
{
return stat_birthtime(get_stat(self));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#inspect;T;[ ;[[@Gi";T;;v;0;[ ;{ ;IC; "Produce a nicely formatted description of stat.
File.stat("/etc/passwd").inspect
#=> "#file'', ``directory'',
``characterSpecial'', ``blockSpecial'',
``fifo'', ``link'',
``socket'', or ``unknown''.
File.stat("/dev/tty").ftype #=> "characterSpecial"
;T;[o;=
;3I"
overload;F;40;;;50;)I"
ftype;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @;; [ ; I"@return [String];T; 0; @;;!F;6i ;>0;[ ; @;; [ ; I"xIdentifies the type of stat. The return string is one of:
``file'', ``directory'',
``characterSpecial'', ``blockSpecial'',
``fifo'', ``link'',
``socket'', or ``unknown''.
File.stat("/dev/tty").ftype #=> "characterSpecial"
@overload ftype
@return [String];T; 0; @;;!F;"o;#;$T;%i;&i;'@;(I"Wstatic VALUE
rb_stat_ftype(VALUE obj)
{
return rb_file_ftype(get_stat(obj));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#directory?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is a directory,
false otherwise.
File.stat("testfile").directory? #=> false
File.stat(".").directory? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"directory?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @V; [ ; I"@return [Boolean];T; 0; @V;!F;6i ;>0;[ ; @V; [ ; I"Returns true if stat is a directory,
false otherwise.
File.stat("testfile").directory? #=> false
File.stat(".").directory? #=> true
@overload directory?
@return [Boolean];T; 0; @V;!F;"o;#;$T;%i;&i;6i ;'@;(I"tstatic VALUE
rb_stat_d(VALUE obj)
{
if (S_ISDIR(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#readable?;T;[ ;[[@Gi_;T;;;0;[ ;{ ;IC; "Returns true if stat is readable by the
effective user id of this process.
File.stat("testfile").readable? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"readable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @q; [ ; I"@return [Boolean];T; 0; @q;!F;6i ;>0;[ ; @q; [ ; I"Returns true if stat is readable by the
effective user id of this process.
File.stat("testfile").readable? #=> true
@overload readable?
@return [Boolean];T; 0; @q;!F;"o;#;$T;%iT;&i\;6i ;'@;(I"static VALUE
rb_stat_r(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
if (rb_stat_owned(obj))
return st->st_mode & S_IRUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IRGRP
if (rb_stat_grpowned(obj))
return st->st_mode & S_IRGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IROTH
if (!(st->st_mode & S_IROTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#readable_real?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is readable by the real
user id of this process.
File.stat("testfile").readable_real? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"readable_real?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if stat is readable by the real
user id of this process.
File.stat("testfile").readable_real? #=> true
@overload readable_real?
@return [Boolean];T; 0; @;!F;"o;#;$T;%iu;&i};6i ;'@;(I"static VALUE
rb_stat_R(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IRUSR
if (rb_stat_rowned(obj))
return st->st_mode & S_IRUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IRGRP
if (rb_group_member(get_stat(obj)->st_gid))
return st->st_mode & S_IRGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IROTH
if (!(st->st_mode & S_IROTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#world_readable?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "KIf stat is readable by others, returns an integer
representing the file permission bits of stat. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
m = File.stat("/etc/passwd").world_readable? #=> 420
sprintf("%o", m) #=> "644";T;[o;=
;3I"
overload;F;40;;;50;)I"world_readable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @; [ ; I"@return [Integer, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"If stat is readable by others, returns an integer
representing the file permission bits of stat. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
m = File.stat("/etc/passwd").world_readable? #=> 420
sprintf("%o", m) #=> "644"
@overload world_readable?
@return [Integer, nil];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_wr(VALUE obj)
{
#ifdef S_IROTH
struct stat *st = get_stat(obj);
if ((st->st_mode & (S_IROTH)) == S_IROTH) {
return UINT2NUM(st->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
else {
return Qnil;
}
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#writable?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is writable by the
effective user id of this process.
File.stat("testfile").writable? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"writable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @Ì; [ ; I"@return [Boolean];T; 0; @Ì;!F;6i ;>0;[ ; @Ì; [ ; I"Returns true if stat is writable by the
effective user id of this process.
File.stat("testfile").writable? #=> true
@overload writable?
@return [Boolean];T; 0; @Ì;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_w(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (geteuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
if (rb_stat_owned(obj))
return st->st_mode & S_IWUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IWGRP
if (rb_stat_grpowned(obj))
return st->st_mode & S_IWGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IWOTH
if (!(st->st_mode & S_IWOTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#writable_real?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is writable by the real
user id of this process.
File.stat("testfile").writable_real? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"writable_real?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ތ; [ ; I"@return [Boolean];T; 0; @ތ;!F;6i ;>0;[ ; @ތ; [ ; I"Returns true if stat is writable by the real
user id of this process.
File.stat("testfile").writable_real? #=> true
@overload writable_real?
@return [Boolean];T; 0; @ތ;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_W(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (getuid() == 0) return Qtrue;
#endif
#ifdef S_IWUSR
if (rb_stat_rowned(obj))
return st->st_mode & S_IWUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IWGRP
if (rb_group_member(get_stat(obj)->st_gid))
return st->st_mode & S_IWGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IWOTH
if (!(st->st_mode & S_IWOTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#world_writable?;T;[ ;[[@Gi ;T;;;0;[ ;{ ;IC; "GIf stat is writable by others, returns an integer
representing the file permission bits of stat. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
m = File.stat("/tmp").world_writable? #=> 511
sprintf("%o", m) #=> "777";T;[o;=
;3I"
overload;F;40;;;50;)I"world_writable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @; [ ; I"@return [Integer, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"|If stat is writable by others, returns an integer
representing the file permission bits of stat. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
m = File.stat("/tmp").world_writable? #=> 511
sprintf("%o", m) #=> "777"
@overload world_writable?
@return [Integer, nil];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_ww(VALUE obj)
{
#ifdef S_IROTH
struct stat *st = get_stat(obj);
if ((st->st_mode & (S_IWOTH)) == S_IWOTH) {
return UINT2NUM(st->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
else {
return Qnil;
}
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#executable?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is executable or if the
operating system doesn't distinguish executable files from
nonexecutable files. The tests are made using the effective owner of
the process.
File.stat("testfile").executable? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I"executable?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I",Returns true if stat is executable or if the
operating system doesn't distinguish executable files from
nonexecutable files. The tests are made using the effective owner of
the process.
File.stat("testfile").executable? #=> false
@overload executable?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_x(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (geteuid() == 0) {
return st->st_mode & S_IXUGO ? Qtrue : Qfalse;
}
#endif
#ifdef S_IXUSR
if (rb_stat_owned(obj))
return st->st_mode & S_IXUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IXGRP
if (rb_stat_grpowned(obj))
return st->st_mode & S_IXGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IXOTH
if (!(st->st_mode & S_IXOTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I" File::Stat#executable_real?;T;[ ;[[@Gi;;T;;;0;[ ;{ ;IC; "USame as executable?, but tests using the real owner of
the process.;T;[o;=
;3I"
overload;F;40;;;50;)I"executable_real?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @0; [ ; I"@return [Boolean];T; 0; @0;!F;6i ;>0;[ ; @0; [ ; I"Same as executable?, but tests using the real owner of
the process.
@overload executable_real?
@return [Boolean];T; 0; @0;!F;"o;#;$T;%i3;&i8;6i ;'@;(I"static VALUE
rb_stat_X(VALUE obj)
{
struct stat *st = get_stat(obj);
#ifdef USE_GETEUID
if (getuid() == 0) {
return st->st_mode & S_IXUGO ? Qtrue : Qfalse;
}
#endif
#ifdef S_IXUSR
if (rb_stat_rowned(obj))
return st->st_mode & S_IXUSR ? Qtrue : Qfalse;
#endif
#ifdef S_IXGRP
if (rb_group_member(get_stat(obj)->st_gid))
return st->st_mode & S_IXGRP ? Qtrue : Qfalse;
#endif
#ifdef S_IXOTH
if (!(st->st_mode & S_IXOTH)) return Qfalse;
#endif
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#file?;T;[ ;[[@Gi^;T;;;0;[ ;{ ;IC; "Returns true if stat is a regular file (not
a device file, pipe, socket, etc.).
File.stat("testfile").file? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"
file?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @K; [ ; I"@return [Boolean];T; 0; @K;!F;6i ;>0;[ ; @K; [ ; I"Returns true if stat is a regular file (not
a device file, pipe, socket, etc.).
File.stat("testfile").file? #=> true
@overload file?
@return [Boolean];T; 0; @K;!F;"o;#;$T;%iS;&i[;6i ;'@;(I"tstatic VALUE
rb_stat_f(VALUE obj)
{
if (S_ISREG(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#zero?;T;[ ;[[@Gip;T;;;0;[ ;{ ;IC; "Returns true if stat is a zero-length file;
false otherwise.
File.stat("testfile").zero? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I"
zero?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @f; [ ; I"@return [Boolean];T; 0; @f;!F;6i ;>0;[ ; @f; [ ; I"Returns true if stat is a zero-length file;
false otherwise.
File.stat("testfile").zero? #=> false
@overload zero?
@return [Boolean];T; 0; @f;!F;"o;#;$T;%ie;&im;6i ;'@;(I"pstatic VALUE
rb_stat_z(VALUE obj)
{
if (get_stat(obj)->st_size == 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#size?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "VReturns the size of stat in bytes.
File.stat("testfile").size #=> 66;T;[o;=
;3I"
overload;F;40;;;50;)I" size;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"|Returns the size of stat in bytes.
File.stat("testfile").size #=> 66
@overload size
@return [Integer];T; 0; @;!F;"o;#;$T;%iw;&i~;6i ;'@;(I"static VALUE
rb_stat_s(VALUE obj)
{
off_t size = get_stat(obj)->st_size;
if (size == 0) return Qnil;
return OFFT2NUM(size);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#owned?;T;[ ;[[@Gi1;T;;;0;[ ;{ ;IC; "Returns true if the effective user id of the process is
the same as the owner of stat.
File.stat("testfile").owned? #=> true
File.stat("/etc/passwd").owned? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I" owned?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if the effective user id of the process is
the same as the owner of stat.
File.stat("testfile").owned? #=> true
File.stat("/etc/passwd").owned? #=> false
@overload owned?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i%;&i.;6i ;'@;(I"{static VALUE
rb_stat_owned(VALUE obj)
{
if (get_stat(obj)->st_uid == geteuid()) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#grpowned?;T;[ ;[[@GiK;T;;;0;[ ;{ ;IC; "Returns true if the effective group id of the process is the same as
the group id of stat. On Windows NT, returns false.
File.stat("testfile").grpowned? #=> true
File.stat("/etc/passwd").grpowned? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I"grpowned?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if the effective group id of the process is the same as
the group id of stat. On Windows NT, returns false.
File.stat("testfile").grpowned? #=> true
File.stat("/etc/passwd").grpowned? #=> false
@overload grpowned?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i?;&iH;6i ;'@;(I"static VALUE
rb_stat_grpowned(VALUE obj)
{
#ifndef _WIN32
if (rb_group_member(get_stat(obj)->st_gid)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#pipe?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "~Returns true if the operating system supports pipes and
stat is a pipe; false otherwise.;T;[o;=
;3I"
overload;F;40;;;50;)I"
pipe?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ҍ; [ ; I"@return [Boolean];T; 0; @ҍ;!F;6i ;>0;[ ; @ҍ; [ ; I"Returns true if the operating system supports pipes and
stat is a pipe; false otherwise.
@overload pipe?
@return [Boolean];T; 0; @ҍ;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_p(VALUE obj)
{
#ifdef S_IFIFO
if (S_ISFIFO(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#symlink?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is a symbolic link,
false if it isn't or if the operating system doesn't
support this feature. As File::stat automatically follows symbolic
links, #symlink? will always be false for an object
returned by File::stat.
File.symlink("testfile", "alink") #=> 0
File.stat("alink").symlink? #=> false
File.lstat("alink").symlink? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"
symlink?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if stat is a symbolic link,
false if it isn't or if the operating system doesn't
support this feature. As File::stat automatically follows symbolic
links, #symlink? will always be false for an object
returned by File::stat.
File.symlink("testfile", "alink") #=> 0
File.stat("alink").symlink? #=> false
File.lstat("alink").symlink? #=> true
@overload symlink?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_l(VALUE obj)
{
#ifdef S_ISLNK
if (S_ISLNK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#socket?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat is a socket,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("testfile").socket? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I" socket?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if stat is a socket,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("testfile").socket? #=> false
@overload socket?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_S(VALUE obj)
{
#ifdef S_ISSOCK
if (S_ISSOCK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#blockdev?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if the file is a block device,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("testfile").blockdev? #=> false
File.stat("/dev/hda1").blockdev? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"blockdev?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @#; [ ; I"@return [Boolean];T; 0; @#;!F;6i ;>0;[ ; @#; [ ; I"Returns true if the file is a block device,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("testfile").blockdev? #=> false
File.stat("/dev/hda1").blockdev? #=> true
@overload blockdev?
@return [Boolean];T; 0; @#;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_b(VALUE obj)
{
#ifdef S_ISBLK
if (S_ISBLK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#chardev?;T;[ ;[[@Gi ;T;;;0;[ ;{ ;IC; "Returns true if the file is a character device,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("/dev/tty").chardev? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I"
chardev?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @>; [ ; I"@return [Boolean];T; 0; @>;!F;6i ;>0;[ ; @>; [ ; I"Returns true if the file is a character device,
false if it isn't or if the operating system doesn't
support this feature.
File.stat("/dev/tty").chardev? #=> true
@overload chardev?
@return [Boolean];T; 0; @>;!F;"o;#;$T;%i;&i;6i ;'@;(I"ustatic VALUE
rb_stat_c(VALUE obj)
{
if (S_ISCHR(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#setuid?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat has the set-user-id
permission bit set, false if it doesn't or if the
operating system doesn't support this feature.
File.stat("/bin/su").setuid? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I" setuid?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @Y; [ ; I"@return [Boolean];T; 0; @Y;!F;6i ;>0;[ ; @Y; [ ; I"Returns true if stat has the set-user-id
permission bit set, false if it doesn't or if the
operating system doesn't support this feature.
File.stat("/bin/su").setuid? #=> true
@overload setuid?
@return [Boolean];T; 0; @Y;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_suid(VALUE obj)
{
#ifdef S_ISUID
if (get_stat(obj)->st_mode & S_ISUID) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#setgid?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat has the set-group-id
permission bit set, false if it doesn't or if the
operating system doesn't support this feature.
File.stat("/usr/sbin/lpc").setgid? #=> true;T;[o;=
;3I"
overload;F;40;;;50;)I" setgid?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @t; [ ; I"@return [Boolean];T; 0; @t;!F;6i ;>0;[ ; @t; [ ; I"Returns true if stat has the set-group-id
permission bit set, false if it doesn't or if the
operating system doesn't support this feature.
File.stat("/usr/sbin/lpc").setgid? #=> true
@overload setgid?
@return [Boolean];T; 0; @t;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_sgid(VALUE obj)
{
#ifdef S_ISGID
if (get_stat(obj)->st_mode & S_ISGID) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File::Stat#sticky?;T;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if stat has its sticky bit set,
false if it doesn't or if the operating system doesn't
support this feature.
File.stat("testfile").sticky? #=> false;T;[o;=
;3I"
overload;F;40;;;50;)I" sticky?;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns true if stat has its sticky bit set,
false if it doesn't or if the operating system doesn't
support this feature.
File.stat("testfile").sticky? #=> false
@overload sticky?
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@;(I"static VALUE
rb_stat_sticky(VALUE obj)
{
#ifdef S_ISVTX
if (get_stat(obj)->st_mode & S_ISVTX) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[@X[;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@GiO[@Gi/;T;: Stat;;K;;;[ ;{ ;IC; "Objects of class File::Stat encapsulate common status information
for File objects. The information is recorded at the moment the
File::Stat object is created; changes made to the file after that
point will not be reflected. File::Stat objects are returned by
IO#stat, File::stat, File#lstat, and File::lstat. Many of these
methods return platform-specific values, and not all values are
meaningful on all systems. See also Kernel#test.;T;[ ; [ ; I"
Objects of class File::Stat encapsulate common status information
for File objects. The information is recorded at the moment the
File::Stat object is created; changes made to the file after that
point will not be reflected. File::Stat objects are returned by
IO#stat, File::stat, File#lstat, and File::lstat. Many of these
methods return platform-specific values, and not all values are
meaningful on all systems. See also Kernel#test.
;T; 0; @;!F;"o;#;$T;%iO;&iW;6i ;'o;L ;M0;N0;O0;: File;'@;Q@?;R0;I"File::Stat;T;S@]o; ; F;
;F;;;I"File.directory?;F;[ ;[[@i ;T;;;0;[ ;{ ;IC; "^Returns true if the named file is a directory,
false otherwise.;T;[o;=
;3I"
overload;F;40;;;50;)I"exist?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file is a directory,
false otherwise.
@overload exist?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i ;&i ;6i ;'@?;(I"(VALUE
rb_file_directory_p(void)
{
};T;)I"
VALUE;T;*To; ; F;
;F;;;I"File.exist?;F;[[I"
fname;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Return true if the named file exists.
_file_name_ can be an IO object.
"file exists" means that stat() or fstat() system call is successful.;T;[o;=
;3I"
overload;F;40;;;50;)I"exist?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ڎ; [ ; I"@return [Boolean];T; 0; @ڎ;!F;6i ;>0;[[I"file_name;T0; @ڎ; [ ; I"Return true if the named file exists.
_file_name_ can be an IO object.
"file exists" means that stat() or fstat() system call is successful.
@overload exist?(file_name)
@return [Boolean];T; 0; @ڎ;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_exist_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.exists?;F;[[I"
fname;T0;[[@Gi;T;: exists?;0;[ ;{ ;IC; ""Deprecated method. Don't use.;T;[o;=
;3I"
overload;F;40;;";50;)I"exists?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"UDeprecated method. Don't use.
@overload exists?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i ;&i
;6i ;'@?;(I"static VALUE
rb_file_exists_p(VALUE obj, VALUE fname)
{
const char *s = "FileTest#";
if (obj == rb_mFileTest) {
s = "FileTest.";
}
else if (obj == rb_cFile ||
(RB_TYPE_P(obj, T_CLASS) &&
RTEST(rb_class_inherited_p(obj, rb_cFile)))) {
s = "File.";
}
rb_warning("%sexists? is a deprecated name, use %sexist? instead", s, s);
return rb_file_exist_p(obj, fname);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.readable?;F;[[I"
fname;T0;[[@Gi*;T;;;0;[ ;{ ;IC; "Returns true if the named file is readable by the effective
user and group id of this process. See eaccess(3).
Note that some OS-level security features may cause this to return true
even though the file is not readable by the effective user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I"readable?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I";Returns true if the named file is readable by the effective
user and group id of this process. See eaccess(3).
Note that some OS-level security features may cause this to return true
even though the file is not readable by the effective user/group.
@overload readable?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i ;&i';6i ;'@?;(I"static VALUE
rb_file_readable_p(VALUE obj, VALUE fname)
{
if (rb_eaccess(fname, R_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.readable_real?;F;[[I"
fname;T0;[[@Gi<;T;;;0;[ ;{ ;IC; "Returns true if the named file is readable by the real
user and group id of this process. See access(3).
Note that some OS-level security features may cause this to return true
even though the file is not readable by the real user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I" readable_real?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @7; [ ; I"@return [Boolean];T; 0; @7;!F;6i ;>0;[[I"file_name;T0; @7; [ ; I"5Returns true if the named file is readable by the real
user and group id of this process. See access(3).
Note that some OS-level security features may cause this to return true
even though the file is not readable by the real user/group.
@overload readable_real?(file_name)
@return [Boolean];T; 0; @7;!F;"o;#;$T;%i1;&i9;6i ;'@?;(I"static VALUE
rb_file_readable_real_p(VALUE obj, VALUE fname)
{
if (rb_access(fname, R_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.world_readable?;F;[[I"
fname;T0;[[@Gi[;T;;;0;[ ;{ ;IC; "If file_name is readable by others, returns an integer
representing the file permission bits of file_name. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
_file_name_ can be an IO object.
File.world_readable?("/etc/passwd") #=> 420
m = File.world_readable?("/etc/passwd")
sprintf("%o", m) #=> "644";T;[o;=
;3I"
overload;F;40;;;50;)I" world_readable?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @V; [ ; I"@return [Integer, nil];T; 0; @V;!F;6i ;>0;[[I"file_name;T0; @V; [ ; I"If file_name is readable by others, returns an integer
representing the file permission bits of file_name. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
_file_name_ can be an IO object.
File.world_readable?("/etc/passwd") #=> 420
m = File.world_readable?("/etc/passwd")
sprintf("%o", m) #=> "644"
@overload world_readable?(file_name)
@return [Integer, nil];T; 0; @V;!F;"o;#;$T;%iK;&iX;6i ;'@?;(I"static VALUE
rb_file_world_readable_p(VALUE obj, VALUE fname)
{
#ifdef S_IROTH
struct stat st;
if (rb_stat(fname, &st) < 0) return Qnil;
if ((st.st_mode & (S_IROTH)) == S_IROTH) {
return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
#endif
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.writable?;F;[[I"
fname;T0;[[@Git;T;;;0;[ ;{ ;IC; "Returns true if the named file is writable by the effective
user and group id of this process. See eaccess(3).
Note that some OS-level security features may cause this to return true
even though the file is not writable by the effective user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I"writable?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @v; [ ; I"@return [Boolean];T; 0; @v;!F;6i ;>0;[[I"file_name;T0; @v; [ ; I";Returns true if the named file is writable by the effective
user and group id of this process. See eaccess(3).
Note that some OS-level security features may cause this to return true
even though the file is not writable by the effective user/group.
@overload writable?(file_name)
@return [Boolean];T; 0; @v;!F;"o;#;$T;%ii;&iq;6i ;'@?;(I"static VALUE
rb_file_writable_p(VALUE obj, VALUE fname)
{
if (rb_eaccess(fname, W_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.writable_real?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if the named file is writable by the real
user and group id of this process. See access(3).
Note that some OS-level security features may cause this to return true
even though the file is not writable by the real user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I" writable_real?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"5Returns true if the named file is writable by the real
user and group id of this process. See access(3).
Note that some OS-level security features may cause this to return true
even though the file is not writable by the real user/group.
@overload writable_real?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i{;&i;6i ;'@?;(I"static VALUE
rb_file_writable_real_p(VALUE obj, VALUE fname)
{
if (rb_access(fname, W_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.world_writable?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "If file_name is writable by others, returns an integer
representing the file permission bits of file_name. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
_file_name_ can be an IO object.
File.world_writable?("/tmp") #=> 511
m = File.world_writable?("/tmp")
sprintf("%o", m) #=> "777";T;[o;=
;3I"
overload;F;40;;;50;)I" world_writable?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @; [ ; I"@return [Integer, nil];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"If file_name is writable by others, returns an integer
representing the file permission bits of file_name. Returns
nil otherwise. The meaning of the bits is platform
dependent; on Unix systems, see stat(2).
_file_name_ can be an IO object.
File.world_writable?("/tmp") #=> 511
m = File.world_writable?("/tmp")
sprintf("%o", m) #=> "777"
@overload world_writable?(file_name)
@return [Integer, nil];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_world_writable_p(VALUE obj, VALUE fname)
{
#ifdef S_IWOTH
struct stat st;
if (rb_stat(fname, &st) < 0) return Qnil;
if ((st.st_mode & (S_IWOTH)) == S_IWOTH) {
return UINT2NUM(st.st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
#endif
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.executable?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if the named file is executable by the effective
user and group id of this process. See eaccess(3).
Windows does not support execute permissions separately from read
permissions. On Windows, a file is only considered executable if it ends in
.bat, .cmd, .com, or .exe.
Note that some OS-level security features may cause this to return true
even though the file is not executable by the effective user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I"executable?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @ԏ; [ ; I"@return [Boolean];T; 0; @ԏ;!F;6i ;>0;[[I"file_name;T0; @ԏ; [ ; I"Returns true if the named file is executable by the effective
user and group id of this process. See eaccess(3).
Windows does not support execute permissions separately from read
permissions. On Windows, a file is only considered executable if it ends in
.bat, .cmd, .com, or .exe.
Note that some OS-level security features may cause this to return true
even though the file is not executable by the effective user/group.
@overload executable?(file_name)
@return [Boolean];T; 0; @ԏ;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_executable_p(VALUE obj, VALUE fname)
{
if (rb_eaccess(fname, X_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.executable_real?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns true if the named file is executable by the real
user and group id of this process. See access(3).
Windows does not support execute permissions separately from read
permissions. On Windows, a file is only considered executable if it ends in
.bat, .cmd, .com, or .exe.
Note that some OS-level security features may cause this to return true
even though the file is not executable by the real user/group.;T;[o;=
;3I"
overload;F;40;;;50;)I" executable_real?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file is executable by the real
user and group id of this process. See access(3).
Windows does not support execute permissions separately from read
permissions. On Windows, a file is only considered executable if it ends in
.bat, .cmd, .com, or .exe.
Note that some OS-level security features may cause this to return true
even though the file is not executable by the real user/group.
@overload executable_real?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_executable_real_p(VALUE obj, VALUE fname)
{
if (rb_access(fname, X_OK) < 0) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.file?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns +true+ if the named +file+ exists and is a regular file.
+file+ can be an IO object.
If the +file+ argument is a symbolic link, it will resolve the symbolic link
and use the file referenced by the link.;T;[o;=
;3I"
overload;F;40;;;50;)I"file?(file);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" file;T0; @; [ ; I" Returns +true+ if the named +file+ exists and is a regular file.
+file+ can be an IO object.
If the +file+ argument is a symbolic link, it will resolve the symbolic link
and use the file referenced by the link.
@overload file?(file)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_file_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (S_ISREG(st.st_mode)) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.zero?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "nReturns true if the named file exists and has
a zero size.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"zero?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @1; [ ; I"@return [Boolean];T; 0; @1;!F;6i ;>0;[[I"file_name;T0; @1; [ ; I"Returns true if the named file exists and has
a zero size.
_file_name_ can be an IO object.
@overload zero?(file_name)
@return [Boolean];T; 0; @1;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (st.st_size == 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.empty?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "nReturns true if the named file exists and has
a zero size.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"zero?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @P; [ ; I"@return [Boolean];T; 0; @P;!F;6i ;>0;[[I"file_name;T0; @P; [ ; @L; 0; @P;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_zero_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (st.st_size == 0) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.size?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "~Returns +nil+ if +file_name+ doesn't exist or has zero size, the size of the
file otherwise.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"size?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;TI"nil;T; @n; [ ; I"@return [Integer, nil];T; 0; @n;!F;6i ;>0;[[I"file_name;T0; @n; [ ; I"Returns +nil+ if +file_name+ doesn't exist or has zero size, the size of the
file otherwise.
_file_name_ can be an IO object.
@overload size?(file_name)
@return [Integer, nil];T; 0; @n;!F;"o;#;$T;%i;&i ;6i ;'@?;(I"static VALUE
rb_file_size_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qnil;
if (st.st_size == 0) return Qnil;
return OFFT2NUM(st.st_size);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.size;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "RReturns the size of file_name.
_file_name_ can be an IO object.
;T;[o;=
;3I"
overload;F;40;;;50;)I"size(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"}Returns the size of file_name.
_file_name_ can be an IO object.
@overload size(file_name)
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_size(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
return OFFT2NUM(st.st_size);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.owned?;F;[[I"
fname;T0;[[@Gi$;T;;;0;[ ;{ ;IC; "Returns true if the named file exists and the
effective used id of the calling process is the owner of
the file.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"owned?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file exists and the
effective used id of the calling process is the owner of
the file.
_file_name_ can be an IO object.
@overload owned?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i!;6i ;'@?;(I"static VALUE
rb_file_owned_p(VALUE obj, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (st.st_uid == geteuid()) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.grpowned?;F;[[I"
fname;T0;[[@GiC;T;;;0;[ ;{ ;IC; "Returns true if the named file exists and the
effective group id of the calling process is the owner of
the file. Returns false on Windows.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"grpowned?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @̐; [ ; I"@return [Boolean];T; 0; @̐;!F;6i ;>0;[[I"file_name;T0; @̐; [ ; I"Returns true if the named file exists and the
effective group id of the calling process is the owner of
the file. Returns false on Windows.
_file_name_ can be an IO object.
@overload grpowned?(file_name)
@return [Boolean];T; 0; @̐;!F;"o;#;$T;%i8;&i@;6i ;'@?;(I"static VALUE
rb_file_grpowned_p(VALUE obj, VALUE fname)
{
#ifndef _WIN32
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (rb_group_member(st.st_gid)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.pipe?;F;[[I"
fname;T0;[[@Gig;T;;;0;[ ;{ ;IC; "]Returns true if the named file is a pipe.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"pipe?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file is a pipe.
_file_name_ can be an IO object.
@overload pipe?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i^;&id;6i ;'@?;(I"#static VALUE
rb_file_pipe_p(VALUE obj, VALUE fname)
{
#ifdef S_IFIFO
# ifndef S_ISFIFO
# define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
# endif
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (S_ISFIFO(st.st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.symlink?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "DReturns true if the named file is a symbolic link.;T;[o;=
;3I"
overload;F;40;;;50;)I"symlink?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @
; [ ; I"@return [Boolean];T; 0; @
;!F;6i ;>0;[[I"file_name;T0; @
; [ ; I"xReturns true if the named file is a symbolic link.
@overload symlink?(file_name)
@return [Boolean];T; 0; @
;!F;"o;#;$T;%ix;&i|;6i ;'@?;(I"Bstatic VALUE
rb_file_symlink_p(VALUE obj, VALUE fname)
{
#ifndef S_ISLNK
# ifdef _S_ISLNK
# define S_ISLNK(m) _S_ISLNK(m)
# else
# ifdef _S_IFLNK
# define S_ISLNK(m) (((m) & S_IFMT) == _S_IFLNK)
# else
# ifdef S_IFLNK
# define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
# endif
# endif
# endif
#endif
#ifdef S_ISLNK
struct stat st;
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (lstat_without_gvl(StringValueCStr(fname), &st) < 0) return Qfalse;
if (S_ISLNK(st.st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.socket?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "_Returns true if the named file is a socket.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"socket?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @); [ ; I"@return [Boolean];T; 0; @);!F;6i ;>0;[[I"file_name;T0; @); [ ; I"Returns true if the named file is a socket.
_file_name_ can be an IO object.
@overload socket?(file_name)
@return [Boolean];T; 0; @);!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_socket_p(VALUE obj, VALUE fname)
{
#ifndef S_ISSOCK
# ifdef _S_ISSOCK
# define S_ISSOCK(m) _S_ISSOCK(m)
# else
# ifdef _S_IFSOCK
# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
# else
# ifdef S_IFSOCK
# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
# endif
# endif
# endif
#endif
#ifdef S_ISSOCK
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (S_ISSOCK(st.st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.blockdev?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "eReturns true if the named file is a block device.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"blockdev?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @H; [ ; I"@return [Boolean];T; 0; @H;!F;6i ;>0;[[I"file_name;T0; @H; [ ; I"Returns true if the named file is a block device.
_file_name_ can be an IO object.
@overload blockdev?(file_name)
@return [Boolean];T; 0; @H;!F;"o;#;$T;%i;&i;6i ;'@?;(I"ostatic VALUE
rb_file_blockdev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISBLK
# ifdef S_IFBLK
# define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
# else
# define S_ISBLK(m) (0) /* anytime false */
# endif
#endif
#ifdef S_ISBLK
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (S_ISBLK(st.st_mode)) return Qtrue;
#endif
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.chardev?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "iReturns true if the named file is a character device.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"chardev?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @g; [ ; I"@return [Boolean];T; 0; @g;!F;6i ;>0;[[I"file_name;T0; @g; [ ; I"Returns true if the named file is a character device.
_file_name_ can be an IO object.
@overload chardev?(file_name)
@return [Boolean];T; 0; @g;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_chardev_p(VALUE obj, VALUE fname)
{
#ifndef S_ISCHR
# define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
#endif
struct stat st;
if (rb_stat(fname, &st) < 0) return Qfalse;
if (S_ISCHR(st.st_mode)) return Qtrue;
return Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.setuid?;F;[[I"
fname;T0;[[@Gid;T;;;0;[ ;{ ;IC; "jReturns true if the named file has the setuid bit set.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"setuid?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file has the setuid bit set.
_file_name_ can be an IO object.
@overload setuid?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i[;&ia;6i ;'@?;(I"static VALUE
rb_file_suid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISUID
return check3rdbyte(fname, S_ISUID);
#else
return Qfalse;
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.setgid?;F;[[I"
fname;T0;[[@Giw;T;;;0;[ ;{ ;IC; "jReturns true if the named file has the setgid bit set.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"setgid?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns true if the named file has the setgid bit set.
_file_name_ can be an IO object.
@overload setgid?(file_name)
@return [Boolean];T; 0; @;!F;"o;#;$T;%in;⁢6i ;'@?;(I"static VALUE
rb_file_sgid_p(VALUE obj, VALUE fname)
{
#ifdef S_ISGID
return check3rdbyte(fname, S_ISGID);
#else
return Qfalse;
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.sticky?;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "jReturns true if the named file has the sticky bit set.
_file_name_ can be an IO object.;T;[o;=
;3I"
overload;F;40;;;50;)I"sticky?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @đ; [ ; I"@return [Boolean];T; 0; @đ;!F;6i ;>0;[[I"file_name;T0; @đ; [ ; I"Returns true if the named file has the sticky bit set.
_file_name_ can be an IO object.
@overload sticky?(file_name)
@return [Boolean];T; 0; @đ;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_sticky_p(VALUE obj, VALUE fname)
{
#ifdef S_ISVTX
return check3rdbyte(fname, S_ISVTX);
#else
return Qnil;
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.identical?;F;[[I" fname1;T0[I" fname2;T0;[[@Gi;T;:identical?;0;[ ;{ ;IC; "Returns true if the named files are identical.
_file_1_ and _file_2_ can be an IO object.
open("a", "w") {}
p File.identical?("a", "a") #=> true
p File.identical?("a", "./a") #=> true
File.link("a", "b")
p File.identical?("a", "b") #=> true
File.symlink("a", "c")
p File.identical?("a", "c") #=> true
open("d", "w") {}
p File.identical?("a", "d") #=> false;T;[o;=
;3I"
overload;F;40;;#;50;)I" identical?(file_1, file_2);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @; [ ; I"@return [Boolean];T; 0; @;!F;6i ;>0;[[I" file_1;T0[I" file_2;T0; @; [ ; I"Returns true if the named files are identical.
_file_1_ and _file_2_ can be an IO object.
open("a", "w") {}
p File.identical?("a", "a") #=> true
p File.identical?("a", "./a") #=> true
File.link("a", "b")
p File.identical?("a", "b") #=> true
File.symlink("a", "c")
p File.identical?("a", "c") #=> true
open("d", "w") {}
p File.identical?("a", "d") #=> false
@overload identical?(file_1, file_2)
@return [Boolean];T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@?;(I"static VALUE
rb_file_identical_p(VALUE obj, VALUE fname1, VALUE fname2)
{
#ifndef _WIN32
struct stat st1, st2;
if (rb_stat(fname1, &st1) < 0) return Qfalse;
if (rb_stat(fname2, &st2) < 0) return Qfalse;
if (st1.st_dev != st2.st_dev) return Qfalse;
if (st1.st_ino != st2.st_ino) return Qfalse;
return Qtrue;
#else
extern VALUE rb_w32_file_identical_p(VALUE, VALUE);
return rb_w32_file_identical_p(fname1, fname2);
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.stat;F;[[I"
fname;T0;[[@Gi$;T;;;0;[ ;{ ;IC; "Returns a File::Stat object for the named file (see File::Stat).
File.stat("testfile").mtime #=> Tue Apr 08 12:58:04 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"stat(file_name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"Returns a File::Stat object for the named file (see File::Stat).
File.stat("testfile").mtime #=> Tue Apr 08 12:58:04 CDT 2003
@overload stat(file_name);T; 0; @;!F;"o;#;$T;%i;&i ;'@?;(I"static VALUE
rb_file_s_stat(VALUE klass, VALUE fname)
{
struct stat st;
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (stat_without_gvl(RSTRING_PTR(fname), &st) < 0) {
rb_sys_fail_path(fname);
}
return rb_stat_new(&st);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.lstat;F;[[I"
fname;T0;[[@Gip;T;;;0;[ ;{ ;IC; "+Same as File::stat, but does not follow the last symbolic link.
Instead, reports on the link itself.
File.symlink("testfile", "link2test") #=> 0
File.stat("testfile").size #=> 66
File.lstat("link2test").size #=> 8
File.stat("link2test").size #=> 66
;T;[o;=
;3I"
overload;F;40;;;50;)I"lstat(file_name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[[I"file_name;T0; @ ; [ ; I"ISame as File::stat, but does not follow the last symbolic link.
Instead, reports on the link itself.
File.symlink("testfile", "link2test") #=> 0
File.stat("testfile").size #=> 66
File.lstat("link2test").size #=> 8
File.stat("link2test").size #=> 66
@overload lstat(file_name);T; 0; @ ;!F;"o;#;$T;%ib;&il;'@?;(I"Wstatic VALUE
rb_file_s_lstat(VALUE klass, VALUE fname)
{
#ifdef HAVE_LSTAT
struct stat st;
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
rb_sys_fail_path(fname);
}
return rb_stat_new(&st);
#else
return rb_file_s_stat(klass, fname);
#endif
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.ftype;F;[[I"
fname;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Identifies the type of the named file; the return string is one of
``file'', ``directory'',
``characterSpecial'', ``blockSpecial'',
``fifo'', ``link'',
``socket'', or ``unknown''.
File.ftype("testfile") #=> "file"
File.ftype("/dev/tty") #=> "characterSpecial"
File.ftype("/tmp/.X11-unix/X0") #=> "socket"
;T;[o;=
;3I"
overload;F;40;;;50;)I"ftype(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @:; [ ; I"@return [String];T; 0; @:;!F;6i ;>0;[[I"file_name;T0; @:; [ ; I"Identifies the type of the named file; the return string is one of
``file'', ``directory'',
``characterSpecial'', ``blockSpecial'',
``fifo'', ``link'',
``socket'', or ``unknown''.
File.ftype("testfile") #=> "file"
File.ftype("/dev/tty") #=> "characterSpecial"
File.ftype("/tmp/.X11-unix/X0") #=> "socket"
@overload ftype(file_name)
@return [String];T; 0; @:;!F;"o;#;$T;%i;&i ;'@?;(I"static VALUE
rb_file_s_ftype(VALUE klass, VALUE fname)
{
struct stat st;
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (lstat_without_gvl(StringValueCStr(fname), &st) == -1) {
rb_sys_fail_path(fname);
}
return rb_file_ftype(&st);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.atime;F;[[I"
fname;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Returns the last access time for the named file as a Time object.
_file_name_ can be an IO object.
File.atime("testfile") #=> Wed Apr 09 08:51:48 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"atime(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @Y; [ ; I"@return [Time];T; 0; @Y;!F;6i ;>0;[[I"file_name;T0; @Y; [ ; I"Returns the last access time for the named file as a Time object.
_file_name_ can be an IO object.
File.atime("testfile") #=> Wed Apr 09 08:51:48 CDT 2003
@overload atime(file_name)
@return [Time];T; 0; @Y;!F;"o;#;$T;%i ;&i ;'@?;(I"static VALUE
rb_file_s_atime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
return stat_atime(&st);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.mtime;F;[[I"
fname;T0;[[@GiQ ;T;;;0;[ ;{ ;IC; "Returns the modification time for the named file as a Time object.
_file_name_ can be an IO object.
File.mtime("testfile") #=> Tue Apr 08 12:58:04 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"mtime(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @x; [ ; I"@return [Time];T; 0; @x;!F;6i ;>0;[[I"file_name;T0; @x; [ ; I"Returns the modification time for the named file as a Time object.
_file_name_ can be an IO object.
File.mtime("testfile") #=> Tue Apr 08 12:58:04 CDT 2003
@overload mtime(file_name)
@return [Time];T; 0; @x;!F;"o;#;$T;%iE ;&iN ;'@?;(I"static VALUE
rb_file_s_mtime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
return stat_mtime(&st);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.ctime;F;[[I"
fname;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "'Returns the change time for the named file (the time at which
directory information about the file was changed, not the file
itself).
_file_name_ can be an IO object.
Note that on Windows (NTFS), returns creation time (birth time).
File.ctime("testfile") #=> Wed Apr 09 08:53:13 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"ctime(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @; [ ; I"@return [Time];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"VReturns the change time for the named file (the time at which
directory information about the file was changed, not the file
itself).
_file_name_ can be an IO object.
Note that on Windows (NTFS), returns creation time (birth time).
File.ctime("testfile") #=> Wed Apr 09 08:53:13 CDT 2003
@overload ctime(file_name)
@return [Time];T; 0; @;!F;"o;#;$T;%iu ;&i ;'@?;(I"static VALUE
rb_file_s_ctime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
return stat_ctime(&st);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.birthtime;F;[[I"
fname;T0;[[@Gi ;T;;;0;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@?;(I"RUBY_FUNC_EXPORTED VALUE
rb_file_s_birthtime(VALUE klass, VALUE fname)
{
statx_data st;
if (rb_statx(fname, &st, STATX_BTIME) < 0) {
int e = errno;
FilePathValue(fname);
rb_syserr_fail_path(e, fname);
}
return statx_birthtime(&st, fname);
};T;)I" RUBY_FUNC_EXPORTED VALUE;T;*To; ; F;
;F;;;I"File.utime;F;[[@c0;[[@Gi ;T;;;0;[ ;{ ;IC; "Sets the access and modification times of each named file to the
first two arguments. If a file is a symlink, this method acts upon
its referent rather than the link itself; for the inverse
behavior see File.lutime. Returns the number of file
names in the argument list.
;T;[o;=
;3I"
overload;F;40;;;50;)I"(utime(atime, mtime, file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @Ē; [ ; I"@return [Integer];T; 0; @Ē;!F;6i ;>0;[ [I"
atime;T0[I"
mtime;T0[I"file_name;T0[I"...;T0; @Ē; [ ; I"RSets the access and modification times of each named file to the
first two arguments. If a file is a symlink, this method acts upon
its referent rather than the link itself; for the inverse
behavior see File.lutime. Returns the number of file
names in the argument list.
@overload utime(atime, mtime, file_name, ...)
@return [Integer];T; 0; @Ē;!F;"o;#;$T;%i ;&i ;'@?;(I"ustatic VALUE
rb_file_s_utime(int argc, VALUE *argv, VALUE _)
{
return utime_internal_i(argc, argv, FALSE);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.chmod;F;[[@c0;[[@Gi
;T;;;0;[ ;{ ;IC; "AChanges permission bits on the named file(s) to the bit pattern
represented by mode_int. Actual effects are operating system
dependent (see the beginning of this section). On Unix systems, see
chmod(2) for details. Returns the number of files
processed.
File.chmod(0644, "testfile", "out") #=> 2
;T;[o;=
;3I"
overload;F;40;;;50;)I"%chmod(mode_int, file_name, ... );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I"
mode_int;T0[I"file_name;T0[I"...;T0; @; [ ; I"Changes permission bits on the named file(s) to the bit pattern
represented by mode_int. Actual effects are operating system
dependent (see the beginning of this section). On Unix systems, see
chmod(2) for details. Returns the number of files
processed.
File.chmod(0644, "testfile", "out") #=> 2
@overload chmod(mode_int, file_name, ... )
@return [Integer];T; 0; @;!F;"o;#;$T;%i
;&i
;'@?;(I"static VALUE
rb_file_s_chmod(int argc, VALUE *argv, VALUE _)
{
mode_t mode;
apply2args(1);
mode = NUM2MODET(*argv++);
return apply2files(chmod_internal, argc, argv, &mode);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.chown;F;[[@c0;[[@Gi
;T;;;0;[ ;{ ;IC; "Changes the owner and group of the named file(s) to the given
numeric owner and group id's. Only a process with superuser
privileges may change the owner of a file. The current owner of a
file may change the file's group to any group to which the owner
belongs. A nil or -1 owner or group id is ignored.
Returns the number of files processed.
File.chown(nil, 100, "testfile")
;T;[o;=
;3I"
overload;F;40;;;50;)I"0chown(owner_int, group_int, file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @
; [ ; I"@return [Integer];T; 0; @
;!F;6i ;>0;[ [I"owner_int;T0[I"group_int;T0[I"file_name;T0[I"...;T0; @
; [ ; I"Changes the owner and group of the named file(s) to the given
numeric owner and group id's. Only a process with superuser
privileges may change the owner of a file. The current owner of a
file may change the file's group to any group to which the owner
belongs. A nil or -1 owner or group id is ignored.
Returns the number of files processed.
File.chown(nil, 100, "testfile")
@overload chown(owner_int, group_int, file_name, ...)
@return [Integer];T; 0; @
;!F;"o;#;$T;%i
;&i
;'@?;(I"static VALUE
rb_file_s_chown(int argc, VALUE *argv, VALUE _)
{
struct chown_args arg;
apply2args(2);
arg.owner = to_uid(*argv++);
arg.group = to_gid(*argv++);
return apply2files(chown_internal, argc, argv, &arg);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.lchmod;F;[[@c0;[[@Gi]
;T;;;0;[ ;{ ;IC; "Equivalent to File::chmod, but does not follow symbolic links (so
it will change the permissions associated with the link, not the
file referenced by the link). Often not available.
;T;[o;=
;3I"
overload;F;40;;;50;)I"%lchmod(mode_int, file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @.; [ ; I"@return [Integer];T; 0; @.;!F;6i ;>0;[[I"
mode_int;T0[I"file_name;T0[I"...;T0; @.; [ ; I"Equivalent to File::chmod, but does not follow symbolic links (so
it will change the permissions associated with the link, not the
file referenced by the link). Often not available.
@overload lchmod(mode_int, file_name, ...)
@return [Integer];T; 0; @.;!F;"o;#;$T;%iS
;&iZ
;'@?;(I"static VALUE
rb_file_s_lchmod(int argc, VALUE *argv, VALUE _)
{
mode_t mode;
apply2args(1);
mode = NUM2MODET(*argv++);
return apply2files(lchmod_internal, argc, argv, &mode);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.lchown;F;[[@c0;[[@Gi
;T;;;0;[ ;{ ;IC; "Equivalent to File::chown, but does not follow symbolic
links (so it will change the owner associated with the link, not the
file referenced by the link). Often not available. Returns number
of files in the argument list.
;T;[o;=
;3I"
overload;F;40;;;50;)I"/lchown(owner_int, group_int, file_name,..);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @P; [ ; I"@return [Integer];T; 0; @P;!F;6i ;>0;[ [I"owner_int;T0[I"group_int;T0[I"file_name;T0[I"..;T0; @P; [ ; I")Equivalent to File::chown, but does not follow symbolic
links (so it will change the owner associated with the link, not the
file referenced by the link). Often not available. Returns number
of files in the argument list.
@overload lchown(owner_int, group_int, file_name,..)
@return [Integer];T; 0; @P;!F;"o;#;$T;%i
;&i
;'@?;(I"static VALUE
rb_file_s_lchown(int argc, VALUE *argv, VALUE _)
{
struct chown_args arg;
apply2args(2);
arg.owner = to_uid(*argv++);
arg.group = to_gid(*argv++);
return apply2files(lchown_internal, argc, argv, &arg);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.lutime;F;[[@c0;[[@Gi ;T;: lutime;0;[ ;{ ;IC; "Sets the access and modification times of each named file to the
first two arguments. If a file is a symlink, this method acts upon
the link itself as opposed to its referent; for the inverse
behavior, see File.utime. Returns the number of file
names in the argument list.
;T;[o;=
;3I"
overload;F;40;;$;50;)I")lutime(atime, mtime, file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @t; [ ; I"@return [Integer];T; 0; @t;!F;6i ;>0;[ [I"
atime;T0[I"
mtime;T0[I"file_name;T0[I"...;T0; @t; [ ; I"USets the access and modification times of each named file to the
first two arguments. If a file is a symlink, this method acts upon
the link itself as opposed to its referent; for the inverse
behavior, see File.utime. Returns the number of file
names in the argument list.
@overload lutime(atime, mtime, file_name, ...)
@return [Integer];T; 0; @t;!F;"o;#;$T;%i ;&i ;'@?;(I"ustatic VALUE
rb_file_s_lutime(int argc, VALUE *argv, VALUE _)
{
return utime_internal_i(argc, argv, TRUE);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.link;F;[[I" from;T0[I"to;T0;[[@Gi ;T;: link;0;[ ;{ ;IC; "+Creates a new name for an existing file using a hard link. Will not
overwrite new_name if it already exists (raising a subclass
of SystemCallError). Not available on all platforms.
File.link("testfile", ".testfile") #=> 0
IO.readlines(".testfile")[0] #=> "This is line one\n"
;T;[o;=
;3I"
overload;F;40;;%;50;)I" link(old_name, new_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @; [ ; I"@return [0];T; 0; @;!F;6i ;>0;[[I"
old_name;T0[I"
new_name;T0; @; [ ; I"^Creates a new name for an existing file using a hard link. Will not
overwrite new_name if it already exists (raising a subclass
of SystemCallError). Not available on all platforms.
File.link("testfile", ".testfile") #=> 0
IO.readlines(".testfile")[0] #=> "This is line one\n"
@overload link(old_name, new_name)
@return [0];T; 0; @;!F;"o;#;$T;%i ;&i ;'@?;(I"0static VALUE
rb_file_s_link(VALUE klass, VALUE from, VALUE to)
{
FilePathValue(from);
FilePathValue(to);
from = rb_str_encode_ospath(from);
to = rb_str_encode_ospath(to);
if (link(StringValueCStr(from), StringValueCStr(to)) < 0) {
sys_fail2(from, to);
}
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.symlink;F;[[I" from;T0[I"to;T0;[[@Gi ;T;: symlink;0;[ ;{ ;IC; "Creates a symbolic link called new_name for the existing file
old_name. Raises a NotImplemented exception on
platforms that do not support symbolic links.
File.symlink("testfile", "link2test") #=> 0
;T;[o;=
;3I"
overload;F;40;;&;50;)I" symlink(old_name, new_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @; [ ; I"@return [0];T; 0; @;!F;6i ;>0;[[I"
old_name;T0[I"
new_name;T0; @; [ ; I"Creates a symbolic link called new_name for the existing file
old_name. Raises a NotImplemented exception on
platforms that do not support symbolic links.
File.symlink("testfile", "link2test") #=> 0
@overload symlink(old_name, new_name)
@return [0];T; 0; @;!F;"o;#;$T;%i ;&i ;'@?;(I"6static VALUE
rb_file_s_symlink(VALUE klass, VALUE from, VALUE to)
{
FilePathValue(from);
FilePathValue(to);
from = rb_str_encode_ospath(from);
to = rb_str_encode_ospath(to);
if (symlink(StringValueCStr(from), StringValueCStr(to)) < 0) {
sys_fail2(from, to);
}
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.readlink;F;[[I" path;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Returns the name of the file referenced by the given link.
Not available on all platforms.
File.symlink("testfile", "link2test") #=> 0
File.readlink("link2test") #=> "testfile"
;T;[o;=
;3I"
overload;F;40;;;50;)I"readlink(link_name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ޓ;!F;6i ;>0;[[I"link_name;T0; @ޓ; [ ; I"Returns the name of the file referenced by the given link.
Not available on all platforms.
File.symlink("testfile", "link2test") #=> 0
File.readlink("link2test") #=> "testfile"
@overload readlink(link_name);T; 0; @ޓ;!F;"o;#;$T;%i ;&i ;'@?;(I"ystatic VALUE
rb_file_s_readlink(VALUE klass, VALUE path)
{
return rb_readlink(path, rb_filesystem_encoding());
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.unlink;F;[[@c0;[[@Gio ;T;;;0;[ ;{ ;IC; "aDeletes the named files, returning the number of names
passed as arguments. Raises an exception on any error.
Since the underlying implementation relies on the
unlink(2) system call, the type of
exception raised depends on its error type (see
https://linux.die.net/man/2/unlink) and has the form of
e.g. Errno::ENOENT.
See also Dir::rmdir.
;T;[o;=
;3I"
overload;F;40;;;50;)I"delete(file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I"file_name;T0[I"...;T0; @o;=
;3I"
overload;F;40;;;50;)I"unlink(file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I"file_name;T0[I"...;T0; @; [ ; I"Deletes the named files, returning the number of names
passed as arguments. Raises an exception on any error.
Since the underlying implementation relies on the
unlink(2) system call, the type of
exception raised depends on its error type (see
https://linux.die.net/man/2/unlink) and has the form of
e.g. Errno::ENOENT.
See also Dir::rmdir.
@overload delete(file_name, ...)
@return [Integer]
@overload unlink(file_name, ...)
@return [Integer];T; 0; @;!F;"o;#;$T;%i_ ;&im ;'@?;(I"}static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
return apply2files(unlink_internal, argc, argv, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.delete;F;[[@c0;[[@Gio ;T;;;0;[ ;{ ;IC; "aDeletes the named files, returning the number of names
passed as arguments. Raises an exception on any error.
Since the underlying implementation relies on the
unlink(2) system call, the type of
exception raised depends on its error type (see
https://linux.die.net/man/2/unlink) and has the form of
e.g. Errno::ENOENT.
See also Dir::rmdir.
;T;[o;=
;3I"
overload;F;40;;;50;)I"delete(file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @); [ ; I"@return [Integer];T; 0; @);!F;6i ;>0;[[I"file_name;T0[I"...;T0; @)o;=
;3I"
overload;F;40;;;50;)I"unlink(file_name, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @); [ ; I"@return [Integer];T; 0; @);!F;6i ;>0;[[I"file_name;T0[I"...;T0; @); [ ; @%; 0; @);!F;"o;#;$T;%i_ ;&im ;'@?;(I"}static VALUE
rb_file_s_unlink(int argc, VALUE *argv, VALUE klass)
{
return apply2files(unlink_internal, argc, argv, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.rename;F;[[I" from;T0[I"to;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Renames the given file to the new name. Raises a SystemCallError
if the file cannot be renamed.
File.rename("afile", "afile.bak") #=> 0
;T;[o;=
;3I"
overload;F;40;;;50;)I" rename(old_name, new_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @Y; [ ; I"@return [0];T; 0; @Y;!F;6i ;>0;[[I"
old_name;T0[I"
new_name;T0; @Y; [ ; I"Renames the given file to the new name. Raises a SystemCallError
if the file cannot be renamed.
File.rename("afile", "afile.bak") #=> 0
@overload rename(old_name, new_name)
@return [0];T; 0; @Y;!F;"o;#;$T;%i ;&i ;'@?;(I"static VALUE
rb_file_s_rename(VALUE klass, VALUE from, VALUE to)
{
struct rename_args ra;
VALUE f, t;
FilePathValue(from);
FilePathValue(to);
f = rb_str_encode_ospath(from);
t = rb_str_encode_ospath(to);
ra.src = StringValueCStr(f);
ra.dst = StringValueCStr(t);
#if defined __CYGWIN__
errno = 0;
#endif
if ((int)(VALUE)rb_thread_call_without_gvl(no_gvl_rename, &ra,
RUBY_UBF_IO, 0) < 0) {
int e = errno;
#if defined DOSISH
switch (e) {
case EEXIST:
if (chmod(ra.dst, 0666) == 0 &&
unlink(ra.dst) == 0 &&
rename(ra.src, ra.dst) == 0)
return INT2FIX(0);
}
#endif
syserr_fail2(e, from, to);
}
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.umask;F;[[@c0;[[@Gi ;T;:
umask;0;[ ;{ ;IC; "VReturns the current umask value for this process. If the optional
argument is given, set the umask to that value and return the
previous value. Umask values are subtracted from the
default permissions, so a umask of 0222 would make a
file read-only for everyone.
File.umask(0006) #=> 18
File.umask #=> 6
;T;[o;=
;3I"
overload;F;40;;';50;)I" umask();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @|; [ ; I"@return [Integer];T; 0; @|;!F;6i ;>0;[ ; @|o;=
;3I"
overload;F;40;;';50;)I"umask(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @|; [ ; I"@return [Integer];T; 0; @|;!F;6i ;>0;[[I" integer;T0; @|; [ ; I"Returns the current umask value for this process. If the optional
argument is given, set the umask to that value and return the
previous value. Umask values are subtracted from the
default permissions, so a umask of 0222 would make a
file read-only for everyone.
File.umask(0006) #=> 18
File.umask #=> 6
@overload umask()
@return [Integer]
@overload umask(integer)
@return [Integer];T; 0; @|;!F;"o;#;$T;%i ;&i ;'@?;(I"Astatic VALUE
rb_file_s_umask(int argc, VALUE *argv, VALUE _)
{
mode_t omask = 0;
switch (argc) {
case 0:
omask = umask(0);
umask(omask);
break;
case 1:
omask = umask(NUM2MODET(argv[0]));
break;
default:
rb_error_arity(argc, 0, 1);
}
return MODET2NUM(omask);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.truncate;F;[[I" path;T0[I"len;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Truncates the file file_name to be at most integer
bytes long. Not available on all platforms.
f = File.new("out", "w")
f.write("1234567890") #=> 10
f.close #=> nil
File.truncate("out", 5) #=> 0
File.size("out") #=> 5
;T;[o;=
;3I"
overload;F;40;;;50;)I"!truncate(file_name, integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @; [ ; I"@return [0];T; 0; @;!F;6i ;>0;[[I"file_name;T0[I" integer;T0; @; [ ; I"PTruncates the file file_name to be at most integer
bytes long. Not available on all platforms.
f = File.new("out", "w")
f.write("1234567890") #=> 10
f.close #=> nil
File.truncate("out", 5) #=> 0
File.size("out") #=> 5
@overload truncate(file_name, integer)
@return [0];T; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
{
struct truncate_arg ta;
int r;
ta.pos = NUM2POS(len);
FilePathValue(path);
path = rb_str_encode_ospath(path);
ta.path = StringValueCStr(path);
r = (int)(VALUE)rb_thread_call_without_gvl(nogvl_truncate, &ta,
RUBY_UBF_IO, NULL);
if (r < 0)
rb_sys_fail_path(path);
return INT2FIX(0);
#undef NUM2POS
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.mkfifo;F;[[@c0;[[@Gi;T;: mkfifo;0;[ ;{ ;IC; "Creates a FIFO special file with name _file_name_. _mode_
specifies the FIFO's permissions. It is modified by the process's
umask in the usual way: the permissions of the created file are
(mode & ~umask).
;T;[o;=
;3I"
overload;F;40;;(;50;)I"!mkfifo(file_name, mode=0666);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @ʔ; [ ; I"@return [0];T; 0; @ʔ;!F;6i ;>0;[[I"file_name;T0[I" mode;TI" 0666;T; @ʔ; [ ; I"Creates a FIFO special file with name _file_name_. _mode_
specifies the FIFO's permissions. It is modified by the process's
umask in the usual way: the permissions of the created file are
(mode & ~umask).
@overload mkfifo(file_name, mode=0666)
@return [0];T; 0; @ʔ;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_mkfifo(int argc, VALUE *argv, VALUE _)
{
VALUE path;
struct mkfifo_arg ma;
ma.mode = 0666;
rb_check_arity(argc, 1, 2);
if (argc > 1) {
ma.mode = NUM2MODET(argv[1]);
}
path = argv[0];
FilePathValue(path);
path = rb_str_encode_ospath(path);
ma.path = RSTRING_PTR(path);
if (rb_thread_call_without_gvl(nogvl_mkfifo, &ma, RUBY_UBF_IO, 0)) {
rb_sys_fail_path(path);
}
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.expand_path;F;[[I"*;T0[I"_;T0;[[@Gi ;T;;;0;[ ;{ ;IC; "Converts a pathname to an absolute pathname. Relative paths are
referenced from the current working directory of the process unless
+dir_string+ is given, in which case it will be used as the
starting point. The given pathname may start with a
``~'', which expands to the process owner's home
directory (the environment variable +HOME+ must be set
correctly). ``~user'' expands to the named
user's home directory.
File.expand_path("~oracle/bin") #=> "/home/oracle/bin"
A simple example of using +dir_string+ is as follows.
File.expand_path("ruby", "/usr/bin") #=> "/usr/bin/ruby"
A more complex example which also resolves parent directory is as follows.
Suppose we are in bin/mygem and want the absolute path of lib/mygem.rb.
File.expand_path("../../lib/mygem.rb", __FILE__)
#=> ".../path/to/project/lib/mygem.rb"
So first it resolves the parent of __FILE__, that is bin/, then go to the
parent, the root of the project and appends +lib/mygem.rb+.
;T;[o;=
;3I"
overload;F;40;;;50;)I"+expand_path(file_name [, dir_string] );T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" file_name[, dir_string];T0; @; [ ; I"(Converts a pathname to an absolute pathname. Relative paths are
referenced from the current working directory of the process unless
+dir_string+ is given, in which case it will be used as the
starting point. The given pathname may start with a
``~'', which expands to the process owner's home
directory (the environment variable +HOME+ must be set
correctly). ``~user'' expands to the named
user's home directory.
File.expand_path("~oracle/bin") #=> "/home/oracle/bin"
A simple example of using +dir_string+ is as follows.
File.expand_path("ruby", "/usr/bin") #=> "/usr/bin/ruby"
A more complex example which also resolves parent directory is as follows.
Suppose we are in bin/mygem and want the absolute path of lib/mygem.rb.
File.expand_path("../../lib/mygem.rb", __FILE__)
#=> ".../path/to/project/lib/mygem.rb"
So first it resolves the parent of __FILE__, that is bin/, then go to the
parent, the root of the project and appends +lib/mygem.rb+.
@overload expand_path(file_name [, dir_string] );T; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"lstatic VALUE
s_expand_path(int c, const VALUE * v, VALUE _)
{
return rb_file_s_expand_path(c, v);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.absolute_path;F;[[I"*;T0[I"_;T0;[[@Gi?;T;;;0;[ ;{ ;IC; "Converts a pathname to an absolute pathname. Relative paths are
referenced from the current working directory of the process unless
dir_string is given, in which case it will be used as the
starting point. If the given pathname starts with a ``~''
it is NOT expanded, it is treated as a normal directory name.
File.absolute_path("~oracle/bin") #=> "~''
it is NOT expanded, it is treated as a normal directory name.
File.absolute_path("~oracle/bin") #=> "true if +file_name+ is an absolute path, and
false otherwise.
File.absolute_path?("c:/foo") #=> false (on Linux), true (on Windows);T;[o;=
;3I"
overload;F;40;;);50;)I" absolute_path?(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Boolean;T; @#; [ ; I"@return [Boolean];T; 0; @#;!F;6i ;>0;[[I"file_name;T0; @#; [ ; I"Returns true if +file_name+ is an absolute path, and
false otherwise.
File.absolute_path?("c:/foo") #=> false (on Linux), true (on Windows)
@overload absolute_path?(file_name)
@return [Boolean];T; 0; @#;!F;"o;#;$T;%iE;&iL;6i ;'@?;(I"static VALUE
s_absolute_path_p(VALUE klass, VALUE fname)
{
VALUE path = rb_get_path(fname);
if (!rb_is_absolute_path(RSTRING_PTR(path))) return Qfalse;
return Qtrue;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.realpath;F;[[@c0;[[@Gi;T;;;0;[ ;{ ;IC; "?Returns the real (absolute) pathname of _pathname_ in the actual
filesystem not containing symlinks or useless dots.
If _dir_string_ is given, it is used as a base directory
for interpreting relative pathname instead of the current directory.
All components of the pathname must exist when this method is
called.
;T;[o;=
;3I"
overload;F;40;;;50;)I"&realpath(pathname [, dir_string]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @B;!F;6i ;>0;[[I"pathname[, dir_string];T0; @B; [ ; I"n Returns the real (absolute) pathname of _pathname_ in the actual
filesystem not containing symlinks or useless dots.
If _dir_string_ is given, it is used as a base directory
for interpreting relative pathname instead of the current directory.
All components of the pathname must exist when this method is
called.
@overload realpath(pathname [, dir_string]);T; 0; @B;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_realpath(int argc, VALUE *argv, VALUE klass)
{
VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
VALUE path = argv[0];
FilePathValue(path);
return rb_realpath_internal(basedir, path, 1);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.realdirpath;F;[[@c0;[[@Gi;T;;;0;[ ;{ ;IC; "HReturns the real (absolute) pathname of _pathname_ in the actual filesystem.
The real pathname doesn't contain symlinks or useless dots.
If _dir_string_ is given, it is used as a base directory
for interpreting relative pathname instead of the current directory.
The last component of the real pathname can be nonexistent.
;T;[o;=
;3I"
overload;F;40;;;50;)I")realdirpath(pathname [, dir_string]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @[;!F;6i ;>0;[[I"pathname[, dir_string];T0; @[; [ ; I"z Returns the real (absolute) pathname of _pathname_ in the actual filesystem.
The real pathname doesn't contain symlinks or useless dots.
If _dir_string_ is given, it is used as a base directory
for interpreting relative pathname instead of the current directory.
The last component of the real pathname can be nonexistent.
@overload realdirpath(pathname [, dir_string]);T; 0; @[;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_realdirpath(int argc, VALUE *argv, VALUE klass)
{
VALUE basedir = (rb_check_arity(argc, 1, 2) > 1) ? argv[1] : Qnil;
VALUE path = argv[0];
FilePathValue(path);
return rb_realpath_internal(basedir, path, 0);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.basename;F;[[@c0;[[@Gi";T;;;0;[ ;{ ;IC; "PReturns the last component of the filename given in
file_name (after first stripping trailing separators),
which can be formed using both File::SEPARATOR and
File::ALT_SEPARATOR as the separator when File::ALT_SEPARATOR is
not nil. If suffix is given and present at the
end of file_name, it is removed. If suffix is ".*",
any extension will be removed.
File.basename("/home/gumby/work/ruby.rb") #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb") #=> "ruby"
File.basename("/home/gumby/work/ruby.rb", ".*") #=> "ruby"
;T;[o;=
;3I"
overload;F;40;;;50;)I"$basename(file_name [, suffix] );T;IC; " ;T;[ ; [ ; I" ;T; 0; @t;!F;6i ;>0;[[I"file_name[, suffix];T0; @t; [ ; I"|Returns the last component of the filename given in
file_name (after first stripping trailing separators),
which can be formed using both File::SEPARATOR and
File::ALT_SEPARATOR as the separator when File::ALT_SEPARATOR is
not nil. If suffix is given and present at the
end of file_name, it is removed. If suffix is ".*",
any extension will be removed.
File.basename("/home/gumby/work/ruby.rb") #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb") #=> "ruby"
File.basename("/home/gumby/work/ruby.rb", ".*") #=> "ruby"
@overload basename(file_name [, suffix] );T; 0; @t;!F;"o;#;$T;%i;&i ;'@?;(I"static VALUE
rb_file_s_basename(int argc, VALUE *argv, VALUE _)
{
VALUE fname, fext, basename;
const char *name, *p;
long f, n;
rb_encoding *enc;
fext = Qnil;
if (rb_check_arity(argc, 1, 2) == 2) {
fext = argv[1];
StringValue(fext);
enc = check_path_encoding(fext);
}
fname = argv[0];
FilePathStringValue(fname);
if (NIL_P(fext) || !(enc = rb_enc_compatible(fname, fext))) {
enc = rb_enc_get(fname);
fext = Qnil;
}
if ((n = RSTRING_LEN(fname)) == 0 || !*(name = RSTRING_PTR(fname)))
return rb_str_new_shared(fname);
p = ruby_enc_find_basename(name, &f, &n, enc);
if (n >= 0) {
if (NIL_P(fext)) {
f = n;
}
else {
const char *fp;
fp = StringValueCStr(fext);
if (!(f = rmext(p, f, n, fp, RSTRING_LEN(fext), enc))) {
f = n;
}
RB_GC_GUARD(fext);
}
if (f == RSTRING_LEN(fname)) return rb_str_new_shared(fname);
}
basename = rb_str_new(p, f);
rb_enc_copy(basename, fname);
return basename;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.dirname;F;[[I"
fname;T0;[[@Gi[;T;;;0;[ ;{ ;IC; "XReturns all components of the filename given in file_name
except the last one (after first stripping trailing separators).
The filename can be formed using both File::SEPARATOR and
File::ALT_SEPARATOR as the separator when File::ALT_SEPARATOR is
not nil.
File.dirname("/home/gumby/work/ruby.rb") #=> "/home/gumby/work"
;T;[o;=
;3I"
overload;F;40;;;50;)I"dirname(file_name);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I"wReturns all components of the filename given in file_name
except the last one (after first stripping trailing separators).
The filename can be formed using both File::SEPARATOR and
File::ALT_SEPARATOR as the separator when File::ALT_SEPARATOR is
not nil.
File.dirname("/home/gumby/work/ruby.rb") #=> "/home/gumby/work"
@overload dirname(file_name);T; 0; @;!F;"o;#;$T;%iN;&iW;'@?;(I"dstatic VALUE
rb_file_s_dirname(VALUE klass, VALUE fname)
{
return rb_file_dirname(fname);
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.extname;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the extension (the portion of file name in +path+
starting from the last period).
If +path+ is a dotfile, or starts with a period, then the starting
dot is not dealt with the start of the extension.
An empty string will also be returned when the period is the last character
in +path+.
On Windows, trailing dots are truncated.
File.extname("test.rb") #=> ".rb"
File.extname("a/b/d/test.rb") #=> ".rb"
File.extname(".a/b/d/test.rb") #=> ".rb"
File.extname("foo.") #=> "" on Windows
File.extname("foo.") #=> "." on non-Windows
File.extname("test") #=> ""
File.extname(".profile") #=> ""
File.extname(".profile.sh") #=> ".sh"
;T;[o;=
;3I"
overload;F;40;;;50;)I"extname(path);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @; [ ; I"@return [String];T; 0; @;!F;6i ;>0;[[I" path;T0; @; [ ; I"Returns the extension (the portion of file name in +path+
starting from the last period).
If +path+ is a dotfile, or starts with a period, then the starting
dot is not dealt with the start of the extension.
An empty string will also be returned when the period is the last character
in +path+.
On Windows, trailing dots are truncated.
File.extname("test.rb") #=> ".rb"
File.extname("a/b/d/test.rb") #=> ".rb"
File.extname(".a/b/d/test.rb") #=> ".rb"
File.extname("foo.") #=> "" on Windows
File.extname("foo.") #=> "." on non-Windows
File.extname("test") #=> ""
File.extname(".profile") #=> ""
File.extname(".profile.sh") #=> ".sh"
@overload extname(path)
@return [String];T; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_extname(VALUE klass, VALUE fname)
{
const char *name, *e;
long len;
VALUE extname;
FilePathStringValue(fname);
name = StringValueCStr(fname);
len = RSTRING_LEN(fname);
e = ruby_enc_find_extname(name, &len, rb_enc_get(fname));
if (len < 1)
return rb_str_new(0, 0);
extname = rb_str_subseq(fname, e - name, len); /* keep the dot, too! */
return extname;
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.path;F;[[I"
fname;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the string representation of the path
File.path("/dev/null") #=> "/dev/null"
File.path(Pathname.new("/tmp")) #=> "/tmp"
;T;[o;=
;3I"
overload;F;40;;;50;)I"path(path);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ƕ; [ ; I"@return [String];T; 0; @ƕ;!F;6i ;>0;[[I" path;T0; @ƕ; [ ; I"Returns the string representation of the path
File.path("/dev/null") #=> "/dev/null"
File.path(Pathname.new("/tmp")) #=> "/tmp"
@overload path(path)
@return [String];T; 0; @ƕ;!F;"o;#;$T;%i;&i;'@?;(I"]static VALUE
rb_file_s_path(VALUE klass, VALUE fname)
{
return rb_get_path(fname);
};T;)I"static VALUE;T;*To;;[[@Gi;F;:Separator;;;;;[ ;{ ;IC; "&separates directory parts in path
;T;[ ; [ ; I"&separates directory parts in path;T; 0; @;!F;"o;#;$T;%i;&i;'@?;I"File::Separator;F;I"separator;To;;[[@Gi;F;:SEPARATOR;;;;;[ ;{ ;IC; "&separates directory parts in path
;T;[ ; [ ; I"&separates directory parts in path;T; 0; @;!F;"o;#;$T;%i;&i;'@?;I"File::SEPARATOR;F;I"separator;To; ; F;
;F;;;I"File.split;F;[[I" path;T0;[[@Gi;T;;;0;[ ;{ ;IC; "Splits the given string into a directory and a file component and
returns them in a two-element array. See also File::dirname and
File::basename.
File.split("/home/gumby/.profile") #=> ["/home/gumby", ".profile"]
;T;[o;=
;3I"
overload;F;40;;;50;)I"split(file_name);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @; [ ; I"@return [Array];T; 0; @;!F;6i ;>0;[[I"file_name;T0; @; [ ; I" Splits the given string into a directory and a file component and
returns them in a two-element array. See also File::dirname and
File::basename.
File.split("/home/gumby/.profile") #=> ["/home/gumby", ".profile"]
@overload split(file_name)
@return [Array];T; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_s_split(VALUE klass, VALUE path)
{
FilePathStringValue(path); /* get rid of converting twice */
return rb_assoc_new(rb_file_dirname(path), rb_file_s_basename(1,&path,Qundef));
};T;)I"static VALUE;T;*To; ; F;
;F;;;I"File.join;F;[[I" args;T0;[[@Gin;T;;;0;[ ;{ ;IC; "Returns a new string formed by joining the strings using
"/".
File.join("usr", "mail", "gumby") #=> "usr/mail/gumby"
;T;[o;=
;3I"
overload;F;40;;;50;)I"join(string, ...);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ ; [ ; I"@return [String];T; 0; @ ;!F;6i ;>0;[[I" string;T0[I"...;T0; @ ; [ ; I"Returns a new string formed by joining the strings using
"/".
File.join("usr", "mail", "gumby") #=> "usr/mail/gumby"
@overload join(string, ...)
@return [String];T; 0; @ ;!F;"o;#;$T;%ic;&ik;'@?;(I"\static VALUE
rb_file_s_join(VALUE klass, VALUE args)
{
return rb_file_join(args);
};T;)I"static VALUE;T;*To;;[[@Gi[@Gi;F;:ALT_SEPARATOR;;;;;[ ;{ ;IC; ",platform specific alternative separator
;T;[ ; [ ; I",platform specific alternative separator;T; 0; @=;!F;"o;#;$T;%i;&i;'@?;I"File::ALT_SEPARATOR;F;I" Qnil;To;;[[@Gi;F;:PATH_SEPARATOR;;;;;[ ;{ ;IC; "path list separator
;T;[ ; [ ; I"path list separator;T; 0; @J;!F;"o;#;$T;%i;&i;'@?;I"File::PATH_SEPARATOR;F;I" rb_fstring_cstr(PATH_SEP);To; ; F;
;;;;I"File#lstat;F;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "ESame as IO#stat, but does not follow the last symbolic link.
Instead, reports on the link itself.
File.symlink("testfile", "link2test") #=> 0
File.stat("testfile").size #=> 66
f = File.new("link2test")
f.lstat.size #=> 8
f.stat.size #=> 66
;T;[o;=
;3I"
overload;F;40;;;50;)I"
lstat;T;IC; " ;T;[ ; [ ; I" ;T; 0; @V;!F;6i ;>0;[ ; @V; [ ; I"WSame as IO#stat, but does not follow the last symbolic link.
Instead, reports on the link itself.
File.symlink("testfile", "link2test") #=> 0
File.stat("testfile").size #=> 66
f = File.new("link2test")
f.lstat.size #=> 8
f.stat.size #=> 66
@overload lstat;T; 0; @V;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_lstat(VALUE obj)
{
#ifdef HAVE_LSTAT
rb_io_t *fptr;
struct stat st;
VALUE path;
GetOpenFile(obj, fptr);
if (NIL_P(fptr->pathv)) return Qnil;
path = rb_str_encode_ospath(fptr->pathv);
if (lstat_without_gvl(RSTRING_PTR(path), &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return rb_stat_new(&st);
#else
return rb_io_stat(obj);
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#atime;F;[ ;[[@Gi8 ;T;;;0;[ ;{ ;IC; "Returns the last access time (a Time object) for file, or
epoch if file has not been accessed.
File.new("testfile").atime #=> Wed Dec 31 18:00:00 CST 1969
;T;[o;=
;3I"
overload;F;40;;;50;)I"
atime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @l; [ ; I"@return [Time];T; 0; @l;!F;6i ;>0;[ ; @l; [ ; I"Returns the last access time (a Time object) for file, or
epoch if file has not been accessed.
File.new("testfile").atime #=> Wed Dec 31 18:00:00 CST 1969
@overload atime
@return [Time];T; 0; @l;!F;"o;#;$T;%i- ;&i5 ;'@?;(I"static VALUE
rb_file_atime(VALUE obj)
{
rb_io_t *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fptr->fd, &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return stat_atime(&st);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#mtime;F;[ ;[[@Gih ;T;;;0;[ ;{ ;IC; "uReturns the modification time for file.
File.new("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"
mtime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @; [ ; I"@return [Time];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the modification time for file.
File.new("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
@overload mtime
@return [Time];T; 0; @;!F;"o;#;$T;%i^ ;&ie ;'@?;(I"static VALUE
rb_file_mtime(VALUE obj)
{
rb_io_t *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fptr->fd, &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return stat_mtime(&st);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#ctime;F;[ ;[[@Gi ;T;;;0;[ ;{ ;IC; "Returns the change time for file (that is, the time directory
information about the file was changed, not the file itself).
Note that on Windows (NTFS), returns creation time (birth time).
File.new("testfile").ctime #=> Wed Apr 09 08:53:14 CDT 2003
;T;[o;=
;3I"
overload;F;40;;;50;)I"
ctime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @; [ ; I"@return [Time];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"*Returns the change time for file (that is, the time directory
information about the file was changed, not the file itself).
Note that on Windows (NTFS), returns creation time (birth time).
File.new("testfile").ctime #=> Wed Apr 09 08:53:14 CDT 2003
@overload ctime
@return [Time];T; 0; @;!F;"o;#;$T;%i ;&i ;'@?;(I"static VALUE
rb_file_ctime(VALUE obj)
{
rb_io_t *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fstat(fptr->fd, &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return stat_ctime(&st);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#birthtime;F;[ ;[[@Gi ;T;;;0;[ ;{ ;IC; "Returns the birth time for file.
File.new("testfile").birthtime #=> Wed Apr 09 08:53:14 CDT 2003
If the platform doesn't have birthtime, raises NotImplementedError.
;T;[o;=
;3I"
overload;F;40;;;50;)I"birthtime;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Time;T; @; [ ; I"@return [Time];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns the birth time for file.
File.new("testfile").birthtime #=> Wed Apr 09 08:53:14 CDT 2003
If the platform doesn't have birthtime, raises NotImplementedError.
@overload birthtime
@return [Time];T; 0; @;!F;"o;#;$T;%i ;&i ;'@?;(I"static VALUE
rb_file_birthtime(VALUE obj)
{
rb_io_t *fptr;
statx_data st;
GetOpenFile(obj, fptr);
if (fstatx_without_gvl(fptr->fd, &st, STATX_BTIME) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return statx_birthtime(&st, fptr->pathv);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#size;F;[ ;[[@Gi ;T;;;0;[ ;{ ;IC; "UReturns the size of file in bytes.
File.new("testfile").size #=> 66
;T;[o;=
;3I"
overload;F;40;;;50;)I" size;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ؖ; [ ; I"@return [Integer];T; 0; @ؖ;!F;6i ;>0;[ ; @ؖ; [ ; I"{Returns the size of file in bytes.
File.new("testfile").size #=> 66
@overload size
@return [Integer];T; 0; @ؖ;!F;"o;#;$T;%i ;&i ;'@?;(I" static VALUE
rb_file_size(VALUE obj)
{
rb_io_t *fptr;
struct stat st;
GetOpenFile(obj, fptr);
if (fptr->mode & FMODE_WRITABLE) {
rb_io_flush_raw(obj, 0);
}
if (fstat(fptr->fd, &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return OFFT2NUM(st.st_size);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#chmod;F;[[I"
vmode;T0;[[@Gi-
;T;;;0;[ ;{ ;IC; " Changes permission bits on file to the bit pattern
represented by mode_int. Actual effects are platform
dependent; on Unix systems, see chmod(2) for details.
Follows symbolic links. Also see File#lchmod.
f = File.new("out", "w");
f.chmod(0644) #=> 0
;T;[o;=
;3I"
overload;F;40;;;50;)I"chmod(mode_int);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @; [ ; I"@return [0];T; 0; @;!F;6i ;>0;[[I"
mode_int;T0; @; [ ; I"GChanges permission bits on file to the bit pattern
represented by mode_int. Actual effects are platform
dependent; on Unix systems, see chmod(2) for details.
Follows symbolic links. Also see File#lchmod.
f = File.new("out", "w");
f.chmod(0644) #=> 0
@overload chmod(mode_int)
@return [0];T; 0; @;!F;"o;#;$T;%i
;&i*
;'@?;(I"static VALUE
rb_file_chmod(VALUE obj, VALUE vmode)
{
rb_io_t *fptr;
mode_t mode;
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
VALUE path;
#endif
mode = NUM2MODET(vmode);
GetOpenFile(obj, fptr);
#ifdef HAVE_FCHMOD
if (fchmod(fptr->fd, mode) == -1) {
if (HAVE_FCHMOD || errno != ENOSYS)
rb_sys_fail_path(fptr->pathv);
}
else {
if (!HAVE_FCHMOD) return INT2FIX(0);
}
#endif
#if !defined HAVE_FCHMOD || !HAVE_FCHMOD
if (NIL_P(fptr->pathv)) return Qnil;
path = rb_str_encode_ospath(fptr->pathv);
if (chmod(RSTRING_PTR(path), mode) == -1)
rb_sys_fail_path(fptr->pathv);
#endif
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#chown;F;[[I"
owner;T0[I"
group;T0;[[@Gi
;T;;;0;[ ;{ ;IC; "Changes the owner and group of file to the given numeric
owner and group id's. Only a process with superuser privileges may
change the owner of a file. The current owner of a file may change
the file's group to any group to which the owner belongs. A
nil or -1 owner or group id is ignored. Follows
symbolic links. See also File#lchown.
File.new("testfile").chown(502, 1000)
;T;[o;=
;3I"
overload;F;40;;;50;)I"!chown(owner_int, group_int );T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @; [ ; I"@return [0];T; 0; @;!F;6i ;>0;[[I"owner_int;T0[I"group_int;T0; @; [ ; I"Changes the owner and group of file to the given numeric
owner and group id's. Only a process with superuser privileges may
change the owner of a file. The current owner of a file may change
the file's group to any group to which the owner belongs. A
nil or -1 owner or group id is ignored. Follows
symbolic links. See also File#lchown.
File.new("testfile").chown(502, 1000)
@overload chown(owner_int, group_int )
@return [0];T; 0; @;!F;"o;#;$T;%i
;&i
;'@?;(I"static VALUE
rb_file_chown(VALUE obj, VALUE owner, VALUE group)
{
rb_io_t *fptr;
rb_uid_t o;
rb_gid_t g;
#ifndef HAVE_FCHOWN
VALUE path;
#endif
o = to_uid(owner);
g = to_gid(group);
GetOpenFile(obj, fptr);
#ifndef HAVE_FCHOWN
if (NIL_P(fptr->pathv)) return Qnil;
path = rb_str_encode_ospath(fptr->pathv);
if (chown(RSTRING_PTR(path), o, g) == -1)
rb_sys_fail_path(fptr->pathv);
#else
if (fchown(fptr->fd, o, g) == -1)
rb_sys_fail_path(fptr->pathv);
#endif
return INT2FIX(0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#truncate;F;[[I"len;T0;[[@Gi;T;;;0;[ ;{ ;IC; "+Truncates file to at most integer bytes. The file
must be opened for writing. Not available on all platforms.
f = File.new("out", "w")
f.syswrite("1234567890") #=> 10
f.truncate(5) #=> 0
f.close() #=> nil
File.size("out") #=> 5
;T;[o;=
;3I"
overload;F;40;;;50;)I"truncate(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;T; @5; [ ; I"@return [0];T; 0; @5;!F;6i ;>0;[[I" integer;T0; @5; [ ; I"WTruncates file to at most integer bytes. The file
must be opened for writing. Not available on all platforms.
f = File.new("out", "w")
f.syswrite("1234567890") #=> 10
f.truncate(5) #=> 0
f.close() #=> nil
File.size("out") #=> 5
@overload truncate(integer)
@return [0];T; 0; @5;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_truncate(VALUE obj, VALUE len)
{
rb_io_t *fptr;
struct ftruncate_arg fa;
fa.pos = NUM2POS(len);
GetOpenFile(obj, fptr);
if (!(fptr->mode & FMODE_WRITABLE)) {
rb_raise(rb_eIOError, "not opened for writing");
}
rb_io_flush_raw(obj, 0);
fa.fd = fptr->fd;
if ((int)rb_thread_io_blocking_region(nogvl_ftruncate, &fa, fa.fd) < 0) {
rb_sys_fail_path(fptr->pathv);
}
return INT2FIX(0);
#undef NUM2POS
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#flock;F;[[I"operation;T0;[[@GiI;T;:
flock;0;[ ;{ ;IC; " Locks or unlocks a file according to locking_constant (a
logical or of the values in the table below).
Returns false if File::LOCK_NB is specified and the
operation would otherwise have blocked. Not available on all
platforms.
Locking constants (in class File):
LOCK_EX | Exclusive lock. Only one process may hold an
| exclusive lock for a given file at a time.
----------+------------------------------------------------
LOCK_NB | Don't block when locking. May be combined
| with other lock options using logical or.
----------+------------------------------------------------
LOCK_SH | Shared lock. Multiple processes may each hold a
| shared lock for a given file at the same time.
----------+------------------------------------------------
LOCK_UN | Unlock.
Example:
# update a counter using write lock
# don't use "w" because it truncates the file before lock.
File.open("counter", File::RDWR|File::CREAT, 0644) {|f|
f.flock(File::LOCK_EX)
value = f.read.to_i + 1
f.rewind
f.write("#{value}\n")
f.flush
f.truncate(f.pos)
}
# read the counter using read lock
File.open("counter", "r") {|f|
f.flock(File::LOCK_SH)
p f.read
}
;T;[o;=
;3I"
overload;F;40;;.;50;)I" flock(locking_constant);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"0;TI"
false;T; @T; [ ; I"@return [0, false];T; 0; @T;!F;6i ;>0;[[I"locking_constant;T0; @T; [ ; I"ELocks or unlocks a file according to locking_constant (a
logical or of the values in the table below).
Returns false if File::LOCK_NB is specified and the
operation would otherwise have blocked. Not available on all
platforms.
Locking constants (in class File):
LOCK_EX | Exclusive lock. Only one process may hold an
| exclusive lock for a given file at a time.
----------+------------------------------------------------
LOCK_NB | Don't block when locking. May be combined
| with other lock options using logical or.
----------+------------------------------------------------
LOCK_SH | Shared lock. Multiple processes may each hold a
| shared lock for a given file at the same time.
----------+------------------------------------------------
LOCK_UN | Unlock.
Example:
# update a counter using write lock
# don't use "w" because it truncates the file before lock.
File.open("counter", File::RDWR|File::CREAT, 0644) {|f|
f.flock(File::LOCK_EX)
value = f.read.to_i + 1
f.rewind
f.write("#{value}\n")
f.flush
f.truncate(f.pos)
}
# read the counter using read lock
File.open("counter", "r") {|f|
f.flock(File::LOCK_SH)
p f.read
}
@overload flock(locking_constant)
@return [0, false];T; 0; @T;!F;"o;#;$T;%i ;&iF;'@?;(I"Ustatic VALUE
rb_file_flock(VALUE obj, VALUE operation)
{
rb_io_t *fptr;
int op[2], op1;
struct timeval time;
op[1] = op1 = NUM2INT(operation);
GetOpenFile(obj, fptr);
op[0] = fptr->fd;
if (fptr->mode & FMODE_WRITABLE) {
rb_io_flush_raw(obj, 0);
}
while ((int)rb_thread_io_blocking_region(rb_thread_flock, op, fptr->fd) < 0) {
int e = errno;
switch (e) {
case EAGAIN:
case EACCES:
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
if (op1 & LOCK_NB) return Qfalse;
time.tv_sec = 0;
time.tv_usec = 100 * 1000; /* 0.1 sec */
rb_thread_wait_for(time);
rb_io_check_closed(fptr);
continue;
case EINTR:
#if defined(ERESTART)
case ERESTART:
#endif
break;
default:
rb_syserr_fail_path(e, fptr->pathv);
}
}
return INT2FIX(0);
};T;)I"static VALUE;T;*T@o; ; F;
;;;;I"File#path;F;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the pathname used to create file as a string. Does
not normalize the name.
The pathname may not point to the file corresponding to file.
For instance, the pathname becomes void when the file has been
moved or deleted.
This method raises IOError for a file created using
File::Constants::TMPFILE because they don't have a pathname.
File.new("testfile").path #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
;T;[o;=
;3I"
overload;F;40;;;50;)I" path;T;IC; " ;T;[ ; [ ; I" ;T; 0; @t;!F;6i ;>0;[ ; @to;=
;3I"
overload;F;40;;;50;)I" to_path;T;IC; " ;T;[ ; [ ; I" ;T; 0; @t;!F;6i ;>0;[ ; @t; [ ; I" Returns the pathname used to create file as a string. Does
not normalize the name.
The pathname may not point to the file corresponding to file.
For instance, the pathname becomes void when the file has been
moved or deleted.
This method raises IOError for a file created using
File::Constants::TMPFILE because they don't have a pathname.
File.new("testfile").path #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
@overload path
@overload to_path;T; 0; @t;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_path(VALUE obj)
{
rb_io_t *fptr;
fptr = RFILE(rb_io_taint_check(obj))->fptr;
rb_io_check_initialized(fptr);
if (NIL_P(fptr->pathv)) {
rb_raise(rb_eIOError, "File is unnamed (TMPFILE?)");
}
return rb_str_dup(fptr->pathv);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"File#to_path;F;[ ;[[@Gi;T;;;0;[ ;{ ;IC; "Returns the pathname used to create file as a string. Does
not normalize the name.
The pathname may not point to the file corresponding to file.
For instance, the pathname becomes void when the file has been
moved or deleted.
This method raises IOError for a file created using
File::Constants::TMPFILE because they don't have a pathname.
File.new("testfile").path #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
;T;[o;=
;3I"
overload;F;40;;;50;)I" path;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @o;=
;3I"
overload;F;40;;;50;)I" to_path;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @; [ ; @; 0; @;!F;"o;#;$T;%i;&i;'@?;(I"static VALUE
rb_file_path(VALUE obj)
{
rb_io_t *fptr;
fptr = RFILE(rb_io_taint_check(obj))->fptr;
rb_io_check_initialized(fptr);
if (NIL_P(fptr->pathv)) {
rb_raise(rb_eIOError, "File is unnamed (TMPFILE?)");
}
return rb_str_dup(fptr->pathv);
};T;)I"static VALUE;T;*T;A@?;BIC;[ ;A@?;CIC;[ ;A@?;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@Gii;F;;!;;K;;;[ ;{ ;IC; "A File is an abstraction of any file object accessible by the
program and is closely associated with class IO. File includes
the methods of module FileTest as class methods, allowing you to
write (for example) File.exist?("foo").
In the description of File methods,
permission bits are a platform-specific
set of bits that indicate permissions of a file. On Unix-based
systems, permissions are viewed as a set of three octets, for the
owner, the group, and the rest of the world. For each of these
entities, permissions may be set to read, write, or execute the
file:
The permission bits 0644 (in octal) would thus be
interpreted as read/write for owner, and read-only for group and
other. Higher-order bits may also be used to indicate the type of
file (plain, directory, pipe, socket, and so on) and various other
special features. If the permissions are for a directory, the
meaning of the execute bit changes; when set the directory can be
searched.
On non-Posix operating systems, there may be only the ability to
make a file read-only or read-write. In this case, the remaining
permission bits will be synthesized to resemble typical values. For
instance, on Windows NT the default permission bits are
0644, which means read/write for owner, read-only for
all others. The only change that can be made is to make the file
read-only, which is reported as 0444.
Various constants for the methods in File can be found in File::Constants.;T;[ ; [ ; I"A File is an abstraction of any file object accessible by the
program and is closely associated with class IO. File includes
the methods of module FileTest as class methods, allowing you to
write (for example) File.exist?("foo").
In the description of File methods,
permission bits are a platform-specific
set of bits that indicate permissions of a file. On Unix-based
systems, permissions are viewed as a set of three octets, for the
owner, the group, and the rest of the world. For each of these
entities, permissions may be set to read, write, or execute the
file:
The permission bits 0644 (in octal) would thus be
interpreted as read/write for owner, and read-only for group and
other. Higher-order bits may also be used to indicate the type of
file (plain, directory, pipe, socket, and so on) and various other
special features. If the permissions are for a directory, the
meaning of the execute bit changes; when set the directory can be
searched.
On non-Posix operating systems, there may be only the ability to
make a file read-only or read-write. In this case, the remaining
permission bits will be synthesized to resemble typical values. For
instance, on Windows NT the default permission bits are
0644, which means read/write for owner, read-only for
all others. The only change that can be made is to make the file
read-only, which is reported as 0444.
Various constants for the methods in File can be found in File::Constants.
;T; 0; @?;!F;"o;#;$T;%i>;&i\;6i ;'@;I" File;F;S@t;I"File::Constants;F;A@t;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{@ {;;I[ ;[[@i3;F;:IO;;K;;;[ ;{ ;IC; " The IO class is the basis for all input and output in Ruby.
An I/O stream may be duplexed (that is, bidirectional), and
so may use more than one native operating system stream.
Many of the examples in this section use the File class, the only standard
subclass of IO. The two classes are closely associated. Like the File
class, the Socket library subclasses from IO (such as TCPSocket or
UDPSocket).
The Kernel#open method can create an IO (or File) object for these types
of arguments:
* A plain string represents a filename suitable for the underlying
operating system.
* A string starting with "|" indicates a subprocess.
The remainder of the string following the "|" is
invoked as a process with appropriate input/output channels
connected to it.
* A string equal to "|-" will create another Ruby
instance as a subprocess.
The IO may be opened with different file modes (read-only, write-only) and
encodings for proper conversion. See IO.new for these options. See
Kernel#open for details of the various command formats described above.
IO.popen, the Open3 library, or Process#spawn may also be used to
communicate with subprocesses through an IO.
Ruby will convert pathnames between different operating system
conventions if possible. For instance, on a Windows system the
filename "/gumby/ruby/test.rb" will be opened as
"\gumby\ruby\test.rb". When specifying a Windows-style
filename in a Ruby string, remember to escape the backslashes:
"C:\\gumby\\ruby\\test.rb"
Our examples here will use the Unix-style forward slashes;
File::ALT_SEPARATOR can be used to get the platform-specific separator
character.
The global constant ARGF (also accessible as $<) provides an
IO-like stream which allows access to all files mentioned on the
command line (or STDIN if no files are mentioned). ARGF#path and its alias
ARGF#filename are provided to access the name of the file currently being
read.
== io/console
The io/console extension provides methods for interacting with the
console. The console can be accessed from IO.console or the standard
input/output/error IO objects.
Requiring io/console adds the following methods:
* IO::console
* IO#raw
* IO#raw!
* IO#cooked
* IO#cooked!
* IO#getch
* IO#echo=
* IO#echo?
* IO#noecho
* IO#winsize
* IO#winsize=
* IO#iflush
* IO#ioflush
* IO#oflush
Example:
require 'io/console'
rows, columns = $stdout.winsize
puts "Your screen is #{columns} wide and #{rows} tall";T;[ ; [ ; I" The IO class is the basis for all input and output in Ruby.
An I/O stream may be duplexed (that is, bidirectional), and
so may use more than one native operating system stream.
Many of the examples in this section use the File class, the only standard
subclass of IO. The two classes are closely associated. Like the File
class, the Socket library subclasses from IO (such as TCPSocket or
UDPSocket).
The Kernel#open method can create an IO (or File) object for these types
of arguments:
* A plain string represents a filename suitable for the underlying
operating system.
* A string starting with "|" indicates a subprocess.
The remainder of the string following the "|" is
invoked as a process with appropriate input/output channels
connected to it.
* A string equal to "|-" will create another Ruby
instance as a subprocess.
The IO may be opened with different file modes (read-only, write-only) and
encodings for proper conversion. See IO.new for these options. See
Kernel#open for details of the various command formats described above.
IO.popen, the Open3 library, or Process#spawn may also be used to
communicate with subprocesses through an IO.
Ruby will convert pathnames between different operating system
conventions if possible. For instance, on a Windows system the
filename "/gumby/ruby/test.rb" will be opened as
"\gumby\ruby\test.rb". When specifying a Windows-style
filename in a Ruby string, remember to escape the backslashes:
"C:\\gumby\\ruby\\test.rb"
Our examples here will use the Unix-style forward slashes;
File::ALT_SEPARATOR can be used to get the platform-specific separator
character.
The global constant ARGF (also accessible as $<) provides an
IO-like stream which allows access to all files mentioned on the
command line (or STDIN if no files are mentioned). ARGF#path and its alias
ARGF#filename are provided to access the name of the file currently being
read.
== io/console
The io/console extension provides methods for interacting with the
console. The console can be accessed from IO.console or the standard
input/output/error IO objects.
Requiring io/console adds the following methods:
* IO::console
* IO#raw
* IO#raw!
* IO#cooked
* IO#cooked!
* IO#getch
* IO#echo=
* IO#echo?
* IO#noecho
* IO#winsize
* IO#winsize=
* IO#iflush
* IO#ioflush
* IO#oflush
Example:
require 'io/console'
rows, columns = $stdout.winsize
puts "Your screen is #{columns} wide and #{rows} tall"
;T; 0; @t;!F;"o;#;$T;%i3;&i_3;6i ;'@;I"IO;F;S@];I"IO::WaitReadable;F;A@t;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@HTi ;F;:SSLErrorWaitReadable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @t;'@[s;I"'OpenSSL::SSL::SSLErrorWaitReadable;F;S@to;
;IC;[ ;A@ޗ;BIC;[ ;A@ޗ;CIC;[@t;A@ޗ;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@HTi ;F;:SSLErrorWaitWritable;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ޗ;'@[s;I"'OpenSSL::SSL::SSLErrorWaitWritable;F;S@to;
;IC;[#o; ; F;
;;;;I")OpenSSL::SSL::SSLContext#ssl_timeout;F;[ ;[[@HTi
;F;:ssl_timeout;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@;)I"def ssl_timeout;To; ; F;
;;;;I"*OpenSSL::SSL::SSLContext#ssl_timeout=;F;[ ;[[@HTi
;F;:ssl_timeout=;;K;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@;)I"def ssl_timeout=;To; ; F;
;;;;I"6OpenSSL::SSL::SSLContext#set_minmax_proto_version;F;[[I"
min_v;T0[I"
max_v;T0;[[@HTi;T;: set_minmax_proto_version;0;[ ;{ ;IC; "cSets the minimum and maximum supported protocol versions. See #min_version=
and #max_version=.
;T;[o;=
;3I"
overload;F;40;;4;50;)I"'set_minmax_proto_version(min, max);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[[I"min;T0[I"max;T0; @; [ ; I"Sets the minimum and maximum supported protocol versions. See #min_version=
and #max_version=.
@overload set_minmax_proto_version(min, max)
@return [nil];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_set_minmax_proto_version(VALUE self, VALUE min_v, VALUE max_v)
{
SSL_CTX *ctx;
int min, max;
GetSSLCTX(self, ctx);
min = parse_proto_version(min_v);
max = parse_proto_version(max_v);
#ifdef HAVE_SSL_CTX_SET_MIN_PROTO_VERSION
if (!SSL_CTX_set_min_proto_version(ctx, min))
ossl_raise(eSSLError, "SSL_CTX_set_min_proto_version");
if (!SSL_CTX_set_max_proto_version(ctx, max))
ossl_raise(eSSLError, "SSL_CTX_set_max_proto_version");
#else
{
unsigned long sum = 0, opts = 0;
int i;
static const struct {
int ver;
unsigned long opts;
} options_map[] = {
{ SSL2_VERSION, SSL_OP_NO_SSLv2 },
{ SSL3_VERSION, SSL_OP_NO_SSLv3 },
{ TLS1_VERSION, SSL_OP_NO_TLSv1 },
{ TLS1_1_VERSION, SSL_OP_NO_TLSv1_1 },
{ TLS1_2_VERSION, SSL_OP_NO_TLSv1_2 },
# if defined(TLS1_3_VERSION)
{ TLS1_3_VERSION, SSL_OP_NO_TLSv1_3 },
# endif
};
for (i = 0; i < numberof(options_map); i++) {
sum |= options_map[i].opts;
if ((min && min > options_map[i].ver) ||
(max && max < options_map[i].ver)) {
opts |= options_map[i].opts;
}
}
SSL_CTX_clear_options(ctx, sum);
SSL_CTX_set_options(ctx, opts);
}
#endif
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"%OpenSSL::SSL::SSLContext#ciphers;F;[ ;[[@HTi;T;: ciphers;0;[ ;{ ;IC; ";The list of cipher suites configured for this context.
;T;[o;=
;3I"
overload;F;40;;5;50;)I" ciphers;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @*; [ ; I"@return [Array];T; 0; @*;!F;6i ;>0;[ ; @*; [ ; I"aThe list of cipher suites configured for this context.
@overload ciphers
@return [Array];T; 0; @*;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_get_ciphers(VALUE self)
{
SSL_CTX *ctx;
STACK_OF(SSL_CIPHER) *ciphers;
const SSL_CIPHER *cipher;
VALUE ary;
int i, num;
GetSSLCTX(self, ctx);
ciphers = SSL_CTX_get_ciphers(ctx);
if (!ciphers)
return rb_ary_new();
num = sk_SSL_CIPHER_num(ciphers);
ary = rb_ary_new2(num);
for(i = 0; i < num; i++){
cipher = sk_SSL_CIPHER_value(ciphers, i);
rb_ary_push(ary, ossl_ssl_cipher_to_ary(cipher));
}
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::SSL::SSLContext#ciphers=;F;[[I"v;T0;[[@HTi
;T;:
ciphers=;0;[ ;{ ;IC; "5ctx.ciphers = [name, ...]
ctx.ciphers = [[name, version, bits, alg_bits], ...]
Sets the list of available cipher suites for this context. Note in a server
context some ciphers require the appropriate certificates. For example, an
RSA cipher suite can only be chosen when an RSA certificate is available.
;T;[ ; [ ; I": ctx.ciphers = [name, ...]
ctx.ciphers = [[name, version, bits, alg_bits], ...]
Sets the list of available cipher suites for this context. Note in a server
context some ciphers require the appropriate certificates. For example, an
RSA cipher suite can only be chosen when an RSA certificate is available.
;T; 0; @E;!F;"o;#;$T;%i ;&i;'@;(I"static VALUE
ossl_sslctx_set_ciphers(VALUE self, VALUE v)
{
SSL_CTX *ctx;
VALUE str, elem;
int i;
rb_check_frozen(self);
if (NIL_P(v))
return v;
else if (RB_TYPE_P(v, T_ARRAY)) {
str = rb_str_new(0, 0);
for (i = 0; i < RARRAY_LEN(v); i++) {
elem = rb_ary_entry(v, i);
if (RB_TYPE_P(elem, T_ARRAY)) elem = rb_ary_entry(elem, 0);
elem = rb_String(elem);
rb_str_append(str, elem);
if (i < RARRAY_LEN(v)-1) rb_str_cat2(str, ":");
}
} else {
str = v;
StringValue(str);
}
GetSSLCTX(self, ctx);
if (!SSL_CTX_set_cipher_list(ctx, StringValueCStr(str))) {
ossl_raise(eSSLError, "SSL_CTX_set_cipher_list");
}
return v;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::SSL::SSLContext#ecdh_curves=;F;[[I"arg;T0;[[@HTiF;T;:ecdh_curves=;0;[ ;{ ;IC; "#Sets the list of "supported elliptic curves" for this context.
For a TLS client, the list is directly used in the Supported Elliptic Curves
Extension. For a server, the list is used by OpenSSL to determine the set of
shared curves. OpenSSL will pick the most appropriate one from it.
Note that this works differently with old OpenSSL (<= 1.0.1). Only one curve
can be set, and this has no effect for TLS clients.
=== Example
ctx1 = OpenSSL::SSL::SSLContext.new
ctx1.ecdh_curves = "X25519:P-256:P-224"
svr = OpenSSL::SSL::SSLServer.new(tcp_svr, ctx1)
Thread.new { svr.accept }
ctx2 = OpenSSL::SSL::SSLContext.new
ctx2.ecdh_curves = "P-256"
cli = OpenSSL::SSL::SSLSocket.new(tcp_sock, ctx2)
cli.connect
p cli.tmp_key.group.curve_name
# => "prime256v1" (is an alias for NIST P-256)
;T;[o;=
;3I"
overload;F;40;;7;50;)I" ecdh_curves=(curve_list);T;IC; " ;T;[ ; [ ; I" ;T; 0; @U;!F;6i ;>0;[[I"curve_list;T0; @U; [ ; I"HSets the list of "supported elliptic curves" for this context.
For a TLS client, the list is directly used in the Supported Elliptic Curves
Extension. For a server, the list is used by OpenSSL to determine the set of
shared curves. OpenSSL will pick the most appropriate one from it.
Note that this works differently with old OpenSSL (<= 1.0.1). Only one curve
can be set, and this has no effect for TLS clients.
=== Example
ctx1 = OpenSSL::SSL::SSLContext.new
ctx1.ecdh_curves = "X25519:P-256:P-224"
svr = OpenSSL::SSL::SSLServer.new(tcp_svr, ctx1)
Thread.new { svr.accept }
ctx2 = OpenSSL::SSL::SSLContext.new
ctx2.ecdh_curves = "P-256"
cli = OpenSSL::SSL::SSLSocket.new(tcp_sock, ctx2)
cli.connect
p cli.tmp_key.group.curve_name
# => "prime256v1" (is an alias for NIST P-256)
@overload ecdh_curves=(curve_list);T; 0; @U;!F;"o;#;$T;%i+;&iC;'@;(I"static VALUE
ossl_sslctx_set_ecdh_curves(VALUE self, VALUE arg)
{
SSL_CTX *ctx;
rb_check_frozen(self);
GetSSLCTX(self, ctx);
StringValueCStr(arg);
#if defined(HAVE_SSL_CTX_SET1_CURVES_LIST)
if (!SSL_CTX_set1_curves_list(ctx, RSTRING_PTR(arg)))
ossl_raise(eSSLError, NULL);
#else
/* OpenSSL does not have SSL_CTX_set1_curves_list()... Fallback to
* SSL_CTX_set_tmp_ecdh(). So only the first curve is used. */
{
VALUE curve, splitted;
EC_KEY *ec;
int nid;
splitted = rb_str_split(arg, ":");
if (!RARRAY_LEN(splitted))
ossl_raise(eSSLError, "invalid input format");
curve = RARRAY_AREF(splitted, 0);
StringValueCStr(curve);
/* SSL_CTX_set1_curves_list() accepts NIST names */
nid = EC_curve_nist2nid(RSTRING_PTR(curve));
if (nid == NID_undef)
nid = OBJ_txt2nid(RSTRING_PTR(curve));
if (nid == NID_undef)
ossl_raise(eSSLError, "unknown curve name");
ec = EC_KEY_new_by_curve_name(nid);
if (!ec)
ossl_raise(eSSLError, NULL);
EC_KEY_set_asn1_flag(ec, OPENSSL_EC_NAMED_CURVE);
if (!SSL_CTX_set_tmp_ecdh(ctx, ec)) {
EC_KEY_free(ec);
ossl_raise(eSSLError, "SSL_CTX_set_tmp_ecdh");
}
EC_KEY_free(ec);
# if defined(HAVE_SSL_CTX_SET_ECDH_AUTO)
/* tmp_ecdh and ecdh_auto conflict. tmp_ecdh is ignored when ecdh_auto
* is enabled. So disable ecdh_auto. */
if (!SSL_CTX_set_ecdh_auto(ctx, 0))
ossl_raise(eSSLError, "SSL_CTX_set_ecdh_auto");
# endif
}
#endif
return arg;
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLContext#security_level;F;[ ;[[@HTi;T;:security_level;0;[ ;{ ;IC; "dReturns the security level for the context.
See also OpenSSL::SSL::SSLContext#security_level=.
;T;[o;=
;3I"
overload;F;40;;8;50;)I"security_level;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @o; [ ; I"@return [Integer];T; 0; @o;!F;6i ;>0;[ ; @o; [ ; I"Returns the security level for the context.
See also OpenSSL::SSL::SSLContext#security_level=.
@overload security_level
@return [Integer];T; 0; @o;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_get_security_level(VALUE self)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
#if defined(HAVE_SSL_CTX_GET_SECURITY_LEVEL)
return INT2NUM(SSL_CTX_get_security_level(ctx));
#else
(void)ctx;
return INT2FIX(0);
#endif
};T;)I"static VALUE;T;*To; ; F;
;;;;I"-OpenSSL::SSL::SSLContext#security_level=;F;[[I"
value;T0;[[@HTi;T;:security_level=;0;[ ;{ ;IC; "Sets the security level for the context. OpenSSL limits parameters according
to the level. The "parameters" include: ciphersuites, curves, key sizes,
certificate signature algorithms, protocol version and so on. For example,
level 1 rejects parameters offering below 80 bits of security, such as
ciphersuites using MD5 for the MAC or RSA keys shorter than 1024 bits.
Note that attempts to set such parameters with insufficient security are
also blocked. You need to lower the level first.
This feature is not supported in OpenSSL < 1.1.0, and setting the level to
other than 0 will raise NotImplementedError. Level 0 means everything is
permitted, the same behavior as previous versions of OpenSSL.
See the manpage of SSL_CTX_set_security_level(3) for details.
;T;[o;=
;3I"
overload;F;40;;9;50;)I" security_level=(integer);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" integer;T0; @; [ ; I" Sets the security level for the context. OpenSSL limits parameters according
to the level. The "parameters" include: ciphersuites, curves, key sizes,
certificate signature algorithms, protocol version and so on. For example,
level 1 rejects parameters offering below 80 bits of security, such as
ciphersuites using MD5 for the MAC or RSA keys shorter than 1024 bits.
Note that attempts to set such parameters with insufficient security are
also blocked. You need to lower the level first.
This feature is not supported in OpenSSL < 1.1.0, and setting the level to
other than 0 will raise NotImplementedError. Level 0 means everything is
permitted, the same behavior as previous versions of OpenSSL.
See the manpage of SSL_CTX_set_security_level(3) for details.
@overload security_level=(integer);T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_set_security_level(VALUE self, VALUE value)
{
SSL_CTX *ctx;
rb_check_frozen(self);
GetSSLCTX(self, ctx);
#if defined(HAVE_SSL_CTX_GET_SECURITY_LEVEL)
SSL_CTX_set_security_level(ctx, NUM2INT(value));
#else
(void)ctx;
if (NUM2INT(value) != 0)
ossl_raise(rb_eNotImpError, "setting security level to other than 0 is "
"not supported in this version of OpenSSL");
#endif
return value;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"2OpenSSL::SSL::SSLContext#enable_fallback_scsv;F;[ ;[[@HTi;T;:enable_fallback_scsv;0;[ ;{ ;IC; "?Activate TLS_FALLBACK_SCSV for this context.
See RFC 7507.
;T;[o;=
;3I"
overload;F;40;;:;50;)I"enable_fallback_scsv();T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"rActivate TLS_FALLBACK_SCSV for this context.
See RFC 7507.
@overload enable_fallback_scsv()
@return [nil];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_enable_fallback_scsv(VALUE self)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
SSL_CTX_set_mode(ctx, SSL_MODE_SEND_FALLBACK_SCSV);
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"-OpenSSL::SSL::SSLContext#add_certificate;F;[[@c0;[[@HTi;T;:add_certificate;0;[ ;{ ;IC; "Adds a certificate to the context. _pkey_ must be a corresponding private
key with _certificate_.
Multiple certificates with different public key type can be added by
repeated calls of this method, and OpenSSL will choose the most appropriate
certificate during the handshake.
#cert=, #key=, and #extra_chain_cert= are old accessor methods for setting
certificate and internally call this method.
=== Parameters
_certificate_::
A certificate. An instance of OpenSSL::X509::Certificate.
_pkey_::
The private key for _certificate_. An instance of OpenSSL::PKey::PKey.
_extra_certs_::
Optional. An array of OpenSSL::X509::Certificate. When sending a
certificate chain, the certificates specified by this are sent following
_certificate_, in the order in the array.
=== Example
rsa_cert = OpenSSL::X509::Certificate.new(...)
rsa_pkey = OpenSSL::PKey.read(...)
ca_intermediate_cert = OpenSSL::X509::Certificate.new(...)
ctx.add_certificate(rsa_cert, rsa_pkey, [ca_intermediate_cert])
ecdsa_cert = ...
ecdsa_pkey = ...
another_ca_cert = ...
ctx.add_certificate(ecdsa_cert, ecdsa_pkey, [another_ca_cert])
=== Note
OpenSSL before the version 1.0.2 could handle only one extra chain across
all key types. Calling this method discards the chain set previously.
;T;[o;=
;3I"
overload;F;40;;;;50;)I"7add_certificate(certiticate, pkey [, extra_certs]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[[I"certiticate;T0[I"pkey[, extra_certs];T0; @; [ ; I"RAdds a certificate to the context. _pkey_ must be a corresponding private
key with _certificate_.
Multiple certificates with different public key type can be added by
repeated calls of this method, and OpenSSL will choose the most appropriate
certificate during the handshake.
#cert=, #key=, and #extra_chain_cert= are old accessor methods for setting
certificate and internally call this method.
=== Parameters
_certificate_::
A certificate. An instance of OpenSSL::X509::Certificate.
_pkey_::
The private key for _certificate_. An instance of OpenSSL::PKey::PKey.
_extra_certs_::
Optional. An array of OpenSSL::X509::Certificate. When sending a
certificate chain, the certificates specified by this are sent following
_certificate_, in the order in the array.
=== Example
rsa_cert = OpenSSL::X509::Certificate.new(...)
rsa_pkey = OpenSSL::PKey.read(...)
ca_intermediate_cert = OpenSSL::X509::Certificate.new(...)
ctx.add_certificate(rsa_cert, rsa_pkey, [ca_intermediate_cert])
ecdsa_cert = ...
ecdsa_pkey = ...
another_ca_cert = ...
ctx.add_certificate(ecdsa_cert, ecdsa_pkey, [another_ca_cert])
=== Note
OpenSSL before the version 1.0.2 could handle only one extra chain across
all key types. Calling this method discards the chain set previously.
@overload add_certificate(certiticate, pkey [, extra_certs])
@return [self];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"Fstatic VALUE
ossl_sslctx_add_certificate(int argc, VALUE *argv, VALUE self)
{
VALUE cert, key, extra_chain_ary;
SSL_CTX *ctx;
X509 *x509;
STACK_OF(X509) *extra_chain = NULL;
EVP_PKEY *pkey, *pub_pkey;
GetSSLCTX(self, ctx);
rb_scan_args(argc, argv, "21", &cert, &key, &extra_chain_ary);
rb_check_frozen(self);
x509 = GetX509CertPtr(cert);
pkey = GetPrivPKeyPtr(key);
/*
* The reference counter is bumped, and decremented immediately.
* X509_get0_pubkey() is only available in OpenSSL >= 1.1.0.
*/
pub_pkey = X509_get_pubkey(x509);
EVP_PKEY_free(pub_pkey);
if (!pub_pkey)
rb_raise(rb_eArgError, "certificate does not contain public key");
if (EVP_PKEY_cmp(pub_pkey, pkey) != 1)
rb_raise(rb_eArgError, "public key mismatch");
if (argc >= 3)
extra_chain = ossl_x509_ary2sk(extra_chain_ary);
if (!SSL_CTX_use_certificate(ctx, x509)) {
sk_X509_pop_free(extra_chain, X509_free);
ossl_raise(eSSLError, "SSL_CTX_use_certificate");
}
if (!SSL_CTX_use_PrivateKey(ctx, pkey)) {
sk_X509_pop_free(extra_chain, X509_free);
ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey");
}
if (extra_chain) {
#if OPENSSL_VERSION_NUMBER >= 0x10002000 && !defined(LIBRESSL_VERSION_NUMBER)
if (!SSL_CTX_set0_chain(ctx, extra_chain)) {
sk_X509_pop_free(extra_chain, X509_free);
ossl_raise(eSSLError, "SSL_CTX_set0_chain");
}
#else
STACK_OF(X509) *orig_extra_chain;
X509 *x509_tmp;
/* First, clear the existing chain */
SSL_CTX_get_extra_chain_certs(ctx, &orig_extra_chain);
if (orig_extra_chain && sk_X509_num(orig_extra_chain)) {
rb_warning("SSL_CTX_set0_chain() is not available; " \
"clearing previously set certificate chain");
SSL_CTX_clear_extra_chain_certs(ctx);
}
while ((x509_tmp = sk_X509_shift(extra_chain))) {
/* Transfers ownership */
if (!SSL_CTX_add_extra_chain_cert(ctx, x509_tmp)) {
X509_free(x509_tmp);
sk_X509_pop_free(extra_chain, X509_free);
ossl_raise(eSSLError, "SSL_CTX_add_extra_chain_cert");
}
}
sk_X509_free(extra_chain);
#endif
}
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::SSL::SSLContext#setup;F;[ ;[[@HTi;T;:
setup;0;[ ;{ ;IC; "This method is called automatically when a new SSLSocket is created.
However, it is not thread-safe and must be called before creating
SSLSocket objects in a multi-threaded program.
;T;[o;=
;3I"
overload;F;40;;<;50;)I"
setup;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"Qtrue #firstt time;T; @ߘ; [ ; I"!@return [Qtrue # first time];T; 0; @ߘ;!F;6i ;>0;[ ; @ߘo;=
;3I"
overload;F;40;;<;50;)I"
setup;T;IC; " ;T;[ ; [ ; I" ;T; 0; @ߘ;!F;6i ;>0;[ ; @ߘ; [ ; I"This method is called automatically when a new SSLSocket is created.
However, it is not thread-safe and must be called before creating
SSLSocket objects in a multi-threaded program.
@overload setup
@return [Qtrue # first time]
@overload setup;T; 0; o; ; F;
;;;;I"$OpenSSL::SSL::SSLContext#freeze;F;[ ;[[@HTi
;F;;s;;K;[ ;{ ;@;'@;(I"static VALUE
ossl_sslctx_setup(VALUE self)
{
SSL_CTX *ctx;
X509 *cert = NULL, *client_ca = NULL;
EVP_PKEY *key = NULL;
char *ca_path = NULL, *ca_file = NULL;
int verify_mode;
long i;
VALUE val;
if(OBJ_FROZEN(self)) return Qnil;
GetSSLCTX(self, ctx);
#if !defined(OPENSSL_NO_DH)
SSL_CTX_set_tmp_dh_callback(ctx, ossl_tmp_dh_callback);
#endif
#if !defined(OPENSSL_NO_EC)
/* We added SSLContext#tmp_ecdh_callback= in Ruby 2.3.0,
* but SSL_CTX_set_tmp_ecdh_callback() was removed in OpenSSL 1.1.0. */
if (RTEST(rb_attr_get(self, id_i_tmp_ecdh_callback))) {
# if defined(HAVE_SSL_CTX_SET_TMP_ECDH_CALLBACK)
rb_warn("#tmp_ecdh_callback= is deprecated; use #ecdh_curves= instead");
SSL_CTX_set_tmp_ecdh_callback(ctx, ossl_tmp_ecdh_callback);
# if defined(HAVE_SSL_CTX_SET_ECDH_AUTO)
/* tmp_ecdh_callback and ecdh_auto conflict; OpenSSL ignores
* tmp_ecdh_callback. So disable ecdh_auto. */
if (!SSL_CTX_set_ecdh_auto(ctx, 0))
ossl_raise(eSSLError, "SSL_CTX_set_ecdh_auto");
# endif
# else
ossl_raise(eSSLError, "OpenSSL does not support tmp_ecdh_callback; "
"use #ecdh_curves= instead");
# endif
}
#endif /* OPENSSL_NO_EC */
val = rb_attr_get(self, id_i_cert_store);
if (!NIL_P(val)) {
X509_STORE *store = GetX509StorePtr(val); /* NO NEED TO DUP */
SSL_CTX_set_cert_store(ctx, store);
#if !defined(HAVE_X509_STORE_UP_REF)
/*
* WORKAROUND:
* X509_STORE can count references, but
* X509_STORE_free() doesn't care it.
* So we won't increment it but mark it by ex_data.
*/
SSL_CTX_set_ex_data(ctx, ossl_sslctx_ex_store_p, ctx);
#else /* Fixed in OpenSSL 1.0.2; bff9ce4db38b (master), 5b4b9ce976fc (1.0.2) */
X509_STORE_up_ref(store);
#endif
}
val = rb_attr_get(self, id_i_extra_chain_cert);
if(!NIL_P(val)){
rb_block_call(val, rb_intern("each"), 0, 0, ossl_sslctx_add_extra_chain_cert_i, self);
}
/* private key may be bundled in certificate file. */
val = rb_attr_get(self, id_i_cert);
cert = NIL_P(val) ? NULL : GetX509CertPtr(val); /* NO DUP NEEDED */
val = rb_attr_get(self, id_i_key);
key = NIL_P(val) ? NULL : GetPrivPKeyPtr(val); /* NO DUP NEEDED */
if (cert && key) {
if (!SSL_CTX_use_certificate(ctx, cert)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_certificate");
}
if (!SSL_CTX_use_PrivateKey(ctx, key)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey");
}
if (!SSL_CTX_check_private_key(ctx)) {
ossl_raise(eSSLError, "SSL_CTX_check_private_key");
}
}
val = rb_attr_get(self, id_i_client_ca);
if(!NIL_P(val)){
if (RB_TYPE_P(val, T_ARRAY)) {
for(i = 0; i < RARRAY_LEN(val); i++){
client_ca = GetX509CertPtr(RARRAY_AREF(val, i));
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
else{
client_ca = GetX509CertPtr(val); /* NO DUP NEEDED. */
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
val = rb_attr_get(self, id_i_ca_file);
ca_file = NIL_P(val) ? NULL : StringValueCStr(val);
val = rb_attr_get(self, id_i_ca_path);
ca_path = NIL_P(val) ? NULL : StringValueCStr(val);
if(ca_file || ca_path){
if (!SSL_CTX_load_verify_locations(ctx, ca_file, ca_path))
rb_warning("can't set verify locations");
}
val = rb_attr_get(self, id_i_verify_mode);
verify_mode = NIL_P(val) ? SSL_VERIFY_NONE : NUM2INT(val);
SSL_CTX_set_verify(ctx, verify_mode, ossl_ssl_verify_callback);
if (RTEST(rb_attr_get(self, id_i_client_cert_cb)))
SSL_CTX_set_client_cert_cb(ctx, ossl_client_cert_cb);
val = rb_attr_get(self, id_i_timeout);
if(!NIL_P(val)) SSL_CTX_set_timeout(ctx, NUM2LONG(val));
val = rb_attr_get(self, id_i_verify_depth);
if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2INT(val));
#ifndef OPENSSL_NO_NEXTPROTONEG
val = rb_attr_get(self, id_i_npn_protocols);
if (!NIL_P(val)) {
VALUE encoded = ssl_encode_npn_protocols(val);
rb_ivar_set(self, id_npn_protocols_encoded, encoded);
SSL_CTX_set_next_protos_advertised_cb(ctx, ssl_npn_advertise_cb, (void *)self);
OSSL_Debug("SSL NPN advertise callback added");
}
if (RTEST(rb_attr_get(self, id_i_npn_select_cb))) {
SSL_CTX_set_next_proto_select_cb(ctx, ssl_npn_select_cb, (void *) self);
OSSL_Debug("SSL NPN select callback added");
}
#endif
#ifdef HAVE_SSL_CTX_SET_ALPN_SELECT_CB
val = rb_attr_get(self, id_i_alpn_protocols);
if (!NIL_P(val)) {
VALUE rprotos = ssl_encode_npn_protocols(val);
/* returns 0 on success */
if (SSL_CTX_set_alpn_protos(ctx, (unsigned char *)RSTRING_PTR(rprotos),
RSTRING_LENINT(rprotos)))
ossl_raise(eSSLError, "SSL_CTX_set_alpn_protos");
OSSL_Debug("SSL ALPN values added");
}
if (RTEST(rb_attr_get(self, id_i_alpn_select_cb))) {
SSL_CTX_set_alpn_select_cb(ctx, ssl_alpn_select_cb, (void *) self);
OSSL_Debug("SSL ALPN select callback added");
}
#endif
rb_obj_freeze(self);
val = rb_attr_get(self, id_i_session_id_context);
if (!NIL_P(val)){
StringValue(val);
if (!SSL_CTX_set_session_id_context(ctx, (unsigned char *)RSTRING_PTR(val),
RSTRING_LENINT(val))){
ossl_raise(eSSLError, "SSL_CTX_set_session_id_context");
}
}
if (RTEST(rb_attr_get(self, id_i_session_get_cb))) {
SSL_CTX_sess_set_get_cb(ctx, ossl_sslctx_session_get_cb);
OSSL_Debug("SSL SESSION get callback added");
}
if (RTEST(rb_attr_get(self, id_i_session_new_cb))) {
SSL_CTX_sess_set_new_cb(ctx, ossl_sslctx_session_new_cb);
OSSL_Debug("SSL SESSION new callback added");
}
if (RTEST(rb_attr_get(self, id_i_session_remove_cb))) {
SSL_CTX_sess_set_remove_cb(ctx, ossl_sslctx_session_remove_cb);
OSSL_Debug("SSL SESSION remove callback added");
}
val = rb_attr_get(self, id_i_servername_cb);
if (!NIL_P(val)) {
SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
OSSL_Debug("SSL TLSEXT servername callback added");
}
return Qtrue;
};T;)I"static VALUE;T;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_setup(VALUE self)
{
SSL_CTX *ctx;
X509 *cert = NULL, *client_ca = NULL;
EVP_PKEY *key = NULL;
char *ca_path = NULL, *ca_file = NULL;
int verify_mode;
long i;
VALUE val;
if(OBJ_FROZEN(self)) return Qnil;
GetSSLCTX(self, ctx);
#if !defined(OPENSSL_NO_DH)
SSL_CTX_set_tmp_dh_callback(ctx, ossl_tmp_dh_callback);
#endif
#if !defined(OPENSSL_NO_EC)
/* We added SSLContext#tmp_ecdh_callback= in Ruby 2.3.0,
* but SSL_CTX_set_tmp_ecdh_callback() was removed in OpenSSL 1.1.0. */
if (RTEST(rb_attr_get(self, id_i_tmp_ecdh_callback))) {
# if defined(HAVE_SSL_CTX_SET_TMP_ECDH_CALLBACK)
rb_warn("#tmp_ecdh_callback= is deprecated; use #ecdh_curves= instead");
SSL_CTX_set_tmp_ecdh_callback(ctx, ossl_tmp_ecdh_callback);
# if defined(HAVE_SSL_CTX_SET_ECDH_AUTO)
/* tmp_ecdh_callback and ecdh_auto conflict; OpenSSL ignores
* tmp_ecdh_callback. So disable ecdh_auto. */
if (!SSL_CTX_set_ecdh_auto(ctx, 0))
ossl_raise(eSSLError, "SSL_CTX_set_ecdh_auto");
# endif
# else
ossl_raise(eSSLError, "OpenSSL does not support tmp_ecdh_callback; "
"use #ecdh_curves= instead");
# endif
}
#endif /* OPENSSL_NO_EC */
val = rb_attr_get(self, id_i_cert_store);
if (!NIL_P(val)) {
X509_STORE *store = GetX509StorePtr(val); /* NO NEED TO DUP */
SSL_CTX_set_cert_store(ctx, store);
#if !defined(HAVE_X509_STORE_UP_REF)
/*
* WORKAROUND:
* X509_STORE can count references, but
* X509_STORE_free() doesn't care it.
* So we won't increment it but mark it by ex_data.
*/
SSL_CTX_set_ex_data(ctx, ossl_sslctx_ex_store_p, ctx);
#else /* Fixed in OpenSSL 1.0.2; bff9ce4db38b (master), 5b4b9ce976fc (1.0.2) */
X509_STORE_up_ref(store);
#endif
}
val = rb_attr_get(self, id_i_extra_chain_cert);
if(!NIL_P(val)){
rb_block_call(val, rb_intern("each"), 0, 0, ossl_sslctx_add_extra_chain_cert_i, self);
}
/* private key may be bundled in certificate file. */
val = rb_attr_get(self, id_i_cert);
cert = NIL_P(val) ? NULL : GetX509CertPtr(val); /* NO DUP NEEDED */
val = rb_attr_get(self, id_i_key);
key = NIL_P(val) ? NULL : GetPrivPKeyPtr(val); /* NO DUP NEEDED */
if (cert && key) {
if (!SSL_CTX_use_certificate(ctx, cert)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_certificate");
}
if (!SSL_CTX_use_PrivateKey(ctx, key)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey");
}
if (!SSL_CTX_check_private_key(ctx)) {
ossl_raise(eSSLError, "SSL_CTX_check_private_key");
}
}
val = rb_attr_get(self, id_i_client_ca);
if(!NIL_P(val)){
if (RB_TYPE_P(val, T_ARRAY)) {
for(i = 0; i < RARRAY_LEN(val); i++){
client_ca = GetX509CertPtr(RARRAY_AREF(val, i));
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
else{
client_ca = GetX509CertPtr(val); /* NO DUP NEEDED. */
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
val = rb_attr_get(self, id_i_ca_file);
ca_file = NIL_P(val) ? NULL : StringValueCStr(val);
val = rb_attr_get(self, id_i_ca_path);
ca_path = NIL_P(val) ? NULL : StringValueCStr(val);
if(ca_file || ca_path){
if (!SSL_CTX_load_verify_locations(ctx, ca_file, ca_path))
rb_warning("can't set verify locations");
}
val = rb_attr_get(self, id_i_verify_mode);
verify_mode = NIL_P(val) ? SSL_VERIFY_NONE : NUM2INT(val);
SSL_CTX_set_verify(ctx, verify_mode, ossl_ssl_verify_callback);
if (RTEST(rb_attr_get(self, id_i_client_cert_cb)))
SSL_CTX_set_client_cert_cb(ctx, ossl_client_cert_cb);
val = rb_attr_get(self, id_i_timeout);
if(!NIL_P(val)) SSL_CTX_set_timeout(ctx, NUM2LONG(val));
val = rb_attr_get(self, id_i_verify_depth);
if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2INT(val));
#ifndef OPENSSL_NO_NEXTPROTONEG
val = rb_attr_get(self, id_i_npn_protocols);
if (!NIL_P(val)) {
VALUE encoded = ssl_encode_npn_protocols(val);
rb_ivar_set(self, id_npn_protocols_encoded, encoded);
SSL_CTX_set_next_protos_advertised_cb(ctx, ssl_npn_advertise_cb, (void *)self);
OSSL_Debug("SSL NPN advertise callback added");
}
if (RTEST(rb_attr_get(self, id_i_npn_select_cb))) {
SSL_CTX_set_next_proto_select_cb(ctx, ssl_npn_select_cb, (void *) self);
OSSL_Debug("SSL NPN select callback added");
}
#endif
#ifdef HAVE_SSL_CTX_SET_ALPN_SELECT_CB
val = rb_attr_get(self, id_i_alpn_protocols);
if (!NIL_P(val)) {
VALUE rprotos = ssl_encode_npn_protocols(val);
/* returns 0 on success */
if (SSL_CTX_set_alpn_protos(ctx, (unsigned char *)RSTRING_PTR(rprotos),
RSTRING_LENINT(rprotos)))
ossl_raise(eSSLError, "SSL_CTX_set_alpn_protos");
OSSL_Debug("SSL ALPN values added");
}
if (RTEST(rb_attr_get(self, id_i_alpn_select_cb))) {
SSL_CTX_set_alpn_select_cb(ctx, ssl_alpn_select_cb, (void *) self);
OSSL_Debug("SSL ALPN select callback added");
}
#endif
rb_obj_freeze(self);
val = rb_attr_get(self, id_i_session_id_context);
if (!NIL_P(val)){
StringValue(val);
if (!SSL_CTX_set_session_id_context(ctx, (unsigned char *)RSTRING_PTR(val),
RSTRING_LENINT(val))){
ossl_raise(eSSLError, "SSL_CTX_set_session_id_context");
}
}
if (RTEST(rb_attr_get(self, id_i_session_get_cb))) {
SSL_CTX_sess_set_get_cb(ctx, ossl_sslctx_session_get_cb);
OSSL_Debug("SSL SESSION get callback added");
}
if (RTEST(rb_attr_get(self, id_i_session_new_cb))) {
SSL_CTX_sess_set_new_cb(ctx, ossl_sslctx_session_new_cb);
OSSL_Debug("SSL SESSION new callback added");
}
if (RTEST(rb_attr_get(self, id_i_session_remove_cb))) {
SSL_CTX_sess_set_remove_cb(ctx, ossl_sslctx_session_remove_cb);
OSSL_Debug("SSL SESSION remove callback added");
}
val = rb_attr_get(self, id_i_servername_cb);
if (!NIL_P(val)) {
SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
OSSL_Debug("SSL TLSEXT servername callback added");
}
return Qtrue;
};T;)@;*T@o;;[[@HTi
;F;:SESSION_CACHE_OFF;;;;;[ ;{ ;IC; ",No session caching for client or server
;T;[ ; [ ; I"-No session caching for client or server
;T; 0; @
;!F;"o;#;$T;%i
;&i
;'@;I"0OpenSSL::SSL::SSLContext::SESSION_CACHE_OFF;F;I"!LONG2NUM(SSL_SESS_CACHE_OFF);To;;[[@HTi
;F;:SESSION_CACHE_CLIENT;;;;;[ ;{ ;IC; "+doesn't actually do anything in 0.9.8e
;T;[ ; [ ; I"+doesn't actually do anything in 0.9.8e;T; 0; @;!F;"o;#;$T;%i
;&i
;'@;I"3OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT;F;I"$LONG2NUM(SSL_SESS_CACHE_CLIENT);To;;[[@HTi
;F;:SESSION_CACHE_SERVER;;;;;[ ;{ ;IC; "3Server sessions are added to the session cache
;T;[ ; [ ; I"4Server sessions are added to the session cache
;T; 0; @";!F;"o;#;$T;%i
;&i
;'@;I"3OpenSSL::SSL::SSLContext::SESSION_CACHE_SERVER;F;I"$LONG2NUM(SSL_SESS_CACHE_SERVER);To;;[[@HTi
;F;:SESSION_CACHE_BOTH;;;;;[ ;{ ;IC; "-no different than CACHE_SERVER in 0.9.8e
;T;[ ; [ ; I"-no different than CACHE_SERVER in 0.9.8e;T; 0; @.;!F;"o;#;$T;%i
;&i
;'@;I"1OpenSSL::SSL::SSLContext::SESSION_CACHE_BOTH;F;I""LONG2NUM(SSL_SESS_CACHE_BOTH);To;;[[@HTi
;F;: SESSION_CACHE_NO_AUTO_CLEAR;;;;;[ ;{ ;IC; "Normally the session cache is checked for expired sessions every 255
connections. Since this may lead to a delay that cannot be controlled,
the automatic flushing may be disabled and #flush_sessions can be
called explicitly.
;T;[ ; [ ; I"Normally the session cache is checked for expired sessions every 255
connections. Since this may lead to a delay that cannot be controlled,
the automatic flushing may be disabled and #flush_sessions can be
called explicitly.
;T; 0; @:;!F;"o;#;$T;%i
;&i
;'@;I":OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_AUTO_CLEAR;F;I"+LONG2NUM(SSL_SESS_CACHE_NO_AUTO_CLEAR);To;;[[@HTi ;F;:%SESSION_CACHE_NO_INTERNAL_LOOKUP;;;;;[ ;{ ;IC; "|Always perform external lookups of sessions even if they are in the
internal cache.
This flag has no effect on clients
;T;[ ; [ ; I"}Always perform external lookups of sessions even if they are in the
internal cache.
This flag has no effect on clients
;T; 0; @F;!F;"o;#;$T;%i
;&i
;'@;I"?OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_LOOKUP;F;I"0LONG2NUM(SSL_SESS_CACHE_NO_INTERNAL_LOOKUP);To;;[[@HTi ;F;:$SESSION_CACHE_NO_INTERNAL_STORE;;;;;[ ;{ ;IC; ">Never automatically store sessions in the internal store.
;T;[ ; [ ; I"?Never automatically store sessions in the internal store.
;T; 0; @R;!F;"o;#;$T;%i ;&i ;'@;I">OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE;F;I"/LONG2NUM(SSL_SESS_CACHE_NO_INTERNAL_STORE);To;;[[@HTi ;F;: SESSION_CACHE_NO_INTERNAL;;;;;[ ;{ ;IC; "WEnables both SESSION_CACHE_NO_INTERNAL_LOOKUP and
SESSION_CACHE_NO_INTERNAL_STORE.
;T;[ ; [ ; I"XEnables both SESSION_CACHE_NO_INTERNAL_LOOKUP and
SESSION_CACHE_NO_INTERNAL_STORE.
;T; 0; @^;!F;"o;#;$T;%i ;&i ;'@;I"8OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL;F;I")LONG2NUM(SSL_SESS_CACHE_NO_INTERNAL);To; ; F;
;;;;I")OpenSSL::SSL::SSLContext#session_add;F;[[I"arg;T0;[[@HTiC;T;:session_add;0;[ ;{ ;IC; ")Adds _session_ to the session cache.
;T;[o;=
;3I"
overload;F;40;;E;50;)I"session_add(session);T;IC; " ;T;[ ; [ ; I" ;T; 0; @j;!F;6i ;>0;[[I" session;T0; @j; [ ; I"JAdds _session_ to the session cache.
@overload session_add(session);T; 0; @j;!F;"o;#;$T;%i=;&i@;'@;(I"static VALUE
ossl_sslctx_session_add(VALUE self, VALUE arg)
{
SSL_CTX *ctx;
SSL_SESSION *sess;
GetSSLCTX(self, ctx);
GetSSLSession(arg, sess);
return SSL_CTX_add_session(ctx, sess) == 1 ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLContext#session_remove;F;[[I"arg;T0;[[@HTiU;T;:session_remove;0;[ ;{ ;IC; ".Removes _session_ from the session cache.
;T;[o;=
;3I"
overload;F;40;;F;50;)I" session_remove(session);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" session;T0; @; [ ; I"RRemoves _session_ from the session cache.
@overload session_remove(session);T; 0; @;!F;"o;#;$T;%iO;&iR;'@;(I"static VALUE
ossl_sslctx_session_remove(VALUE self, VALUE arg)
{
SSL_CTX *ctx;
SSL_SESSION *sess;
GetSSLCTX(self, ctx);
GetSSLSession(arg, sess);
return SSL_CTX_remove_session(ctx, sess) == 1 ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"0OpenSSL::SSL::SSLContext#session_cache_mode;F;[ ;[[@HTig;T;:session_cache_mode;0;[ ;{ ;IC; "$The current session cache mode.
;T;[o;=
;3I"
overload;F;40;;G;50;)I"session_cache_mode;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"WThe current session cache mode.
@overload session_cache_mode
@return [Integer];T; 0; @;!F;"o;#;$T;%ia;&ie;'@;(I"static VALUE
ossl_sslctx_get_session_cache_mode(VALUE self)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
return LONG2NUM(SSL_CTX_get_session_cache_mode(ctx));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"1OpenSSL::SSL::SSLContext#session_cache_mode=;F;[[I"arg;T0;[[@HTiy;T;:session_cache_mode=;0;[ ;{ ;IC; "Sets the SSL session cache mode. Bitwise-or together the desired
SESSION_CACHE_* constants to set. See SSL_CTX_set_session_cache_mode(3) for
details.
;T;[o;=
;3I"
overload;F;40;;H;50;)I"!session_cache_mode=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I" integer;T0; @; [ ; I"Sets the SSL session cache mode. Bitwise-or together the desired
SESSION_CACHE_* constants to set. See SSL_CTX_set_session_cache_mode(3) for
details.
@overload session_cache_mode=(integer)
@return [Integer];T; 0; @;!F;"o;#;$T;%iq;&iw;'@;(I"static VALUE
ossl_sslctx_set_session_cache_mode(VALUE self, VALUE arg)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
SSL_CTX_set_session_cache_mode(ctx, NUM2LONG(arg));
return arg;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"0OpenSSL::SSL::SSLContext#session_cache_size;F;[ ;[[@HTi;T;:session_cache_size;0;[ ;{ ;IC; "`Returns the current session cache size. Zero is used to represent an
unlimited cache size.
;T;[o;=
;3I"
overload;F;40;;I;50;)I"session_cache_size;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ؙ; [ ; I"@return [Integer];T; 0; @ؙ;!F;6i ;>0;[ ; @ؙ; [ ; I"Returns the current session cache size. Zero is used to represent an
unlimited cache size.
@overload session_cache_size
@return [Integer];T; 0; @ؙ;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_get_session_cache_size(VALUE self)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
return LONG2NUM(SSL_CTX_sess_get_cache_size(ctx));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"1OpenSSL::SSL::SSLContext#session_cache_size=;F;[[I"arg;T0;[[@HTi;T;:session_cache_size=;0;[ ;{ ;IC; "Sets the session cache size. Returns the previously valid session cache
size. Zero is used to represent an unlimited session cache size.
;T;[o;=
;3I"
overload;F;40;;J;50;)I"!session_cache_size=(integer);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I" integer;T0; @; [ ; I"Sets the session cache size. Returns the previously valid session cache
size. Zero is used to represent an unlimited session cache size.
@overload session_cache_size=(integer)
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_set_session_cache_size(VALUE self, VALUE arg)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
SSL_CTX_sess_set_cache_size(ctx, NUM2LONG(arg));
return arg;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"1OpenSSL::SSL::SSLContext#session_cache_stats;F;[ ;[[@HTi;T;:session_cache_stats;0;[ ;{ ;IC; "Returns a Hash containing the following keys:
:accept:: Number of started SSL/TLS handshakes in server mode
:accept_good:: Number of established SSL/TLS sessions in server mode
:accept_renegotiate:: Number of start renegotiations in server mode
:cache_full:: Number of sessions that were removed due to cache overflow
:cache_hits:: Number of successfully reused connections
:cache_misses:: Number of sessions proposed by clients that were not found
in the cache
:cache_num:: Number of sessions in the internal session cache
:cb_hits:: Number of sessions retrieved from the external cache in server
mode
:connect:: Number of started SSL/TLS handshakes in client mode
:connect_good:: Number of established SSL/TLS sessions in client mode
:connect_renegotiate:: Number of start renegotiations in client mode
:timeouts:: Number of sessions proposed by clients that were found in the
cache but had expired due to timeouts
;T;[o;=
;3I"
overload;F;40;;K;50;)I"session_cache_stats;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Hash;T; @; [ ; I"@return [Hash];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Returns a Hash containing the following keys:
:accept:: Number of started SSL/TLS handshakes in server mode
:accept_good:: Number of established SSL/TLS sessions in server mode
:accept_renegotiate:: Number of start renegotiations in server mode
:cache_full:: Number of sessions that were removed due to cache overflow
:cache_hits:: Number of successfully reused connections
:cache_misses:: Number of sessions proposed by clients that were not found
in the cache
:cache_num:: Number of sessions in the internal session cache
:cb_hits:: Number of sessions retrieved from the external cache in server
mode
:connect:: Number of started SSL/TLS handshakes in client mode
:connect_good:: Number of established SSL/TLS sessions in client mode
:connect_renegotiate:: Number of start renegotiations in client mode
:timeouts:: Number of sessions proposed by clients that were found in the
cache but had expired due to timeouts
@overload session_cache_stats
@return [Hash];T; 0; @;!F;"o;#;$T;%i;&i;'@;(I"9static VALUE
ossl_sslctx_get_session_cache_stats(VALUE self)
{
SSL_CTX *ctx;
VALUE hash;
GetSSLCTX(self, ctx);
hash = rb_hash_new();
rb_hash_aset(hash, ID2SYM(rb_intern("cache_num")), LONG2NUM(SSL_CTX_sess_number(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("connect")), LONG2NUM(SSL_CTX_sess_connect(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("connect_good")), LONG2NUM(SSL_CTX_sess_connect_good(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("connect_renegotiate")), LONG2NUM(SSL_CTX_sess_connect_renegotiate(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("accept")), LONG2NUM(SSL_CTX_sess_accept(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("accept_good")), LONG2NUM(SSL_CTX_sess_accept_good(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("accept_renegotiate")), LONG2NUM(SSL_CTX_sess_accept_renegotiate(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("cache_hits")), LONG2NUM(SSL_CTX_sess_hits(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("cb_hits")), LONG2NUM(SSL_CTX_sess_cb_hits(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("cache_misses")), LONG2NUM(SSL_CTX_sess_misses(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("cache_full")), LONG2NUM(SSL_CTX_sess_cache_full(ctx)));
rb_hash_aset(hash, ID2SYM(rb_intern("timeouts")), LONG2NUM(SSL_CTX_sess_timeouts(ctx)));
return hash;
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLContext#flush_sessions;F;[[@c0;[[@HTi;T;:flush_sessions;0;[ ;{ ;IC; "HRemoves sessions in the internal cache that have expired at _time_.
;T;[o;=
;3I"
overload;F;40;;L;50;)I"flush_sessions(time);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @-; [ ; I"@return [self];T; 0; @-;!F;6i ;>0;[[I" time;T0; @-; [ ; I"zRemoves sessions in the internal cache that have expired at _time_.
@overload flush_sessions(time)
@return [self];T; 0; @-;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_flush_sessions(int argc, VALUE *argv, VALUE self)
{
VALUE arg1;
SSL_CTX *ctx;
time_t tm = 0;
rb_scan_args(argc, argv, "01", &arg1);
GetSSLCTX(self, ctx);
if (NIL_P(arg1)) {
tm = time(0);
} else if (rb_obj_is_instance_of(arg1, rb_cTime)) {
tm = NUM2LONG(rb_funcall(arg1, rb_intern("to_i"), 0));
} else {
ossl_raise(rb_eArgError, "arg must be Time or nil");
}
SSL_CTX_flush_sessions(ctx, (long)tm);
return self;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"%OpenSSL::SSL::SSLContext#options;F;[ ;[[@HTi;T;;;0;[ ;{ ;IC; ""Gets various OpenSSL options.
;T;[ ; [ ; I"#Gets various OpenSSL options.
;T; 0; @K;!F;"o;#;$T;%i;&i;'@;(I"static VALUE
ossl_sslctx_get_options(VALUE self)
{
SSL_CTX *ctx;
GetSSLCTX(self, ctx);
/*
* Do explicit cast because SSL_CTX_get_options() returned (signed) long in
* OpenSSL before 1.1.0.
*/
return ULONG2NUM((unsigned long)SSL_CTX_get_options(ctx));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::SSL::SSLContext#options=;F;[[I" options;T0;[[@HTi;T;:
options=;0;[ ;{ ;IC; ""Sets various OpenSSL options.
;T;[ ; [ ; I"#Sets various OpenSSL options.
;T; 0; @Y;!F;"o;#;$T;%i;&i;'@;(I"\static VALUE
ossl_sslctx_set_options(VALUE self, VALUE options)
{
SSL_CTX *ctx;
rb_check_frozen(self);
GetSSLCTX(self, ctx);
SSL_CTX_clear_options(ctx, SSL_CTX_get_options(ctx));
if (NIL_P(options)) {
SSL_CTX_set_options(ctx, SSL_OP_ALL);
} else {
SSL_CTX_set_options(ctx, NUM2ULONG(options));
}
return self;
};T;)I"static VALUE;T;*T;A@;BIC;[ ;A@;CIC;[ ;A@;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{@;@;@;<;I[ ;[[@HTi [@HTi ;T;:SSLContext;;K;;;[ ;{ ;IC; " An SSLContext is used to set various options regarding certificates,
algorithms, verification, session caching, etc. The SSLContext is
used to create an SSLSocket.
All attributes must be set before creating an SSLSocket as the
SSLContext will be frozen afterward.
;T;[ ; [ ; I"
An SSLContext is used to set various options regarding certificates,
algorithms, verification, session caching, etc. The SSLContext is
used to create an SSLSocket.
All attributes must be set before creating an SSLSocket as the
SSLContext will be frozen afterward.
;T; 0; @;!F;"o;#;$T;%i ;&i ;'@[s;I" OpenSSL::SSL::SSLContext;F;S@]o;
;IC;[ o; ; F;
;;;;I"'OpenSSL::SSL::SSLSocket#initialize;F;[[@c0;[[@i|[@HTi.;T;;;0;[ ;{ ;IC; "Creates a new SSL socket from _io_ which must be a real IO object (not an
IO-like object that responds to read/write).
If _ctx_ is provided the SSL Sockets initial params will be taken from
the context.
The OpenSSL::Buffering module provides additional IO methods.
This method will freeze the SSLContext if one is provided;
however, session management is still allowed in the frozen SSLContext.
;T;[o;=
;3I"
overload;F;40;;;50;)I" new(io);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"aSSLSocket;T; @}; [ ; I"@return [aSSLSocket];T; 0; @};!F;6i ;>0;[[I"io;T0; @}o;=
;3I"
overload;F;40;;;50;)I"new(io, ctx);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"aSSLSocket;T; @}; [ ; I"@return [aSSLSocket];T; 0; @};!F;6i ;>0;[[I"io;T0[I"ctx;T0; @}; [ ; I"Creates a new SSL socket from _io_ which must be a real IO object (not an
IO-like object that responds to read/write).
If _ctx_ is provided the SSL Sockets initial params will be taken from
the context.
The OpenSSL::Buffering module provides additional IO methods.
This method will freeze the SSLContext if one is provided;
however, session management is still allowed in the frozen SSLContext.
@overload new(io)
@return [aSSLSocket]
@overload new(io, ctx)
@return [aSSLSocket];T; 0; @};!F;"o;#;$T;%i ;&i-;'@{;(I"VALUE
rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
{
rb_notimplement();
UNREACHABLE_RETURN(Qnil);
};T;)I"
VALUE;T;*To; ; F;
;;;;I"$OpenSSL::SSL::SSLSocket#connect;F;[ ;[[@HTi;T;: connect;0;[ ;{ ;IC; "Initiates an SSL/TLS handshake with a server. The handshake may be started
after unencrypted data has been sent over the socket.
;T;[o;=
;3I"
overload;F;40;;O;50;)I" connect;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Initiates an SSL/TLS handshake with a server. The handshake may be started
after unencrypted data has been sent over the socket.
@overload connect
@return [self];T; 0; @;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_connect(VALUE self)
{
ossl_ssl_setup(self);
return ossl_start_ssl(self, SSL_connect, "SSL_connect", Qfalse);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"-OpenSSL::SSL::SSLSocket#connect_nonblock;F;[[@c0;[[@HTi;T;:connect_nonblock;0;[ ;{ ;IC; "Initiates the SSL/TLS handshake as a client in non-blocking manner.
# emulates blocking connect
begin
ssl.connect_nonblock
rescue IO::WaitReadable
IO.select([s2])
retry
rescue IO::WaitWritable
IO.select(nil, [s2])
retry
end
By specifying a keyword argument _exception_ to +false+, you can indicate
that connect_nonblock should not raise an IO::WaitReadable or
IO::WaitWritable exception, but return the symbol +:wait_readable+ or
+:wait_writable+ instead.
;T;[o;=
;3I"
overload;F;40;;P;50;)I" connect_nonblock([options]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @Ț; [ ; I"@return [self];T; 0; @Ț;!F;6i ;>0;[[I"[options];T0; @Ț; [ ; I" Initiates the SSL/TLS handshake as a client in non-blocking manner.
# emulates blocking connect
begin
ssl.connect_nonblock
rescue IO::WaitReadable
IO.select([s2])
retry
rescue IO::WaitWritable
IO.select(nil, [s2])
retry
end
By specifying a keyword argument _exception_ to +false+, you can indicate
that connect_nonblock should not raise an IO::WaitReadable or
IO::WaitWritable exception, but return the symbol +:wait_readable+ or
+:wait_writable+ instead.
@overload connect_nonblock([options])
@return [self];T; 0; @Ț;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_connect_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE opts;
rb_scan_args(argc, argv, "0:", &opts);
ossl_ssl_setup(self);
return ossl_start_ssl(self, SSL_connect, "SSL_connect", opts);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::SSL::SSLSocket#accept;F;[ ;[[@HTi;T;: accept;0;[ ;{ ;IC; "Waits for a SSL/TLS client to initiate a handshake. The handshake may be
started after unencrypted data has been sent over the socket.
;T;[o;=
;3I"
overload;F;40;;Q;50;)I" accept;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"Waits for a SSL/TLS client to initiate a handshake. The handshake may be
started after unencrypted data has been sent over the socket.
@overload accept
@return [self];T; 0; @;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_accept(VALUE self)
{
ossl_ssl_setup(self);
return ossl_start_ssl(self, SSL_accept, "SSL_accept", Qfalse);
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLSocket#accept_nonblock;F;[[@c0;[[@HTi$;T;:accept_nonblock;0;[ ;{ ;IC; "Initiates the SSL/TLS handshake as a server in non-blocking manner.
# emulates blocking accept
begin
ssl.accept_nonblock
rescue IO::WaitReadable
IO.select([s2])
retry
rescue IO::WaitWritable
IO.select(nil, [s2])
retry
end
By specifying a keyword argument _exception_ to +false+, you can indicate
that accept_nonblock should not raise an IO::WaitReadable or
IO::WaitWritable exception, but return the symbol +:wait_readable+ or
+:wait_writable+ instead.
;T;[o;=
;3I"
overload;F;40;;R;50;)I" accept_nonblock([options]);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" self;T; @; [ ; I"@return [self];T; 0; @;!F;6i ;>0;[[I"[options];T0; @; [ ; I" Initiates the SSL/TLS handshake as a server in non-blocking manner.
# emulates blocking accept
begin
ssl.accept_nonblock
rescue IO::WaitReadable
IO.select([s2])
retry
rescue IO::WaitWritable
IO.select(nil, [s2])
retry
end
By specifying a keyword argument _exception_ to +false+, you can indicate
that accept_nonblock should not raise an IO::WaitReadable or
IO::WaitWritable exception, but return the symbol +:wait_readable+ or
+:wait_writable+ instead.
@overload accept_nonblock([options])
@return [self];T; 0; @;!F;"o;#;$T;%i;&i";'@{;(I"static VALUE
ossl_ssl_accept_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE opts;
rb_scan_args(argc, argv, "0:", &opts);
ossl_ssl_setup(self);
return ossl_start_ssl(self, SSL_accept, "SSL_accept", opts);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::SSL::SSLSocket#sysread;F;[[@c0;[[@HTi;T;;;0;[ ;{ ;IC; "}Reads _length_ bytes from the SSL connection. If a pre-allocated _buffer_
is provided the data will be written into it.
;T;[o;=
;3I"
overload;F;40;;;50;)I"sysread(length);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @ ; [ ; I"@return [String];T; 0; @ ;!F;6i ;>0;[[I" length;T0; @ o;=
;3I"
overload;F;40;;;50;)I" sysread(length, buffer);T;IC; " ;T;[ ; [ ; I" ;T; 0; @ ;!F;6i ;>0;[[I" length;T0[I" buffer;T0; @ ; [ ; I"Reads _length_ bytes from the SSL connection. If a pre-allocated _buffer_
is provided the data will be written into it.
@overload sysread(length)
@return [String]
@overload sysread(length, buffer);T; 0; @ ;!F;"o;#;$T;%i;&i;'@{;(I"~static VALUE
ossl_ssl_read(int argc, VALUE *argv, VALUE self)
{
return ossl_ssl_read_internal(argc, argv, self, 0);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"-OpenSSL::SSL::SSLSocket#sysread_nonblock;F;[[@c0;[[@HTi;T;:sysread_nonblock;0;[ ;{ ;IC; "UA non-blocking version of #sysread. Raises an SSLError if reading would
block. If "exception: false" is passed, this method returns a symbol of
:wait_readable, :wait_writable, or nil, rather than raising an exception.
Reads _length_ bytes from the SSL connection. If a pre-allocated _buffer_
is provided the data will be written into it.
;T;[o;=
;3I"
overload;F;40;;S;50;)I" sysread_nonblock(length);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @I; [ ; I"@return [String];T; 0; @I;!F;6i ;>0;[[I" length;T0; @Io;=
;3I"
overload;F;40;;S;50;)I"%sysread_nonblock(length, buffer);T;IC; " ;T;[ ; [ ; I" ;T; 0; @I;!F;6i ;>0;[[I" length;T0[I" buffer;T0; @Io;=
;3I"
overload;F;40;;S;50;)I"/sysread_nonblock(length[, buffer [, opts]);T;IC; " ;T;[ ; [ ; I" ;T; 0; @I;!F;6i ;>0;[[I" length[, buffer [, opts]);T0; @I; [ ; I"A non-blocking version of #sysread. Raises an SSLError if reading would
block. If "exception: false" is passed, this method returns a symbol of
:wait_readable, :wait_writable, or nil, rather than raising an exception.
Reads _length_ bytes from the SSL connection. If a pre-allocated _buffer_
is provided the data will be written into it.
@overload sysread_nonblock(length)
@return [String]
@overload sysread_nonblock(length, buffer)
@overload sysread_nonblock(length[, buffer [, opts]);T; 0; @I;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_read_nonblock(int argc, VALUE *argv, VALUE self)
{
return ossl_ssl_read_internal(argc, argv, self, 1);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"%OpenSSL::SSL::SSLSocket#syswrite;F;[[I"str;T0;[[@HTi;T;;;0;[ ;{ ;IC; "+Writes _string_ to the SSL connection.
;T;[o;=
;3I"
overload;F;40;;;50;)I"syswrite(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @}; [ ; I"@return [Integer];T; 0; @};!F;6i ;>0;[[I" string;T0; @}; [ ; I"\Writes _string_ to the SSL connection.
@overload syswrite(string)
@return [Integer];T; 0; @};!F;"o;#;$T;%i ;&i;'@{;(I"rstatic VALUE
ossl_ssl_write(VALUE self, VALUE str)
{
return ossl_ssl_write_internal(self, str, Qfalse);
};T;)I"static VALUE;T;*To; ; F;
;;;;I".OpenSSL::SSL::SSLSocket#syswrite_nonblock;F;[[@c0;[[@HTi ;T;:syswrite_nonblock;0;[ ;{ ;IC; "pWrites _string_ to the SSL connection in a non-blocking manner. Raises an
SSLError if writing would block.
;T;[o;=
;3I"
overload;F;40;;T;50;)I" syswrite_nonblock(string);T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @; [ ; I"@return [Integer];T; 0; @;!F;6i ;>0;[[I" string;T0; @; [ ; I"Writes _string_ to the SSL connection in a non-blocking manner. Raises an
SSLError if writing would block.
@overload syswrite_nonblock(string)
@return [Integer];T; 0; @;!F;"o;#;$T;%i;&i ;'@{;(I"static VALUE
ossl_ssl_write_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE str, opts;
rb_scan_args(argc, argv, "1:", &str, &opts);
return ossl_ssl_write_internal(self, str, opts);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!OpenSSL::SSL::SSLSocket#stop;F;[ ;[[@HTi/;T;;;0;[ ;{ ;IC; "[Sends "close notify" to the peer and tries to shut down the SSL connection
gracefully.
;T;[o;=
;3I"
overload;F;40;;;50;)I" stop;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"|Sends "close notify" to the peer and tries to shut down the SSL connection
gracefully.
@overload stop
@return [nil];T; 0; @;!F;"o;#;$T;%i(;&i-;'@{;(I"static VALUE
ossl_ssl_stop(VALUE self)
{
SSL *ssl;
int ret;
GetSSL(self, ssl);
if (!ssl_started(ssl))
return Qnil;
ret = SSL_shutdown(ssl);
if (ret == 1) /* Have already received close_notify */
return Qnil;
if (ret == 0) /* Sent close_notify, but we don't wait for reply */
return Qnil;
/*
* XXX: Something happened. Possibly it failed because the underlying socket
* is not writable/readable, since it is in non-blocking mode. We should do
* some proper error handling using SSL_get_error() and maybe retry, but we
* can't block here. Give up for now.
*/
ossl_clear_error();
return Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"!OpenSSL::SSL::SSLSocket#cert;F;[ ;[[@HTiN;T;: cert;0;[ ;{ ;IC; "3The X509 certificate for this socket endpoint.
;T;[o;=
;3I"
overload;F;40;;U;50;)I" cert;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @՛; [ ; I"@return [nil];T; 0; @՛;!F;6i ;>0;[ ; @՛; [ ; I"TThe X509 certificate for this socket endpoint.
@overload cert
@return [nil];T; 0; @՛;!F;"o;#;$T;%iH;&iL;'@{;(I"Nstatic VALUE
ossl_ssl_get_cert(VALUE self)
{
SSL *ssl;
X509 *cert = NULL;
GetSSL(self, ssl);
/*
* Is this OpenSSL bug? Should add a ref?
* TODO: Ask for.
*/
cert = SSL_get_certificate(ssl); /* NO DUPs => DON'T FREE. */
if (!cert) {
return Qnil;
}
return ossl_x509_new(cert);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::SSL::SSLSocket#peer_cert;F;[ ;[[@HTih;T;:peer_cert;0;[ ;{ ;IC; "1The X509 certificate for this socket's peer.
;T;[o;=
;3I"
overload;F;40;;V;50;)I"peer_cert;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;T; @; [ ; I"@return [nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"WThe X509 certificate for this socket's peer.
@overload peer_cert
@return [nil];T; 0; @;!F;"o;#;$T;%ib;&if;'@{;(I">static VALUE
ossl_ssl_get_peer_cert(VALUE self)
{
SSL *ssl;
X509 *cert = NULL;
VALUE obj;
GetSSL(self, ssl);
cert = SSL_get_peer_certificate(ssl); /* Adds a ref => Safe to FREE. */
if (!cert) {
return Qnil;
}
obj = ossl_x509_new(cert);
X509_free(cert);
return obj;
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLSocket#peer_cert_chain;F;[ ;[[@HTi;T;:peer_cert_chain;0;[ ;{ ;IC; "7The X509 certificate chain for this socket's peer.
;T;[o;=
;3I"
overload;F;40;;W;50;)I"peer_cert_chain;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;TI"nil;T; @ ; [ ; I"@return [Array, nil];T; 0; @ ;!F;6i ;>0;[ ; @ ; [ ; I"jThe X509 certificate chain for this socket's peer.
@overload peer_cert_chain
@return [Array, nil];T; 0; @ ;!F;"o;#;$T;%i|;&i;'@{;(I"static VALUE
ossl_ssl_get_peer_cert_chain(VALUE self)
{
SSL *ssl;
STACK_OF(X509) *chain;
X509 *cert;
VALUE ary;
int i, num;
GetSSL(self, ssl);
chain = SSL_get_peer_cert_chain(ssl);
if(!chain) return Qnil;
num = sk_X509_num(chain);
ary = rb_ary_new2(num);
for (i = 0; i < num; i++){
cert = sk_X509_value(chain, i);
rb_ary_push(ary, ossl_x509_new(cert));
}
return ary;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"(OpenSSL::SSL::SSLSocket#ssl_version;F;[ ;[[@HTi;T;:ssl_version;0;[ ;{ ;IC; "uReturns a String representing the SSL/TLS version that was negotiated
for the connection, for example "TLSv1.2".
;T;[o;=
;3I"
overload;F;40;;X;50;)I"ssl_version;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @'; [ ; I"@return [String];T; 0; @';!F;6i ;>0;[ ; @'; [ ; I"Returns a String representing the SSL/TLS version that was negotiated
for the connection, for example "TLSv1.2".
@overload ssl_version
@return [String];T; 0; @';!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_get_version(VALUE self)
{
SSL *ssl;
GetSSL(self, ssl);
return rb_str_new2(SSL_get_version(ssl));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"#OpenSSL::SSL::SSLSocket#cipher;F;[ ;[[@HTi;T;;;0;[ ;{ ;IC; "nReturns the cipher suite actually used in the current session, or nil if
no session has been established.
;T;[o;=
;3I"
overload;F;40;;;50;)I" cipher;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"nil;TI"
Array;T; @B; [ ; I"@return [nil, Array];T; 0; @B;!F;6i ;>0;[ ; @B; [ ; I"Returns the cipher suite actually used in the current session, or nil if
no session has been established.
@overload cipher
@return [nil, Array];T; 0; @B;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_get_cipher(VALUE self)
{
SSL *ssl;
const SSL_CIPHER *cipher;
GetSSL(self, ssl);
cipher = SSL_get_current_cipher(ssl);
return cipher ? ossl_ssl_cipher_to_ary(cipher) : Qnil;
};T;)I"static VALUE;T;*To; ; F;
;;;;I""OpenSSL::SSL::SSLSocket#state;F;[ ;[[@HTi;T;:
state;0;[ ;{ ;IC; "YA description of the current connection state. This is for diagnostic
purposes only.
;T;[o;=
;3I"
overload;F;40;;Y;50;)I"
state;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" String;T; @^; [ ; I"@return [String];T; 0; @^;!F;6i ;>0;[ ; @^; [ ; I"~A description of the current connection state. This is for diagnostic
purposes only.
@overload state
@return [String];T; 0; @^;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_get_state(VALUE self)
{
SSL *ssl;
VALUE ret;
GetSSL(self, ssl);
ret = rb_str_new2(SSL_state_string(ssl));
if (ruby_verbose) {
rb_str_cat2(ret, ": ");
rb_str_cat2(ret, SSL_state_string_long(ssl));
}
return ret;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::SSL::SSLSocket#pending;F;[ ;[[@HTi;T;: pending;0;[ ;{ ;IC; "DThe number of bytes that are immediately available for reading.
;T;[o;=
;3I"
overload;F;40;;Z;50;)I" pending;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @y; [ ; I"@return [Integer];T; 0; @y;!F;6i ;>0;[ ; @y; [ ; I"lThe number of bytes that are immediately available for reading.
@overload pending
@return [Integer];T; 0; @y;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_pending(VALUE self)
{
SSL *ssl;
GetSSL(self, ssl);
return INT2NUM(SSL_pending(ssl));
};T;)I"static VALUE;T;*To; ; F;
;;;;I",OpenSSL::SSL::SSLSocket#session_reused?;F;[ ;[[@HTi;T;:session_reused?;0;[ ;{ ;IC; "LReturns +true+ if a reused session was negotiated during the handshake.;T;[o;=
;3I"
overload;F;40;;[;50;)I"session_reused?;T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[ ; @o;2
;3I" return;F;4@|;0;5[@~; @; [ ; I"hReturns +true+ if a reused session was negotiated during the handshake.
@overload session_reused?;T; 0; @;!F;"o;#;$T;%i;&i;6i ;'@{;(I"static VALUE
ossl_ssl_session_reused(VALUE self)
{
SSL *ssl;
GetSSL(self, ssl);
return SSL_session_reused(ssl) ? Qtrue : Qfalse;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"%OpenSSL::SSL::SSLSocket#session=;F;[[I" arg1;T0;[[@HTi;T;:
session=;0;[ ;{ ;IC; "DSets the Session to be used when the connection is established.
;T;[o;=
;3I"
overload;F;40;;\;50;)I"session=(session);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I" session;T0; @; [ ; I"bSets the Session to be used when the connection is established.
@overload session=(session);T; 0; @;!F;"o;#;$T;%i;&i;'@{;(I"static VALUE
ossl_ssl_set_session(VALUE self, VALUE arg1)
{
SSL *ssl;
SSL_SESSION *sess;
GetSSL(self, ssl);
GetSSLSession(arg1, sess);
if (SSL_set_session(ssl, sess) != 1)
ossl_raise(eSSLError, "SSL_set_session");
return arg1;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::SSL::SSLSocket#verify_result;F;[ ;[[@HTi, ;T;:verify_result;0;[ ;{ ;IC; "Returns the result of the peer certificates verification. See verify(1)
for error values and descriptions.
If no peer certificate was presented X509_V_OK is returned.
;T;[o;=
;3I"
overload;F;40;;];50;)I"verify_result;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" Integer;T; @ǜ; [ ; I"@return [Integer];T; 0; @ǜ;!F;6i ;>0;[ ; @ǜ; [ ; I"Returns the result of the peer certificates verification. See verify(1)
for error values and descriptions.
If no peer certificate was presented X509_V_OK is returned.
@overload verify_result
@return [Integer];T; 0; @ǜ;!F;"o;#;$T;%i# ;&i* ;'@{;(I"static VALUE
ossl_ssl_get_verify_result(VALUE self)
{
SSL *ssl;
GetSSL(self, ssl);
return INT2NUM(SSL_get_verify_result(ssl));
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::SSL::SSLSocket#client_ca;F;[ ;[[@HTiA ;T;:client_ca;0;[ ;{ ;IC; "EReturns the list of client CAs. Please note that in contrast to
SSLContext#client_ca= no array of X509::Certificate is returned but
X509::Name instances of the CA's subject distinguished name.
In server mode, returns the list set by SSLContext#client_ca=.
In client mode, returns the list of client CAs sent from the server.
;T;[o;=
;3I"
overload;F;40;;^;50;)I"client_ca;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"
Array;T; @; [ ; I"@return [Array];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"mReturns the list of client CAs. Please note that in contrast to
SSLContext#client_ca= no array of X509::Certificate is returned but
X509::Name instances of the CA's subject distinguished name.
In server mode, returns the list set by SSLContext#client_ca=.
In client mode, returns the list of client CAs sent from the server.
@overload client_ca
@return [Array];T; 0; @;!F;"o;#;$T;%i6 ;&i? ;'@{;(I"static VALUE
ossl_ssl_get_client_ca_list(VALUE self)
{
SSL *ssl;
STACK_OF(X509_NAME) *ca;
GetSSL(self, ssl);
ca = SSL_get_client_CA_list(ssl);
return ossl_x509name_sk2ary(ca);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"&OpenSSL::SSL::SSLSocket#hostname=;F;[[I"arg;T0;[[@HTi ;T;:hostname=;0;[ ;{ ;IC; "ZSets the server hostname used for SNI. This needs to be set before
SSLSocket#connect.
;T;[o;=
;3I"
overload;F;40;;_;50;)I"hostname=(hostname);T;IC; " ;T;[ ; [ ; I" ;T; 0; @;!F;6i ;>0;[[I"
hostname;T0; @; [ ; I"zSets the server hostname used for SNI. This needs to be set before
SSLSocket#connect.
@overload hostname=(hostname);T; 0; @;!F;"o;#;$T;%i ;&i ;'@{;(I"estatic VALUE
ossl_ssl_set_hostname(VALUE self, VALUE arg)
{
SSL *ssl;
char *hostname = NULL;
GetSSL(self, ssl);
if (!NIL_P(arg))
hostname = StringValueCStr(arg);
if (!SSL_set_tlsext_host_name(ssl, hostname))
ossl_raise(eSSLError, NULL);
/* for SSLSocket#hostname */
rb_ivar_set(self, id_i_hostname, arg);
return arg;
};T;)I"static VALUE;T;*To; ; F;
;;;;I"$OpenSSL::SSL::SSLSocket#tmp_key;F;[ ;[[@HTi ;T;: tmp_key;0;[ ;{ ;IC; "FReturns the ephemeral key used in case of forward secrecy cipher.
;T;[o;=
;3I"
overload;F;40;;`;50;)I" tmp_key;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I" PKey;TI"nil;T; @; [ ; I"@return [PKey, nil];T; 0; @;!F;6i ;>0;[ ; @; [ ; I"pReturns the ephemeral key used in case of forward secrecy cipher.
@overload tmp_key
@return [PKey, nil];T; 0; @;!F;"o;#;$T;%i ;&i ;'@{;(I"static VALUE
ossl_ssl_tmp_key(VALUE self)
{
SSL *ssl;
EVP_PKEY *key;
GetSSL(self, ssl);
if (!SSL_get_server_tmp_key(ssl, &key))
return Qnil;
return ossl_pkey_new(key);
};T;)I"static VALUE;T;*To; ; F;
;;;;I"*OpenSSL::SSL::SSLSocket#alpn_protocol;F;[ ;[[@HTin ;T;:alpn_protocol;0;[ ;{ ;IC; "cReturns the ALPN protocol string that was finally selected by the server
during the handshake.
;T;[o;=
;3I"
overload;F;40;;a;50;)I"alpn_protocol;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"String | nil;T; @3; [ ; I"@return [String | nil];T; 0; @3;!F;6i ;>0;[ ; @3; [ ; I"Returns the ALPN protocol string that was finally selected by the server
during the handshake.
@overload alpn_protocol
@return [String | nil];T; 0; @3;!F;"o;#;$T;%ig ;&il ;'@{;(I"static VALUE
ossl_ssl_alpn_protocol(VALUE self)
{
SSL *ssl;
const unsigned char *out;
unsigned int outlen;
GetSSL(self, ssl);
SSL_get0_alpn_selected(ssl, &out, &outlen);
if (!outlen)
return Qnil;
else
return rb_str_new((const char *) out, outlen);
};T;)I"static VALUE;T;*To; ; F;
;;;;I")OpenSSL::SSL::SSLSocket#npn_protocol;F;[ ;[[@HTiU ;T;:npn_protocol;0;[ ;{ ;IC; "^Returns the protocol string that was finally selected by the client
during the handshake.
;T;[o;=
;3I"
overload;F;40;;b;50;)I"npn_protocol;T;IC; " ;T;[o;2
;3I" return;F;4I" ;T;0;5[I"String | nil;T; @N; [ ; I"@return [String | nil];T; 0; @N;!F;6i ;>0;[ ; @N; [ ; I"Returns the protocol string that was finally selected by the client
during the handshake.
@overload npn_protocol
@return [String | nil];T; 0; @N;!F;"o;#;$T;%iN ;&iS ;'@{;(I" static VALUE
ossl_ssl_npn_protocol(VALUE self)
{
SSL *ssl;
const unsigned char *out;
unsigned int outlen;
GetSSL(self, ssl);
SSL_get0_next_proto_negotiated(ssl, &out, &outlen);
if (!outlen)
return Qnil;
else
return rb_str_new((const char *) out, outlen);
};T;)I"static VALUE;T;*T;A@{;BIC;[ ;A@{;CIC;[ ;A@{;DIC;E{;FIC;E{ ;GT;IC;E{ ;GT;GT;H{ ;I[ ;[[@HTi ;F;:SSLSocket;;K;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @{;6i ;'@[s;I" OpenSSL::SSL::SSLSocket;F;S@]o;;[[@HTiF ;F;:VERIFY_NONE;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @x;'@[s;I" OpenSSL::SSL::VERIFY_NONE;F;I" INT2NUM(SSL_VERIFY_NONE);To;;[[@HTiG ;F;:VERIFY_PEER;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I" OpenSSL::SSL::VERIFY_PEER;F;I" INT2NUM(SSL_VERIFY_PEER);To;;[[@HTiH ;F;: VERIFY_FAIL_IF_NO_PEER_CERT;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I".OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT;F;I"-INT2NUM(SSL_VERIFY_FAIL_IF_NO_PEER_CERT);To;;[[@HTiI ;F;:VERIFY_CLIENT_ONCE;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I"%OpenSSL::SSL::VERIFY_CLIENT_ONCE;F;I"$INT2NUM(SSL_VERIFY_CLIENT_ONCE);To;;[[@HTiK ;F;: OP_ALL;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I"OpenSSL::SSL::OP_ALL;F;I"ULONG2NUM(SSL_OP_ALL);To;;[[@HTiL ;F;: OP_LEGACY_SERVER_CONNECT;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I"+OpenSSL::SSL::OP_LEGACY_SERVER_CONNECT;F;I",ULONG2NUM(SSL_OP_LEGACY_SERVER_CONNECT);To;;[[@HTiN ;F;:OP_TLSEXT_PADDING;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I"$OpenSSL::SSL::OP_TLSEXT_PADDING;F;I"%ULONG2NUM(SSL_OP_TLSEXT_PADDING);To;;[[@HTiQ ;F;: OP_SAFARI_ECDHE_ECDSA_BUG;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I",OpenSSL::SSL::OP_SAFARI_ECDHE_ECDSA_BUG;F;I"-ULONG2NUM(SSL_OP_SAFARI_ECDHE_ECDSA_BUG);To;;[[@HTiT ;F;:OP_ALLOW_NO_DHE_KEX;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ȝ;'@[s;I"&OpenSSL::SSL::OP_ALLOW_NO_DHE_KEX;F;I"'ULONG2NUM(SSL_OP_ALLOW_NO_DHE_KEX);To;;[[@HTiV ;F;:#OP_DONT_INSERT_EMPTY_FRAGMENTS;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ҝ;'@[s;I"1OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS;F;I"2ULONG2NUM(SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);To;;[[@HTiW ;F;:OP_NO_TICKET;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @ܝ;'@[s;I" OpenSSL::SSL::OP_NO_TICKET;F;I" ULONG2NUM(SSL_OP_NO_TICKET);To;;[[@HTiX ;F;:.OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;;;;;[ ;{ ;IC; " ;T;[ ; [ ; @|; 0; @;'@[s;I"