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 `require
'continuation' before using this method. Performing a
cont.call will cause the #callcc
to return (as will falling through the end of the block). The
value returned by the #callcc is the value of the
block, or the value passed to cont.call. See
class Continuation for more details. Also see
Kernel#throw for an alternative mechanism for
unwinding a call stack.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" callcc; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" cont; T;@o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@;[ ;I"#@yield [cont]
@return [Object]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"4Generates a Continuation object, which it passes to
the associated block. You need to require
'continuation' before using this method. Performing a
cont.call will cause the #callcc
to return (as will falling through the end of the block). The
value returned by the #callcc is the value of the
block, or the value passed to cont.call. See
class Continuation for more details. Also see
Kernel#throw for an alternative mechanism for
unwinding a call stack.
@overload callcc
@yield [cont]
@return [Object]; T;0;@; F; o; ; T; i;!i;"@l;;I"static VALUE; T;AI"static VALUE
rb_callcc(VALUE self)
{
volatile int called;
volatile VALUE val = cont_capture(&called);
if (called) {
return val;
}
else {
return rb_yield(val);
}
}; T;BTo;1;2F;3;4;;;#I"Kernel#exec; F;5[[@0; [[I"process.c; Ti ;
T;: exec;0;[ ;{ ;IC;"A
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;7
;8I"
overload; F;90;;;:0;;I"'exec([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"[env,][,options]; T0;@;[ ;I"p
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
@overload exec([env,] command... [,options]); T;0;@; F; o; ; T; ii ;!i ;"@l;;I"
VALUE; T;AI"VALUE
rb_f_exec(int argc, VALUE *argv)
{
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
#define CHILD_ERRMSG_BUFLEN 80
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
execarg_obj = rb_execarg_new(argc, argv, TRUE);
eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
#if defined(__APPLE__) || defined(__HAIKU__)
rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg));
#else
rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
#endif
RB_GC_GUARD(execarg_obj);
if (errmsg[0])
rb_sys_fail(errmsg);
rb_sys_fail_str(fail_str);
return Qnil; /* dummy */
}; T;BTo;1;2F;3;4;;;#I"Kernel#fork; F;5[ ; [[@i
;
T;: fork;0;[ ;{ ;IC;"Creates a subprocess. If a block is specified, that block is run
in the subprocess, and the subprocess terminates with a status of
zero. Otherwise, the +fork+ call returns twice, once in
the parent, returning the process ID of the child, and once in
the child, returning _nil_. The child process can exit using
Kernel.exit! to avoid running any
at_exit functions. The parent process should
use Process.wait to collect the termination statuses
of its children or use Process.detach to register
disinterest in their status; otherwise, the operating system
may accumulate zombie processes.
The thread calling fork is the only thread in the created child process.
fork doesn't copy other threads.
If fork is not usable, Process.respond_to?(:fork) returns false.
Note that fork(2) is not avaiable on some platforms like Windows and NetBSD 4.
Therefore you should use spawn() instead of fork().
; T;[o;7
;8I"
overload; F;90;;;:0;;I" fork; T;IC;" ; T;[o;<
;8I"
yield; F;9I"[]; T;0;:0;@o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@;[ ;I"$@yield []
@return [Fixnum, nil]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;;:0;;I" fork; T;IC;" ; T;[o;<
;8I"
yield; F;9I"[]; T;0;:0;@o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@;[ ;I"$@yield []
@return [Fixnum, nil]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Creates a subprocess. If a block is specified, that block is run
in the subprocess, and the subprocess terminates with a status of
zero. Otherwise, the +fork+ call returns twice, once in
the parent, returning the process ID of the child, and once in
the child, returning _nil_. The child process can exit using
Kernel.exit! to avoid running any
at_exit functions. The parent process should
use Process.wait to collect the termination statuses
of its children or use Process.detach to register
disinterest in their status; otherwise, the operating system
may accumulate zombie processes.
The thread calling fork is the only thread in the created child process.
fork doesn't copy other threads.
If fork is not usable, Process.respond_to?(:fork) returns false.
Note that fork(2) is not avaiable on some platforms like Windows and NetBSD 4.
Therefore you should use spawn() instead of fork().
@overload fork
@yield []
@return [Fixnum, nil]
@overload fork
@yield []
@return [Fixnum, nil]; T;0;@; F; o; ; T; i
;!i
;"@l;;I"static VALUE; T;AI"|static VALUE
rb_f_fork(VALUE obj)
{
rb_pid_t pid;
rb_secure(2);
switch (pid = rb_fork_ruby(NULL)) {
case 0:
rb_thread_atfork();
if (rb_block_given_p()) {
int status;
rb_protect(rb_yield, Qundef, &status);
ruby_stop(status);
}
return Qnil;
case -1:
rb_sys_fail("fork(2)");
return Qnil;
default:
return PIDT2NUM(pid);
}
}; T;BTo;1;2F;3;4;;;#I"Kernel#exit!; F;5[[@0; [[@i6;
T;:
exit!;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;7
;8I"
overload; F;90;;;:0;;I"exit!(status=false); T;IC;" ; T;[ ;[ ;I" ; T;0;@>; F;=i ;>0;5[[I" status; TI"
false; T;@>;[ ;I"Exits the process immediately. No exit handlers are
run. status is returned to the underlying system as the
exit status.
Process.exit!(true)
@overload exit!(status=false); T;0;@>; F; o; ; T; i+;!i2;"@l;;I"static VALUE; T;AI"$static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
VALUE status;
int istatus;
if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) {
istatus = exit_status_code(status);
}
else {
istatus = EXIT_FAILURE;
}
_exit(istatus);
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"Kernel#system; F;5[[@0; [[@i(;
T;: system;0;[ ;{ ;IC;"uExecutes _command..._ in a subshell.
_command..._ is one of following forms.
commandline : command line string which is passed to the standard shell
cmdname, arg1, ... : command name and one or more arguments (no shell)
[cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
system returns +true+ if the command gives zero exit status,
+false+ for non zero exit status.
Returns +nil+ if command execution fails.
An error status is available in $?.
The arguments are processed in the same way as
for Kernel.spawn.
The hash arguments, env and options, are same as
exec and spawn.
See Kernel.spawn for details.
system("echo *")
system("echo", "*")
produces:
config.h main.rb
*
See Kernel.exec for the standard shell.
; T;[o;7
;8I"
overload; F;90;;;:0;;I")system([env,] command... [,options]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@X;[ ;I" @return [true, false, nil]; T;0;@X; F;=i ;>0;5[[I"[env,][,options]; T0;@X;[ ;I"Executes _command..._ in a subshell.
_command..._ is one of following forms.
commandline : command line string which is passed to the standard shell
cmdname, arg1, ... : command name and one or more arguments (no shell)
[cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
system returns +true+ if the command gives zero exit status,
+false+ for non zero exit status.
Returns +nil+ if command execution fails.
An error status is available in $?.
The arguments are processed in the same way as
for Kernel.spawn.
The hash arguments, env and options, are same as
exec and spawn.
See Kernel.spawn for details.
system("echo *")
system("echo", "*")
produces:
config.h main.rb
*
See Kernel.exec for the standard shell.
@overload system([env,] command... [,options])
@return [true, false, nil]; T;0;@X; F; o; ; T; i;!i%;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_system(int argc, VALUE *argv)
{
rb_pid_t pid;
int status;
#if defined(SIGCLD) && !defined(SIGCHLD)
# define SIGCHLD SIGCLD
#endif
#ifdef SIGCHLD
RETSIGTYPE (*chfunc)(int);
rb_last_status_clear();
chfunc = signal(SIGCHLD, SIG_DFL);
#endif
pid = rb_spawn_internal(argc, argv, NULL, 0);
#if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
if (pid > 0) {
int ret, status;
ret = rb_waitpid(pid, &status, 0);
if (ret == (rb_pid_t)-1)
rb_sys_fail("Another thread waited the process started by system().");
}
#endif
#ifdef SIGCHLD
signal(SIGCHLD, chfunc);
#endif
if (pid < 0) {
return Qnil;
}
status = PST2INT(rb_last_status_get());
if (status == EXIT_SUCCESS) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Kernel#spawn; F;5[[@0; [[@iU;
T;:
spawn;0;[ ;{ ;IC;"Y)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
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 to 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 => true : don't 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 or positive integer.
true and zero means the process should be a process leader of a new
process group.
Other values specifies a process group to be belongs.
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, a fixnum, 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, 3=>"/dev/null") # read mode
For stdout and stderr,
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 true 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;7
;8I"
overload; F;90;;;:0;;I"(spawn([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@x; F;=i ;>0;5[[I"[env,][,options]; T0;@xo;7
;8I"
overload; F;90;;;:0;;I"(spawn([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@x; F;=i ;>0;5[[I"[env,][,options]; T0;@x;[ ;I")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
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 to 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 => true : don't 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 or positive integer.
true and zero means the process should be a process leader of a new
process group.
Other values specifies a process group to be belongs.
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, a fixnum, 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, 3=>"/dev/null") # read mode
For stdout and stderr,
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 true 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.
@overload spawn([env,] command... [,options])
@overload spawn([env,] command... [,options]); T;0;@x; F; o; ; T; iL;!iQ;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_spawn(int argc, VALUE *argv)
{
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);
eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg));
RB_GC_GUARD(execarg_obj);
if (pid == -1) {
const char *prog = errmsg;
if (!prog[0]) {
rb_sys_fail_str(fail_str);
}
rb_sys_fail(prog);
}
#if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;4;;;#I"Kernel#sleep; F;5[[@0; [[@i;
T;:
sleep;0;[ ;{ ;IC;"Suspends the current thread for _duration_ seconds (which may be any number,
including a +Float+ with fractional seconds). Returns the actual number of
seconds slept (rounded), which may be less than that asked for if another
thread calls Thread#run. Called without an argument, sleep()
will sleep forever.
Time.new #=> 2008-03-08 19:56:19 +0900
sleep 1.2 #=> 1
Time.new #=> 2008-03-08 19:56:20 +0900
sleep 1.9 #=> 2
Time.new #=> 2008-03-08 19:56:22 +0900
; T;[o;7
;8I"
overload; F;90;;;:0;;I"sleep([duration]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[[I"[duration]; T0;@;[ ;I""Suspends the current thread for _duration_ seconds (which may be any number,
including a +Float+ with fractional seconds). Returns the actual number of
seconds slept (rounded), which may be less than that asked for if another
thread calls Thread#run. Called without an argument, sleep()
will sleep forever.
Time.new #=> 2008-03-08 19:56:19 +0900
sleep 1.2 #=> 1
Time.new #=> 2008-03-08 19:56:20 +0900
sleep 1.9 #=> 2
Time.new #=> 2008-03-08 19:56:22 +0900
@overload sleep([duration])
@return [Fixnum]; T;0;@; F; o; ; T; is;!i;"@l;;I"static VALUE; T;AI"$static VALUE
rb_f_sleep(int argc, VALUE *argv)
{
time_t beg, end;
beg = time(0);
if (argc == 0) {
rb_thread_sleep_forever();
}
else {
rb_check_arity(argc, 0, 1);
rb_thread_wait_for(rb_time_interval(argv[0]));
}
end = time(0) - beg;
return INT2FIX(end);
}; T;BTo;1;2F;3;4;;;#I"Kernel#exit; F;5[[@0; [[@i;
T;: exit;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;7
;8I"
overload; F;90;;;:0;;I"exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" status; TI" true; T;@o;7
;8I"
overload; F;90;:Kernel::exit;:0;;I" Kernel::exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" status; TI" true; T;@o;7
;8I"
overload; F;90;:Process::exit;:0;;I" Process::exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" status; TI" true; T;@;[ ;I"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
@overload exit(status=true)
@overload Kernel::exit(status=true)
@overload Process::exit(status=true); T;0;@; F; o; ; T; iV;!i{;"@l;;I"
VALUE; T;AI"VALUE
rb_f_exit(int argc, VALUE *argv)
{
VALUE status;
int istatus;
if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) {
istatus = exit_status_code(status);
}
else {
istatus = EXIT_SUCCESS;
}
rb_exit(istatus);
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"Kernel#abort; F;5[[@0; [[@i;
T;:
abort;0;[ ;{ ;IC;"Terminate execution immediately, effectively by calling
Kernel.exit(false). If _msg_ is given, it is written
to STDERR prior to terminating.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
abort; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;:Kernel::abort;:0;;I"Kernel::abort([msg]); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"
[msg]; T0;@o;7
;8I"
overload; F;90;:Process::abort;:0;;I"Process::abort([msg]); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"
[msg]; T0;@;[ ;I"Terminate execution immediately, effectively by calling
Kernel.exit(false). If _msg_ is given, it is written
to STDERR prior to terminating.
@overload abort
@overload Kernel::abort([msg])
@overload Process::abort([msg]); T;0;@; F; o; ; T; i;!i;"@l;;I"
VALUE; T;AI"VALUE
rb_f_abort(int argc, VALUE *argv)
{
if (argc == 0) {
if (!NIL_P(GET_THREAD()->errinfo)) {
ruby_error_print();
}
rb_exit(EXIT_FAILURE);
}
else {
VALUE args[2];
rb_scan_args(argc, argv, "1", &args[1]);
StringValue(argv[0]);
rb_io_puts(argc, argv, rb_stderr);
args[0] = INT2NUM(EXIT_FAILURE);
rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
}
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"Kernel#warn; F;5[[@0; [[I" error.c; Ti;
T;: warn;0;[ ;{ ;IC;"Displays each of the given messages followed by a record separator on
STDERR unless warnings have been disabled (for example with the
-W0 flag).
warn("warning 1", "warning 2")
produces:
warning 1
warning 2
; T;[o;7
;8I"
overload; F;90;;;:0;;I"warn(msg, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@ ;[ ;I"@return [nil]; T;0;@ ; F;=i ;>0;5[[I"msg; T0[I"...; T0;@ ;[ ;I"Displays each of the given messages followed by a record separator on
STDERR unless warnings have been disabled (for example with the
-W0 flag).
warn("warning 1", "warning 2")
produces:
warning 1
warning 2
@overload warn(msg, ...)
@return [nil]; T;0;@ ; F; o; ; T; i;!i;"@l;;I"static VALUE; T;AI"static VALUE
rb_warn_m(int argc, VALUE *argv, VALUE exc)
{
if (!NIL_P(ruby_verbose) && argc > 0) {
rb_io_puts(argc, argv, rb_stderr);
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Kernel#raise; F;5[[@0; [[@7if;
T;:
raise;0;[ ;{ ;IC;"With no arguments, raises the exception in $! or raises
a RuntimeError if $! is +nil+.
With a single +String+ argument, raises a
+RuntimeError+ with the string as a message. Otherwise,
the first parameter should be the name of an +Exception+
class (or an object that returns an +Exception+ object when sent
an +exception+ message). The optional second parameter sets the
message associated with the exception, and the third parameter is an
array of callback information. Exceptions are caught by the
+rescue+ clause of begin...end blocks.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"
raise; T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[ ;@5 o;7
;8I"
overload; F;90;;;:0;;I"raise(string); T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[[I" string; T0;@5 o;7
;8I"
overload; F;90;;;:0;;I"*raise(exception [, string [, array]]); T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[[I""exception[, string [, array]]; T0;@5 o;7
;8I"
overload; F;90;: fail;:0;;I" fail; T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[ ;@5 o;7
;8I"
overload; F;90;; ;:0;;I"fail(string); T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[[I" string; T0;@5 o;7
;8I"
overload; F;90;; ;:0;;I")fail(exception [, string [, array]]); T;IC;" ; T;[ ;[ ;I" ; T;0;@5 ; F;=i ;>0;5[[I""exception[, string [, array]]; T0;@5 ;[ ;I"QWith no arguments, raises the exception in $! or raises
a RuntimeError if $! is +nil+.
With a single +String+ argument, raises a
+RuntimeError+ with the string as a message. Otherwise,
the first parameter should be the name of an +Exception+
class (or an object that returns an +Exception+ object when sent
an +exception+ message). The optional second parameter sets the
message associated with the exception, and the third parameter is an
array of callback information. Exceptions are caught by the
+rescue+ clause of begin...end blocks.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
@overload raise
@overload raise(string)
@overload raise(exception [, string [, array]])
@overload fail
@overload fail(string)
@overload fail(exception [, string [, array]]); T;0;@5 ; F; o; ; T; iN;!ib;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_raise(int argc, VALUE *argv)
{
VALUE err;
if (argc == 0) {
err = get_errinfo();
if (!NIL_P(err)) {
argc = 1;
argv = &err;
}
}
rb_raise_jump(rb_make_exception(argc, argv));
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"Kernel#fail; F;5[[@0; [[@7if;
T;; ;0;[ ;{ ;IC;"With no arguments, raises the exception in $! or raises
a RuntimeError if $! is +nil+.
With a single +String+ argument, raises a
+RuntimeError+ with the string as a message. Otherwise,
the first parameter should be the name of an +Exception+
class (or an object that returns an +Exception+ object when sent
an +exception+ message). The optional second parameter sets the
message associated with the exception, and the third parameter is an
array of callback information. Exceptions are caught by the
+rescue+ clause of begin...end blocks.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"
raise; T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[ ;@| o;7
;8I"
overload; F;90;;;:0;;I"raise(string); T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[[I" string; T0;@| o;7
;8I"
overload; F;90;;;:0;;I"*raise(exception [, string [, array]]); T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[[I""exception[, string [, array]]; T0;@| o;7
;8I"
overload; F;90;; ;:0;;I" fail; T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[ ;@| o;7
;8I"
overload; F;90;; ;:0;;I"fail(string); T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[[I" string; T0;@| o;7
;8I"
overload; F;90;; ;:0;;I")fail(exception [, string [, array]]); T;IC;" ; T;[ ;[ ;I" ; T;0;@| ; F;=i ;>0;5[[I""exception[, string [, array]]; T0;@| ;[ ;@x ;0;@| ; F; o; ; T; iN;!ib;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_raise(int argc, VALUE *argv)
{
VALUE err;
if (argc == 0) {
err = get_errinfo();
if (!NIL_P(err)) {
argc = 1;
argv = &err;
}
}
rb_raise_jump(rb_make_exception(argc, argv));
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I" Kernel#global_variables; F;5[ ; [[@iT;
T;:global_variables;0;[ ;{ ;IC;"{Returns an array of the names of global variables.
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"global_variables; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@ ;[ ;I"@return [Array]; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;I"Returns an array of the names of global variables.
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
@overload global_variables
@return [Array]; T;0;@ ; F; o; ; T; iK;!iQ;"@l;;I"
VALUE; T;AI""VALUE
rb_f_global_variables(void)
{
VALUE ary = rb_ary_new();
char buf[2];
int i;
st_foreach_safe(rb_global_tbl, gvar_i, ary);
buf[0] = '$';
for (i = 1; i <= 9; ++i) {
buf[1] = (char)(i + '0');
rb_ary_push(ary, ID2SYM(rb_intern2(buf, 2)));
}
return ary;
}; T;BTo;1;2F;3;4;;;#I"Kernel#__method__; F;5[ ; [[@7i;
T;:__method__;0;[ ;{ ;IC;"Returns the name at the definition of the current method as a
Symbol.
If called outside of a method, it returns nil.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"__method__; T;IC;" ; T;[ ;[ ;I" ; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;I"Returns the name at the definition of the current method as a
Symbol.
If called outside of a method, it returns nil.
@overload __method__; T;0;@ ; F; o; ; T; i;!i;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_method_name(void)
{
ID fname = prev_frame_func(); /* need *method* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
}; T;BTo;1;2F;3;4;;;#I"Kernel#__callee__; F;5[ ; [[@7i1;
T;:__callee__;0;[ ;{ ;IC;"{Returns the called name of the current method as a Symbol.
If called outside of a method, it returns nil.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"__callee__; T;IC;" ; T;[ ;[ ;I" ; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;I"Returns the called name of the current method as a Symbol.
If called outside of a method, it returns nil.
@overload __callee__; T;0;@ ; F; o; ; T; i(;!i-;"@l;;I"static VALUE; T;AI"static VALUE
rb_f_callee_name(void)
{
ID fname = prev_frame_callee(); /* need *callee* ID */
if (fname) {
return ID2SYM(fname);
}
else {
return Qnil;
}
}; T;BTo;1;2F;3;4;;;#I"Kernel#__dir__; F;5[ ; [[@7iH;
T;: __dir__;0;[ ;{ ;IC;"+Returns the canonicalized absolute path of the directory of the file from
which this method is called. It means symlinks in the path is resolved.
If __FILE__ is nil, it returns nil.
The return value equals to File.dirname(File.realpath(__FILE__)).
; T;[o;7
;8I"
overload; F;90;;;:0;;I" __dir__; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ ;[ ;I"@return [String]; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;I"SReturns the canonicalized absolute path of the directory of the file from
which this method is called. It means symlinks in the path is resolved.
If __FILE__ is nil, it returns nil.
The return value equals to File.dirname(File.realpath(__FILE__)).
@overload __dir__
@return [String]; T;0;@ ; F; o; ; T; i>;!iF;"@l;;I"static VALUE; T;AI"static VALUE
f_current_dirname(void)
{
VALUE base = rb_current_realfilepath();
if (NIL_P(base)) {
return Qnil;
}
base = rb_file_dirname(base);
return base;
}; T;BTo;1;2F;3;4;;;#I"Kernel#trace_var; F;5[[@0; [[@i;
T;:trace_var;0;[ ;{ ;IC;"Controls tracing of assignments to global variables. The parameter
+symbol_ identifies the variable (as either a string name or a
symbol identifier). _cmd_ (which may be a string or a
+Proc+ object) or block is executed whenever the variable
is assigned. The block or +Proc+ object receives the
variable's new value as a parameter. Also see
Kernel::untrace_var.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
produces:
$_ is now 'hello'
$_ is now ' there'
; T;[o;7
;8I"
overload; F;90;;;:0;;I" trace_var(symbol, cmd ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@$ ;[ ;I"@return [nil]; T;0;@$ ; F;=i ;>0;5[[I" symbol; T0[I"cmd; T0;@$ o;7
;8I"
overload; F;90;;;:0;;I"trace_var(symbol); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"val; T;@$ o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@$ ;[ ;I" @yield [val]
@return [nil]; T;0;@$ ; F;=i ;>0;5[[I" symbol; T0;@$ ;[ ;I"}Controls tracing of assignments to global variables. The parameter
+symbol_ identifies the variable (as either a string name or a
symbol identifier). _cmd_ (which may be a string or a
+Proc+ object) or block is executed whenever the variable
is assigned. The block or +Proc+ object receives the
variable's new value as a parameter. Also see
Kernel::untrace_var.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
produces:
$_ is now 'hello'
$_ is now ' there'
@overload trace_var(symbol, cmd )
@return [nil]
@overload trace_var(symbol)
@yield [val]
@return [nil]; T;0;@$ ; F; o; ; T; ix;!i;"@l;;I"
VALUE; T;AI"wVALUE
rb_f_trace_var(int argc, VALUE *argv)
{
VALUE var, cmd;
struct global_entry *entry;
struct trace_var *trace;
if (rb_scan_args(argc, argv, "11", &var, &cmd) == 1) {
cmd = rb_block_proc();
}
if (NIL_P(cmd)) {
return rb_f_untrace_var(argc, argv);
}
entry = rb_global_entry(rb_to_id(var));
if (OBJ_TAINTED(cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted variable trace");
}
trace = ALLOC(struct trace_var);
trace->next = entry->var->trace;
trace->func = rb_trace_eval;
trace->data = cmd;
trace->removed = 0;
entry->var->trace = trace;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Kernel#untrace_var; F;5[[@0; [[@i;
T;:untrace_var;0;[ ;{ ;IC;"Removes tracing for the specified command on the given global
variable and returns +nil+. If no command is specified,
removes all tracing for that variable and returns an array
containing the commands actually removed.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"!untrace_var(symbol [, cmd] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; TI"nil; T;@X ;[ ;I"@return [Array, nil]; T;0;@X ; F;=i ;>0;5[[I"symbol[, cmd]; T0;@X ;[ ;I"Removes tracing for the specified command on the given global
variable and returns +nil+. If no command is specified,
removes all tracing for that variable and returns an array
containing the commands actually removed.
@overload untrace_var(symbol [, cmd] )
@return [Array, nil]; T;0;@X ; F; o; ; T; i;!i;"@l;;I"
VALUE; T;AI"VALUE
rb_f_untrace_var(int argc, VALUE *argv)
{
VALUE var, cmd;
ID id;
struct global_entry *entry;
struct trace_var *trace;
st_data_t data;
rb_scan_args(argc, argv, "11", &var, &cmd);
id = rb_check_id(&var);
if (!id) {
rb_name_error_str(var, "undefined global variable %"PRIsVALUE"", QUOTE(var));
}
if (!st_lookup(rb_global_tbl, (st_data_t)id, &data)) {
rb_name_error(id, "undefined global variable %"PRIsVALUE"", QUOTE_ID(id));
}
trace = (entry = (struct global_entry *)data)->var->trace;
if (NIL_P(cmd)) {
VALUE ary = rb_ary_new();
while (trace) {
struct trace_var *next = trace->next;
rb_ary_push(ary, (VALUE)trace->data);
trace->removed = 1;
trace = next;
}
if (!entry->var->block_trace) remove_trace(entry->var);
return ary;
}
else {
while (trace) {
if (trace->data == cmd) {
trace->removed = 1;
if (!entry->var->block_trace) remove_trace(entry->var);
return rb_ary_new3(1, cmd);
}
trace = trace->next;
}
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Kernel#Pathname; F;5[[I"str; T0; [[I" ext/pathname/pathname.c; Ti;
T;:
Pathname;0;[ ;{ ;IC;"Y:call-seq:
Pathname(path) -> pathname
Creates a new Pathname object from the given string, +path+, and returns
pathname object.
In order to use this constructor, you must first require the Pathname
standard library extension.
require 'pathname'
Pathname("/home/zzak")
#=> #: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; i ;!i ;=i ;"@;#I" Object; F;vo; ;IC;[o;1;2F;3;4;: private;#I"BasicObject#initialize; F;5[ ; [[@R
i;
T;:initialize;0;[ ;{ ;IC;"Not documented
; T;[ ;[ ;I"Not documented
; T;0;@ ; F; o; ; T; i;!i;"@ ;;I"static VALUE; T;AI"9static VALUE
rb_obj_dummy(void)
{
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"BasicObject#==; F;5[[I" obj2; T0; [[@R
i;
T;;O;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 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;7
;8I"
overload; F;90;;O;:0;;I"==(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ o;7
;8I"
overload; F;90;;;:0;;I"equal?(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ o;7
;8I"
overload; F;90;;V;:0;;I"eql?(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ ;[ ;@;0;@ ; F; o; ; T; in;!i;"@ ;;I"
VALUE; T;AI"jVALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"BasicObject#equal?; F;5[[I" obj2; T0; [[@R
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 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;7
;8I"
overload; F;90;;O;:0;;I"==(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ o;7
;8I"
overload; F;90;;;:0;;I"equal?(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ o;7
;8I"
overload; F;90;;V;:0;;I"eql?(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ ;[ ;I"@return [Boolean]; T;0;@ ; F;=i ;>0;5[[I"
other; T0;@ o;<
;8I" return; F;9@f;0;:[@h;@ ;[ ;@;0;@ ; F; o; ; T; in;!i;"@ ;;I"
VALUE; T;AI"jVALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"BasicObject#!; F;5[ ; [[@R
i;
T;:!;0;[ ;{ ;IC;"Boolean negate.
; T;[o;7
;8I"
overload; F;90;; ;:0;;I" !obj; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@W ;[ ;I"@return [Boolean]; T;0;@W ; F;=i ;>0;5[ ;@W ;[ ;I"9Boolean negate.
@overload !obj
@return [Boolean]; T;0;@W ; F; o; ; T; i;!i;"@ ;;I"
VALUE; T;AI"LVALUE
rb_obj_not(VALUE obj)
{
return RTEST(obj) ? Qfalse : Qtrue;
}; T;BTo;1;2F;3;4;;;#I"BasicObject#!=; F;5[[I" obj2; T0; [[@R
i;
T;:!=;0;[ ;{ ;IC;"@Returns true if two objects are not-equal, otherwise false.
; T;[o;7
;8I"
overload; F;90;;
;:0;;I"!=(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@r ;[ ;I"@return [Boolean]; T;0;@r ; F;=i ;>0;5[[I"
other; T0;@r ;[ ;I"jReturns true if two objects are not-equal, otherwise false.
@overload !=(other)
@return [Boolean]; T;0;@r ; F; o; ; T; i;!i;"@ ;;I"
VALUE; T;AI"VALUE
rb_obj_not_equal(VALUE obj1, VALUE obj2)
{
VALUE result = rb_funcall(obj1, id_eq, 1, obj2);
return RTEST(result) ? Qfalse : Qtrue;
}; T;BTo;1;2F;3;4;;
;#I"'BasicObject#singleton_method_added; F;5[ ; [[@R
i;
T;;w;0;[ ;{ ;IC;"Not documented
; T;[ ;[ ;@ ;0;@ ; F; o; ; T; i;!i;"@ ;;I"static VALUE; T;AI"9static VALUE
rb_obj_dummy(void)
{
return Qnil;
}; T;BTo;1;2F;3;4;;
;#I")BasicObject#singleton_method_removed; F;5[ ; [[@R
i;
T;: singleton_method_removed;0;[ ;{ ;IC;"Not documented
; T;[ ;[ ;@ ;0;@ ; F; o; ; T; i;!i;"@ ;;I"static VALUE; T;AI"9static VALUE
rb_obj_dummy(void)
{
return Qnil;
}; T;BTo;1;2F;3;4;;
;#I"+BasicObject#singleton_method_undefined; F;5[ ; [[@R
i;
T;: singleton_method_undefined;0;[ ;{ ;IC;"Not documented
; T;[ ;[ ;@ ;0;@ ; F; o; ; T; i;!i;"@ ;;I"static VALUE; T;AI"9static VALUE
rb_obj_dummy(void)
{
return Qnil;
}; T;BTo;1;2F;3;4;;;#I" BasicObject#instance_eval; F;5[[@0; [[@iL;
T;:instance_eval;0;[ ;{ ;IC;"aEvaluates 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. In the version of instance_eval
that takes 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
end
k = KlassWithSecret.new
k.instance_eval { @secret } #=> 99
; T;[o;7
;8I"
overload; F;90;;;:0;;I"3instance_eval(string [, filename [, lineno]] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@ ;[ ;I"@return [Object]; T;0;@ ; F;=i ;>0;5[[I""string[, filename [, lineno]]; T0;@ o;7
;8I"
overload; F;90;;;:0;;I"instance_eval; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" ; T;@ o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@ ;[ ;I" @yield [ ]
@return [Object]; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;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. In the version of instance_eval
that takes 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
end
k = KlassWithSecret.new
k.instance_eval { @secret } #=> 99
@overload instance_eval(string [, filename [, lineno]] )
@return [Object]
@overload instance_eval
@yield [ ]
@return [Object]; T;0;@ ; F; o; ; T; i5;!iK;"@ ;;I"
VALUE; T;AI" VALUE
rb_obj_instance_eval(int argc, VALUE *argv, VALUE self)
{
VALUE klass;
if (SPECIAL_CONST_P(self)) {
klass = rb_special_singleton_class(self);
}
else {
klass = rb_singleton_class(self);
}
return specific_eval(argc, argv, klass, self);
}; T;BTo;1;2F;3;4;;;#I" BasicObject#instance_exec; F;5[[@0; [[@il;
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;7
;8I"
overload; F;90;;;:0;;I"instance_exec(arg...); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" var...; T;@ o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@ ;[ ;I"%@yield [var...]
@return [Object]; T;0;@ ; F;=i ;>0;5[[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; iZ;!ij;"@ ;;I"
VALUE; T;AI"VALUE
rb_obj_instance_exec(int argc, VALUE *argv, VALUE self)
{
VALUE klass;
if (SPECIAL_CONST_P(self)) {
klass = rb_special_singleton_class(self);
}
else {
klass = rb_singleton_class(self);
}
return yield_under(klass, self, rb_ary_new4(argc, argv));
}; T;BTo;1;2F;3;4;;
;#I" BasicObject#method_missing; F;5[[@0; [[@iw;
T;:method_missing;0;[ ;{ ;IC;"zInvoked 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(methId)
str = methId.id2name
roman_to_int(str)
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
; T;[o;7
;8I"
overload; F;90;;;:0;;I"&method_missing(symbol [, *args] ); T;IC;" ; T;[ ;[ ;I" ; T;0;@ ; F;=i ;>0;5[[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(methId)
str = methId.id2name
roman_to_int(str)
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
@overload method_missing(symbol [, *args] ); T;0;@ ; F; o; ; T; iV;!is;"@ ;;I"static VALUE; T;AI"static VALUE
rb_method_missing(int argc, const VALUE *argv, VALUE obj)
{
rb_thread_t *th = GET_THREAD();
raise_method_missing(th, argc, argv, obj, th->method_missing_reason);
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"BasicObject#__send__; F;5[[@0; [[@i;
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.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
; T;[ o;7
;8I"
overload; F;90;;;:0;;I" send(symbol [, args...]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@$ ;[ ;I"@return [Object]; T;0;@$ ; F;=i ;>0;5[[I"symbol[, args...]; T0;@$ o;7
;8I"
overload; F;90;;;:0;;I"!__send__(symbol [, args...]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@$ ;[ ;I"@return [Object]; T;0;@$ ; F;=i ;>0;5[[I"symbol[, args...]; T0;@$ o;7
;8I"
overload; F;90;;;:0;;I" send(string [, args...]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@$ ;[ ;I"@return [Object]; T;0;@$ ; F;=i ;>0;5[[I"string[, args...]; T0;@$ o;7
;8I"
overload; F;90;;;:0;;I"!__send__(string [, args...]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@$ ;[ ;I"@return [Object]; T;0;@$ ; F;=i ;>0;5[[I"string[, args...]; T0;@$ ;[ ;@;0;@$ ; F; o; ; T; i{;!i;"@ ;;I"
VALUE; T;AI"sVALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal(argc, argv, recv, CALL_FCALL);
}; T;BTo;1;2F;3;4;;;#I"BasicObject#__id__; F;5[ ; [[@SiG ;
T;: __id__;0;[ ;{ ;IC;"Generates a Fixnum hash value for this object.
This function must have the property that a.eql?(b) implies
a.hash == b.hash.
The hash value is used by Hash class.
Any hash value that exceeds the capacity of a Fixnum will be truncated
before being used.
; T;[o;7
;8I"
overload; F;90;;W;:0;;I" hash; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@n ;[ ;I"@return [Fixnum]; T;0;@n ; F;=i ;>0;5[ ;@n ;[ ;@f;0;@n ; F; o; ; T; i8 ;!iD ;"@ ;;I"
VALUE; T;AI"DVALUE
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
*/
if (SYMBOL_P(obj)) {
return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
}
else if (FLONUM_P(obj)) {
#if SIZEOF_LONG == SIZEOF_VOIDP
return LONG2NUM((SIGNED_VALUE)obj);
#else
return LL2NUM((SIGNED_VALUE)obj);
#endif
}
else if (SPECIAL_CONST_P(obj)) {
return LONG2NUM((SIGNED_VALUE)obj);
}
return nonspecial_obj_id(obj);
}; T;BT;l@ ;mIC;[ ;l@ ;nIC;[ ;l@ ;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@R
ip [@R
i [@i;
T;:BasicObject;;@;;;[ ;{ ;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)
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)
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; ip ;!i ;=i ;"@;#I"BasicObject; F;vo; ;0;0;0;: Qnil;"@;0;;q;;qo; ;IC;[:o;1;2F;3;4;;;#I"Integer#integer?; F;5[ ; [[@
io ;
T;;~;0;[ ;{ ;IC;"CSince +int+ is already an Integer, this always returns +true+.
; T;[o;7
;8I"
overload; F;90;;~;:0;;I"
integer?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; T;@ ;[ ;I"@return [true]; T;0;@ ; F;=i ;>0;5[ ;@ o;<
;8I" return; F;9@f;0;:[@h;@ ;[ ;I"iSince +int+ is already an Integer, this always returns +true+.
@overload integer?
@return [true]; T;0;@ ; F; o; ; T; ih ;!il ;"@ ;;I"static VALUE; T;AI"int - 1.
If no block is given, an Enumerator is returned instead.
5.times do |i|
print i, " "
end
#=> 0 1 2 3 4
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
times; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"i; T;@T o;<
;8I" return; F;9I" ; T;0;:[I" self; T;@T ;[ ;I" @yield [i]
@return [self]; T;0;@T ; F;=i ;>0;5[ ;@T o;7
;8I"
overload; F;90;;;:0;;I"
times; T;IC;" ; T;[ ;[ ;I" ; T;0;@T ; F;=i ;>0;5[ ;@T ;[ ;I"Iterates the given block +int+ times, passing in values from zero to
int - 1.
If no block is given, an Enumerator is returned instead.
5.times do |i|
print i, " "
end
#=> 0 1 2 3 4
@overload times
@yield [i]
@return [self]
@overload times; T;0;@T ; F; o; ; T; ix;!i;"@ ;;I"static VALUE; T;AI"static VALUE
int_dotimes(VALUE num)
{
RETURN_SIZED_ENUMERATOR(num, 0, 0, int_dotimes_size);
if (FIXNUM_P(num)) {
long i, end;
end = FIX2LONG(num);
for (i=0; ifix[0] is the least significant bit.
For example:
a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010
; T;[o;7
;8I"
overload; F;90;;D;:0;;I"
[](n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; TI"1; T;@&;[ ;I"@return [ 0, 1]; T;0;@&; F;=i ;>0;5[[I"n; T0;@&;[ ;I" Bit Reference---Returns the +n+th bit in the binary representation of
+fix+, where fix[0] is the least significant bit.
For example:
a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010
@overload [](n)
@return [ 0, 1]; T;0;@&; F; o; ; T; i
;!i
;"@#;;I"static VALUE; T;AI"static VALUE
fix_aref(VALUE fix, VALUE idx)
{
long val = FIX2LONG(fix);
long i;
idx = rb_to_int(idx);
if (!FIXNUM_P(idx)) {
idx = rb_big_norm(idx);
if (!FIXNUM_P(idx)) {
if (!RBIGNUM_SIGN(idx) || val >= 0)
return INT2FIX(0);
return INT2FIX(1);
}
}
i = FIX2LONG(idx);
if (i < 0) return INT2FIX(0);
if (SIZEOF_LONG*CHAR_BIT-1 <= i) {
if (val < 0) return INT2FIX(1);
return INT2FIX(0);
}
if (val & (1L<allocate to create a new object of
class's class, then invokes that object's
initialize method, passing it args.
This is the method that ends up getting called whenever
an object is constructed using .new.
; T;[o;7
;8I"
overload; F;90;:new;:0;;I"new(args, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@0(;[ ;I"@return [Object]; T;0;@0(; F;=i ;>0;5[[I" args; T0[I"...; T0;@0(;[ ;I"*Calls allocate to create a new object of
class's class, then invokes that object's
initialize method, passing it args.
This is the method that ends up getting called whenever
an object is constructed using .new.
@overload new(args, ...)
@return [Object]; T;0;@0(; F; o; ; T; i4;!i=;"@.(;;I"
VALUE; T;AI"VALUE
rb_class_new_instance(int argc, VALUE *argv, VALUE klass)
{
VALUE obj;
obj = rb_obj_alloc(klass);
rb_obj_call_init(obj, argc, argv);
return obj;
}; T;BTo;1;2F;3;4;;;#I"Exception#exception; F;5[[@0; [[@ ip;
T;;L;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;@P(; F; o; ; T; ic;!il;"@.(;;I"static VALUE; T;AI"static VALUE
exc_exception(int argc, VALUE *argv, VALUE self)
{
VALUE exc;
if (argc == 0) return self;
if (argc == 1 && self == argv[0]) return self;
exc = rb_obj_clone(self);
exc_initialize(argc, argv, exc);
return exc;
}; T;BTo;1;2F;3;4;;;#I"Exception#initialize; F;5[[@0; [[@ iW;
T;; ;0;[ ;{ ;IC;"HConstruct a new Exception object, optionally passing in
a message.
; T;[o;7
;8I"
overload; F;90;;M;:0;;I"new(msg = nil); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"Exception; T;@_(;[ ;I"@return [Exception]; T;0;@_(; F;=i ;>0;5[[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; iO;!iT;"@.(;;I"static VALUE; T;AI"static VALUE
exc_initialize(int argc, VALUE *argv, VALUE exc)
{
VALUE arg;
rb_scan_args(argc, argv, "01", &arg);
rb_iv_set(exc, "mesg", arg);
rb_iv_set(exc, "bt", Qnil);
return exc;
}; T;BTo;1;2F;3;4;;;#I"Exception#==; F;5[[I"obj; T0; [[@ iE;
T;;O;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;7
;8I"
overload; F;90;;O;:0;;I" ==(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@~(;[ ;I"@return [Boolean]; T;0;@~(; F;=i ;>0;5[[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<;!iB;"@.(;;I"static VALUE; T;AI"static VALUE
exc_equal(VALUE exc, VALUE obj)
{
VALUE mesg, backtrace;
ID id_mesg;
if (exc == obj) return Qtrue;
CONST_ID(id_mesg, "mesg");
if (rb_obj_class(exc) != rb_obj_class(obj)) {
int status = 0;
ID id_message, id_backtrace;
CONST_ID(id_message, "message");
CONST_ID(id_backtrace, "backtrace");
obj = rb_protect(try_convert_to_exception, obj, &status);
if (status || 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;BTo;1;2F;3;4;;;#I"Exception#to_s; F;5[ ; [[@ i;
T;;6;0;[ ;{ ;IC;"UReturns exception's message (or the name of the exception if
no message is set).
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@(;[ ;I"@return [String]; T;0;@(; F;=i ;>0;5[ ;@(;[ ;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; T;AI"static VALUE
exc_to_s(VALUE exc)
{
VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc));
return rb_String(mesg);
}; T;BTo;1;2F;3;4;;;#I"Exception#message; F;5[ ; [[@ i;
T;: message;0;[ ;{ ;IC;"Returns the result of invoking exception.to_s.
Normally this returns the exception's message or name. By
supplying a to_str method, exceptions are agreeing to
be used where Strings are expected.
; T;[o;7
;8I"
overload; F;90;;N;:0;;I" message; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@(;[ ;I"@return [String]; T;0;@(; F;=i ;>0;5[ ;@(;[ ;I"Returns the result of invoking exception.to_s.
Normally this returns the exception's message or name. By
supplying a to_str method, exceptions are agreeing to
be used where Strings are expected.
@overload message
@return [String]; T;0;@(; F; o; ; T; i;!i;"@.(;;I"static VALUE; T;AI"astatic VALUE
exc_message(VALUE exc)
{
return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}; T;BTo;1;2F;3;4;;;#I"Exception#inspect; F;5[ ; [[@ i;
T;;?;0;[ ;{ ;IC;"3Return this exception's class name and message
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@(;[ ;I"@return [String]; T;0;@(; F;=i ;>0;5[ ;@(;[ ;I"ZReturn this exception's class name and message
@overload inspect
@return [String]; T;0;@(; F; o; ; T; i;!i;"@.(;;I"static VALUE; T;AI"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_str_dup(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;BTo;1;2F;3;4;;;#I"Exception#backtrace; F;5[ ; [[@ 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
; T;[o;7
;8I"
overload; F;90;;O;:0;;I"backtrace; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@(;[ ;I"@return [Array]; T;0;@(; F;=i ;>0;5[ ;@(;[ ;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
@overload backtrace
@return [Array]; T;0;@(; F; o; ; T; i;!i;"@.(;;I"static VALUE; T;AI"static VALUE
exc_backtrace(VALUE exc)
{
ID bt;
VALUE obj;
CONST_ID(bt, "bt");
obj = rb_attr_get(exc, bt);
if (rb_backtrace_p(obj)) {
obj = rb_backtrace_to_str_ary(obj);
/* rb_iv_set(exc, "bt", obj); */
}
return obj;
}; T;BTo;1;2F;3;4;;;#I""Exception#backtrace_locations; F;5[ ; [[@ 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.
Now, this method is not affected by Exception#set_backtrace().
; T;[o;7
;8I"
overload; F;90;;P;:0;;I"backtrace_locations; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@ );[ ;I"@return [Array]; T;0;@ ); F;=i ;>0;5[ ;@ );[ ;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.
Now, this method is not affected by Exception#set_backtrace().
@overload backtrace_locations
@return [Array]; T;0;@ ); F; o; ; T; i;!i;"@.(;;I"static VALUE; T;AI"static VALUE
exc_backtrace_locations(VALUE exc)
{
ID bt_locations;
VALUE obj;
CONST_ID(bt_locations, "bt_locations");
obj = rb_attr_get(exc, bt_locations);
if (!NIL_P(obj)) {
obj = rb_backtrace_to_location_ary(obj);
}
return obj;
}; T;BTo;1;2F;3;4;;;#I" Exception#set_backtrace; F;5[[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;7
;8I"
overload; F;90;;Q;:0;;I" set_backtrace(backtrace); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@$);[ ;I"@return [Array]; T;0;@$); F;=i ;>0;5[[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"static VALUE; T;AI"ustatic VALUE
exc_set_backtrace(VALUE exc, VALUE bt)
{
return rb_iv_set(exc, "bt", rb_check_backtrace(bt));
}; T;BTo;1;2F;3;4;;;#I"Exception#cause; F;5[ ; [[@ i,;
T;:
cause;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@C);"@.(;;I"
VALUE; T;AI"|VALUE
exc_cause(VALUE exc)
{
ID id_cause;
CONST_ID(id_cause, "cause");
return rb_attr_get(exc, id_cause);
}; T;BT;l@.(;mIC;[ ;l@.(;nIC;[ ;l@.(;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i;
F;:Exception;;@;;;[ ;{ ;IC;"Descendants of class Exception are used to communicate between
Kernel#raise and +rescue+ statements in begin ... end blocks.
Exception objects carry information about the exception -- its type (the
exception's class name), an optional descriptive string, and optional
traceback information. Exception subclasses may add additional
information like NameError#name.
Programs may make subclasses of Exception, typically of StandardError or
RuntimeError, to provide custom classes and add additional information.
See the subclass list below for defaults for +raise+ and +rescue+.
When an exception has been raised but not yet handled (in +rescue+,
+ensure+, +at_exit+ and +END+ blocks) the global variable $!
will contain the current exception and $@ contains the
current exception's backtrace.
It is recommended that a library should have one subclass of StandardError
or RuntimeError and have specific exception types inherit from it. This
allows the user to rescue a generic exception type to catch all exceptions
the library may raise even if future versions of the library add new
exception subclasses.
For example:
class MyLibrary
class Error < RuntimeError
end
class WidgetError < Error
end
class FrobError < Error
end
end
To handle both WidgetError and FrobError the library user can rescue
MyLibrary::Error.
The built-in subclasses of Exception are:
* NoMemoryError
* ScriptError
* LoadError
* NotImplementedError
* SyntaxError
* SecurityError
* SignalException
* Interrupt
* StandardError -- default for +rescue+
* ArgumentError
* EncodingError
* FiberError
* IOError
* EOFError
* IndexError
* KeyError
* StopIteration
* LocalJumpError
* NameError
* NoMethodError
* RangeError
* FloatDomainError
* RegexpError
* RuntimeError -- default for +raise+
* SystemCallError
* Errno::*
* ThreadError
* TypeError
* ZeroDivisionError
* SystemExit
* SystemStackError
* fatal -- impossible to rescue
; T;[ ;[ ;I"Descendants of class Exception are used to communicate between
Kernel#raise and +rescue+ statements in begin ... end blocks.
Exception objects carry information about the exception -- its type (the
exception's class name), an optional descriptive string, and optional
traceback information. Exception subclasses may add additional
information like NameError#name.
Programs may make subclasses of Exception, typically of StandardError or
RuntimeError, to provide custom classes and add additional information.
See the subclass list below for defaults for +raise+ and +rescue+.
When an exception has been raised but not yet handled (in +rescue+,
+ensure+, +at_exit+ and +END+ blocks) the global variable $!
will contain the current exception and $@ contains the
current exception's backtrace.
It is recommended that a library should have one subclass of StandardError
or RuntimeError and have specific exception types inherit from it. This
allows the user to rescue a generic exception type to catch all exceptions
the library may raise even if future versions of the library add new
exception subclasses.
For example:
class MyLibrary
class Error < RuntimeError
end
class WidgetError < Error
end
class FrobError < Error
end
end
To handle both WidgetError and FrobError the library user can rescue
MyLibrary::Error.
The built-in subclasses of Exception are:
* NoMemoryError
* ScriptError
* LoadError
* NotImplementedError
* SyntaxError
* SecurityError
* SignalException
* Interrupt
* StandardError -- default for +rescue+
* ArgumentError
* EncodingError
* FiberError
* IOError
* EOFError
* IndexError
* KeyError
* StopIteration
* LocalJumpError
* NameError
* NoMethodError
* RangeError
* FloatDomainError
* RegexpError
* RuntimeError -- default for +raise+
* SystemCallError
* Errno::*
* ThreadError
* TypeError
* ZeroDivisionError
* SystemExit
* SystemStackError
* fatal -- impossible to rescue
; T;0;@.(; F; o; ; T; i;!i;"@;#I"Exception; F;v@ ;;qo; ;IC;[ ;l@`);mIC;[ ;l@`);nIC;[ ;l@`);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@
i[@
i&;
T;:FloatDomainError;;@;;;[ ;{ ;IC;"Raised when attempting to convert special float values (in particular
+infinite+ or +NaN+) to numerical classes which don't support them.
Float::INFINITY.to_r
#=> FloatDomainError: Infinity
; T;[ ;[ ;I"
Raised when attempting to convert special float values (in particular
+infinite+ or +NaN+) to numerical classes which don't support them.
Float::INFINITY.to_r
#=> FloatDomainError: Infinity
; T;0;@`); F; o; ; T; i;!i;"@;#I"FloatDomainError; F;vo; ;0;0;0;:RangeError;"@;o; ;IC;[ ;l@u);mIC;[ ;l@u);nIC;[ ;l@u);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i[@ i
;
T;;U;;@;;;[ ;{ ;IC;"Raised when a given numerical value is out of range.
[1, 2, 3].drop(1 << 100)
raises the exception:
RangeError: bignum too big to convert into `long'
; T;[ ;[ ;I"
Raised when a given numerical value is out of range.
[1, 2, 3].drop(1 << 100)
raises the exception:
RangeError: bignum too big to convert into `long'
; T;0;@u); F; o; ; T; i;!i;"@;#I"RangeError; F;v@(;;q@o;;IC;["o;;IC;[o;1;2F;3;q;;;#I"Bug::Debug.attrset; F;5[ ; [ ;
F;: attrset;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);BTo;1;2F;3;q;;;#I"Bug::Debug.id2str; F;5[[I"sym; T0; [[I" ext/-test-/symbol/type.c; Ti+;
T;: id2str;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);;I"static VALUE; T;AI"Zstatic VALUE
bug_id2str(VALUE self, VALUE sym)
{
return rb_id2str(SYM2ID(sym));
}; T;BT;l@);mIC;[ ;l@);nIC;[ ;l@);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/debug/init.c; Ti;
F;:
Debug;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);#I"Bug::Debug; Fo; ;IC;[o;1;2F;3;q;;;#I"Bug::Symbol.interned?; F;5[[I" name; T0; [[I" ext/-test-/symbol/intern.c; Ti;
T;:interned?;0;[ ;{ ;IC;" ; T;[o;<
;8I" return; F;9@f;0;:[@h;@);[ ;@f;0;@);"@);;I"static VALUE; T;AI"{static VALUE
bug_sym_interned_p(VALUE self, VALUE name)
{
ID id = rb_check_id(&name);
return id ? Qtrue : Qfalse;
}; T;BTo;1;2F;3;q;;;#I"Bug::Symbol.zero; F;5[[I" length; T0; [[I" ext/-test-/bignum/bigzero.c; Ti;
T;: zero;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);;I"static VALUE; T;AI"static VALUE
bug_big_zero(VALUE self, VALUE length)
{
long len = NUM2ULONG(length);
VALUE z = rb_big_new(len, 1);
MEMZERO(RBIGNUM_DIGITS(z), BDIGIT, len);
return z;
}; T;BTo;1;2F;3;q;;;#I"Bug::Symbol.negzero; F;5[[I" length; T0; [[@)i;
T;: negzero;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);;I"static VALUE; T;AI"static VALUE
bug_big_negzero(VALUE self, VALUE length)
{
long len = NUM2ULONG(length);
VALUE z = rb_big_new(len, 0);
MEMZERO(RBIGNUM_DIGITS(z), BDIGIT, len);
return z;
}; T;BT;l@);mIC;[ ;l@);nIC;[ ;l@);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/symbol/init.c; Ti;
F;: Symbol;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@);#I"Bug::Symbol; F;vo; ;0;0;0;;\;"@;o; ;IC;[ o;1;2F;3;q;;;#I"Symbol.all_symbols; F;5[ ; [[@
i);
T;:all_symbols;0;[ ;{ ;IC;"Returns an array of all the symbols currently in Ruby's symbol
table.
Symbol.all_symbols.size #=> 903
Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
:chown, :EOFError, :$;, :String,
:LOCK_SH, :"setuid?", :$<,
:default_proc, :compact, :extend,
:Tms, :getwd, :$=, :ThreadGroup,
:wait2, :$>]
; T;[o;7
;8I"
overload; F;90;;];:0;;I"all_symbols; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@);[ ;I"@return [Array]; T;0;@); F;=i ;>0;5[ ;@);[ ;I"Returns an array of all the symbols currently in Ruby's symbol
table.
Symbol.all_symbols.size #=> 903
Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
:chown, :EOFError, :$;, :String,
:LOCK_SH, :"setuid?", :$<,
:default_proc, :compact, :extend,
:Tms, :getwd, :$=, :ThreadGroup,
:wait2, :$>]
@overload all_symbols
@return [Array]; T;0;@); F; o; ; T; i);!i);"@);;I"
VALUE; T;AI"VALUE
rb_sym_all_symbols(void)
{
VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
st_foreach(global_symbols.sym_id, symbols_i, ary);
return ary;
}; T;BTo;1;2F;3;4;;;#I"Symbol#==; F;5[[I" sym2; T0; [[I"
string.c; Ti ;
T;;O;0;[ ;{ ;IC;"dEquality---If sym and obj are exactly the same
symbol, returns true.
; T;[o;7
;8I"
overload; F;90;;O;:0;;I" ==(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@*;[ ;I"@return [Boolean]; T;0;@*; F;=i ;>0;5[[I"obj; T0;@*;[ ;I"Equality---If sym and obj are exactly the same
symbol, returns true.
@overload ==(obj)
@return [Boolean]; T;0;@*; F; o; ; T; i ;!i ;"@);;I"static VALUE; T;AI"nstatic VALUE
sym_equal(VALUE sym1, VALUE sym2)
{
if (sym1 == sym2) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Symbol#===; F;5[[I" sym2; T0; [[@*i ;
T;;P;0;[ ;{ ;IC;"dEquality---If sym and obj are exactly the same
symbol, returns true.
; T;[o;7
;8I"
overload; F;90;;O;:0;;I" ==(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@4*;[ ;I"@return [Boolean]; T;0;@4*; F;=i ;>0;5[[I"obj; T0;@4*;[ ;@0*;0;@4*; F; o; ; T; i ;!i ;"@);;I"static VALUE; T;AI"nstatic VALUE
sym_equal(VALUE sym1, VALUE sym2)
{
if (sym1 == sym2) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Symbol#inspect; F;5[ ; [[@*i ;
T;;?;0;[ ;{ ;IC;"bReturns the representation of sym as a symbol literal.
:fred.inspect #=> ":fred"
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@R*;[ ;I"@return [String]; T;0;@R*; F;=i ;>0;5[ ;@R*;[ ;I"Returns the representation of sym as a symbol literal.
:fred.inspect #=> ":fred"
@overload inspect
@return [String]; T;0;@R*; F; o; ; T; i ;!i ;"@);;I"static VALUE; T;AI"Hstatic VALUE
sym_inspect(VALUE sym)
{
VALUE str;
const char *ptr;
long len;
ID id = SYM2ID(sym);
char *dest;
sym = rb_id2str(id);
if (!rb_str_symname_p(sym)) {
str = rb_str_inspect(sym);
len = RSTRING_LEN(str);
rb_str_resize(str, len + 1);
dest = RSTRING_PTR(str);
memmove(dest + 1, dest, len);
dest[0] = ':';
}
else {
rb_encoding *enc = STR_ENC_GET(sym);
ptr = RSTRING_PTR(sym);
len = RSTRING_LEN(sym);
str = rb_enc_str_new(0, len + 1, enc);
dest = RSTRING_PTR(str);
dest[0] = ':';
memcpy(dest + 1, ptr, len);
}
return str;
}; T;BTo;1;2F;3;4;;;#I"Symbol#to_s; F;5[ ; [[@*i !;
T;;6;0;[ ;{ ;IC;"[Returns the name or string corresponding to sym.
:fred.id2name #=> "fred"
; T;[o;7
;8I"
overload; F;90;: id2name;:0;;I" id2name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@m*;[ ;I"@return [String]; T;0;@m*; F;=i ;>0;5[ ;@m*o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@m*;[ ;I"@return [String]; T;0;@m*; F;=i ;>0;5[ ;@m*;[ ;I"Returns the name or string corresponding to sym.
:fred.id2name #=> "fred"
@overload id2name
@return [String]
@overload to_s
@return [String]; T;0;@m*; F; o; ; T; i!;!i !;"@);;I"
VALUE; T;AI"oVALUE
rb_sym_to_s(VALUE sym)
{
ID id = SYM2ID(sym);
return str_new3(rb_cString, rb_id2str(id));
}; T;BTo;1;2F;3;4;;;#I"Symbol#id2name; F;5[ ; [[@*i !;
T;;^;0;[ ;{ ;IC;"[Returns the name or string corresponding to sym.
:fred.id2name #=> "fred"
; T;[o;7
;8I"
overload; F;90;;^;:0;;I" id2name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@*;[ ;I"@return [String]; T;0;@*; F;=i ;>0;5[ ;@*o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@*;[ ;I"@return [String]; T;0;@*; F;=i ;>0;5[ ;@*;[ ;@*;0;@*; F; o; ; T; i!;!i !;"@);;I"
VALUE; T;AI"oVALUE
rb_sym_to_s(VALUE sym)
{
ID id = SYM2ID(sym);
return str_new3(rb_cString, rb_id2str(id));
}; T;BTo;1;2F;3;4;;;#I"Symbol#intern; F;5[ ; [[@*i3!;
T;: intern;0;[ ;{ ;IC;"In general, to_sym returns the Symbol corresponding
to an object. As sym is already a symbol, self is returned
in this case.
; T;[o;7
;8I"
overload; F;90;: to_sym;:0;;I" to_sym; T;IC;" ; T;[ ;[ ;I" ; T;0;@*; F;=i ;>0;5[ ;@*o;7
;8I"
overload; F;90;;_;:0;;I" intern; T;IC;" ; T;[ ;[ ;I" ; T;0;@*; F;=i ;>0;5[ ;@*;[ ;I"In general, to_sym returns the Symbol corresponding
to an object. As sym is already a symbol, self is returned
in this case.
@overload to_sym
@overload intern; T;0;@*; F; o; ; T; i)!;!i/!;"@);;I"static VALUE; T;AI";static VALUE
sym_to_sym(VALUE sym)
{
return sym;
}; T;BTo;1;2F;3;4;;;#I"Symbol#to_sym; F;5[ ; [[@*i3!;
T;;`;0;[ ;{ ;IC;"In general, to_sym returns the Symbol corresponding
to an object. As sym is already a symbol, self is returned
in this case.
; T;[o;7
;8I"
overload; F;90;;`;:0;;I" to_sym; T;IC;" ; T;[ ;[ ;I" ; T;0;@*; F;=i ;>0;5[ ;@*o;7
;8I"
overload; F;90;;_;:0;;I" intern; T;IC;" ; T;[ ;[ ;I" ; T;0;@*; F;=i ;>0;5[ ;@*;[ ;@*;0;@*; F; o; ; T; i)!;!i/!;"@);;I"static VALUE; T;AI";static VALUE
sym_to_sym(VALUE sym)
{
return sym;
}; T;BTo;1;2F;3;4;;;#I"Symbol#to_proc; F;5[ ; [[@*iN!;
T;: to_proc;0;[ ;{ ;IC;"wReturns a _Proc_ object which respond to the given method by _sym_.
(1..3).collect(&:to_s) #=> ["1", "2", "3"]
; T;[o;7
;8I"
overload; F;90;;a;:0;;I" to_proc; T;IC;" ; T;[ ;[ ;I" ; T;0;@*; F;=i ;>0;5[ ;@*;[ ;I"Returns a _Proc_ object which respond to the given method by _sym_.
(1..3).collect(&:to_s) #=> ["1", "2", "3"]
@overload to_proc; T;0;@*; F; o; ; T; iE!;!iJ!;"@);;I"static VALUE; T;AI"static VALUE
sym_to_proc(VALUE sym)
{
static VALUE sym_proc_cache = Qfalse;
enum {SYM_PROC_CACHE_SIZE = 67};
VALUE proc;
long id, index;
VALUE *aryp;
if (!sym_proc_cache) {
sym_proc_cache = rb_ary_tmp_new(SYM_PROC_CACHE_SIZE * 2);
rb_gc_register_mark_object(sym_proc_cache);
rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE*2 - 1, Qnil);
}
id = SYM2ID(sym);
index = (id % SYM_PROC_CACHE_SIZE) << 1;
aryp = RARRAY_PTR(sym_proc_cache);
if (aryp[index] == sym) {
return aryp[index + 1];
}
else {
proc = rb_proc_new(sym_call, (VALUE)id);
rb_block_clear_env_self(proc);
aryp[index] = sym;
aryp[index + 1] = proc;
return proc;
}
}; T;BTo;1;2F;3;4;;;#I"Symbol#succ; F;5[ ; [[@*iu!;
T;;;0;[ ;{ ;IC;"/Same as sym.to_s.succ.intern.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" succ; T;IC;" ; T;[ ;[ ;I" ; T;0;@
+; F;=i ;>0;5[ ;@
+;[ ;I"@Same as sym.to_s.succ.intern.
@overload succ; T;0;@
+; F; o; ; T; im!;!ip!;"@);;I"static VALUE; T;AI"bstatic VALUE
sym_succ(VALUE sym)
{
return rb_str_intern(rb_str_succ(rb_sym_to_s(sym)));
}; T;BTo;1;2F;3;4;;;#I"Symbol#next; F;5[ ; [[@*iu!;
T;; ;0;[ ;{ ;IC;"/Same as sym.to_s.succ.intern.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" succ; T;IC;" ; T;[ ;[ ;I" ; T;0;@#+; F;=i ;>0;5[ ;@#+;[ ;@ +;0;@#+; F; o; ; T; im!;!ip!;"@);;I"static VALUE; T;AI"bstatic VALUE
sym_succ(VALUE sym)
{
return rb_str_intern(rb_str_succ(rb_sym_to_s(sym)));
}; T;BTo;1;2F;3;4;;;#I"Symbol#<=>; F;5[[I"
other; T0; [[@*i!;
T;;Q;0;[ ;{ ;IC;" Compares +symbol+ with +other_symbol+ after calling #to_s on each of the
symbols. Returns -1, 0, +1 or nil depending on whether +symbol+ is less
than, equal to, or greater than +other_symbol+.
+nil+ is returned if the two values are incomparable.
See String#<=> for more information.
; T;[o;7
;8I"
overload; F;90;;Q;:0;;I"<=>(other_symbol); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[ I"-1; TI"0; TI"+1; TI"nil; T;@8+;[ ;I" @return [-1, 0, +1, nil]; T;0;@8+; F;=i ;>0;5[[I"other_symbol; T0;@8+;[ ;I"YCompares +symbol+ with +other_symbol+ after calling #to_s on each of the
symbols. Returns -1, 0, +1 or nil depending on whether +symbol+ is less
than, equal to, or greater than +other_symbol+.
+nil+ is returned if the two values are incomparable.
See String#<=> for more information.
@overload <=>(other_symbol)
@return [-1, 0, +1, nil]; T;0;@8+; F; o; ; T; i{!;!i!;"@);;I"static VALUE; T;AI"static VALUE
sym_cmp(VALUE sym, VALUE other)
{
if (!SYMBOL_P(other)) {
return Qnil;
}
return rb_str_cmp_m(rb_sym_to_s(sym), rb_sym_to_s(other));
}; T;BTo;1;2F;3;4;;;#I"Symbol#casecmp; F;5[[I"
other; T0; [[@*i!;
T;: casecmp;0;[ ;{ ;IC;"9Case-insensitive version of Symbol#<=>.
; T;[o;7
;8I"
overload; F;90;;b;:0;;I"casecmp(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[ I"-1; TI"0; TI"+1; TI"nil; T;@Z+;[ ;I" @return [-1, 0, +1, nil]; T;0;@Z+; F;=i ;>0;5[[I"
other; T0;@Z+;[ ;I"qCase-insensitive version of Symbol#<=>.
@overload casecmp(other)
@return [-1, 0, +1, nil]; T;0;@Z+; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"static VALUE
sym_casecmp(VALUE sym, VALUE other)
{
if (!SYMBOL_P(other)) {
return Qnil;
}
return rb_str_casecmp(rb_sym_to_s(sym), rb_sym_to_s(other));
}; T;BTo;1;2F;3;4;;;#I"Symbol#=~; F;5[[I"
other; T0; [[@*i!;
T;;;0;[ ;{ ;IC;"*Returns sym.to_s =~ obj.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" =~(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@|+;[ ;I"@return [Fixnum, nil]; T;0;@|+; F;=i ;>0;5[[I"obj; T0;@|+o;7
;8I"
overload; F;90;:
match;:0;;I"match(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@|+;[ ;I"@return [Fixnum, nil]; T;0;@|+; F;=i ;>0;5[[I"obj; T0;@|+;[ ;I"~Returns sym.to_s =~ obj.
@overload =~(obj)
@return [Fixnum, nil]
@overload match(obj)
@return [Fixnum, nil]; T;0;@|+; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"istatic VALUE
sym_match(VALUE sym, VALUE other)
{
return rb_str_match(rb_sym_to_s(sym), other);
}; T;BTo;1;2F;3;4;;;#I"Symbol#[]; F;5[[@0; [[@*i!;
T;;D;0;[ ;{ ;IC;"%Returns sym.to_s[].
; T;[ o;7
;8I"
overload; F;90;;D;:0;;I" [](idx); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"idx; T0;@+o;7
;8I"
overload; F;90;;D;:0;;I"
[](b, n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"b; T0[I"n; T0;@+o;7
;8I"
overload; F;90;:
slice;:0;;I"slice(idx); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"idx; T0;@+o;7
;8I"
overload; F;90;;d;:0;;I"slice(b, n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"b; T0[I"n; T0;@+;[ ;I"Returns sym.to_s[].
@overload [](idx)
@return [String]
@overload [](b, n)
@return [String]
@overload slice(idx)
@return [String]
@overload slice(b, n)
@return [String]; T;0;@+; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"xstatic VALUE
sym_aref(int argc, VALUE *argv, VALUE sym)
{
return rb_str_aref_m(argc, argv, rb_sym_to_s(sym));
}; T;BTo;1;2F;3;4;;;#I"Symbol#slice; F;5[[@0; [[@*i!;
T;;d;0;[ ;{ ;IC;"%Returns sym.to_s[].
; T;[ o;7
;8I"
overload; F;90;;D;:0;;I" [](idx); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"idx; T0;@+o;7
;8I"
overload; F;90;;D;:0;;I"
[](b, n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"b; T0[I"n; T0;@+o;7
;8I"
overload; F;90;;d;:0;;I"slice(idx); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"idx; T0;@+o;7
;8I"
overload; F;90;;d;:0;;I"slice(b, n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[[I"b; T0[I"n; T0;@+;[ ;@+;0;@+; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"xstatic VALUE
sym_aref(int argc, VALUE *argv, VALUE sym)
{
return rb_str_aref_m(argc, argv, rb_sym_to_s(sym));
}; T;BTo;1;2F;3;4;;;#I"Symbol#length; F;5[ ; [[@*i!;
T;: length;0;[ ;{ ;IC;"*Same as sym.to_s.length.
; T;[o;7
;8I"
overload; F;90;;e;:0;;I" length; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@I,;[ ;I"@return [Integer]; T;0;@I,; F;=i ;>0;5[ ;@I,o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@I,;[ ;I"@return [Integer]; T;0;@I,; F;=i ;>0;5[ ;@I,;[ ;I"tSame as sym.to_s.length.
@overload length
@return [Integer]
@overload size
@return [Integer]; T;0;@I,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"]static VALUE
sym_length(VALUE sym)
{
return rb_str_length(rb_id2str(SYM2ID(sym)));
}; T;BTo;1;2F;3;4;;;#I"Symbol#size; F;5[ ; [[@*i!;
T;;G;0;[ ;{ ;IC;"*Same as sym.to_s.length.
; T;[o;7
;8I"
overload; F;90;;e;:0;;I" length; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@q,;[ ;I"@return [Integer]; T;0;@q,; F;=i ;>0;5[ ;@q,o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@q,;[ ;I"@return [Integer]; T;0;@q,; F;=i ;>0;5[ ;@q,;[ ;@m,;0;@q,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"]static VALUE
sym_length(VALUE sym)
{
return rb_str_length(rb_id2str(SYM2ID(sym)));
}; T;BTo;1;2F;3;4;;;#I"Symbol#empty?; F;5[ ; [[@*i!;
T;: empty?;0;[ ;{ ;IC;"&Returns that _sym_ is :"" or not.
; T;[o;7
;8I"
overload; F;90;;f;:0;;I" empty?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@,;[ ;I"@return [Boolean]; T;0;@,; F;=i ;>0;5[ ;@,o;<
;8I" return; F;9@f;0;:[@h;@,;[ ;I"MReturns that _sym_ is :"" or not.
@overload empty?
@return [Boolean]; T;0;@,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"[static VALUE
sym_empty(VALUE sym)
{
return rb_str_empty(rb_id2str(SYM2ID(sym)));
}; T;BTo;1;2F;3;4;;;#I"Symbol#match; F;5[[I"
other; T0; [[@*i!;
T;;c;0;[ ;{ ;IC;"*Returns sym.to_s =~ obj.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" =~(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@,;[ ;I"@return [Fixnum, nil]; T;0;@,; F;=i ;>0;5[[I"obj; T0;@,o;7
;8I"
overload; F;90;;c;:0;;I"match(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@,;[ ;I"@return [Fixnum, nil]; T;0;@,; F;=i ;>0;5[[I"obj; T0;@,;[ ;@+;0;@,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"istatic VALUE
sym_match(VALUE sym, VALUE other)
{
return rb_str_match(rb_sym_to_s(sym), other);
}; T;BTo;1;2F;3;4;;;#I"Symbol#upcase; F;5[ ; [[@*i!;
T;: upcase;0;[ ;{ ;IC;"1Same as sym.to_s.upcase.intern.
; T;[o;7
;8I"
overload; F;90;;g;:0;;I" upcase; T;IC;" ; T;[ ;[ ;I" ; T;0;@,; F;=i ;>0;5[ ;@,;[ ;I"DSame as sym.to_s.upcase.intern.
@overload upcase; T;0;@,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"lstatic VALUE
sym_upcase(VALUE sym)
{
return rb_str_intern(rb_str_upcase(rb_id2str(SYM2ID(sym))));
}; T;BTo;1;2F;3;4;;;#I"Symbol#downcase; F;5[ ; [[@*i!;
T;:
downcase;0;[ ;{ ;IC;"3Same as sym.to_s.downcase.intern.
; T;[o;7
;8I"
overload; F;90;;h;:0;;I"
downcase; T;IC;" ; T;[ ;[ ;I" ; T;0;@,; F;=i ;>0;5[ ;@,;[ ;I"HSame as sym.to_s.downcase.intern.
@overload downcase; T;0;@,; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"pstatic VALUE
sym_downcase(VALUE sym)
{
return rb_str_intern(rb_str_downcase(rb_id2str(SYM2ID(sym))));
}; T;BTo;1;2F;3;4;;;#I"Symbol#capitalize; F;5[ ; [[@*i!;
T;:capitalize;0;[ ;{ ;IC;"5Same as sym.to_s.capitalize.intern.
; T;[o;7
;8I"
overload; F;90;;i;:0;;I"capitalize; T;IC;" ; T;[ ;[ ;I" ; T;0;@-; F;=i ;>0;5[ ;@-;[ ;I"LSame as sym.to_s.capitalize.intern.
@overload capitalize; T;0;@-; F; o; ; T; i!;!i!;"@);;I"static VALUE; T;AI"tstatic VALUE
sym_capitalize(VALUE sym)
{
return rb_str_intern(rb_str_capitalize(rb_id2str(SYM2ID(sym))));
}; T;BTo;1;2F;3;4;;;#I"Symbol#swapcase; F;5[ ; [[@*i
";
T;:
swapcase;0;[ ;{ ;IC;"3Same as sym.to_s.swapcase.intern.
; T;[o;7
;8I"
overload; F;90;;j;:0;;I"
swapcase; T;IC;" ; T;[ ;[ ;I" ; T;0;@'-; F;=i ;>0;5[ ;@'-;[ ;I"HSame as sym.to_s.swapcase.intern.
@overload swapcase; T;0;@'-; F; o; ; T; i";!i";"@);;I"static VALUE; T;AI"pstatic VALUE
sym_swapcase(VALUE sym)
{
return rb_str_intern(rb_str_swapcase(rb_id2str(SYM2ID(sym))));
}; T;BTo;1;2F;3;4;;;#I"Symbol#encoding; F;5[ ; [[@*i";
T;:
encoding;0;[ ;{ ;IC;"GReturns the Encoding object that represents the encoding of _sym_.
; T;[o;7
;8I"
overload; F;90;;k;:0;;I"
encoding; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@=-;[ ;I"@return [Encoding]; T;0;@=-; F;=i ;>0;5[ ;@=-;[ ;I"qReturns the Encoding object that represents the encoding of _sym_.
@overload encoding
@return [Encoding]; T;0;@=-; F; o; ; T; i";!i";"@);;I"static VALUE; T;AI"astatic VALUE
sym_encoding(VALUE sym)
{
return rb_obj_encoding(rb_id2str(SYM2ID(sym)));
}; T;BT;l@);mIC;[ ;l@);nIC;[o; ;0;0;0;;;"@;@ ;0;l@);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@*i [@*i";
T;;\;;@;;;[ ;{ ;IC;"********************************************************************
Symbol objects represent names and some strings
inside the Ruby
interpreter. They are generated using the :name and
:"string" literals
syntax, and by the various to_sym methods. The same
Symbol object will be created for a given name or string
for the duration of a program's execution, regardless of the context
or meaning of that name. Thus if Fred is a constant in
one context, a method in another, and a class in a third, the
Symbol :Fred will be the same object in
all three contexts.
module One
class Fred
end
$f1 = :Fred
end
module Two
Fred = 1
$f2 = :Fred
end
def Fred()
end
$f3 = :Fred
$f1.object_id #=> 2514190
$f2.object_id #=> 2514190
$f3.object_id #=> 2514190; T;[ ;[ ;I"********************************************************************
Symbol objects represent names and some strings
inside the Ruby
interpreter. They are generated using the :name and
:"string" literals
syntax, and by the various to_sym methods. The same
Symbol object will be created for a given name or string
for the duration of a program's execution, regardless of the context
or meaning of that name. Thus if Fred is a constant in
one context, a method in another, and a class in a third, the
Symbol :Fred will be the same object in
all three contexts.
module One
class Fred
end
$f1 = :Fred
end
module Two
Fred = 1
$f2 = :Fred
end
def Fred()
end
$f3 = :Fred
$f1.object_id #=> 2514190
$f2.object_id #=> 2514190
$f3.object_id #=> 2514190
; T;0;@); F; o; ; T; i ;!i ;=i ;"@;#I" Symbol; F;v@ ;;qo;1;2F;3;4;;
;#I"Bug#funcall; F;5[[@0; [[I" ext/-test-/bug-3662/bug.c; Ti;
T;: funcall;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@k-; F;>0;"@);;I"static VALUE; T;AI"static VALUE
bug_funcall(int argc, VALUE *argv, VALUE self)
{
if (argc < 1) rb_raise(rb_eArgError, "not enough argument");
return rb_funcall2(self, rb_to_id(*argv), argc-1, argv+1);
}; T;BTo;1;2T;3;q;;;#I"Bug.funcall; F;5@m-; @o-;
T;;l;0;@r-;{ ;IC;" ; T;[ ;[ ;@f;0;@z-;=i ;"@);;@x-;A@y-;BTo;1;2F;3;4;;
;#I"Bug#notimplement; F;5[ ; [ ;
F;:notimplement;;@;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@-; F;>0;"@);BTo;1;2T;3;q;;;#I"Bug.notimplement; F;5@-; @-;
F;;m;;@;@-;{ ;IC;" ; T;[ ;[ ;@f;0;@-;=i ;"@);BTo; ;IC;[o; ;IC;[ ;l@-;mIC;[ ;l@-;nIC;[ ;l@-;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I"%ext/-test-/exception/dataerror.c; Ti";
F;:DataError;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@-;#I"Bug::Bignum::DataError; F;vo; ;0;0;0;;K;"@;@(;;qo;1;2F;3;4;;
;#I"Bug::Bignum#ensured; F;5[[I" object; T0; [[I"#ext/-test-/exception/ensured.c; Ti;
T;: ensured;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@-; F;>0;"@-;;I"static VALUE; T;AI"nstatic VALUE
ensured(VALUE module, VALUE object)
{
return rb_ensure(begin, object, ensure, object);
}; T;BTo;1;2T;3;q;;;#I"Bug::Bignum.ensured; F;5@-; @-;
T;;o;0;@-;{ ;IC;" ; T;[ ;[ ;@f;0;@-;=i ;"@-;;@-;A@-;BT;l@-;mIC;[ ;l@-;nIC;[ ;l@-;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/bignum/init.c; Ti;
F;: Bignum;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@);#I"Bug::Bignum; F;vo; ;0;0;0;;;"@;o; ;IC;[}o;1;2F;3;4;;;#I" String#str2big_poweroftwo; F;5[[I"
vbase; T0[I"
badcheck; T0; [[I" ext/-test-/bignum/str2big.c; Ti ;
T;:str2big_poweroftwo;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@-;;I"static VALUE; T;AI"static VALUE
str2big_poweroftwo(VALUE str, VALUE vbase, VALUE badcheck)
{
return rb_str2big_poweroftwo(str, NUM2INT(vbase), RTEST(badcheck));
}; T;BTo;1;2F;3;4;;;#I"String#str2big_normal; F;5[[I"
vbase; T0[I"
badcheck; T0; [[@-i;
T;:str2big_normal;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@-;;I"static VALUE; T;AI"static VALUE
str2big_normal(VALUE str, VALUE vbase, VALUE badcheck)
{
return rb_str2big_normal(str, NUM2INT(vbase), RTEST(badcheck));
}; T;BTo;1;2F;3;4;;;#I" String#str2big_karatsuba; F;5[[I"
vbase; T0[I"
badcheck; T0; [[@-i;
T;:str2big_karatsuba;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@-;;I"static VALUE; T;AI"static VALUE
str2big_karatsuba(VALUE str, VALUE vbase, VALUE badcheck)
{
return rb_str2big_karatsuba(str, NUM2INT(vbase), RTEST(badcheck));
}; T;BTo;1;2F;3;4;;;#I"String#str2big_gmp; F;5[[I"
vbase; T0[I"
badcheck; T0; [[@-i ;
T;:str2big_gmp;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@-;"@-;;I"static VALUE; T;AI"static VALUE
str2big_gmp(VALUE str, VALUE vbase, VALUE badcheck)
{
return rb_str2big_gmp(str, NUM2INT(vbase), RTEST(badcheck));
}; T;BTo;1;2F;3;4;;;#I"String#to_c; F;5[ ; [[@ei;
T;;|;0;[ ;{ ;IC;"sReturns a complex which denotes the string form. The parser
ignores leading whitespaces and trailing garbage. Any digit
sequences can be separated by an underscore. Returns zero for null
or garbage string.
'9'.to_c #=> (9+0i)
'2.5'.to_c #=> (2.5+0i)
'2.5/1'.to_c #=> ((5/2)+0i)
'-3/2'.to_c #=> ((-3/2)+0i)
'-i'.to_c #=> (0-1i)
'45i'.to_c #=> (0+45i)
'3-4i'.to_c #=> (3-4i)
'-4e2-4e-2i'.to_c #=> (-400.0-0.04i)
'-0.0-0.0i'.to_c #=> (-0.0-0.0i)
'1/2+3/4i'.to_c #=> ((1/2)+(3/4)*i)
'ruby'.to_c #=> (0+0i)
See Kernel.Complex.
; T;[o;7
;8I"
overload; F;90;;|;:0;;I" to_c; T;IC;" ; T;[ ;[ ;I" ; T;0;@.; F;=i ;>0;5[ ;@.;[ ;I"Returns a complex which denotes the string form. The parser
ignores leading whitespaces and trailing garbage. Any digit
sequences can be separated by an underscore. Returns zero for null
or garbage string.
'9'.to_c #=> (9+0i)
'2.5'.to_c #=> (2.5+0i)
'2.5/1'.to_c #=> ((5/2)+0i)
'-3/2'.to_c #=> ((-3/2)+0i)
'-i'.to_c #=> (0-1i)
'45i'.to_c #=> (0+45i)
'3-4i'.to_c #=> (3-4i)
'-4e2-4e-2i'.to_c #=> (-400.0-0.04i)
'-0.0-0.0i'.to_c #=> (-0.0-0.0i)
'1/2+3/4i'.to_c #=> ((1/2)+(3/4)*i)
'ruby'.to_c #=> (0+0i)
See Kernel.Complex.
@overload to_c; T;0;@.; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"Jstatic VALUE
string_to_c(VALUE self)
{
char *s;
VALUE num;
rb_must_asciicompat(self);
s = RSTRING_PTR(self);
if (s && s[RSTRING_LEN(self)]) {
rb_str_modify(self);
s = RSTRING_PTR(self);
s[RSTRING_LEN(self)] = '\0';
}
if (!s)
s = (char *)"";
(void)parse_comp(s, 0, &num);
return num;
}; T;BTo;1;2F;3;q;;;#I"String.try_convert; F;5[[I"str; T0; [[@*i;
T;:try_convert;0;[ ;{ ;IC;"Try to convert obj into a String, using to_str method.
Returns converted string or nil if obj cannot be converted
for any reason.
String.try_convert("str") #=> "str"
String.try_convert(/re/) #=> nil
; T;[o;7
;8I"
overload; F;90;;u;:0;;I"try_convert(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@%.;[ ;I"@return [String, nil]; T;0;@%.; F;=i ;>0;5[[I"obj; T0;@%.;[ ;I"Try to convert obj into a String, using to_str method.
Returns converted string or nil if obj cannot be converted
for any reason.
String.try_convert("str") #=> "str"
String.try_convert(/re/) #=> nil
@overload try_convert(obj)
@return [String, nil]; T;0;@%.; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"hstatic VALUE
rb_str_s_try_convert(VALUE dummy, VALUE str)
{
return rb_check_string_type(str);
}; T;BTo;1;2F;3;4;;;#I"String#initialize; F;5[[@0; [[@*i<;
T;; ;0;[ ;{ ;IC;"AReturns a new string object containing a copy of str.
; T;[o;7
;8I"
overload; F;90;;M;:0;;I"new(str=""); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@E.;[ ;I"@return [String]; T;0;@E.; F;=i ;>0;5[[I"str; TI"""; T;@E.;[ ;I"lReturns a new string object containing a copy of str.
@overload new(str="")
@return [String]; T;0;@E.; F; o; ; T; i5;!i9;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_init(int argc, VALUE *argv, VALUE str)
{
VALUE orig;
if (argc > 0 && rb_scan_args(argc, argv, "01", &orig) == 1)
rb_str_replace(str, orig);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#initialize_copy; F;5[[I" str2; T0; [[@*i;
T;;x;0;[ ;{ ;IC;"Replaces the contents and taintedness of str with the corresponding
values in other_str.
s = "hello" #=> "hello"
s.replace "world" #=> "world"
; T;[o;7
;8I"
overload; F;90;: replace;:0;;I"replace(other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@d.;[ ;I"@return [String]; T;0;@d.; F;=i ;>0;5[[I"other_str; T0;@d.;[ ;I"Replaces the contents and taintedness of str with the corresponding
values in other_str.
s = "hello" #=> "hello"
s.replace "world" #=> "world"
@overload replace(other_str)
@return [String]; T;0;@d.; F; o; ; T; i;!i;"@-;;I"
VALUE; T;AI"VALUE
rb_str_replace(VALUE str, VALUE str2)
{
str_modifiable(str);
if (str == str2) return str;
StringValue(str2);
str_discard(str);
return str_replace(str, str2);
}; T;BTo;1;2F;3;4;;;#I"String#<=>; F;5[[I" str2; T0; [[@*i"
;
T;;Q;0;[ ;{ ;IC;"Comparison---Returns -1, 0, +1 or nil depending on whether +string+ is less
than, equal to, or greater than +other_string+.
+nil+ is returned if the two values are incomparable.
If the strings are of different lengths, and the strings are equal when
compared up to the shortest length, then the longer string is considered
greater than the shorter one.
<=> is the basis for the methods <,
<=, >, >=, and
between?, included from module Comparable. The method
String#== does not use Comparable#==.
"abcdef" <=> "abcde" #=> 1
"abcdef" <=> "abcdef" #=> 0
"abcdef" <=> "abcdefg" #=> -1
"abcdef" <=> "ABCDEF" #=> 1
; T;[o;7
;8I"
overload; F;90;;Q;:0;;I"<=>(other_string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[ I"-1; TI"0; TI"+1; TI"nil; T;@.;[ ;I" @return [-1, 0, +1, nil]; T;0;@.; F;=i ;>0;5[[I"other_string; T0;@.;[ ;I"
Comparison---Returns -1, 0, +1 or nil depending on whether +string+ is less
than, equal to, or greater than +other_string+.
+nil+ is returned if the two values are incomparable.
If the strings are of different lengths, and the strings are equal when
compared up to the shortest length, then the longer string is considered
greater than the shorter one.
<=> is the basis for the methods <,
<=, >, >=, and
between?, included from module Comparable. The method
String#== does not use Comparable#==.
"abcdef" <=> "abcde" #=> 1
"abcdef" <=> "abcdef" #=> 0
"abcdef" <=> "abcdefg" #=> -1
"abcdef" <=> "ABCDEF" #=> 1
@overload <=>(other_string)
@return [-1, 0, +1, nil]; T;0;@.; F; o; ; T; i
;!i
;"@-;;I"static VALUE; T;AI"xstatic VALUE
rb_str_cmp_m(VALUE str1, VALUE str2)
{
int result;
if (!RB_TYPE_P(str2, T_STRING)) {
VALUE tmp = rb_check_funcall(str2, rb_intern("to_str"), 0, 0);
if (RB_TYPE_P(tmp, T_STRING)) {
result = rb_str_cmp(str1, tmp);
}
else {
return rb_invcmp(str1, str2);
}
}
else {
result = rb_str_cmp(str1, str2);
}
return INT2FIX(result);
}; T;BTo;1;2F;3;4;;;#I"String#==; F;5[[I" str2; T0; [[@*i ;
T;;O;0;[ ;{ ;IC;"=== Equality
Returns whether +str+ == +obj+, similar to Object#==.
If +obj+ is not an instance of String but responds to +to_str+, then the
two strings are compared using case equality Object#===.
Otherwise, returns similarly to String#eql?, comparing length and content.
; T;[o;7
;8I"
overload; F;90;;O;:0;;I" ==(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@.;[ ;I"@return [Boolean]; T;0;@.; F;=i ;>0;5[[I"obj; T0;@.o;7
;8I"
overload; F;90;;P;:0;;I"
===(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@.;[ ;I"@return [Boolean]; T;0;@.; F;=i ;>0;5[[I"obj; T0;@.;[ ;I"a=== Equality
Returns whether +str+ == +obj+, similar to Object#==.
If +obj+ is not an instance of String but responds to +to_str+, then the
two strings are compared using case equality Object#===.
Otherwise, returns similarly to String#eql?, comparing length and content.
@overload ==(obj)
@return [Boolean]
@overload ===(obj)
@return [Boolean]; T;0;@.; F; o; ; T; i ;!i ;"@-;;I"
VALUE; T;AI"VALUE
rb_str_equal(VALUE str1, VALUE str2)
{
if (str1 == str2) return Qtrue;
if (!RB_TYPE_P(str2, T_STRING)) {
if (!rb_respond_to(str2, rb_intern("to_str"))) {
return Qfalse;
}
return rb_equal(str2, str1);
}
return str_eql(str1, str2);
}; T;BTo;1;2F;3;4;;;#I"String#===; F;5[[I" str2; T0; [[@*i ;
T;;P;0;[ ;{ ;IC;"=== Equality
Returns whether +str+ == +obj+, similar to Object#==.
If +obj+ is not an instance of String but responds to +to_str+, then the
two strings are compared using case equality Object#===.
Otherwise, returns similarly to String#eql?, comparing length and content.
; T;[o;7
;8I"
overload; F;90;;O;:0;;I" ==(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@.;[ ;I"@return [Boolean]; T;0;@.; F;=i ;>0;5[[I"obj; T0;@.o;7
;8I"
overload; F;90;;P;:0;;I"
===(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@.;[ ;I"@return [Boolean]; T;0;@.; F;=i ;>0;5[[I"obj; T0;@.;[ ;@.;0;@.; F; o; ; T; i ;!i ;"@-;;I"
VALUE; T;AI"VALUE
rb_str_equal(VALUE str1, VALUE str2)
{
if (str1 == str2) return Qtrue;
if (!RB_TYPE_P(str2, T_STRING)) {
if (!rb_respond_to(str2, rb_intern("to_str"))) {
return Qfalse;
}
return rb_equal(str2, str1);
}
return str_eql(str1, str2);
}; T;BTo;1;2F;3;4;;;#I"String#eql?; F;5[[I" str2; T0; [[@*i
;
T;;V;0;[ ;{ ;IC;"DTwo strings are equal if they have the same length and content.
; T;[o;7
;8I"
overload; F;90;;V;:0;;I"eql?(other); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ /;[ ;I"@return [Boolean]; T;0;@ /; F;=i ;>0;5[[I"
other; T0;@ /o;<
;8I" return; F;9@f;0;:[@h;@ /;[ ;I"pTwo strings are equal if they have the same length and content.
@overload eql?(other)
@return [Boolean]; T;0;@ /; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_eql(VALUE str1, VALUE str2)
{
if (str1 == str2) return Qtrue;
if (!RB_TYPE_P(str2, T_STRING)) return Qfalse;
return str_eql(str1, str2);
}; T;BTo;1;2F;3;4;;;#I"String#hash; F;5[ ; [[@*i ;
T;;W;0;[ ;{ ;IC;"String#<=>.
"abcdef".casecmp("abcde") #=> 1
"aBcDeF".casecmp("abcdef") #=> 0
"abcdef".casecmp("abcdefg") #=> -1
"abcdef".casecmp("ABCDEF") #=> 0
; T;[o;7
;8I"
overload; F;90;;b;:0;;I"casecmp(other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[ I"-1; TI"0; TI"+1; TI"nil; T;@=/;[ ;I" @return [-1, 0, +1, nil]; T;0;@=/; F;=i ;>0;5[[I"other_str; T0;@=/;[ ;I"Case-insensitive version of String#<=>.
"abcdef".casecmp("abcde") #=> 1
"aBcDeF".casecmp("abcdef") #=> 0
"abcdef".casecmp("abcdefg") #=> -1
"abcdef".casecmp("ABCDEF") #=> 0
@overload casecmp(other_str)
@return [-1, 0, +1, nil]; T;0;@=/; F; o; ; T; i6
;!i?
;"@-;;I"static VALUE; T;AI"sstatic VALUE
rb_str_casecmp(VALUE str1, VALUE str2)
{
long len;
rb_encoding *enc;
char *p1, *p1end, *p2, *p2end;
StringValue(str2);
enc = rb_enc_compatible(str1, str2);
if (!enc) {
return Qnil;
}
p1 = RSTRING_PTR(str1); p1end = RSTRING_END(str1);
p2 = RSTRING_PTR(str2); p2end = RSTRING_END(str2);
if (single_byte_optimizable(str1) && single_byte_optimizable(str2)) {
while (p1 < p1end && p2 < p2end) {
if (*p1 != *p2) {
unsigned int c1 = TOUPPER(*p1 & 0xff);
unsigned int c2 = TOUPPER(*p2 & 0xff);
if (c1 != c2)
return INT2FIX(c1 < c2 ? -1 : 1);
}
p1++;
p2++;
}
}
else {
while (p1 < p1end && p2 < p2end) {
int l1, c1 = rb_enc_ascget(p1, p1end, &l1, enc);
int l2, c2 = rb_enc_ascget(p2, p2end, &l2, enc);
if (0 <= c1 && 0 <= c2) {
c1 = TOUPPER(c1);
c2 = TOUPPER(c2);
if (c1 != c2)
return INT2FIX(c1 < c2 ? -1 : 1);
}
else {
int r;
l1 = rb_enc_mbclen(p1, p1end, enc);
l2 = rb_enc_mbclen(p2, p2end, enc);
len = l1 < l2 ? l1 : l2;
r = memcmp(p1, p2, len);
if (r != 0)
return INT2FIX(r < 0 ? -1 : 1);
if (l1 != l2)
return INT2FIX(l1 < l2 ? -1 : 1);
}
p1 += l1;
p2 += l2;
}
}
if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0);
if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1);
return INT2FIX(-1);
}; T;BTo;1;2F;3;4;;;#I"
String#+; F;5[[I" str2; T0; [[@*iG;
T;;F;0;[ ;{ ;IC;"Concatenation---Returns a new String containing
other_str concatenated to str.
"Hello from " + self.to_s #=> "Hello from main"
; T;[o;7
;8I"
overload; F;90;;F;:0;;I"+(other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@_/;[ ;I"@return [String]; T;0;@_/; F;=i ;>0;5[[I"other_str; T0;@_/;[ ;I"Concatenation---Returns a new String containing
other_str concatenated to str.
"Hello from " + self.to_s #=> "Hello from main"
@overload +(other_str)
@return [String]; T;0;@_/; F; o; ; T; i=;!iD;"@-;;I"
VALUE; T;AI"sVALUE
rb_str_plus(VALUE str1, VALUE str2)
{
VALUE str3;
rb_encoding *enc;
StringValue(str2);
enc = rb_enc_check(str1, str2);
str3 = rb_str_new(0, RSTRING_LEN(str1)+RSTRING_LEN(str2));
memcpy(RSTRING_PTR(str3), RSTRING_PTR(str1), RSTRING_LEN(str1));
memcpy(RSTRING_PTR(str3) + RSTRING_LEN(str1),
RSTRING_PTR(str2), RSTRING_LEN(str2));
RSTRING_PTR(str3)[RSTRING_LEN(str3)] = '\0';
FL_SET_RAW(str3, OBJ_TAINTED_RAW(str1) | OBJ_TAINTED_RAW(str2));
ENCODING_CODERANGE_SET(str3, rb_enc_to_index(enc),
ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2)));
return str3;
}; T;BTo;1;2F;3;4;;;#I"
String#*; F;5[[I"
times; T0; [[@*if;
T;;G;0;[ ;{ ;IC;"Copy --- Returns a new String containing +integer+ copies of the receiver.
+integer+ must be greater than or equal to 0.
"Ho! " * 3 #=> "Ho! Ho! Ho! "
"Ho! " * 0 #=> ""
; T;[o;7
;8I"
overload; F;90;;G;:0;;I"*(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@~/;[ ;I"@return [String]; T;0;@~/; F;=i ;>0;5[[I" integer; T0;@~/;[ ;I"Copy --- Returns a new String containing +integer+ copies of the receiver.
+integer+ must be greater than or equal to 0.
"Ho! " * 3 #=> "Ho! Ho! Ho! "
"Ho! " * 0 #=> ""
@overload *(integer)
@return [String]; T;0;@~/; F; o; ; T; i[;!ic;"@-;;I"
VALUE; T;AI"VALUE
rb_str_times(VALUE str, VALUE times)
{
VALUE str2;
long n, len;
char *ptr2;
len = NUM2LONG(times);
if (len < 0) {
rb_raise(rb_eArgError, "negative argument");
}
if (len && LONG_MAX/len < RSTRING_LEN(str)) {
rb_raise(rb_eArgError, "argument too big");
}
str2 = rb_str_new5(str, 0, len *= RSTRING_LEN(str));
ptr2 = RSTRING_PTR(str2);
if (len) {
n = RSTRING_LEN(str);
memcpy(ptr2, RSTRING_PTR(str), n);
while (n <= len/2) {
memcpy(ptr2 + n, ptr2, n);
n *= 2;
}
memcpy(ptr2 + n, ptr2, len-n);
}
ptr2[RSTRING_LEN(str2)] = '\0';
OBJ_INFECT(str2, str);
rb_enc_cr_str_copy_for_substr(str2, str);
return str2;
}; T;BTo;1;2F;3;4;;;#I"
String#%; F;5[[I"arg; T0; [[@*i;
T;;K;0;[ ;{ ;IC;"Format---Uses str as a format specification, and returns the result
of applying it to arg. If the format specification contains more than
one substitution, then arg must be an Array or Hash
containing the values to be substituted. See Kernel::sprintf for
details of the format string.
"%05d" % 123 #=> "00123"
"%-5s: %08x" % [ "ID", self.object_id ] #=> "ID : 200e14d6"
"foo = %{foo}" % { :foo => 'bar' } #=> "foo = bar"
; T;[o;7
;8I"
overload; F;90;;K;:0;;I" %(arg); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@/;[ ;I"@return [String]; T;0;@/; F;=i ;>0;5[[I"arg; T0;@/;[ ;I"8Format---Uses str as a format specification, and returns the result
of applying it to arg. If the format specification contains more than
one substitution, then arg must be an Array or Hash
containing the values to be substituted. See Kernel::sprintf for
details of the format string.
"%05d" % 123 #=> "00123"
"%-5s: %08x" % [ "ID", self.object_id ] #=> "ID : 200e14d6"
"foo = %{foo}" % { :foo => 'bar' } #=> "foo = bar"
@overload %(arg)
@return [String]; T;0;@/; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_format_m(VALUE str, VALUE arg)
{
volatile VALUE tmp = rb_check_array_type(arg);
if (!NIL_P(tmp)) {
return rb_str_format(RARRAY_LENINT(tmp), RARRAY_CONST_PTR(tmp), str);
}
return rb_str_format(1, &arg, str);
}; T;BTo;1;2F;3;4;;;#I"String#[]; F;5[[@0; [[@*i*;
T;;D;0;[ ;{ ;IC;"Element Reference --- If passed a single +index+, returns a substring of
one character at that index. If passed a +start+ index and a +length+,
returns a substring containing +length+ characters starting at the
+index+. If passed a +range+, its beginning and end are interpreted as
offsets delimiting the substring to be returned.
In these three cases, if an index is negative, it is counted from the end
of the string. For the +start+ and +range+ cases the starting index
is just before a character and an index matching the string's size.
Additionally, an empty string is returned when the starting index for a
character range is at the end of the string.
Returns +nil+ if the initial index falls outside the string or the length
is negative.
If a +Regexp+ is supplied, the matching portion of the string is
returned. If a +capture+ follows the regular expression, which may be a
capture group index or name, follows the regular expression that component
of the MatchData is returned instead.
If a +match_str+ is given, that string is returned if it occurs in
the string.
Returns +nil+ if the regular expression does not match or the match string
cannot be found.
a = "hello there"
a[1] #=> "e"
a[2, 3] #=> "llo"
a[2..3] #=> "ll"
a[-3, 2] #=> "er"
a[7..-2] #=> "her"
a[-4..-2] #=> "her"
a[-2..-4] #=> ""
a[11, 0] #=> ""
a[11] #=> nil
a[12, 0] #=> nil
a[12..-1] #=> nil
a[/[aeiou](.)\1/] #=> "ell"
a[/[aeiou](.)\1/, 0] #=> "ell"
a[/[aeiou](.)\1/, 1] #=> "l"
a[/[aeiou](.)\1/, 2] #=> nil
a[/(?String#[]. If the replacement string is not the same length as
the text it is replacing, the string will be adjusted accordingly. If the
regular expression or string is used as the index doesn't match a position
in the string, IndexError is raised. If the regular expression
form is used, the optional second Fixnum allows you to specify
which portion of the match to replace (effectively using the
MatchData indexing rules. The forms that take a
Fixnum will raise an IndexError if the value is
out of range; the Range form will raise a
RangeError, and the Regexp and String
will raise an IndexError on negative match.
; T;[ o;7
;8I"
overload; F;90;;w;:0;;I"[]=(fixnum); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I" fixnum; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(fixnum, fixnum); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I" fixnum; T0[I" fixnum; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(range); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I"
range; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(regexp); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I" regexp; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(regexp, fixnum); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I" regexp; T0[I" fixnum; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(regexp, name); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I" regexp; T0[I" name; T0;@0o;7
;8I"
overload; F;90;;w;:0;;I"[]=(other_str); T;IC;" ; T;[ ;[ ;I" ; T;0;@0; F;=i ;>0;5[[I"other_str; T0;@0;[ ;I"AElement Assignment---Replaces some or all of the content of str. The
portion of the string affected is determined using the same criteria as
String#[]. If the replacement string is not the same length as
the text it is replacing, the string will be adjusted accordingly. If the
regular expression or string is used as the index doesn't match a position
in the string, IndexError is raised. If the regular expression
form is used, the optional second Fixnum allows you to specify
which portion of the match to replace (effectively using the
MatchData indexing rules. The forms that take a
Fixnum will raise an IndexError if the value is
out of range; the Range form will raise a
RangeError, and the Regexp and String
will raise an IndexError on negative match.
@overload []=(fixnum)
@overload []=(fixnum, fixnum)
@overload []=(range)
@overload []=(regexp)
@overload []=(regexp, fixnum)
@overload []=(regexp, name)
@overload []=(other_str); T;0;@0; F; o; ; T; i;!i
;"@-;;I"static VALUE; T;AI"nstatic VALUE
rb_str_aset_m(int argc, VALUE *argv, VALUE str)
{
if (argc == 3) {
if (RB_TYPE_P(argv[0], T_REGEXP)) {
rb_str_subpat_set(str, argv[0], argv[1], argv[2]);
}
else {
rb_str_splice(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]);
}
return argv[2];
}
rb_check_arity(argc, 2, 3);
return rb_str_aset(str, argv[0], argv[1]);
}; T;BTo;1;2F;3;4;;;#I"String#insert; F;5[[I"idx; T0[I" str2; T0; [[@*i/;
T;: insert;0;[ ;{ ;IC;"Inserts other_str before the character at the given
index, modifying str. Negative indices count from the
end of the string, and insert after the given character.
The intent is insert aString so that it starts at the given
index.
"abcd".insert(0, 'X') #=> "Xabcd"
"abcd".insert(3, 'X') #=> "abcXd"
"abcd".insert(4, 'X') #=> "abcdX"
"abcd".insert(-3, 'X') #=> "abXcd"
"abcd".insert(-1, 'X') #=> "abcdX"
; T;[o;7
;8I"
overload; F;90;;x;:0;;I" insert(index, other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@0;[ ;I"@return [String]; T;0;@0; F;=i ;>0;5[[I"
index; T0[I"other_str; T0;@0;[ ;I"Inserts other_str before the character at the given
index, modifying str. Negative indices count from the
end of the string, and insert after the given character.
The intent is insert aString so that it starts at the given
index.
"abcd".insert(0, 'X') #=> "Xabcd"
"abcd".insert(3, 'X') #=> "abcXd"
"abcd".insert(4, 'X') #=> "abcdX"
"abcd".insert(-3, 'X') #=> "abXcd"
"abcd".insert(-1, 'X') #=> "abcdX"
@overload insert(index, other_str)
@return [String]; T;0;@0; F; o; ; T; i ;!i,;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_insert(VALUE str, VALUE idx, VALUE str2)
{
long pos = NUM2LONG(idx);
if (pos == -1) {
return rb_str_append(str, str2);
}
else if (pos < 0) {
pos++;
}
rb_str_splice(str, pos, 0, str2);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#length; F;5[ ; [[@*i;
T;;e;0;[ ;{ ;IC;"0Returns the character length of str.
; T;[o;7
;8I"
overload; F;90;;e;:0;;I" length; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@1;[ ;I"@return [Integer]; T;0;@1; F;=i ;>0;5[ ;@1o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@1;[ ;I"@return [Integer]; T;0;@1; F;=i ;>0;5[ ;@1;[ ;I"zReturns the character length of str.
@overload length
@return [Integer]
@overload size
@return [Integer]; T;0;@1; F; o; ; T; i ;!i;"@-;;I"
VALUE; T;AI"}VALUE
rb_str_length(VALUE str)
{
long len;
len = str_strlen(str, STR_ENC_GET(str));
return LONG2NUM(len);
}; T;BTo;1;2F;3;4;;;#I"String#size; F;5[ ; [[@*i;
T;;G;0;[ ;{ ;IC;"0Returns the character length of str.
; T;[o;7
;8I"
overload; F;90;;e;:0;;I" length; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@91;[ ;I"@return [Integer]; T;0;@91; F;=i ;>0;5[ ;@91o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@91;[ ;I"@return [Integer]; T;0;@91; F;=i ;>0;5[ ;@91;[ ;@51;0;@91; F; o; ; T; i ;!i;"@-;;I"
VALUE; T;AI"}VALUE
rb_str_length(VALUE str)
{
long len;
len = str_strlen(str, STR_ENC_GET(str));
return LONG2NUM(len);
}; T;BTo;1;2F;3;4;;;#I"String#bytesize; F;5[ ; [[@*i$;
T;:
bytesize;0;[ ;{ ;IC;"iReturns the length of +str+ in bytes.
"\x80\u3042".bytesize #=> 4
"hello".bytesize #=> 5
; T;[o;7
;8I"
overload; F;90;;y;:0;;I"
bytesize; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@`1;[ ;I"@return [Integer]; T;0;@`1; F;=i ;>0;5[ ;@`1;[ ;I"Returns the length of +str+ in bytes.
"\x80\u3042".bytesize #=> 4
"hello".bytesize #=> 5
@overload bytesize
@return [Integer]; T;0;@`1; F; o; ; T; i;!i!;"@-;;I"static VALUE; T;AI"Wstatic VALUE
rb_str_bytesize(VALUE str)
{
return LONG2NUM(RSTRING_LEN(str));
}; T;BTo;1;2F;3;4;;;#I"String#empty?; F;5[ ; [[@*i5;
T;;f;0;[ ;{ ;IC;"Returns true if str has a length of zero.
"hello".empty? #=> false
" ".empty? #=> false
"".empty? #=> true
; T;[o;7
;8I"
overload; F;90;;f;:0;;I" empty?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@{1;[ ;I"@return [Boolean]; T;0;@{1; F;=i ;>0;5[ ;@{1o;<
;8I" return; F;9@f;0;:[@h;@{1;[ ;I"Returns true if str has a length of zero.
"hello".empty? #=> false
" ".empty? #=> false
"".empty? #=> true
@overload empty?
@return [Boolean]; T;0;@{1; F; o; ; T; i*;!i2;"@-;;I"static VALUE; T;AI"nstatic VALUE
rb_str_empty(VALUE str)
{
if (RSTRING_LEN(str) == 0)
return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"String#=~; F;5[[I"y; T0; [[@*i ;
T;;;0;[ ;{ ;IC;"FMatch---If obj is a Regexp, use it as a pattern to match
against str,and returns the position the match starts, or
nil if there is no match. Otherwise, invokes
obj.=~, passing str as an argument. The default
=~ in Object returns nil.
Note: str =~ regexp is not the same as
regexp =~ str. Strings captured from named capture groups
are assigned to local variables only in the second case.
"cat o' 9 tails" =~ /\d/ #=> 7
"cat o' 9 tails" =~ 9 #=> nil
; T;[o;7
;8I"
overload; F;90;;;:0;;I" =~(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@1;[ ;I"@return [Fixnum, nil]; T;0;@1; F;=i ;>0;5[[I"obj; T0;@1;[ ;I"rMatch---If obj is a Regexp, use it as a pattern to match
against str,and returns the position the match starts, or
nil if there is no match. Otherwise, invokes
obj.=~, passing str as an argument. The default
=~ in Object returns nil.
Note: str =~ regexp is not the same as
regexp =~ str. Strings captured from named capture groups
are assigned to local variables only in the second case.
"cat o' 9 tails" =~ /\d/ #=> 7
"cat o' 9 tails" =~ 9 #=> nil
@overload =~(obj)
@return [Fixnum, nil]; T;0;@1; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"Kstatic VALUE
rb_str_match(VALUE x, VALUE y)
{
if (SPECIAL_CONST_P(y)) goto generic;
switch (BUILTIN_TYPE(y)) {
case T_STRING:
rb_raise(rb_eTypeError, "type mismatch: String given");
case T_REGEXP:
return rb_reg_match(y, x);
generic:
default:
return rb_funcall(y, rb_intern("=~"), 1, x);
}
}; T;BTo;1;2F;3;4;;;#I"String#match; F;5[[@0; [[@*i ;
T;;c;0;[ ;{ ;IC;"Converts pattern to a Regexp (if it isn't already one),
then invokes its match method on str. If the second
parameter is present, it specifies the position in the string to begin the
search.
'hello'.match('(.)\1') #=> #Regexp (if it isn't already one),
then invokes its match method on str. If the second
parameter is present, it specifies the position in the string to begin the
search.
'hello'.match('(.)\1') #=> #String#succ, but modifies the receiver in
place.
; T;[o;7
;8I"
overload; F;90;;z;:0;;I"
succ!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@2;[ ;I"@return [String]; T;0;@2; F;=i ;>0;5[ ;@2o;7
;8I"
overload; F;90;:
next!;:0;;I"
next!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@2;[ ;I"@return [String]; T;0;@2; F;=i ;>0;5[ ;@2;[ ;I"Equivalent to String#succ, but modifies the receiver in
place.
@overload succ!
@return [String]
@overload next!
@return [String]; T;0;@2; F; o; ; T; i
;!i
;"@-;;I"static VALUE; T;AI"tstatic VALUE
rb_str_succ_bang(VALUE str)
{
rb_str_shared_replace(str, rb_str_succ(str));
return str;
}; T;BTo;1;2F;3;4;;;#I"String#next; F;5[ ; [[@*i ;
T;; ;0;[ ;{ ;IC;")Returns the successor to str. The successor is calculated by
incrementing characters starting from the rightmost alphanumeric (or
the rightmost character if there are no alphanumerics) in the
string. Incrementing a digit always results in another digit, and
incrementing a letter results in another letter of the same case.
Incrementing nonalphanumerics uses the underlying character set's
collating sequence.
If the increment generates a ``carry,'' the character to the left of
it is incremented. This process repeats until there is no carry,
adding an additional character if necessary.
"abcd".succ #=> "abce"
"THX1138".succ #=> "THX1139"
"<String#succ, but modifies the receiver in
place.
; T;[o;7
;8I"
overload; F;90;;z;:0;;I"
succ!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@a2;[ ;I"@return [String]; T;0;@a2; F;=i ;>0;5[ ;@a2o;7
;8I"
overload; F;90;;{;:0;;I"
next!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@a2;[ ;I"@return [String]; T;0;@a2; F;=i ;>0;5[ ;@a2;[ ;@62;0;@a2; F; o; ; T; i
;!i
;"@-;;I"static VALUE; T;AI"tstatic VALUE
rb_str_succ_bang(VALUE str)
{
rb_str_shared_replace(str, rb_str_succ(str));
return str;
}; T;BTo;1;2F;3;4;;;#I"String#upto; F;5[[@0; [[@*iH
;
T;;;0;[ ;{ ;IC;"Iterates through successive values, starting at str and
ending at other_str inclusive, passing each value in turn to
the block. The String#succ method is used to generate
each value. If optional second argument exclusive is omitted or is false,
the last value will be included; otherwise it will be excluded.
If no block is given, an enumerator is returned instead.
"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
print s, ' '
end
produces:
a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6
If str and other_str contains only ascii numeric characters,
both are recognized as decimal numbers. In addition, the width of
string (e.g. leading zeros) is handled appropriately.
"9".upto("11").to_a #=> ["9", "10", "11"]
"25".upto("5").to_a #=> []
"07".upto("11").to_a #=> ["07", "08", "09", "10", "11"]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"%upto(other_str, exclusive=false); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"s; T;@2o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@2;[ ;I" @yield [s]
@return [String]; T;0;@2; F;=i ;>0;5[[I"other_str; T0[I"exclusive; TI"
false; T;@2o;7
;8I"
overload; F;90;;;:0;;I"%upto(other_str, exclusive=false); T;IC;" ; T;[ ;[ ;I" ; T;0;@2; F;=i ;>0;5[[I"other_str; T0[I"exclusive; TI"
false; T;@2;[ ;I"Iterates through successive values, starting at str and
ending at other_str inclusive, passing each value in turn to
the block. The String#succ method is used to generate
each value. If optional second argument exclusive is omitted or is false,
the last value will be included; otherwise it will be excluded.
If no block is given, an enumerator is returned instead.
"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
print s, ' '
end
produces:
a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6
If str and other_str contains only ascii numeric characters,
both are recognized as decimal numbers. In addition, the width of
string (e.g. leading zeros) is handled appropriately.
"9".upto("11").to_a #=> ["9", "10", "11"]
"25".upto("5").to_a #=> []
"07".upto("11").to_a #=> ["07", "08", "09", "10", "11"]
@overload upto(other_str, exclusive=false)
@yield [s]
@return [String]
@overload upto(other_str, exclusive=false); T;0;@2; F; o; ; T; i(
;!iF
;"@-;;I"static VALUE; T;AI" static VALUE
rb_str_upto(int argc, VALUE *argv, VALUE beg)
{
VALUE end, exclusive;
VALUE current, after_end;
ID succ;
int n, excl, ascii;
rb_encoding *enc;
rb_scan_args(argc, argv, "11", &end, &exclusive);
RETURN_ENUMERATOR(beg, argc, argv);
excl = RTEST(exclusive);
CONST_ID(succ, "succ");
StringValue(end);
enc = rb_enc_check(beg, end);
ascii = (is_ascii_string(beg) && is_ascii_string(end));
/* single character */
if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1 && ascii) {
char c = RSTRING_PTR(beg)[0];
char e = RSTRING_PTR(end)[0];
if (c > e || (excl && c == e)) return beg;
for (;;) {
rb_yield(rb_enc_str_new(&c, 1, enc));
if (!excl && c == e) break;
c++;
if (excl && c == e) break;
}
return beg;
}
/* both edges are all digits */
if (ascii && ISDIGIT(RSTRING_PTR(beg)[0]) && ISDIGIT(RSTRING_PTR(end)[0])) {
char *s, *send;
VALUE b, e;
int width;
s = RSTRING_PTR(beg); send = RSTRING_END(beg);
width = rb_long2int(send - s);
while (s < send) {
if (!ISDIGIT(*s)) goto no_digits;
s++;
}
s = RSTRING_PTR(end); send = RSTRING_END(end);
while (s < send) {
if (!ISDIGIT(*s)) goto no_digits;
s++;
}
b = rb_str_to_inum(beg, 10, FALSE);
e = rb_str_to_inum(end, 10, FALSE);
if (FIXNUM_P(b) && FIXNUM_P(e)) {
long bi = FIX2LONG(b);
long ei = FIX2LONG(e);
rb_encoding *usascii = rb_usascii_encoding();
while (bi <= ei) {
if (excl && bi == ei) break;
rb_yield(rb_enc_sprintf(usascii, "%.*ld", width, bi));
bi++;
}
}
else {
ID op = excl ? '<' : rb_intern("<=");
VALUE args[2], fmt = rb_obj_freeze(rb_usascii_str_new_cstr("%.*d"));
args[0] = INT2FIX(width);
while (rb_funcall(b, op, 1, e)) {
args[1] = b;
rb_yield(rb_str_format(numberof(args), args, fmt));
b = rb_funcall(b, succ, 0, 0);
}
}
return beg;
}
/* normal case */
no_digits:
n = rb_str_cmp(beg, end);
if (n > 0 || (excl && n == 0)) return beg;
after_end = rb_funcall(end, succ, 0, 0);
current = rb_str_dup(beg);
while (!rb_str_equal(current, after_end)) {
VALUE next = Qnil;
if (excl || !rb_str_equal(current, end))
next = rb_funcall(current, succ, 0, 0);
rb_yield(current);
if (NIL_P(next)) break;
current = next;
StringValue(current);
if (excl && rb_str_equal(current, end)) break;
if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0)
break;
}
return beg;
}; T;BTo;1;2F;3;4;;;#I"String#index; F;5[[@0; [[@*i
;
T;:
index;0;[ ;{ ;IC;"Returns the index of the first occurrence of the given substring or
pattern (regexp) in str. Returns nil if not
found. If the second parameter is present, it specifies the position in the
string to begin the search.
"hello".index('e') #=> 1
"hello".index('lo') #=> 3
"hello".index('a') #=> nil
"hello".index(?e) #=> 1
"hello".index(/[aeiou]/, -3) #=> 4
; T;[o;7
;8I"
overload; F;90;;|;:0;;I" index(substring [, offset]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@2;[ ;I"@return [Fixnum, nil]; T;0;@2; F;=i ;>0;5[[I"substring[, offset]; T0;@2o;7
;8I"
overload; F;90;;|;:0;;I" index(regexp [, offset]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@2;[ ;I"@return [Fixnum, nil]; T;0;@2; F;=i ;>0;5[[I"regexp[, offset]; T0;@2;[ ;I"?Returns the index of the first occurrence of the given substring or
pattern (regexp) in str. Returns nil if not
found. If the second parameter is present, it specifies the position in the
string to begin the search.
"hello".index('e') #=> 1
"hello".index('lo') #=> 3
"hello".index('a') #=> nil
"hello".index(?e) #=> 1
"hello".index(/[aeiou]/, -3) #=> 4
@overload index(substring [, offset])
@return [Fixnum, nil]
@overload index(regexp [, offset])
@return [Fixnum, nil]; T;0;@2; F; o; ; T; i
;!i
;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_index_m(int argc, VALUE *argv, VALUE str)
{
VALUE sub;
VALUE initpos;
long pos;
if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) {
pos = NUM2LONG(initpos);
}
else {
pos = 0;
}
if (pos < 0) {
pos += str_strlen(str, STR_ENC_GET(str));
if (pos < 0) {
if (RB_TYPE_P(sub, T_REGEXP)) {
rb_backref_set(Qnil);
}
return Qnil;
}
}
if (SPECIAL_CONST_P(sub)) goto generic;
switch (BUILTIN_TYPE(sub)) {
case T_REGEXP:
if (pos > str_strlen(str, STR_ENC_GET(str)))
return Qnil;
pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
rb_enc_check(str, sub), single_byte_optimizable(str));
pos = rb_reg_search(sub, str, pos, 0);
pos = rb_str_sublen(str, pos);
break;
generic:
default: {
VALUE tmp;
tmp = rb_check_string_type(sub);
if (NIL_P(tmp)) {
rb_raise(rb_eTypeError, "type mismatch: %s given",
rb_obj_classname(sub));
}
sub = tmp;
}
/* fall through */
case T_STRING:
pos = rb_str_index(str, sub, pos);
pos = rb_str_sublen(str, pos);
break;
}
if (pos == -1) return Qnil;
return LONG2NUM(pos);
}; T;BTo;1;2F;3;4;;;#I"String#rindex; F;5[[@0; [[@*i_ ;
T;: rindex;0;[ ;{ ;IC;"Returns the index of the last occurrence of the given substring or
pattern (regexp) in str. Returns nil if not
found. If the second parameter is present, it specifies the position in the
string to end the search---characters beyond this point will not be
considered.
"hello".rindex('e') #=> 1
"hello".rindex('l') #=> 3
"hello".rindex('a') #=> nil
"hello".rindex(?e) #=> 1
"hello".rindex(/[aeiou]/, -2) #=> 1
; T;[o;7
;8I"
overload; F;90;;};:0;;I"!rindex(substring [, fixnum]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@2;[ ;I"@return [Fixnum, nil]; T;0;@2; F;=i ;>0;5[[I"substring[, fixnum]; T0;@2o;7
;8I"
overload; F;90;;};:0;;I" rindex(regexp [, fixnum]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@2;[ ;I"@return [Fixnum, nil]; T;0;@2; F;=i ;>0;5[[I"regexp[, fixnum]; T0;@2;[ ;I"yReturns the index of the last occurrence of the given substring or
pattern (regexp) in str. Returns nil if not
found. If the second parameter is present, it specifies the position in the
string to end the search---characters beyond this point will not be
considered.
"hello".rindex('e') #=> 1
"hello".rindex('l') #=> 3
"hello".rindex('a') #=> nil
"hello".rindex(?e) #=> 1
"hello".rindex(/[aeiou]/, -2) #=> 1
@overload rindex(substring [, fixnum])
@return [Fixnum, nil]
@overload rindex(regexp [, fixnum])
@return [Fixnum, nil]; T;0;@2; F; o; ; T; iM ;!i] ;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
{
VALUE sub;
VALUE vpos;
rb_encoding *enc = STR_ENC_GET(str);
long pos, len = str_strlen(str, enc);
if (rb_scan_args(argc, argv, "11", &sub, &vpos) == 2) {
pos = NUM2LONG(vpos);
if (pos < 0) {
pos += len;
if (pos < 0) {
if (RB_TYPE_P(sub, T_REGEXP)) {
rb_backref_set(Qnil);
}
return Qnil;
}
}
if (pos > len) pos = len;
}
else {
pos = len;
}
if (SPECIAL_CONST_P(sub)) goto generic;
switch (BUILTIN_TYPE(sub)) {
case T_REGEXP:
/* enc = rb_get_check(str, sub); */
pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
STR_ENC_GET(str), single_byte_optimizable(str));
if (!RREGEXP(sub)->ptr || RREGEXP_SRC_LEN(sub)) {
pos = rb_reg_search(sub, str, pos, 1);
pos = rb_str_sublen(str, pos);
}
if (pos >= 0) return LONG2NUM(pos);
break;
generic:
default: {
VALUE tmp;
tmp = rb_check_string_type(sub);
if (NIL_P(tmp)) {
rb_raise(rb_eTypeError, "type mismatch: %s given",
rb_obj_classname(sub));
}
sub = tmp;
}
/* fall through */
case T_STRING:
pos = rb_str_rindex(str, sub, pos);
if (pos >= 0) return LONG2NUM(pos);
break;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#replace; F;5[[I" str2; T0; [[@*i;
T;;v;0;[ ;{ ;IC;"Replaces the contents and taintedness of str with the corresponding
values in other_str.
s = "hello" #=> "hello"
s.replace "world" #=> "world"
; T;[o;7
;8I"
overload; F;90;;v;:0;;I"replace(other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@3;[ ;I"@return [String]; T;0;@3; F;=i ;>0;5[[I"other_str; T0;@3;[ ;@.;0;@3; F; o; ; T; i;!i;"@-;;I"
VALUE; T;AI"VALUE
rb_str_replace(VALUE str, VALUE str2)
{
str_modifiable(str);
if (str == str2) return str;
StringValue(str2);
str_discard(str);
return str_replace(str, str2);
}; T;BTo;1;2F;3;4;;;#I"String#clear; F;5[ ; [[@*i;
T;:
clear;0;[ ;{ ;IC;"=Makes string empty.
a = "abcde"
a.clear #=> ""
; T;[o;7
;8I"
overload; F;90;;~;:0;;I"
clear; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@73;[ ;I"@return [String]; T;0;@73; F;=i ;>0;5[ ;@73;[ ;I"bMakes string empty.
a = "abcde"
a.clear #=> ""
@overload clear
@return [String]; T;0;@73; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"4static VALUE
rb_str_clear(VALUE str)
{
str_discard(str);
STR_SET_EMBED(str);
STR_SET_EMBED_LEN(str, 0);
RSTRING_PTR(str)[0] = 0;
if (rb_enc_asciicompat(STR_ENC_GET(str)))
ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);
else
ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#chr; F;5[ ; [[@*i;
T;; ;0;[ ;{ ;IC;"gReturns a one-character string at the beginning of the string.
a = "abcde"
a.chr #=> "a"
; T;[o;7
;8I"
overload; F;90;; ;:0;;I"chr; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@R3;[ ;I"@return [String]; T;0;@R3; F;=i ;>0;5[ ;@R3;[ ;I"Returns a one-character string at the beginning of the string.
a = "abcde"
a.chr #=> "a"
@overload chr
@return [String]; T;0;@R3; F; o; ; T; i;!i ;"@-;;I"static VALUE; T;AI"Pstatic VALUE
rb_str_chr(VALUE str)
{
return rb_str_substr(str, 0, 1);
}; T;BTo;1;2F;3;4;;;#I"String#getbyte; F;5[[I"
index; T0; [[@*i;
T;: getbyte;0;[ ;{ ;IC;"3returns the indexth byte as an integer.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"getbyte(index); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
0 .. 255; T;@m3;[ ;I"@return [0 .. 255]; T;0;@m3; F;=i ;>0;5[[I"
index; T0;@m3;[ ;I"creturns the indexth byte as an integer.
@overload getbyte(index)
@return [0 .. 255]; T;0;@m3; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_getbyte(VALUE str, VALUE index)
{
long pos = NUM2LONG(index);
if (pos < 0)
pos += RSTRING_LEN(str);
if (pos < 0 || RSTRING_LEN(str) <= pos)
return Qnil;
return INT2FIX((unsigned char)RSTRING_PTR(str)[pos]);
}; T;BTo;1;2F;3;4;;;#I"String#setbyte; F;5[[I"
index; T0[I"
value; T0; [[@*i-;
T;: setbyte;0;[ ;{ ;IC;"8modifies the indexth byte as integer.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" setbyte(index, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@3;[ ;I"@return [Integer]; T;0;@3; F;=i ;>0;5[[I"
index; T0[I" integer; T0;@3;[ ;I"pmodifies the indexth byte as integer.
@overload setbyte(index, integer)
@return [Integer]; T;0;@3; F; o; ; T; i';!i+;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_setbyte(VALUE str, VALUE index, VALUE value)
{
long pos = NUM2LONG(index);
int byte = NUM2INT(value);
rb_str_modify(str);
if (pos < -RSTRING_LEN(str) || RSTRING_LEN(str) <= pos)
rb_raise(rb_eIndexError, "index %ld out of string", pos);
if (pos < 0)
pos += RSTRING_LEN(str);
RSTRING_PTR(str)[pos] = byte;
return value;
}; T;BTo;1;2F;3;4;;;#I"String#byteslice; F;5[[@0; [[@*i;
T;:byteslice;0;[ ;{ ;IC;"VByte Reference---If passed a single Fixnum, returns a
substring of one byte at that position. If passed two Fixnum
objects, returns a substring starting at the offset given by the first, and
a length given by the second. If given a Range, a substring containing
bytes at offsets given by the range is returned. In all three cases, if
an offset is negative, it is counted from the end of str. Returns
nil if the initial offset falls outside the string, the length
is negative, or the beginning of the range is greater than the end.
The encoding of the resulted string keeps original encoding.
"hello".byteslice(1) #=> "e"
"hello".byteslice(-1) #=> "o"
"hello".byteslice(1, 2) #=> "el"
"\x80\u3042".byteslice(1, 3) #=> "\u3042"
"\x03\u3042\xff".byteslice(1..3) #=> "\u3042"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"byteslice(fixnum); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@3;[ ;I"@return [String, nil]; T;0;@3; F;=i ;>0;5[[I" fixnum; T0;@3o;7
;8I"
overload; F;90;;;:0;;I" byteslice(fixnum, fixnum); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@3;[ ;I"@return [String, nil]; T;0;@3; F;=i ;>0;5[[I" fixnum; T0[I" fixnum; T0;@3o;7
;8I"
overload; F;90;;;:0;;I"byteslice(range); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@3;[ ;I"@return [String, nil]; T;0;@3; F;=i ;>0;5[[I"
range; T0;@3;[ ;I"Byte Reference---If passed a single Fixnum, returns a
substring of one byte at that position. If passed two Fixnum
objects, returns a substring starting at the offset given by the first, and
a length given by the second. If given a Range, a substring containing
bytes at offsets given by the range is returned. In all three cases, if
an offset is negative, it is counted from the end of str. Returns
nil if the initial offset falls outside the string, the length
is negative, or the beginning of the range is greater than the end.
The encoding of the resulted string keeps original encoding.
"hello".byteslice(1) #=> "e"
"hello".byteslice(-1) #=> "o"
"hello".byteslice(1, 2) #=> "el"
"\x80\u3042".byteslice(1, 3) #=> "\u3042"
"\x03\u3042\xff".byteslice(1..3) #=> "\u3042"
@overload byteslice(fixnum)
@return [String, nil]
@overload byteslice(fixnum, fixnum)
@return [String, nil]
@overload byteslice(range)
@return [String, nil]; T;0;@3; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_byteslice(int argc, VALUE *argv, VALUE str)
{
if (argc == 2) {
return str_byte_substr(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]));
}
rb_check_arity(argc, 1, 2);
return str_byte_aref(str, argv[0]);
}; T;BTo;1;2F;3;4;;;#I"String#scrub; F;5[[@0; [[@*ia ;
T;:
scrub;0;[ ;{ ;IC;"{If the string is invalid byte sequence then replace invalid bytes with given replacement
character, else returns self.
If block is given, replace invalid bytes with returned value of the block.
"abc\u3042\x81".scrub #=> "abc\u3042\uFFFD"
"abc\u3042\x81".scrub("*") #=> "abc\u3042*"
"abc\u3042\xE3\x80".scrub{|bytes| '<'+bytes.unpack('H*')[0]+'>' } #=> "abc\u30420 is returned. This method never raises an
exception when base is valid.
"12345".to_i #=> 12345
"99 red balloons".to_i #=> 99
"0a".to_i #=> 0
"0a".to_i(16) #=> 10
"hello".to_i #=> 0
"1100101".to_i(2) #=> 101
"1100101".to_i(8) #=> 294977
"1100101".to_i(10) #=> 1100101
"1100101".to_i(16) #=> 17826049
; T;[o;7
;8I"
overload; F;90;;\;:0;;I"to_i(base=10); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@s4;[ ;I"@return [Integer]; T;0;@s4; F;=i ;>0;5[[I" base; TI"10; T;@s4;[ ;I"Returns the result of interpreting leading characters in str as an
integer base base (between 2 and 36). Extraneous characters past the
end of a valid number are ignored. If there is not a valid number at the
start of str, 0 is returned. This method never raises an
exception when base is valid.
"12345".to_i #=> 12345
"99 red balloons".to_i #=> 99
"0a".to_i #=> 0
"0a".to_i(16) #=> 10
"hello".to_i #=> 0
"1100101".to_i(2) #=> 101
"1100101".to_i(8) #=> 294977
"1100101".to_i(10) #=> 1100101
"1100101".to_i(16) #=> 17826049
@overload to_i(base=10)
@return [Integer]; T;0;@s4; F; o; ; T; i1;!iC;"@-;;I"static VALUE; T;AI":static VALUE
rb_str_to_i(int argc, VALUE *argv, VALUE str)
{
int base;
if (argc == 0) base = 10;
else {
VALUE b;
rb_scan_args(argc, argv, "01", &b);
base = NUM2INT(b);
}
if (base < 0) {
rb_raise(rb_eArgError, "invalid radix %d", base);
}
return rb_str_to_inum(str, base, FALSE);
}; T;BTo;1;2F;3;4;;;#I"String#to_f; F;5[ ; [[@*ig;
T;;X;0;[ ;{ ;IC;"Returns the result of interpreting leading characters in str as a
floating point number. Extraneous characters past the end of a valid number
are ignored. If there is not a valid number at the start of str,
0.0 is returned. This method never raises an exception.
"123.45e1".to_f #=> 1234.5
"45.67 degrees".to_f #=> 45.67
"thx1138".to_f #=> 0.0
; T;[o;7
;8I"
overload; F;90;;X;:0;;I" to_f; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@4;[ ;I"@return [Float]; T;0;@4; F;=i ;>0;5[ ;@4;[ ;I"Returns the result of interpreting leading characters in str as a
floating point number. Extraneous characters past the end of a valid number
are ignored. If there is not a valid number at the start of str,
0.0 is returned. This method never raises an exception.
"123.45e1".to_f #=> 1234.5
"45.67 degrees".to_f #=> 45.67
"thx1138".to_f #=> 0.0
@overload to_f
@return [Float]; T;0;@4; F; o; ; T; iY;!id;"@-;;I"static VALUE; T;AI"[static VALUE
rb_str_to_f(VALUE str)
{
return DBL2NUM(rb_str_to_dbl(str, FALSE));
}; T;BTo;1;2F;3;4;;;#I"String#to_s; F;5[ ; [[@*iv;
T;;6;0;[ ;{ ;IC;"Returns the receiver.
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4o;7
;8I"
overload; F;90;: to_str;:0;;I" to_str; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4;[ ;I"bReturns the receiver.
@overload to_s
@return [String]
@overload to_str
@return [String]; T;0;@4; F; o; ; T; in;!it;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_to_s(VALUE str)
{
if (rb_obj_class(str) != rb_cString) {
return str_duplicate(rb_cString, str);
}
return str;
}; T;BTo;1;2F;3;4;;;#I"String#to_str; F;5[ ; [[@*iv;
T;;;0;[ ;{ ;IC;"Returns the receiver.
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4o;7
;8I"
overload; F;90;;;:0;;I" to_str; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4;[ ;@4;0;@4; F; o; ; T; in;!it;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_to_s(VALUE str)
{
if (rb_obj_class(str) != rb_cString) {
return str_duplicate(rb_cString, str);
}
return str;
}; T;BTo;1;2F;3;4;;;#I"String#inspect; F;5[ ; [[@*i;
T;;?;0;[ ;{ ;IC;"Returns a printable version of _str_, surrounded by quote marks,
with special characters escaped.
str = "hello"
str[3] = "\b"
str.inspect #=> "\"hel\\bo\""
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4;[ ;I"Returns a printable version of _str_, surrounded by quote marks,
with special characters escaped.
str = "hello"
str[3] = "\b"
str.inspect #=> "\"hel\\bo\""
@overload inspect
@return [String]; T;0;@4; F; o; ; T; i;!i;"@-;;I"
VALUE; T;AI"
VALUE
rb_str_inspect(VALUE str)
{
int encidx = ENCODING_GET(str);
rb_encoding *enc = rb_enc_from_index(encidx), *actenc;
const char *p, *pend, *prev;
char buf[CHAR_ESC_LEN + 1];
VALUE result = rb_str_buf_new(0);
rb_encoding *resenc = rb_default_internal_encoding();
int unicode_p = rb_enc_unicode_p(enc);
int asciicompat = rb_enc_asciicompat(enc);
if (resenc == NULL) resenc = rb_default_external_encoding();
if (!rb_enc_asciicompat(resenc)) resenc = rb_usascii_encoding();
rb_enc_associate(result, resenc);
str_buf_cat2(result, "\"");
p = RSTRING_PTR(str); pend = RSTRING_END(str);
prev = p;
actenc = get_actual_encoding(encidx, str);
if (actenc != enc) {
enc = actenc;
if (unicode_p) unicode_p = rb_enc_unicode_p(enc);
}
while (p < pend) {
unsigned int c, cc;
int n;
n = rb_enc_precise_mbclen(p, pend, enc);
if (!MBCLEN_CHARFOUND_P(n)) {
if (p > prev) str_buf_cat(result, prev, p - prev);
n = rb_enc_mbminlen(enc);
if (pend < p + n)
n = (int)(pend - p);
while (n--) {
snprintf(buf, CHAR_ESC_LEN, "\\x%02X", *p & 0377);
str_buf_cat(result, buf, strlen(buf));
prev = ++p;
}
continue;
}
n = MBCLEN_CHARFOUND_LEN(n);
c = rb_enc_mbc_to_codepoint(p, pend, enc);
p += n;
if ((asciicompat || unicode_p) &&
(c == '"'|| c == '\\' ||
(c == '#' &&
p < pend &&
MBCLEN_CHARFOUND_P(rb_enc_precise_mbclen(p,pend,enc)) &&
(cc = rb_enc_codepoint(p,pend,enc),
(cc == '$' || cc == '@' || cc == '{'))))) {
if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
str_buf_cat2(result, "\\");
if (asciicompat || enc == resenc) {
prev = p - n;
continue;
}
}
switch (c) {
case '\n': cc = 'n'; break;
case '\r': cc = 'r'; break;
case '\t': cc = 't'; break;
case '\f': cc = 'f'; break;
case '\013': cc = 'v'; break;
case '\010': cc = 'b'; break;
case '\007': cc = 'a'; break;
case 033: cc = 'e'; break;
default: cc = 0; break;
}
if (cc) {
if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
buf[0] = '\\';
buf[1] = (char)cc;
str_buf_cat(result, buf, 2);
prev = p;
continue;
}
if ((enc == resenc && rb_enc_isprint(c, enc)) ||
(asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c))) {
continue;
}
else {
if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
rb_str_buf_cat_escaped_char(result, c, unicode_p);
prev = p;
continue;
}
}
if (p > prev) str_buf_cat(result, prev, p - prev);
str_buf_cat2(result, "\"");
OBJ_INFECT_RAW(result, str);
return result;
}; T;BTo;1;2F;3;4;;;#I"String#dump; F;5[ ; [[@*i%;
T;: dump;0;[ ;{ ;IC;"Produces a version of +str+ with all non-printing characters replaced by
\nnn notation and all special characters escaped.
"hello \n ''".dump #=> "\"hello \\n ''\"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" dump; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@5;[ ;I"@return [String]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"Produces a version of +str+ with all non-printing characters replaced by
\nnn notation and all special characters escaped.
"hello \n ''".dump #=> "\"hello \\n ''\"
@overload dump
@return [String]; T;0;@5; F; o; ; T; i;!i";"@-;;I"
VALUE; T;AI"U
VALUE
rb_str_dump(VALUE str)
{
rb_encoding *enc = rb_enc_get(str);
long len;
const char *p, *pend;
char *q, *qend;
VALUE result;
int u8 = (enc == rb_utf8_encoding());
len = 2; /* "" */
p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
while (p < pend) {
unsigned char c = *p++;
switch (c) {
case '"': case '\\':
case '\n': case '\r':
case '\t': case '\f':
case '\013': case '\010': case '\007': case '\033':
len += 2;
break;
case '#':
len += IS_EVSTR(p, pend) ? 2 : 1;
break;
default:
if (ISPRINT(c)) {
len++;
}
else {
if (u8 && c > 0x7F) { /* \u{NN} */
int n = rb_enc_precise_mbclen(p-1, pend, enc);
if (MBCLEN_CHARFOUND_P(n)) {
unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
while (cc >>= 4) len++;
len += 5;
p += MBCLEN_CHARFOUND_LEN(n)-1;
break;
}
}
len += 4; /* \xNN */
}
break;
}
}
if (!rb_enc_asciicompat(enc)) {
len += 19; /* ".force_encoding('')" */
len += strlen(enc->name);
}
result = rb_str_new5(str, 0, len);
p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
q = RSTRING_PTR(result); qend = q + len + 1;
*q++ = '"';
while (p < pend) {
unsigned char c = *p++;
if (c == '"' || c == '\\') {
*q++ = '\\';
*q++ = c;
}
else if (c == '#') {
if (IS_EVSTR(p, pend)) *q++ = '\\';
*q++ = '#';
}
else if (c == '\n') {
*q++ = '\\';
*q++ = 'n';
}
else if (c == '\r') {
*q++ = '\\';
*q++ = 'r';
}
else if (c == '\t') {
*q++ = '\\';
*q++ = 't';
}
else if (c == '\f') {
*q++ = '\\';
*q++ = 'f';
}
else if (c == '\013') {
*q++ = '\\';
*q++ = 'v';
}
else if (c == '\010') {
*q++ = '\\';
*q++ = 'b';
}
else if (c == '\007') {
*q++ = '\\';
*q++ = 'a';
}
else if (c == '\033') {
*q++ = '\\';
*q++ = 'e';
}
else if (ISPRINT(c)) {
*q++ = c;
}
else {
*q++ = '\\';
if (u8) {
int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1;
if (MBCLEN_CHARFOUND_P(n)) {
int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
p += n;
snprintf(q, qend-q, "u{%x}", cc);
q += strlen(q);
continue;
}
}
snprintf(q, qend-q, "x%02X", c);
q += 3;
}
}
*q++ = '"';
*q = '\0';
if (!rb_enc_asciicompat(enc)) {
snprintf(q, qend-q, ".force_encoding(\"%s\")", enc->name);
enc = rb_ascii8bit_encoding();
}
OBJ_INFECT_RAW(result, str);
/* result from dump is ASCII */
rb_enc_associate(result, enc);
ENC_CODERANGE_SET(result, ENC_CODERANGE_7BIT);
return result;
}; T;BTo;1;2F;3;4;;;#I"String#upcase; F;5[ ; [[@*i;
T;;g;0;[ ;{ ;IC;"Returns a copy of str with all lowercase letters replaced with their
uppercase counterparts. The operation is locale insensitive---only
characters ``a'' to ``z'' are affected.
Note: case replacement is effective only in ASCII region.
"hEllO".upcase #=> "HELLO"
; T;[o;7
;8I"
overload; F;90;;g;:0;;I" upcase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@25;[ ;I"@return [String]; T;0;@25; F;=i ;>0;5[ ;@25;[ ;I"7Returns a copy of str with all lowercase letters replaced with their
uppercase counterparts. The operation is locale insensitive---only
characters ``a'' to ``z'' are affected.
Note: case replacement is effective only in ASCII region.
"hEllO".upcase #=> "HELLO"
@overload upcase
@return [String]; T;0;@25; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"vstatic VALUE
rb_str_upcase(VALUE str)
{
str = rb_str_dup(str);
rb_str_upcase_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#downcase; F;5[ ; [[@*iO;
T;;h;0;[ ;{ ;IC;"Returns a copy of str with all uppercase letters replaced with their
lowercase counterparts. The operation is locale insensitive---only
characters ``A'' to ``Z'' are affected.
Note: case replacement is effective only in ASCII region.
"hEllO".downcase #=> "hello"
; T;[o;7
;8I"
overload; F;90;;h;:0;;I"
downcase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@M5;[ ;I"@return [String]; T;0;@M5; F;=i ;>0;5[ ;@M5;[ ;I";Returns a copy of str with all uppercase letters replaced with their
lowercase counterparts. The operation is locale insensitive---only
characters ``A'' to ``Z'' are affected.
Note: case replacement is effective only in ASCII region.
"hEllO".downcase #=> "hello"
@overload downcase
@return [String]; T;0;@M5; F; o; ; T; iC;!iL;"@-;;I"static VALUE; T;AI"zstatic VALUE
rb_str_downcase(VALUE str)
{
str = rb_str_dup(str);
rb_str_downcase_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#capitalize; F;5[ ; [[@*i;
T;;i;0;[ ;{ ;IC;"Returns a copy of str with the first character converted to uppercase
and the remainder to lowercase.
Note: case conversion is effective only in ASCII region.
"hello".capitalize #=> "Hello"
"HELLO".capitalize #=> "Hello"
"123ABC".capitalize #=> "123abc"
; T;[o;7
;8I"
overload; F;90;;i;:0;;I"capitalize; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@h5;[ ;I"@return [String]; T;0;@h5; F;=i ;>0;5[ ;@h5;[ ;I"@Returns a copy of str with the first character converted to uppercase
and the remainder to lowercase.
Note: case conversion is effective only in ASCII region.
"hello".capitalize #=> "Hello"
"HELLO".capitalize #=> "Hello"
"123ABC".capitalize #=> "123abc"
@overload capitalize
@return [String]; T;0;@h5; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"~static VALUE
rb_str_capitalize(VALUE str)
{
str = rb_str_dup(str);
rb_str_capitalize_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#swapcase; F;5[ ; [[@*i;
T;;j;0;[ ;{ ;IC;" Returns a copy of str with uppercase alphabetic characters converted
to lowercase and lowercase characters converted to uppercase.
Note: case conversion is effective only in ASCII region.
"Hello".swapcase #=> "hELLO"
"cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11"
; T;[o;7
;8I"
overload; F;90;;j;:0;;I"
swapcase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@5;[ ;I"@return [String]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"DReturns a copy of str with uppercase alphabetic characters converted
to lowercase and lowercase characters converted to uppercase.
Note: case conversion is effective only in ASCII region.
"Hello".swapcase #=> "hELLO"
"cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11"
@overload swapcase
@return [String]; T;0;@5; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"zstatic VALUE
rb_str_swapcase(VALUE str)
{
str = rb_str_dup(str);
rb_str_swapcase_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#upcase!; F;5[ ; [[@*i;
T;: upcase!;0;[ ;{ ;IC;"Upcases the contents of str, returning nil if no changes
were made.
Note: case replacement is effective only in ASCII region.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" upcase!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@5;[ ;I"@return [String, nil]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"Upcases the contents of str, returning nil if no changes
were made.
Note: case replacement is effective only in ASCII region.
@overload upcase!
@return [String, nil]; T;0;@5; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"!static VALUE
rb_str_upcase_bang(VALUE str)
{
rb_encoding *enc;
char *s, *send;
int modify = 0;
int n;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
rb_str_check_dummy_enc(enc);
s = RSTRING_PTR(str); send = RSTRING_END(str);
if (single_byte_optimizable(str)) {
while (s < send) {
unsigned int c = *(unsigned char*)s;
if (rb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') {
*s = 'A' + (c - 'a');
modify = 1;
}
s++;
}
}
else {
int ascompat = rb_enc_asciicompat(enc);
while (s < send) {
unsigned int c;
if (ascompat && (c = *(unsigned char*)s) < 0x80) {
if (rb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') {
*s = 'A' + (c - 'a');
modify = 1;
}
s++;
}
else {
c = rb_enc_codepoint_len(s, send, &n, enc);
if (rb_enc_islower(c, enc)) {
/* assuming toupper returns codepoint with same size */
rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc);
modify = 1;
}
s += n;
}
}
}
if (modify) return str;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#downcase!; F;5[ ; [[@*i;
T;:downcase!;0;[ ;{ ;IC;"Downcases the contents of str, returning nil if no
changes were made.
Note: case replacement is effective only in ASCII region.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"downcase!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@5;[ ;I"@return [String, nil]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"Downcases the contents of str, returning nil if no
changes were made.
Note: case replacement is effective only in ASCII region.
@overload downcase!
@return [String, nil]; T;0;@5; F; o; ; T; i;!i ;"@-;;I"static VALUE; T;AI"$static VALUE
rb_str_downcase_bang(VALUE str)
{
rb_encoding *enc;
char *s, *send;
int modify = 0;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
rb_str_check_dummy_enc(enc);
s = RSTRING_PTR(str); send = RSTRING_END(str);
if (single_byte_optimizable(str)) {
while (s < send) {
unsigned int c = *(unsigned char*)s;
if (rb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') {
*s = 'a' + (c - 'A');
modify = 1;
}
s++;
}
}
else {
int ascompat = rb_enc_asciicompat(enc);
while (s < send) {
unsigned int c;
int n;
if (ascompat && (c = *(unsigned char*)s) < 0x80) {
if (rb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') {
*s = 'a' + (c - 'A');
modify = 1;
}
s++;
}
else {
c = rb_enc_codepoint_len(s, send, &n, enc);
if (rb_enc_isupper(c, enc)) {
/* assuming toupper returns codepoint with same size */
rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc);
modify = 1;
}
s += n;
}
}
}
if (modify) return str;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#capitalize!; F;5[ ; [[@*if;
T;:capitalize!;0;[ ;{ ;IC;"5Modifies str by converting the first character to uppercase and the
remainder to lowercase. Returns nil if no changes are made.
Note: case conversion is effective only in ASCII region.
a = "hello"
a.capitalize! #=> "Hello"
a #=> "Hello"
a.capitalize! #=> nil
; T;[o;7
;8I"
overload; F;90;;;:0;;I"capitalize!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@5;[ ;I"@return [String, nil]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"eModifies str by converting the first character to uppercase and the
remainder to lowercase. Returns nil if no changes are made.
Note: case conversion is effective only in ASCII region.
a = "hello"
a.capitalize! #=> "Hello"
a #=> "Hello"
a.capitalize! #=> nil
@overload capitalize!
@return [String, nil]; T;0;@5; F; o; ; T; iX;!ic;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_capitalize_bang(VALUE str)
{
rb_encoding *enc;
char *s, *send;
int modify = 0;
unsigned int c;
int n;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
rb_str_check_dummy_enc(enc);
if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
s = RSTRING_PTR(str); send = RSTRING_END(str);
c = rb_enc_codepoint_len(s, send, &n, enc);
if (rb_enc_islower(c, enc)) {
rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc);
modify = 1;
}
s += n;
while (s < send) {
c = rb_enc_codepoint_len(s, send, &n, enc);
if (rb_enc_isupper(c, enc)) {
rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc);
modify = 1;
}
s += n;
}
if (modify) return str;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#swapcase!; F;5[ ; [[@*i;
T;:swapcase!;0;[ ;{ ;IC;"Equivalent to String#swapcase, but modifies the receiver in
place, returning str, or nil if no changes were made.
Note: case conversion is effective only in ASCII region.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"swapcase!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@5;[ ;I"@return [String, nil]; T;0;@5; F;=i ;>0;5[ ;@5;[ ;I"Equivalent to String#swapcase, but modifies the receiver in
place, returning str, or nil if no changes were made.
Note: case conversion is effective only in ASCII region.
@overload swapcase!
@return [String, nil]; T;0;@5; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_swapcase_bang(VALUE str)
{
rb_encoding *enc;
char *s, *send;
int modify = 0;
int n;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
rb_str_check_dummy_enc(enc);
s = RSTRING_PTR(str); send = RSTRING_END(str);
while (s < send) {
unsigned int c = rb_enc_codepoint_len(s, send, &n, enc);
if (rb_enc_isupper(c, enc)) {
/* assuming toupper returns codepoint with same size */
rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc);
modify = 1;
}
else if (rb_enc_islower(c, enc)) {
/* assuming tolower returns codepoint with same size */
rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc);
modify = 1;
}
s += n;
}
if (modify) return str;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#hex; F;5[ ; [[@*i ;
T;:hex;0;[ ;{ ;IC;"*Treats leading characters from str as a string of hexadecimal digits
(with an optional sign and an optional 0x) and returns the
corresponding number. Zero is returned on error.
"0x0a".hex #=> 10
"-1234".hex #=> -4660
"0".hex #=> 0
"wombat".hex #=> 0
; T;[o;7
;8I"
overload; F;90;;;:0;;I"hex; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@6;[ ;I"@return [Integer]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"NTreats leading characters from str as a string of hexadecimal digits
(with an optional sign and an optional 0x) and returns the
corresponding number. Zero is returned on error.
"0x0a".hex #=> 10
"-1234".hex #=> -4660
"0".hex #=> 0
"wombat".hex #=> 0
@overload hex
@return [Integer]; T;0;@6; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"Vstatic VALUE
rb_str_hex(VALUE str)
{
return rb_str_to_inum(str, 16, FALSE);
}; T;BTo;1;2F;3;4;;;#I"String#oct; F;5[ ; [[@*i ;
T;:oct;0;[ ;{ ;IC;"Treats leading characters of str as a string of octal digits (with an
optional sign) and returns the corresponding number. Returns 0 if the
conversion fails.
"123".oct #=> 83
"-377".oct #=> -255
"bad".oct #=> 0
"0377bad".oct #=> 255
; T;[o;7
;8I"
overload; F;90;;;:0;;I"oct; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@)6;[ ;I"@return [Integer]; T;0;@)6; F;=i ;>0;5[ ;@)6;[ ;I"4Treats leading characters of str as a string of octal digits (with an
optional sign) and returns the corresponding number. Returns 0 if the
conversion fails.
"123".oct #=> 83
"-377".oct #=> -255
"bad".oct #=> 0
"0377bad".oct #=> 255
@overload oct
@return [Integer]; T;0;@)6; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"Vstatic VALUE
rb_str_oct(VALUE str)
{
return rb_str_to_inum(str, -8, FALSE);
}; T;BTo;1;2F;3;4;;;#I"String#split; F;5[[@0; [[@*i6;
T;:
split;0;[ ;{ ;IC;"$Divides str into substrings based on a delimiter, returning an array
of these substrings.
If pattern is a String, then its contents are used as
the delimiter when splitting str. If pattern is a single
space, str is split on whitespace, with leading whitespace and runs
of contiguous whitespace characters ignored.
If pattern is a Regexp, str is divided where the
pattern matches. Whenever the pattern matches a zero-length string,
str is split into individual characters. If pattern contains
groups, the respective matches will be returned in the array as well.
If pattern is omitted, the value of $; is used. If
$; is nil (which is the default), str is
split on whitespace as if ` ' were specified.
If the limit parameter is omitted, trailing null fields are
suppressed. If limit is a positive number, at most that number of
fields will be returned (if limit is 1, the entire
string is returned as the only entry in an array). If negative, there is no
limit to the number of fields returned, and trailing null fields are not
suppressed.
When the input +str+ is empty an empty Array is returned as the string is
considered to have no fields to split.
" now's the time".split #=> ["now's", "the", "time"]
" now's the time".split(' ') #=> ["now's", "the", "time"]
" now's the time".split(/ /) #=> ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(%r{,\s*}) #=> ["1", "2.34", "56", "7"]
"hello".split(//) #=> ["h", "e", "l", "l", "o"]
"hello".split(//, 3) #=> ["h", "e", "llo"]
"hi mom".split(%r{\s*}) #=> ["h", "i", "m", "o", "m"]
"mellow yellow".split("ello") #=> ["m", "w y", "w"]
"1,2,,3,4,,".split(',') #=> ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4) #=> ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4) #=> ["1", "2", "", "3", "4", "", ""]
"".split(',', -1) #=> []
; T;[o;7
;8I"
overload; F;90;;;:0;;I" split(pattern=$;, [limit]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@D6;[ ;I"@return [Array]; T;0;@D6; F;=i ;>0;5[[I" pattern; TI"$;; T[I" [limit]; T0;@D6;[ ;I"]Divides str into substrings based on a delimiter, returning an array
of these substrings.
If pattern is a String, then its contents are used as
the delimiter when splitting str. If pattern is a single
space, str is split on whitespace, with leading whitespace and runs
of contiguous whitespace characters ignored.
If pattern is a Regexp, str is divided where the
pattern matches. Whenever the pattern matches a zero-length string,
str is split into individual characters. If pattern contains
groups, the respective matches will be returned in the array as well.
If pattern is omitted, the value of $; is used. If
$; is nil (which is the default), str is
split on whitespace as if ` ' were specified.
If the limit parameter is omitted, trailing null fields are
suppressed. If limit is a positive number, at most that number of
fields will be returned (if limit is 1, the entire
string is returned as the only entry in an array). If negative, there is no
limit to the number of fields returned, and trailing null fields are not
suppressed.
When the input +str+ is empty an empty Array is returned as the string is
considered to have no fields to split.
" now's the time".split #=> ["now's", "the", "time"]
" now's the time".split(' ') #=> ["now's", "the", "time"]
" now's the time".split(/ /) #=> ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(%r{,\s*}) #=> ["1", "2.34", "56", "7"]
"hello".split(//) #=> ["h", "e", "l", "l", "o"]
"hello".split(//, 3) #=> ["h", "e", "llo"]
"hi mom".split(%r{\s*}) #=> ["h", "i", "m", "o", "m"]
"mellow yellow".split("ello") #=> ["m", "w y", "w"]
"1,2,,3,4,,".split(',') #=> ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4) #=> ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4) #=> ["1", "2", "", "3", "4", "", ""]
"".split(',', -1) #=> []
@overload split(pattern=$;, [limit])
@return [Array]; T;0;@D6; F; o; ; T; i;!i3;"@-;;I"static VALUE; T;AI"9static VALUE
rb_str_split_m(int argc, VALUE *argv, VALUE str)
{
rb_encoding *enc;
VALUE spat;
VALUE limit;
enum {awk, string, regexp} split_type;
long beg, end, i = 0;
int lim = 0;
VALUE result, tmp;
if (rb_scan_args(argc, argv, "02", &spat, &limit) == 2) {
lim = NUM2INT(limit);
if (lim <= 0) limit = Qnil;
else if (lim == 1) {
if (RSTRING_LEN(str) == 0)
return rb_ary_new2(0);
return rb_ary_new3(1, str);
}
i = 1;
}
enc = STR_ENC_GET(str);
if (NIL_P(spat) && NIL_P(spat = rb_fs)) {
split_type = awk;
}
else {
if (RB_TYPE_P(spat, T_STRING)) {
rb_encoding *enc2 = STR_ENC_GET(spat);
split_type = string;
if (RSTRING_LEN(spat) == 0) {
/* Special case - split into chars */
spat = rb_reg_regcomp(spat);
split_type = regexp;
}
else if (rb_enc_asciicompat(enc2) == 1) {
if (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){
split_type = awk;
}
}
else {
int l;
if (rb_enc_ascget(RSTRING_PTR(spat), RSTRING_END(spat), &l, enc2) == ' ' &&
RSTRING_LEN(spat) == l) {
split_type = awk;
}
}
}
else {
spat = get_pat(spat, 1);
split_type = regexp;
}
}
result = rb_ary_new();
beg = 0;
if (split_type == awk) {
char *ptr = RSTRING_PTR(str);
char *eptr = RSTRING_END(str);
char *bptr = ptr;
int skip = 1;
unsigned int c;
end = beg;
if (is_ascii_string(str)) {
while (ptr < eptr) {
c = (unsigned char)*ptr++;
if (skip) {
if (ascii_isspace(c)) {
beg = ptr - bptr;
}
else {
end = ptr - bptr;
skip = 0;
if (!NIL_P(limit) && lim <= i) break;
}
}
else if (ascii_isspace(c)) {
rb_ary_push(result, rb_str_subseq(str, beg, end-beg));
skip = 1;
beg = ptr - bptr;
if (!NIL_P(limit)) ++i;
}
else {
end = ptr - bptr;
}
}
}
else {
while (ptr < eptr) {
int n;
c = rb_enc_codepoint_len(ptr, eptr, &n, enc);
ptr += n;
if (skip) {
if (rb_isspace(c)) {
beg = ptr - bptr;
}
else {
end = ptr - bptr;
skip = 0;
if (!NIL_P(limit) && lim <= i) break;
}
}
else if (rb_isspace(c)) {
rb_ary_push(result, rb_str_subseq(str, beg, end-beg));
skip = 1;
beg = ptr - bptr;
if (!NIL_P(limit)) ++i;
}
else {
end = ptr - bptr;
}
}
}
}
else if (split_type == string) {
char *ptr = RSTRING_PTR(str);
char *temp = ptr;
char *eptr = RSTRING_END(str);
char *sptr = RSTRING_PTR(spat);
long slen = RSTRING_LEN(spat);
if (is_broken_string(str)) {
rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str)));
}
if (is_broken_string(spat)) {
rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(spat)));
}
enc = rb_enc_check(str, spat);
while (ptr < eptr &&
(end = rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
/* Check we are at the start of a char */
char *t = rb_enc_right_char_head(ptr, ptr + end, eptr, enc);
if (t != ptr + end) {
ptr = t;
continue;
}
rb_ary_push(result, rb_str_subseq(str, ptr - temp, end));
ptr += end + slen;
if (!NIL_P(limit) && lim <= ++i) break;
}
beg = ptr - temp;
}
else {
char *ptr = RSTRING_PTR(str);
long len = RSTRING_LEN(str);
long start = beg;
long idx;
int last_null = 0;
struct re_registers *regs;
while ((end = rb_reg_search(spat, str, start, 0)) >= 0) {
regs = RMATCH_REGS(rb_backref_get());
if (start == end && BEG(0) == END(0)) {
if (!ptr) {
rb_ary_push(result, str_new_empty(str));
break;
}
else if (last_null == 1) {
rb_ary_push(result, rb_str_subseq(str, beg,
rb_enc_fast_mbclen(ptr+beg,
ptr+len,
enc)));
beg = start;
}
else {
if (ptr+start == ptr+len)
start++;
else
start += rb_enc_fast_mbclen(ptr+start,ptr+len,enc);
last_null = 1;
continue;
}
}
else {
rb_ary_push(result, rb_str_subseq(str, beg, end-beg));
beg = start = END(0);
}
last_null = 0;
for (idx=1; idx < regs->num_regs; idx++) {
if (BEG(idx) == -1) continue;
if (BEG(idx) == END(idx))
tmp = str_new_empty(str);
else
tmp = rb_str_subseq(str, BEG(idx), END(idx)-BEG(idx));
rb_ary_push(result, tmp);
}
if (!NIL_P(limit) && lim <= ++i) break;
}
}
if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
if (RSTRING_LEN(str) == beg)
tmp = str_new_empty(str);
else
tmp = rb_str_subseq(str, beg, RSTRING_LEN(str)-beg);
rb_ary_push(result, tmp);
}
if (NIL_P(limit) && lim == 0) {
long len;
while ((len = RARRAY_LEN(result)) > 0 &&
(tmp = RARRAY_AREF(result, len-1), RSTRING_LEN(tmp) == 0))
rb_ary_pop(result);
}
return result;
}; T;BTo;1;2F;3;4;;;#I"String#lines; F;5[[@0; [[@*i;
T;:
lines;0;[ ;{ ;IC;"Returns an array of lines in str split using the supplied
record separator ($/ by default). This is a
shorthand for str.each_line(separator).to_a.
If a block is given, which is a deprecated form, works the same as
each_line.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"lines(separator=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@e6;[ ;I"@return [Array]; T;0;@e6; F;=i ;>0;5[[I"separator; TI"$/; T;@e6;[ ;I"BReturns an array of lines in str split using the supplied
record separator ($/ by default). This is a
shorthand for str.each_line(separator).to_a.
If a block is given, which is a deprecated form, works the same as
each_line.
@overload lines(separator=$/)
@return [Array]; T;0;@e6; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"{static VALUE
rb_str_lines(int argc, VALUE *argv, VALUE str)
{
return rb_str_enumerate_lines(argc, argv, str, 1);
}; T;BTo;1;2F;3;4;;;#I"String#bytes; F;5[ ; [[@*i
;
T;:
bytes;0;[ ;{ ;IC;"Returns an array of bytes in str. This is a shorthand for
str.each_byte.to_a.
If a block is given, which is a deprecated form, works the same as
each_byte.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
bytes; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@6;[ ;I"@return [Array]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"Returns an array of bytes in str. This is a shorthand for
str.each_byte.to_a.
If a block is given, which is a deprecated form, works the same as
each_byte.
@overload bytes
@return [Array]; T;0;@6; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"Xstatic VALUE
rb_str_bytes(VALUE str)
{
return rb_str_enumerate_bytes(str, 1);
}; T;BTo;1;2F;3;4;;;#I"String#chars; F;5[ ; [[@*it;
T;:
chars;0;[ ;{ ;IC;"Returns an array of characters in str. This is a shorthand
for str.each_char.to_a.
If a block is given, which is a deprecated form, works the same as
each_char.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
chars; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@6;[ ;I"@return [Array]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"Returns an array of characters in str. This is a shorthand
for str.each_char.to_a.
If a block is given, which is a deprecated form, works the same as
each_char.
@overload chars
@return [Array]; T;0;@6; F; o; ; T; ii;!iq;"@-;;I"static VALUE; T;AI"Xstatic VALUE
rb_str_chars(VALUE str)
{
return rb_str_enumerate_chars(str, 1);
}; T;BTo;1;2F;3;4;;;#I"String#codepoints; F;5[ ; [[@*i;
T;:codepoints;0;[ ;{ ;IC;"Returns an array of the Integer ordinals of the
characters in str. This is a shorthand for
str.each_codepoint.to_a.
If a block is given, which is a deprecated form, works the same as
each_codepoint.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"codepoints; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@6;[ ;I"@return [Array]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I" Returns an array of the Integer ordinals of the
characters in str. This is a shorthand for
str.each_codepoint.to_a.
If a block is given, which is a deprecated form, works the same as
each_codepoint.
@overload codepoints
@return [Array]; T;0;@6; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"bstatic VALUE
rb_str_codepoints(VALUE str)
{
return rb_str_enumerate_codepoints(str, 1);
}; T;BTo;1;2F;3;4;;;#I"String#reverse; F;5[ ; [[@*i;
T;: reverse;0;[ ;{ ;IC;"wReturns a new string with the characters from str in reverse order.
"stressed".reverse #=> "desserts"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" reverse; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@6;[ ;I"@return [String]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"Returns a new string with the characters from str in reverse order.
"stressed".reverse #=> "desserts"
@overload reverse
@return [String]; T;0;@6; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_reverse(VALUE str)
{
rb_encoding *enc;
VALUE rev;
char *s, *e, *p;
int cr;
if (RSTRING_LEN(str) <= 1) return rb_str_dup(str);
enc = STR_ENC_GET(str);
rev = rb_str_new5(str, 0, RSTRING_LEN(str));
s = RSTRING_PTR(str); e = RSTRING_END(str);
p = RSTRING_END(rev);
cr = ENC_CODERANGE(str);
if (RSTRING_LEN(str) > 1) {
if (single_byte_optimizable(str)) {
while (s < e) {
*--p = *s++;
}
}
else if (cr == ENC_CODERANGE_VALID) {
while (s < e) {
int clen = rb_enc_fast_mbclen(s, e, enc);
p -= clen;
memcpy(p, s, clen);
s += clen;
}
}
else {
cr = rb_enc_asciicompat(enc) ?
ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID;
while (s < e) {
int clen = rb_enc_mbclen(s, e, enc);
if (clen > 1 || (*s & 0x80)) cr = ENC_CODERANGE_UNKNOWN;
p -= clen;
memcpy(p, s, clen);
s += clen;
}
}
}
STR_SET_LEN(rev, RSTRING_LEN(str));
OBJ_INFECT_RAW(rev, str);
str_enc_copy(rev, str);
ENC_CODERANGE_SET(rev, cr);
return rev;
}; T;BTo;1;2F;3;4;;;#I"String#reverse!; F;5[ ; [[@*i;
T;:
reverse!;0;[ ;{ ;IC;""Reverses str in place.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
reverse!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@6;[ ;I"@return [String]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"JReverses str in place.
@overload reverse!
@return [String]; T;0;@6; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_reverse_bang(VALUE str)
{
if (RSTRING_LEN(str) > 1) {
if (single_byte_optimizable(str)) {
char *s, *e, c;
str_modify_keep_cr(str);
s = RSTRING_PTR(str);
e = RSTRING_END(str) - 1;
while (s < e) {
c = *s;
*s++ = *e;
*e-- = c;
}
}
else {
rb_str_shared_replace(str, rb_str_reverse(str));
}
}
else {
str_modify_keep_cr(str);
}
return str;
}; T;BTo;1;2F;3;4;;;#I"String#concat; F;5[[I" str2; T0; [[@*i" ;
T;: concat;0;[ ;{ ;IC;"Append---Concatenates the given object to str. If the object is a
Integer, it is considered as a codepoint, and is converted
to a character before concatenation.
a = "hello "
a << "world" #=> "hello world"
a.concat(33) #=> "hello world!"
; T;[ o;7
;8I"
overload; F;90;;E;:0;;I"<<(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ 7;[ ;I"@return [String]; T;0;@ 7; F;=i ;>0;5[[I" integer; T0;@ 7o;7
;8I"
overload; F;90;;;:0;;I"concat(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ 7;[ ;I"@return [String]; T;0;@ 7; F;=i ;>0;5[[I" integer; T0;@ 7o;7
;8I"
overload; F;90;;E;:0;;I" <<(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ 7;[ ;I"@return [String]; T;0;@ 7; F;=i ;>0;5[[I"obj; T0;@ 7o;7
;8I"
overload; F;90;;;:0;;I"concat(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ 7;[ ;I"@return [String]; T;0;@ 7; F;=i ;>0;5[[I"obj; T0;@ 7;[ ;I"Append---Concatenates the given object to str. If the object is a
Integer, it is considered as a codepoint, and is converted
to a character before concatenation.
a = "hello "
a << "world" #=> "hello world"
a.concat(33) #=> "hello world!"
@overload <<(integer)
@return [String]
@overload concat(integer)
@return [String]
@overload <<(obj)
@return [String]
@overload concat(obj)
@return [String]; T;0;@ 7; F; o; ; T; i ;!i" ;"@-;;I"
VALUE; T;AI"nVALUE
rb_str_concat(VALUE str1, VALUE str2)
{
unsigned int code;
rb_encoding *enc = STR_ENC_GET(str1);
if (FIXNUM_P(str2) || RB_TYPE_P(str2, T_BIGNUM)) {
if (rb_num_to_uint(str2, &code) == 0) {
}
else if (FIXNUM_P(str2)) {
rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(str2));
}
else {
rb_raise(rb_eRangeError, "bignum out of char range");
}
}
else {
return rb_str_append(str1, str2);
}
if (enc == rb_usascii_encoding()) {
/* US-ASCII automatically extended to ASCII-8BIT */
char buf[1];
buf[0] = (char)code;
if (code > 0xFF) {
rb_raise(rb_eRangeError, "%u out of char range", code);
}
rb_str_cat(str1, buf, 1);
if (code > 127) {
rb_enc_associate(str1, rb_ascii8bit_encoding());
ENC_CODERANGE_SET(str1, ENC_CODERANGE_VALID);
}
}
else {
long pos = RSTRING_LEN(str1);
int cr = ENC_CODERANGE(str1);
int len;
char *buf;
switch (len = rb_enc_codelen(code, enc)) {
case ONIGERR_INVALID_CODE_POINT_VALUE:
rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
break;
case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
case 0:
rb_raise(rb_eRangeError, "%u out of char range", code);
break;
}
buf = ALLOCA_N(char, len + 1);
rb_enc_mbcput(code, buf, enc);
if (rb_enc_precise_mbclen(buf, buf + len + 1, enc) != len) {
rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
}
rb_str_resize(str1, pos+len);
memcpy(RSTRING_PTR(str1) + pos, buf, len);
if (cr == ENC_CODERANGE_7BIT && code > 127)
cr = ENC_CODERANGE_VALID;
ENC_CODERANGE_SET(str1, cr);
}
return str1;
}; T;BTo;1;2F;3;4;;;#I"String#<<; F;5[[I" str2; T0; [[@*i" ;
T;;E;0;[ ;{ ;IC;"Append---Concatenates the given object to str. If the object is a
Integer, it is considered as a codepoint, and is converted
to a character before concatenation.
a = "hello "
a << "world" #=> "hello world"
a.concat(33) #=> "hello world!"
; T;[ o;7
;8I"
overload; F;90;;E;:0;;I"<<(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@W7;[ ;I"@return [String]; T;0;@W7; F;=i ;>0;5[[I" integer; T0;@W7o;7
;8I"
overload; F;90;;;:0;;I"concat(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@W7;[ ;I"@return [String]; T;0;@W7; F;=i ;>0;5[[I" integer; T0;@W7o;7
;8I"
overload; F;90;;E;:0;;I" <<(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@W7;[ ;I"@return [String]; T;0;@W7; F;=i ;>0;5[[I"obj; T0;@W7o;7
;8I"
overload; F;90;;;:0;;I"concat(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@W7;[ ;I"@return [String]; T;0;@W7; F;=i ;>0;5[[I"obj; T0;@W7;[ ;@S7;0;@W7; F; o; ; T; i ;!i" ;"@-;;I"
VALUE; T;AI"nVALUE
rb_str_concat(VALUE str1, VALUE str2)
{
unsigned int code;
rb_encoding *enc = STR_ENC_GET(str1);
if (FIXNUM_P(str2) || RB_TYPE_P(str2, T_BIGNUM)) {
if (rb_num_to_uint(str2, &code) == 0) {
}
else if (FIXNUM_P(str2)) {
rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(str2));
}
else {
rb_raise(rb_eRangeError, "bignum out of char range");
}
}
else {
return rb_str_append(str1, str2);
}
if (enc == rb_usascii_encoding()) {
/* US-ASCII automatically extended to ASCII-8BIT */
char buf[1];
buf[0] = (char)code;
if (code > 0xFF) {
rb_raise(rb_eRangeError, "%u out of char range", code);
}
rb_str_cat(str1, buf, 1);
if (code > 127) {
rb_enc_associate(str1, rb_ascii8bit_encoding());
ENC_CODERANGE_SET(str1, ENC_CODERANGE_VALID);
}
}
else {
long pos = RSTRING_LEN(str1);
int cr = ENC_CODERANGE(str1);
int len;
char *buf;
switch (len = rb_enc_codelen(code, enc)) {
case ONIGERR_INVALID_CODE_POINT_VALUE:
rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
break;
case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
case 0:
rb_raise(rb_eRangeError, "%u out of char range", code);
break;
}
buf = ALLOCA_N(char, len + 1);
rb_enc_mbcput(code, buf, enc);
if (rb_enc_precise_mbclen(buf, buf + len + 1, enc) != len) {
rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
}
rb_str_resize(str1, pos+len);
memcpy(RSTRING_PTR(str1) + pos, buf, len);
if (cr == ENC_CODERANGE_7BIT && code > 127)
cr = ENC_CODERANGE_VALID;
ENC_CODERANGE_SET(str1, cr);
}
return str1;
}; T;BTo;1;2F;3;4;;;#I"String#prepend; F;5[[I" str2; T0; [[@*ik ;
T;: prepend;0;[ ;{ ;IC;"Prepend---Prepend the given string to str.
a = "world"
a.prepend("hello ") #=> "hello world"
a #=> "hello world"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"prepend(other_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@7;[ ;I"@return [String]; T;0;@7; F;=i ;>0;5[[I"other_str; T0;@7;[ ;I"Prepend---Prepend the given string to str.
a = "world"
a.prepend("hello ") #=> "hello world"
a #=> "hello world"
@overload prepend(other_str)
@return [String]; T;0;@7; F; o; ; T; i` ;!ih ;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_prepend(VALUE str, VALUE str2)
{
StringValue(str2);
StringValue(str);
rb_str_update(str, 0L, 0L, str2);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#crypt; F;5[[I" salt; T0; [[@*i ;
T;:
crypt;0;[ ;{ ;IC;"Applies a one-way cryptographic hash to str by invoking the
standard library function crypt(3) with the given
salt string. While the format and the result are system and
implementation dependent, using a salt matching the regular
expression \A[a-zA-Z0-9./]{2} should be valid and
safe on any platform, in which only the first two characters are
significant.
This method is for use in system specific scripts, so if you want
a cross-platform hash function consider using Digest or OpenSSL
instead.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"crypt(salt_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@7;[ ;I"@return [String]; T;0;@7; F;=i ;>0;5[[I"
salt_str; T0;@7;[ ;I"BApplies a one-way cryptographic hash to str by invoking the
standard library function crypt(3) with the given
salt string. While the format and the result are system and
implementation dependent, using a salt matching the regular
expression \A[a-zA-Z0-9./]{2} should be valid and
safe on any platform, in which only the first two characters are
significant.
This method is for use in system specific scripts, so if you want
a cross-platform hash function consider using Digest or OpenSSL
instead.
@overload crypt(salt_str)
@return [String]; T;0;@7; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"Tstatic VALUE
rb_str_crypt(VALUE str, VALUE salt)
{
extern char *crypt(const char *, const char *);
VALUE result;
const char *s, *saltp;
char *res;
#ifdef BROKEN_CRYPT
char salt_8bit_clean[3];
#endif
StringValue(salt);
if (RSTRING_LEN(salt) < 2)
rb_raise(rb_eArgError, "salt too short (need >=2 bytes)");
s = RSTRING_PTR(str);
if (!s) s = "";
saltp = RSTRING_PTR(salt);
#ifdef BROKEN_CRYPT
if (!ISASCII((unsigned char)saltp[0]) || !ISASCII((unsigned char)saltp[1])) {
salt_8bit_clean[0] = saltp[0] & 0x7f;
salt_8bit_clean[1] = saltp[1] & 0x7f;
salt_8bit_clean[2] = '\0';
saltp = salt_8bit_clean;
}
#endif
res = crypt(s, saltp);
if (!res) {
rb_sys_fail("crypt");
}
result = rb_str_new2(res);
FL_SET_RAW(result, OBJ_TAINTED_RAW(str) | OBJ_TAINTED_RAW(salt));
return result;
}; T;BTo;1;2F;3;4;;;#I"String#intern; F;5[ ; [[@*i* ;
T;;_;0;[ ;{ ;IC;"Returns the Symbol corresponding to str, creating the
symbol if it did not previously exist. See Symbol#id2name.
"Koala".intern #=> :Koala
s = 'cat'.to_sym #=> :cat
s == :cat #=> true
s = '@cat'.to_sym #=> :@cat
s == :@cat #=> true
This can also be used to create symbols that cannot be represented using the
:xxx notation.
'cat and dog'.to_sym #=> :"cat and dog"
; T;[o;7
;8I"
overload; F;90;;_;:0;;I" intern; T;IC;" ; T;[ ;[ ;I" ; T;0;@7; F;=i ;>0;5[ ;@7o;7
;8I"
overload; F;90;;`;:0;;I" to_sym; T;IC;" ; T;[ ;[ ;I" ; T;0;@7; F;=i ;>0;5[ ;@7;[ ;I" Returns the Symbol corresponding to str, creating the
symbol if it did not previously exist. See Symbol#id2name.
"Koala".intern #=> :Koala
s = 'cat'.to_sym #=> :cat
s == :cat #=> true
s = '@cat'.to_sym #=> :@cat
s == :@cat #=> true
This can also be used to create symbols that cannot be represented using the
:xxx notation.
'cat and dog'.to_sym #=> :"cat and dog"
@overload intern
@overload to_sym; T;0;@7; F; o; ; T; i ;!i& ;"@-;;I"
VALUE; T;AI"VALUE
rb_str_intern(VALUE s)
{
VALUE str = RB_GC_GUARD(s);
ID id;
id = rb_intern_str(str);
return ID2SYM(id);
}; T;BTo;1;2F;3;4;;;#I"String#to_sym; F;5[ ; [[@*i* ;
T;;`;0;[ ;{ ;IC;"Returns the Symbol corresponding to str, creating the
symbol if it did not previously exist. See Symbol#id2name.
"Koala".intern #=> :Koala
s = 'cat'.to_sym #=> :cat
s == :cat #=> true
s = '@cat'.to_sym #=> :@cat
s == :@cat #=> true
This can also be used to create symbols that cannot be represented using the
:xxx notation.
'cat and dog'.to_sym #=> :"cat and dog"
; T;[o;7
;8I"
overload; F;90;;_;:0;;I" intern; T;IC;" ; T;[ ;[ ;I" ; T;0;@7; F;=i ;>0;5[ ;@7o;7
;8I"
overload; F;90;;`;:0;;I" to_sym; T;IC;" ; T;[ ;[ ;I" ; T;0;@7; F;=i ;>0;5[ ;@7;[ ;@7;0;@7; F; o; ; T; i ;!i& ;"@-;;I"
VALUE; T;AI"VALUE
rb_str_intern(VALUE s)
{
VALUE str = RB_GC_GUARD(s);
ID id;
id = rb_intern_str(str);
return ID2SYM(id);
}; T;BTo;1;2F;3;4;;;#I"String#ord; F;5[ ; [[@*i> ;
T;; ;0;[ ;{ ;IC;"bReturn the Integer ordinal of a one-character string.
"a".ord #=> 97
; T;[o;7
;8I"
overload; F;90;; ;:0;;I"ord; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@8;[ ;I"@return [Integer]; T;0;@8; F;=i ;>0;5[ ;@8;[ ;I"Return the Integer ordinal of a one-character string.
"a".ord #=> 97
@overload ord
@return [Integer]; T;0;@8; F; o; ; T; i5 ;!i; ;"@-;;I"
VALUE; T;AI"VALUE
rb_str_ord(VALUE s)
{
unsigned int c;
c = rb_enc_codepoint(RSTRING_PTR(s), RSTRING_END(s), STR_ENC_GET(s));
return UINT2NUM(c);
}; T;BTo;1;2F;3;4;;;#I"String#include?; F;5[[I"arg; T0; [[@*i$;
T;:
include?;0;[ ;{ ;IC;"Returns true if str contains the given string or
character.
"hello".include? "lo" #=> true
"hello".include? "ol" #=> false
"hello".include? ?h #=> true
; T;[o;7
;8I"
overload; F;90;;;:0;;I"include? other_str; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@68;[ ;I"@return [Boolean]; T;0;@68; F;=i ;>0;5[[I"other_str; T0;@68o;<
;8I" return; F;9@f;0;:[@h;@68;[ ;I"Returns true if str contains the given string or
character.
"hello".include? "lo" #=> true
"hello".include? "ol" #=> false
"hello".include? ?h #=> true
@overload include? other_str
@return [Boolean]; T;0;@68; F; o; ; T; i;!i!;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_include(VALUE str, VALUE arg)
{
long i;
StringValue(arg);
i = rb_str_index(str, arg, 0);
if (i == -1) return Qfalse;
return Qtrue;
}; T;BTo;1;2F;3;4;;;#I"String#start_with?; F;5[[@0; [[@*i ;
T;:start_with?;0;[ ;{ ;IC;"Returns true if +str+ starts with one of the +prefixes+ given.
"hello".start_with?("hell") #=> true
# returns true if one of the prefixes matches.
"hello".start_with?("heaven", "hell") #=> true
"hello".start_with?("heaven", "paradise") #=> false
; T;[o;7
;8I"
overload; F;90;;;:0;;I" start_with?([prefixes]+); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@X8;[ ;I"@return [Boolean]; T;0;@X8; F;=i ;>0;5[[I"[prefixes]; T0;@X8o;<
;8I" return; F;9@f;0;:[@h;@X8;[ ;I"JReturns true if +str+ starts with one of the +prefixes+ given.
"hello".start_with?("hell") #=> true
# returns true if one of the prefixes matches.
"hello".start_with?("heaven", "hell") #=> true
"hello".start_with?("heaven", "paradise") #=> false
@overload start_with?([prefixes]+)
@return [Boolean]; T;0;@X8; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"Wstatic VALUE
rb_str_start_with(int argc, VALUE *argv, VALUE str)
{
int i;
for (i=0; iRegexp or a String). For each match, a result is
generated and either added to the result array or passed to the block. If
the pattern contains no groups, each individual result consists of the
matched string, $&. If the pattern contains groups, each
individual result is itself an array containing one entry per group.
a = "cruel world"
a.scan(/\w+/) #=> ["cruel", "world"]
a.scan(/.../) #=> ["cru", "el ", "wor"]
a.scan(/(...)/) #=> [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/) #=> [["cr", "ue"], ["l ", "wo"]]
And the block form:
a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|x,y| print y, x }
print "\n"
produces:
<Regexp or a String). For each match, a result is
generated and either added to the result array or passed to the block. If
the pattern contains no groups, each individual result consists of the
matched string, $&. If the pattern contains groups, each
individual result is itself an array containing one entry per group.
a = "cruel world"
a.scan(/\w+/) #=> ["cruel", "world"]
a.scan(/.../) #=> ["cru", "el ", "wor"]
a.scan(/(...)/) #=> [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/) #=> [["cr", "ue"], ["l ", "wo"]]
And the block form:
a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|x,y| print y, x }
print "\n"
produces:
<String of length integer with str left justified
and padded with padstr; otherwise, returns str.
"hello".ljust(4) #=> "hello"
"hello".ljust(20) #=> "hello "
"hello".ljust(20, '1234') #=> "hello123412341234123"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" ljust(integer, padstr=' '); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@8;[ ;I"@return [String]; T;0;@8; F;=i ;>0;5[[I" integer; T0[I" padstr; TI"' '; T;@8;[ ;I"If integer is greater than the length of str, returns a new
String of length integer with str left justified
and padded with padstr; otherwise, returns str.
"hello".ljust(4) #=> "hello"
"hello".ljust(20) #=> "hello "
"hello".ljust(20, '1234') #=> "hello123412341234123"
@overload ljust(integer, padstr=' ')
@return [String]; T;0;@8; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"ustatic VALUE
rb_str_ljust(int argc, VALUE *argv, VALUE str)
{
return rb_str_justify(argc, argv, str, 'l');
}; T;BTo;1;2F;3;4;;;#I"String#rjust; F;5[[@0; [[@*i ;
T;:
rjust;0;[ ;{ ;IC;"tIf integer is greater than the length of str, returns a new
String of length integer with str right justified
and padded with padstr; otherwise, returns str.
"hello".rjust(4) #=> "hello"
"hello".rjust(20) #=> " hello"
"hello".rjust(20, '1234') #=> "123412341234123hello"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rjust(integer, padstr=' '); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@8;[ ;I"@return [String]; T;0;@8; F;=i ;>0;5[[I" integer; T0[I" padstr; TI"' '; T;@8;[ ;I"If integer is greater than the length of str, returns a new
String of length integer with str right justified
and padded with padstr; otherwise, returns str.
"hello".rjust(4) #=> "hello"
"hello".rjust(20) #=> " hello"
"hello".rjust(20, '1234') #=> "123412341234123hello"
@overload rjust(integer, padstr=' ')
@return [String]; T;0;@8; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"ustatic VALUE
rb_str_rjust(int argc, VALUE *argv, VALUE str)
{
return rb_str_justify(argc, argv, str, 'r');
}; T;BTo;1;2F;3;4;;;#I"String#center; F;5[[@0; [[@*i ;
T;: center;0;[ ;{ ;IC;"SCenters +str+ in +width+. If +width+ is greater than the length of +str+,
returns a new String of length +width+ with +str+ centered and padded with
+padstr+; otherwise, returns +str+.
"hello".center(4) #=> "hello"
"hello".center(20) #=> " hello "
"hello".center(20, '123') #=> "1231231hello12312312"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" center(width, padstr=' '); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@9;[ ;I"@return [String]; T;0;@9; F;=i ;>0;5[[I"
width; T0[I" padstr; TI"' '; T;@9;[ ;I"Centers +str+ in +width+. If +width+ is greater than the length of +str+,
returns a new String of length +width+ with +str+ centered and padded with
+padstr+; otherwise, returns +str+.
"hello".center(4) #=> "hello"
"hello".center(20) #=> " hello "
"hello".center(20, '123') #=> "1231231hello12312312"
@overload center(width, padstr=' ')
@return [String]; T;0;@9; F; o; ; T; i ;!i ;"@-;;I"static VALUE; T;AI"vstatic VALUE
rb_str_center(int argc, VALUE *argv, VALUE str)
{
return rb_str_justify(argc, argv, str, 'c');
}; T;BTo;1;2F;3;4;;;#I"String#sub; F;5[[@0; [[@*i;
T;:sub;0;[ ;{ ;IC;"eReturns a copy of +str+ with the _first_ occurrence of +pattern+
replaced by the second argument. The +pattern+ is typically a Regexp; if
given as a String, any regular expression metacharacters it contains will
be interpreted literally, e.g. '\\\d' will match a backlash
followed by 'd', instead of a digit.
If +replacement+ is a String it will be substituted for the matched text.
It may contain back-references to the pattern's capture groups of the form
"\\d", where d is a group number, or
"\\k" , where n is a group name. If it is a
double-quoted string, both back-references must be preceded by an
additional backslash. However, within +replacement+ the special match
variables, such as &$, will not refer to the current match.
If +replacement+ is a String that looks like a pattern's capture group but
is actaully not a pattern capture group e.g. "\\'", then it
will have to be preceded by two backslashes like so "\\\\'".
If the second argument is a Hash, and the matched text is one of its keys,
the corresponding value is the replacement string.
In the block form, the current match string is passed in as a parameter,
and variables such as $1, $2, $`,
$&, and $' will be set appropriately. The value
returned by the block will be substituted for the match on each call.
The result inherits any tainting in the original string or any supplied
replacement string.
"hello".sub(/[aeiou]/, '*') #=> "h*llo"
"hello".sub(/([aeiou])/, '<\1>') #=> "h'\\\d' will match a backlash
followed by 'd', instead of a digit.
If +replacement+ is a String it will be substituted for the matched text.
It may contain back-references to the pattern's capture groups of the form
"\\d", where d is a group number, or
"\\k" , where n is a group name. If it is a
double-quoted string, both back-references must be preceded by an
additional backslash. However, within +replacement+ the special match
variables, such as &$, will not refer to the current match.
If +replacement+ is a String that looks like a pattern's capture group but
is actaully not a pattern capture group e.g. "\\'", then it
will have to be preceded by two backslashes like so "\\\\'".
If the second argument is a Hash, and the matched text is one of its keys,
the corresponding value is the replacement string.
In the block form, the current match string is passed in as a parameter,
and variables such as $1, $2, $`,
$&, and $' will be set appropriately. The value
returned by the block will be substituted for the match on each call.
The result inherits any tainting in the original string or any supplied
replacement string.
"hello".sub(/[aeiou]/, '*') #=> "h*llo"
"hello".sub(/([aeiou])/, '<\1>') #=> "hRegexp; if given as a String, any
regular expression metacharacters it contains will be interpreted
literally, e.g. '\\\d' will match a backlash followed by 'd',
instead of a digit.
If replacement is a String it will be substituted for
the matched text. It may contain back-references to the pattern's capture
groups of the form \\\d, where d is a group number, or
\\\k, where n is a group name. If it is a
double-quoted string, both back-references must be preceded by an
additional backslash. However, within replacement the special match
variables, such as $&, will not refer to the current match.
If the second argument is a Hash, and the matched text is one
of its keys, the corresponding value is the replacement string.
In the block form, the current match string is passed in as a parameter,
and variables such as $1, $2, $`,
$&, and $' will be set appropriately. The value
returned by the block will be substituted for the match on each call.
The result inherits any tainting in the original string or any supplied
replacement string.
When neither a block nor a second argument is supplied, an
Enumerator is returned.
"hello".gsub(/[aeiou]/, '*') #=> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>') #=> "hRegexp; if given as a String, any
regular expression metacharacters it contains will be interpreted
literally, e.g. '\\\d' will match a backlash followed by 'd',
instead of a digit.
If replacement is a String it will be substituted for
the matched text. It may contain back-references to the pattern's capture
groups of the form \\\d, where d is a group number, or
\\\k, where n is a group name. If it is a
double-quoted string, both back-references must be preceded by an
additional backslash. However, within replacement the special match
variables, such as $&, will not refer to the current match.
If the second argument is a Hash, and the matched text is one
of its keys, the corresponding value is the replacement string.
In the block form, the current match string is passed in as a parameter,
and variables such as $1, $2, $`,
$&, and $' will be set appropriately. The value
returned by the block will be substituted for the match on each call.
The result inherits any tainting in the original string or any supplied
replacement string.
When neither a block nor a second argument is supplied, an
Enumerator is returned.
"hello".gsub(/[aeiou]/, '*') #=> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>') #=> "hString with the last character removed. If the
string ends with \r\n, both characters are removed. Applying
chop to an empty string returns an empty
string. String#chomp is often a safer alternative, as it leaves
the string unchanged if it doesn't end in a record separator.
"string\r\n".chop #=> "string"
"string\n\r".chop #=> "string\n"
"string\n".chop #=> "string"
"string".chop #=> "strin"
"x".chop.chop #=> ""
; T;[o;7
;8I"
overload; F;90;;;:0;;I" chop; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@9;[ ;I"@return [String]; T;0;@9; F;=i ;>0;5[ ;@9;[ ;I")Returns a new String with the last character removed. If the
string ends with \r\n, both characters are removed. Applying
chop to an empty string returns an empty
string. String#chomp is often a safer alternative, as it leaves
the string unchanged if it doesn't end in a record separator.
"string\r\n".chop #=> "string"
"string\n\r".chop #=> "string\n"
"string\n".chop #=> "string"
"string".chop #=> "strin"
"x".chop.chop #=> ""
@overload chop
@return [String]; T;0;@9; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"cstatic VALUE
rb_str_chop(VALUE str)
{
return rb_str_subseq(str, 0, chopped_length(str));
}; T;BTo;1;2F;3;4;;;#I"String#chomp; F;5[[@0; [[@*i;
T;:
chomp;0;[ ;{ ;IC;"LReturns a new String with the given record separator removed
from the end of str (if present). If $/ has not been
changed from the default Ruby record separator, then chomp also
removes carriage return characters (that is it will remove \n,
\r, and \r\n). If $/ is an empty string,
it will remove all trailing newlines from the string.
"hello".chomp #=> "hello"
"hello\n".chomp #=> "hello"
"hello\r\n".chomp #=> "hello"
"hello\n\r".chomp #=> "hello\n"
"hello\r".chomp #=> "hello"
"hello \n there".chomp #=> "hello \n there"
"hello".chomp("llo") #=> "he"
"hello\r\n\r\n".chomp('') #=> "hello"
"hello\r\n\r\r\n".chomp('') #=> "hello\r\n\r"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"chomp(separator=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@9;[ ;I"@return [String]; T;0;@9; F;=i ;>0;5[[I"separator; TI"$/; T;@9;[ ;I"Returns a new String with the given record separator removed
from the end of str (if present). If $/ has not been
changed from the default Ruby record separator, then chomp also
removes carriage return characters (that is it will remove \n,
\r, and \r\n). If $/ is an empty string,
it will remove all trailing newlines from the string.
"hello".chomp #=> "hello"
"hello\n".chomp #=> "hello"
"hello\r\n".chomp #=> "hello"
"hello\n\r".chomp #=> "hello\n"
"hello\r".chomp #=> "hello"
"hello \n there".chomp #=> "hello \n there"
"hello".chomp("llo") #=> "he"
"hello\r\n\r\n".chomp('') #=> "hello"
"hello\r\n\r\r\n".chomp('') #=> "hello\r\n\r"
@overload chomp(separator=$/)
@return [String]; T;0;@9; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_chomp(int argc, VALUE *argv, VALUE str)
{
str = rb_str_dup(str);
rb_str_chomp_bang(argc, argv, str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#strip; F;5[ ; [[@*iJ ;
T;:
strip;0;[ ;{ ;IC;"Returns a copy of str with leading and trailing whitespace removed.
" hello ".strip #=> "hello"
"\tgoodbye\r\n".strip #=> "goodbye"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
strip; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@9;[ ;I"@return [String]; T;0;@9; F;=i ;>0;5[ ;@9;[ ;I"Returns a copy of str with leading and trailing whitespace removed.
" hello ".strip #=> "hello"
"\tgoodbye\r\n".strip #=> "goodbye"
@overload strip
@return [String]; T;0;@9; F; o; ; T; i@ ;!iG ;"@-;;I"static VALUE; T;AI"tstatic VALUE
rb_str_strip(VALUE str)
{
str = rb_str_dup(str);
rb_str_strip_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#lstrip; F;5[ ; [[@*i;
T;: lstrip;0;[ ;{ ;IC;"Returns a copy of str with leading whitespace removed. See also
String#rstrip and String#strip.
" hello ".lstrip #=> "hello "
"hello".lstrip #=> "hello"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" lstrip; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@:;[ ;I"@return [String]; T;0;@:; F;=i ;>0;5[ ;@:;[ ;I"Returns a copy of str with leading whitespace removed. See also
String#rstrip and String#strip.
" hello ".lstrip #=> "hello "
"hello".lstrip #=> "hello"
@overload lstrip
@return [String]; T;0;@:; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"vstatic VALUE
rb_str_lstrip(VALUE str)
{
str = rb_str_dup(str);
rb_str_lstrip_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#rstrip; F;5[ ; [[@*i$ ;
T;: rstrip;0;[ ;{ ;IC;"Returns a copy of str with trailing whitespace removed. See also
String#lstrip and String#strip.
" hello ".rstrip #=> " hello"
"hello".rstrip #=> "hello"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rstrip; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@5:;[ ;I"@return [String]; T;0;@5:; F;=i ;>0;5[ ;@5:;[ ;I"Returns a copy of str with trailing whitespace removed. See also
String#lstrip and String#strip.
" hello ".rstrip #=> " hello"
"hello".rstrip #=> "hello"
@overload rstrip
@return [String]; T;0;@5:; F; o; ; T; i ;!i! ;"@-;;I"static VALUE; T;AI"vstatic VALUE
rb_str_rstrip(VALUE str)
{
str = rb_str_dup(str);
rb_str_rstrip_bang(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#sub!; F;5[[@0; [[@*i;
T;: sub!;0;[ ;{ ;IC;"Performs the same substitution as String#sub in-place.
Returns +str+ if a substitution was performed or +nil+ if no substitution
was performed.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" sub!(pattern, replacement); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@P:;[ ;I"@return [String, nil]; T;0;@P:; F;=i ;>0;5[[I" pattern; T0[I"replacement; T0;@P:o;7
;8I"
overload; F;90;;;:0;;I"sub!(pattern); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"
match; T;@P:o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@P:;[ ;I")@yield [match]
@return [String, nil]; T;0;@P:; F;=i ;>0;5[[I" pattern; T0;@P:;[ ;I"Performs the same substitution as String#sub in-place.
Returns +str+ if a substitution was performed or +nil+ if no substitution
was performed.
@overload sub!(pattern, replacement)
@return [String, nil]
@overload sub!(pattern)
@yield [match]
@return [String, nil]; T;0;@P:; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"7
static VALUE
rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
{
VALUE pat, repl, hash = Qnil;
int iter = 0;
int tainted = 0;
long plen;
int min_arity = rb_block_given_p() ? 1 : 2;
rb_check_arity(argc, min_arity, 2);
if (argc == 1) {
iter = 1;
}
else {
repl = argv[1];
hash = rb_check_hash_type(argv[1]);
if (NIL_P(hash)) {
StringValue(repl);
}
tainted = OBJ_TAINTED_RAW(repl);
}
pat = get_pat(argv[0], 1);
str_modifiable(str);
if (rb_reg_search(pat, str, 0, 0) >= 0) {
rb_encoding *enc;
int cr = ENC_CODERANGE(str);
VALUE match = rb_backref_get();
struct re_registers *regs = RMATCH_REGS(match);
long beg0 = BEG(0);
long end0 = END(0);
char *p, *rp;
long len, rlen;
if (iter || !NIL_P(hash)) {
p = RSTRING_PTR(str); len = RSTRING_LEN(str);
if (iter) {
repl = rb_obj_as_string(rb_yield(rb_reg_nth_match(0, match)));
}
else {
repl = rb_hash_aref(hash, rb_str_subseq(str, beg0, end0 - beg0));
repl = rb_obj_as_string(repl);
}
str_mod_check(str, p, len);
rb_check_frozen(str);
}
else {
repl = rb_reg_regsub(repl, str, regs, pat);
}
enc = rb_enc_compatible(str, repl);
if (!enc) {
rb_encoding *str_enc = STR_ENC_GET(str);
p = RSTRING_PTR(str); len = RSTRING_LEN(str);
if (coderange_scan(p, beg0, str_enc) != ENC_CODERANGE_7BIT ||
coderange_scan(p+end0, len-end0, str_enc) != ENC_CODERANGE_7BIT) {
rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s",
rb_enc_name(str_enc),
rb_enc_name(STR_ENC_GET(repl)));
}
enc = STR_ENC_GET(repl);
}
rb_str_modify(str);
rb_enc_associate(str, enc);
tainted |= OBJ_TAINTED_RAW(repl);
if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) {
int cr2 = ENC_CODERANGE(repl);
if (cr2 == ENC_CODERANGE_BROKEN ||
(cr == ENC_CODERANGE_VALID && cr2 == ENC_CODERANGE_7BIT))
cr = ENC_CODERANGE_UNKNOWN;
else
cr = cr2;
}
plen = end0 - beg0;
rp = RSTRING_PTR(repl); rlen = RSTRING_LEN(repl);
len = RSTRING_LEN(str);
if (rlen > plen) {
RESIZE_CAPA(str, len + rlen - plen);
}
p = RSTRING_PTR(str);
if (rlen != plen) {
memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen);
}
memcpy(p + beg0, rp, rlen);
len += rlen - plen;
STR_SET_LEN(str, len);
RSTRING_PTR(str)[len] = '\0';
ENC_CODERANGE_SET(str, cr);
FL_SET_RAW(str, tainted);
return str;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#gsub!; F;5[[@0; [[@*i;
T;:
gsub!;0;[ ;{ ;IC;"Performs the substitutions of String#gsub in place, returning
str, or nil if no substitutions were performed.
If no block and no replacement is given, an enumerator is returned instead.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" gsub!(pattern, replacement); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@:;[ ;I"@return [String, nil]; T;0;@:; F;=i ;>0;5[[I" pattern; T0[I"replacement; T0;@:o;7
;8I"
overload; F;90;;;:0;;I"gsub!(pattern); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"
match; T;@:o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@:;[ ;I")@yield [match]
@return [String, nil]; T;0;@:; F;=i ;>0;5[[I" pattern; T0;@:o;7
;8I"
overload; F;90;;;:0;;I"gsub!(pattern); T;IC;" ; T;[ ;[ ;I" ; T;0;@:; F;=i ;>0;5[[I" pattern; T0;@:;[ ;I"|Performs the substitutions of String#gsub in place, returning
str, or nil if no substitutions were performed.
If no block and no replacement is given, an enumerator is returned instead.
@overload gsub!(pattern, replacement)
@return [String, nil]
@overload gsub!(pattern)
@yield [match]
@return [String, nil]
@overload gsub!(pattern); T;0;@:; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_gsub_bang(int argc, VALUE *argv, VALUE str)
{
str_modify_keep_cr(str);
return str_gsub(argc, argv, str, 1);
}; T;BTo;1;2F;3;4;;;#I"String#chop!; F;5[ ; [[@*i;
T;:
chop!;0;[ ;{ ;IC;"Processes str as for String#chop, returning str,
or nil if str is the empty string. See also
String#chomp!.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
chop!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@:;[ ;I"@return [String, nil]; T;0;@:; F;=i ;>0;5[ ;@:;[ ;I"Processes str as for String#chop, returning str,
or nil if str is the empty string. See also
String#chomp!.
@overload chop!
@return [String, nil]; T;0;@:; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI">static VALUE
rb_str_chop_bang(VALUE str)
{
str_modify_keep_cr(str);
if (RSTRING_LEN(str) > 0) {
long len;
len = chopped_length(str);
STR_SET_LEN(str, len);
RSTRING_PTR(str)[len] = '\0';
if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
ENC_CODERANGE_CLEAR(str);
}
return str;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#chomp!; F;5[[@0; [[@*i&;
T;: chomp!;0;[ ;{ ;IC;"Modifies str in place as described for String#chomp,
returning str, or nil if no modifications were made.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"chomp!(separator=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@:;[ ;I"@return [String, nil]; T;0;@:; F;=i ;>0;5[[I"separator; TI"$/; T;@:;[ ;I"Modifies str in place as described for String#chomp,
returning str, or nil if no modifications were made.
@overload chomp!(separator=$/)
@return [String, nil]; T;0;@:; F; o; ; T; i ;!i#;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_chomp_bang(int argc, VALUE *argv, VALUE str)
{
rb_encoding *enc;
VALUE rs;
int newline;
char *p, *pp, *e;
long len, rslen;
str_modify_keep_cr(str);
len = RSTRING_LEN(str);
if (len == 0) return Qnil;
p = RSTRING_PTR(str);
e = p + len;
if (argc == 0) {
rs = rb_rs;
if (rs == rb_default_rs) {
smart_chomp:
enc = rb_enc_get(str);
if (rb_enc_mbminlen(enc) > 1) {
pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc);
if (rb_enc_is_newline(pp, e, enc)) {
e = pp;
}
pp = e - rb_enc_mbminlen(enc);
if (pp >= p) {
pp = rb_enc_left_char_head(p, pp, e, enc);
if (rb_enc_ascget(pp, e, 0, enc) == '\r') {
e = pp;
}
}
if (e == RSTRING_END(str)) {
return Qnil;
}
len = e - RSTRING_PTR(str);
STR_SET_LEN(str, len);
}
else {
if (RSTRING_PTR(str)[len-1] == '\n') {
STR_DEC_LEN(str);
if (RSTRING_LEN(str) > 0 &&
RSTRING_PTR(str)[RSTRING_LEN(str)-1] == '\r') {
STR_DEC_LEN(str);
}
}
else if (RSTRING_PTR(str)[len-1] == '\r') {
STR_DEC_LEN(str);
}
else {
return Qnil;
}
}
RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
return str;
}
}
else {
rb_scan_args(argc, argv, "01", &rs);
}
if (NIL_P(rs)) return Qnil;
StringValue(rs);
rslen = RSTRING_LEN(rs);
if (rslen == 0) {
while (len>0 && p[len-1] == '\n') {
len--;
if (len>0 && p[len-1] == '\r')
len--;
}
if (len < RSTRING_LEN(str)) {
STR_SET_LEN(str, len);
RSTRING_PTR(str)[len] = '\0';
return str;
}
return Qnil;
}
if (rslen > len) return Qnil;
newline = RSTRING_PTR(rs)[rslen-1];
if (rslen == 1 && newline == '\n')
goto smart_chomp;
enc = rb_enc_check(str, rs);
if (is_broken_string(rs)) {
return Qnil;
}
pp = e - rslen;
if (p[len-1] == newline &&
(rslen <= 1 ||
memcmp(RSTRING_PTR(rs), pp, rslen) == 0)) {
if (rb_enc_left_char_head(p, pp, e, enc) != pp)
return Qnil;
if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) {
ENC_CODERANGE_CLEAR(str);
}
STR_SET_LEN(str, RSTRING_LEN(str) - rslen);
RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
return str;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#strip!; F;5[ ; [[@*i5 ;
T;: strip!;0;[ ;{ ;IC;"uRemoves leading and trailing whitespace from str. Returns
nil if str was not altered.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" strip!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@;;[ ;I"@return [String, nil]; T;0;@;; F;=i ;>0;5[ ;@;;[ ;I"Removes leading and trailing whitespace from str. Returns
nil if str was not altered.
@overload strip!
@return [String, nil]; T;0;@;; F; o; ; T; i- ;!i2 ;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_strip_bang(VALUE str)
{
VALUE l = rb_str_lstrip_bang(str);
VALUE r = rb_str_rstrip_bang(str);
if (NIL_P(l) && NIL_P(r)) return Qnil;
return str;
}; T;BTo;1;2F;3;4;;;#I"String#lstrip!; F;5[ ; [[@*i;
T;: lstrip!;0;[ ;{ ;IC;"Removes leading whitespace from str, returning nil if no
change was made. See also String#rstrip! and
String#strip!.
" hello ".lstrip #=> "hello "
"hello".lstrip! #=> nil
; T;[o;7
;8I"
overload; F;90;;;:0;;I" lstrip!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" self; TI"nil; T;@ ;;[ ;I"@return [self, nil]; T;0;@ ;; F;=i ;>0;5[ ;@ ;;[ ;I"Removes leading whitespace from str, returning nil if no
change was made. See also String#rstrip! and
String#strip!.
" hello ".lstrip #=> "hello "
"hello".lstrip! #=> nil
@overload lstrip!
@return [self, nil]; T;0;@ ;; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"Xstatic VALUE
rb_str_lstrip_bang(VALUE str)
{
rb_encoding *enc;
char *s, *t, *e;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
s = RSTRING_PTR(str);
if (!s || RSTRING_LEN(str) == 0) return Qnil;
e = t = RSTRING_END(str);
/* remove spaces at head */
while (s < e) {
int n;
unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
if (!rb_isspace(cc)) break;
s += n;
}
if (s > RSTRING_PTR(str)) {
STR_SET_LEN(str, t-s);
memmove(RSTRING_PTR(str), s, RSTRING_LEN(str));
RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
return str;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#rstrip!; F;5[ ; [[@*i;
T;: rstrip!;0;[ ;{ ;IC;"Removes trailing whitespace from str, returning nil if
no change was made. See also String#lstrip! and
String#strip!.
" hello ".rstrip #=> " hello"
"hello".rstrip! #=> nil
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rstrip!; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" self; TI"nil; T;@:;;[ ;I"@return [self, nil]; T;0;@:;; F;=i ;>0;5[ ;@:;;[ ;I"Removes trailing whitespace from str, returning nil if
no change was made. See also String#lstrip! and
String#strip!.
" hello ".rstrip #=> " hello"
"hello".rstrip! #=> nil
@overload rstrip!
@return [self, nil]; T;0;@:;; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI" static VALUE
rb_str_rstrip_bang(VALUE str)
{
rb_encoding *enc;
char *s, *t, *e;
str_modify_keep_cr(str);
enc = STR_ENC_GET(str);
rb_str_check_dummy_enc(enc);
s = RSTRING_PTR(str);
if (!s || RSTRING_LEN(str) == 0) return Qnil;
t = e = RSTRING_END(str);
/* remove trailing spaces or '\0's */
if (single_byte_optimizable(str)) {
unsigned char c;
while (s < t && ((c = *(t-1)) == '\0' || ascii_isspace(c))) t--;
}
else {
char *tp;
while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
unsigned int c = rb_enc_codepoint(tp, e, enc);
if (c && !rb_isspace(c)) break;
t = tp;
}
}
if (t < e) {
long len = t-RSTRING_PTR(str);
STR_SET_LEN(str, len);
RSTRING_PTR(str)[len] = '\0';
return str;
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"String#tr; F;5[[I"src; T0[I" repl; T0; [[@*iE;
T;:tr;0;[ ;{ ;IC;"Returns a copy of +str+ with the characters in +from_str+ replaced by the
corresponding characters in +to_str+. If +to_str+ is shorter than
+from_str+, it is padded with its last character in order to maintain the
correspondence.
"hello".tr('el', 'ip') #=> "hippo"
"hello".tr('aeiou', '*') #=> "h*ll*"
"hello".tr('aeiou', 'AA*') #=> "hAll*"
Both strings may use the c1-c2 notation to denote ranges of
characters, and +from_str+ may start with a ^, which denotes
all characters except those listed.
"hello".tr('a-y', 'b-z') #=> "ifmmp"
"hello".tr('^aeiou', '*') #=> "*e**o"
The backslash character \ can be used to escape
^ or - and is otherwise ignored unless it
appears at the end of a range or the end of the +from_str+ or +to_str+:
"hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld"
"hello-world".tr("a\\-eo", "*") #=> "h*ll**w*rld"
"hello\r\nworld".tr("\r", "") #=> "hello\nworld"
"hello\r\nworld".tr("\\r", "") #=> "hello\r\nwold"
"hello\r\nworld".tr("\\\r", "") #=> "hello\nworld"
"X['\\b']".tr("X\\", "") #=> "['b']"
"X['\\b']".tr("X-\\]", "") #=> "'b'"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"tr(from_str, to_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@V;;[ ;I"@return [String]; T;0;@V;; F;=i ;>0;5[[I"
from_str; T0[I" to_str; T0;@V;;[ ;I"Returns a copy of +str+ with the characters in +from_str+ replaced by the
corresponding characters in +to_str+. If +to_str+ is shorter than
+from_str+, it is padded with its last character in order to maintain the
correspondence.
"hello".tr('el', 'ip') #=> "hippo"
"hello".tr('aeiou', '*') #=> "h*ll*"
"hello".tr('aeiou', 'AA*') #=> "hAll*"
Both strings may use the c1-c2 notation to denote ranges of
characters, and +from_str+ may start with a ^, which denotes
all characters except those listed.
"hello".tr('a-y', 'b-z') #=> "ifmmp"
"hello".tr('^aeiou', '*') #=> "*e**o"
The backslash character \ can be used to escape
^ or - and is otherwise ignored unless it
appears at the end of a range or the end of the +from_str+ or +to_str+:
"hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld"
"hello-world".tr("a\\-eo", "*") #=> "h*ll**w*rld"
"hello\r\nworld".tr("\r", "") #=> "hello\nworld"
"hello\r\nworld".tr("\\r", "") #=> "hello\r\nwold"
"hello\r\nworld".tr("\\\r", "") #=> "hello\nworld"
"X['\\b']".tr("X\\", "") #=> "['b']"
"X['\\b']".tr("X-\\]", "") #=> "'b'"
@overload tr(from_str, to_str)
@return [String]; T;0;@V;; F; o; ; T; i";!iB;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_tr(VALUE str, VALUE src, VALUE repl)
{
str = rb_str_dup(str);
tr_trans(str, src, repl, 0);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#tr_s; F;5[[I"src; T0[I" repl; T0; [[@*i;
T;: tr_s;0;[ ;{ ;IC;"Processes a copy of str as described under String#tr,
then removes duplicate characters in regions that were affected by the
translation.
"hello".tr_s('l', 'r') #=> "hero"
"hello".tr_s('el', '*') #=> "h*o"
"hello".tr_s('el', 'hx') #=> "hhxo"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"tr_s(from_str, to_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@y;;[ ;I"@return [String]; T;0;@y;; F;=i ;>0;5[[I"
from_str; T0[I" to_str; T0;@y;;[ ;I"NProcesses a copy of str as described under String#tr,
then removes duplicate characters in regions that were affected by the
translation.
"hello".tr_s('l', 'r') #=> "hero"
"hello".tr_s('el', '*') #=> "h*o"
"hello".tr_s('el', 'hx') #=> "hhxo"
@overload tr_s(from_str, to_str)
@return [String]; T;0;@y;; F; o; ; T; i{;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_tr_s(VALUE str, VALUE src, VALUE repl)
{
str = rb_str_dup(str);
tr_trans(str, src, repl, 1);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#delete; F;5[[@0; [[@*i;
T;: delete;0;[ ;{ ;IC;"cReturns a copy of str with all characters in the intersection of its
arguments deleted. Uses the same rules for building the set of characters as
String#count.
"hello".delete "l","lo" #=> "heo"
"hello".delete "lo" #=> "he"
"hello".delete "aeiou", "^e" #=> "hell"
"hello".delete "ej-m" #=> "ho"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"delete([other_str]+); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;;[ ;I"@return [String]; T;0;@;; F;=i ;>0;5[[I"[other_str]; T0;@;;[ ;I"Returns a copy of str with all characters in the intersection of its
arguments deleted. Uses the same rules for building the set of characters as
String#count.
"hello".delete "l","lo" #=> "heo"
"hello".delete "lo" #=> "he"
"hello".delete "aeiou", "^e" #=> "hell"
"hello".delete "ej-m" #=> "ho"
@overload delete([other_str]+)
@return [String]; T;0;@;; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_delete(int argc, VALUE *argv, VALUE str)
{
str = rb_str_dup(str);
rb_str_delete_bang(argc, argv, str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#squeeze; F;5[[@0; [[@*ic;
T;: squeeze;0;[ ;{ ;IC;"Builds a set of characters from the other_str parameter(s) using the
procedure described for String#count. Returns a new string
where runs of the same character that occur in this set are replaced by a
single character. If no arguments are given, all runs of identical
characters are replaced by a single character.
"yellow moon".squeeze #=> "yelow mon"
" now is the".squeeze(" ") #=> " now is the"
"putters shoot balls".squeeze("m-z") #=> "puters shot balls"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"squeeze([other_str]*); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;;[ ;I"@return [String]; T;0;@;; F;=i ;>0;5[[I"[other_str]; T0;@;;[ ;I"=Builds a set of characters from the other_str parameter(s) using the
procedure described for String#count. Returns a new string
where runs of the same character that occur in this set are replaced by a
single character. If no arguments are given, all runs of identical
characters are replaced by a single character.
"yellow moon".squeeze #=> "yelow mon"
" now is the".squeeze(" ") #=> " now is the"
"putters shoot balls".squeeze("m-z") #=> "puters shot balls"
@overload squeeze([other_str]*)
@return [String]; T;0;@;; F; o; ; T; iT;!i`;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_squeeze(int argc, VALUE *argv, VALUE str)
{
str = rb_str_dup(str);
rb_str_squeeze_bang(argc, argv, str);
return str;
}; T;BTo;1;2F;3;4;;;#I"String#count; F;5[[@0; [[@*i;
T;:
count;0;[ ;{ ;IC;"sEach +other_str+ parameter defines a set of characters to count. The
intersection of these sets defines the characters to count in +str+. Any
+other_str+ that starts with a caret ^ is negated. The
sequence c1-c2 means all characters between c1 and c2. The
backslash character \ can be used to escape ^ or
- and is otherwise ignored unless it appears at the end of a
sequence or the end of a +other_str+.
a = "hello world"
a.count "lo" #=> 5
a.count "lo", "o" #=> 2
a.count "hello", "^l" #=> 4
a.count "ej-m" #=> 4
"hello^world".count "\\^aeiou" #=> 4
"hello-world".count "a\\-eo" #=> 4
c = "hello world\\r\\n"
c.count "\\" #=> 2
c.count "\\A" #=> 0
c.count "X-\\w" #=> 3
; T;[o;7
;8I"
overload; F;90;;;:0;;I"count([other_str]+); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;;[ ;I"@return [Fixnum]; T;0;@;; F;=i ;>0;5[[I"[other_str]; T0;@;;[ ;I"Each +other_str+ parameter defines a set of characters to count. The
intersection of these sets defines the characters to count in +str+. Any
+other_str+ that starts with a caret ^ is negated. The
sequence c1-c2 means all characters between c1 and c2. The
backslash character \ can be used to escape ^ or
- and is otherwise ignored unless it appears at the end of a
sequence or the end of a +other_str+.
a = "hello world"
a.count "lo" #=> 5
a.count "lo", "o" #=> 2
a.count "hello", "^l" #=> 4
a.count "ej-m" #=> 4
"hello^world".count "\\^aeiou" #=> 4
"hello-world".count "a\\-eo" #=> 4
c = "hello world\\r\\n"
c.count "\\" #=> 2
c.count "\\A" #=> 0
c.count "X-\\w" #=> 3
@overload count([other_str]+)
@return [Fixnum]; T;0;@;; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"`static VALUE
rb_str_count(int argc, VALUE *argv, VALUE str)
{
char table[TR_TABLE_SIZE];
rb_encoding *enc = 0;
VALUE del = 0, nodel = 0, tstr;
char *s, *send;
int i;
int ascompat;
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
tstr = argv[0];
StringValue(tstr);
enc = rb_enc_check(str, tstr);
if (argc == 1) {
const char *ptstr;
if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) &&
(ptstr = RSTRING_PTR(tstr),
ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (const unsigned char *)ptstr, (const unsigned char *)ptstr+1)) &&
!is_broken_string(str)) {
int n = 0;
int clen;
unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc);
s = RSTRING_PTR(str);
if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0);
send = RSTRING_END(str);
while (s < send) {
if (*(unsigned char*)s++ == c) n++;
}
return INT2NUM(n);
}
}
tr_setup_table(tstr, table, TRUE, &del, &nodel, enc);
for (i=1; iString#tr. Returns str, or nil if no
changes were made.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"tr!(from_str, to_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@;;[ ;I"@return [String, nil]; T;0;@;; F;=i ;>0;5[[I"
from_str; T0[I" to_str; T0;@;;[ ;I"Translates str in place, using the same rules as
String#tr. Returns str, or nil if no
changes were made.
@overload tr!(from_str, to_str)
@return [String, nil]; T;0;@;; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"nstatic VALUE
rb_str_tr_bang(VALUE str, VALUE src, VALUE repl)
{
return tr_trans(str, src, repl, 0);
}; T;BTo;1;2F;3;4;;;#I"String#tr_s!; F;5[[I"src; T0[I" repl; T0; [[@*it;
T;:
tr_s!;0;[ ;{ ;IC;"Performs String#tr_s processing on str in place,
returning str, or nil if no changes were made.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" tr_s!(from_str, to_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@<;[ ;I"@return [String, nil]; T;0;@<; F;=i ;>0;5[[I"
from_str; T0[I" to_str; T0;@<;[ ;I"Performs String#tr_s processing on str in place,
returning str, or nil if no changes were made.
@overload tr_s!(from_str, to_str)
@return [String, nil]; T;0;@<; F; o; ; T; il;!iq;"@-;;I"static VALUE; T;AI"pstatic VALUE
rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl)
{
return tr_trans(str, src, repl, 1);
}; T;BTo;1;2F;3;4;;;#I"String#delete!; F;5[[@0; [[@*i;
T;: delete!;0;[ ;{ ;IC;"|Performs a delete operation in place, returning str, or
nil if str was not modified.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"delete!([other_str]+); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@><;[ ;I"@return [String, nil]; T;0;@><; F;=i ;>0;5[[I"[other_str]; T0;@><;[ ;I"Performs a delete operation in place, returning str, or
nil if str was not modified.
@overload delete!([other_str]+)
@return [String, nil]; T;0;@><; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"!static VALUE
rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
{
char squeez[TR_TABLE_SIZE];
rb_encoding *enc = 0;
char *s, *send, *t;
VALUE del = 0, nodel = 0;
int modify = 0;
int i, ascompat, cr;
if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
for (i=0; inil if no changes were made.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"squeeze!([other_str]*); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@]<;[ ;I"@return [String, nil]; T;0;@]<; F;=i ;>0;5[[I"[other_str]; T0;@]<;[ ;I"Squeezes str in place, returning either str, or
nil if no changes were made.
@overload squeeze!([other_str]*)
@return [String, nil]; T;0;@]<; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"<static VALUE
rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
{
char squeez[TR_TABLE_SIZE];
rb_encoding *enc = 0;
VALUE del = 0, nodel = 0;
char *s, *send, *t;
int i, modify = 0;
int ascompat, singlebyte = single_byte_optimizable(str);
unsigned int save;
if (argc == 0) {
enc = STR_ENC_GET(str);
}
else {
for (i=0; i$/ by default), passing each substring in
turn to the supplied block. If a zero-length record separator is
supplied, the string is split into paragraphs delimited by
multiple successive newlines.
If no block is given, an enumerator is returned instead.
print "Example one\n"
"hello\nworld".each_line {|s| p s}
print "Example two\n"
"hello\nworld".each_line('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each_line('') {|s| p s}
produces:
Example one
"hello\n"
"world"
Example two
"hel"
"l"
"o\nworl"
"d"
Example three
"hello\n\n\n"
"world"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" each_line(separator=$/); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" substr; T;@|$/ by default), passing each substring in
turn to the supplied block. If a zero-length record separator is
supplied, the string is split into paragraphs delimited by
multiple successive newlines.
If no block is given, an enumerator is returned instead.
print "Example one\n"
"hello\nworld".each_line {|s| p s}
print "Example two\n"
"hello\nworld".each_line('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each_line('') {|s| p s}
produces:
Example one
"hello\n"
"world"
Example two
"hel"
"l"
"o\nworl"
"d"
Example three
"hello\n\n\n"
"world"
@overload each_line(separator=$/)
@yield [substr]
@return [String]
@overload each_line(separator=$/); T;0;@|<; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"static VALUE
rb_str_each_line(int argc, VALUE *argv, VALUE str)
{
return rb_str_enumerate_lines(argc, argv, str, 0);
}; T;BTo;1;2F;3;4;;;#I"String#each_byte; F;5[ ; [[@*i;
T;:each_byte;0;[ ;{ ;IC;"Passes each byte in str to the given block, or returns an
enumerator if no block is given.
"hello".each_byte {|c| print c, ' ' }
produces:
104 101 108 108 111
; T;[o;7
;8I"
overload; F;90;;;:0;;I"each_byte; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" fixnum; T;@Integer ordinal of each character in str,
also known as a codepoint when applied to Unicode strings to the
given block.
If no block is given, an enumerator is returned instead.
"hello\u0639".each_codepoint {|c| print c, ' ' }
produces:
104 101 108 108 111 1593
; T;[o;7
;8I"
overload; F;90;;;:0;;I"each_codepoint; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" integer; T;@Integer ordinal of each character in str,
also known as a codepoint when applied to Unicode strings to the
given block.
If no block is given, an enumerator is returned instead.
"hello\u0639".each_codepoint {|c| print c, ' ' }
produces:
104 101 108 108 111 1593
@overload each_codepoint
@yield [integer]
@return [String]
@overload each_codepoint; T;0;@<; F; o; ; T; i;!i;"@-;;I"static VALUE; T;AI"fstatic VALUE
rb_str_each_codepoint(VALUE str)
{
return rb_str_enumerate_codepoints(str, 0);
}; T;BTo;1;2F;3;4;;;#I"String#sum; F;5[[@0; [[@*iQ ;
T;:sum;0;[ ;{ ;IC;"3Returns a basic n-bit checksum of the characters in str,
where n is the optional Fixnum parameter, defaulting
to 16. The result is simply the sum of the binary value of each character in
str modulo 2**n - 1. This is not a particularly good
checksum.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"sum(n=16); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@#=;[ ;I"@return [Integer]; T;0;@#=; F;=i ;>0;5[[I"n; TI"16; T;@#=;[ ;I"]Returns a basic n-bit checksum of the characters in str,
where n is the optional Fixnum parameter, defaulting
to 16. The result is simply the sum of the binary value of each character in
str modulo 2**n - 1. This is not a particularly good
checksum.
@overload sum(n=16)
@return [Integer]; T;0;@#=; F; o; ; T; iF ;!iN ;"@-;;I"static VALUE; T;AI"-static VALUE
rb_str_sum(int argc, VALUE *argv, VALUE str)
{
VALUE vbits;
int bits;
char *ptr, *p, *pend;
long len;
VALUE sum = INT2FIX(0);
unsigned long sum0 = 0;
if (argc == 0) {
bits = 16;
}
else {
rb_scan_args(argc, argv, "01", &vbits);
bits = NUM2INT(vbits);
}
ptr = p = RSTRING_PTR(str);
len = RSTRING_LEN(str);
pend = p + len;
while (p < pend) {
if (FIXNUM_MAX - UCHAR_MAX < sum0) {
sum = rb_funcall(sum, '+', 1, LONG2FIX(sum0));
str_mod_check(str, ptr, len);
sum0 = 0;
}
sum0 += (unsigned char)*p;
p++;
}
if (bits == 0) {
if (sum0) {
sum = rb_funcall(sum, '+', 1, LONG2FIX(sum0));
}
}
else {
if (sum == INT2FIX(0)) {
if (bits < (int)sizeof(long)*CHAR_BIT) {
sum0 &= (((unsigned long)1)<*'') will use up all
remaining elements. The directives sSiIlL may each be
followed by an underscore (``_'') or
exclamation mark (``!'') to use the underlying
platform's native size for the specified type; otherwise, it uses a
platform-independent consistent size. Spaces are ignored in the
format string. See also Array#pack.
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now=20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]
This table summarizes the various formats and the Ruby classes
returned by each.
Integer | |
Directive | Returns | Meaning
-----------------------------------------------------------------
C | Integer | 8-bit unsigned (unsigned char)
S | Integer | 16-bit unsigned, native endian (uint16_t)
L | Integer | 32-bit unsigned, native endian (uint32_t)
Q | Integer | 64-bit unsigned, native endian (uint64_t)
| |
c | Integer | 8-bit signed (signed char)
s | Integer | 16-bit signed, native endian (int16_t)
l | Integer | 32-bit signed, native endian (int32_t)
q | Integer | 64-bit signed, native endian (int64_t)
| |
S_, S! | Integer | unsigned short, native endian
I, I_, I! | Integer | unsigned int, native endian
L_, L! | Integer | unsigned long, native endian
Q_, Q! | Integer | unsigned long long, native endian (ArgumentError
| | if the platform has no long long type.)
| | (Q_ and Q! is available since Ruby 2.1.)
| |
s_, s! | Integer | signed short, native endian
i, i_, i! | Integer | signed int, native endian
l_, l! | Integer | signed long, native endian
q_, q! | Integer | signed long long, native endian (ArgumentError
| | if the platform has no long long type.)
| | (q_ and q! is available since Ruby 2.1.)
| |
S> L> Q> | Integer | same as the directives without ">" except
s> l> q> | | big endian
S!> I!> | | (available since Ruby 1.9.3)
L!> Q!> | | "S>" is same as "n"
s!> i!> | | "L>" is same as "N"
l!> q!> | |
| |
S< L< Q< | Integer | same as the directives without "<" except
s< l< q< | | little endian
S!< I!< | | (available since Ruby 1.9.3)
L!< Q!< | | "S<" is same as "v"
s!< i!< | | "L<" is same as "V"
l!< q!< | |
| |
n | Integer | 16-bit unsigned, network (big-endian) byte order
N | Integer | 32-bit unsigned, network (big-endian) byte order
v | Integer | 16-bit unsigned, VAX (little-endian) byte order
V | Integer | 32-bit unsigned, VAX (little-endian) byte order
| |
U | Integer | UTF-8 character
w | Integer | BER-compressed integer (see Array.pack)
Float | |
Directive | Returns | Meaning
-----------------------------------------------------------------
D, d | Float | double-precision, native format
F, f | Float | single-precision, native format
E | Float | double-precision, little-endian byte order
e | Float | single-precision, little-endian byte order
G | Float | double-precision, network (big-endian) byte order
g | Float | single-precision, network (big-endian) byte order
String | |
Directive | Returns | Meaning
-----------------------------------------------------------------
A | String | arbitrary binary string (remove trailing nulls and ASCII spaces)
a | String | arbitrary binary string
Z | String | null-terminated string
B | String | bit string (MSB first)
b | String | bit string (LSB first)
H | String | hex string (high nibble first)
h | String | hex string (low nibble first)
u | String | UU-encoded string
M | String | quoted-printable, MIME encoding (see RFC2045)
m | String | base64 encoded string (RFC 2045) (default)
| | base64 encoded string (RFC 4648) if followed by 0
P | String | pointer to a structure (fixed-length string)
p | String | pointer to a null-terminated string
Misc. | |
Directive | Returns | Meaning
-----------------------------------------------------------------
@ | --- | skip to the offset given by the length argument
X | --- | skip backward one byte
x | --- | skip forward one byte
; T;[o;7
;8I"
overload; F;90;;;:0;;I"unpack(format); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@}?;[ ;I"@return [Array]; T;0;@}?; F;=i ;>0;5[[I" format; T0;@}?;[ ;I"Decodes str (which may contain binary data) according to the
format string, returning an array of each value extracted. The
format string consists of a sequence of single-character directives,
summarized in the table at the end of this entry.
Each directive may be followed
by a number, indicating the number of times to repeat with this
directive. An asterisk (``*'') will use up all
remaining elements. The directives sSiIlL may each be
followed by an underscore (``_'') or
exclamation mark (``!'') to use the underlying
platform's native size for the specified type; otherwise, it uses a
platform-independent consistent size. Spaces are ignored in the
format string. See also Array#pack.
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now=20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]
This table summarizes the various formats and the Ruby classes
returned by each.
Integer | |
Directive | Returns | Meaning
-----------------------------------------------------------------
C | Integer | 8-bit unsigned (unsigned char)
S | Integer | 16-bit unsigned, native endian (uint16_t)
L | Integer | 32-bit unsigned, native endian (uint32_t)
Q | Integer | 64-bit unsigned, native endian (uint64_t)
| |
c | Integer | 8-bit signed (signed char)
s | Integer | 16-bit signed, native endian (int16_t)
l | Integer | 32-bit signed, native endian (int32_t)
q | Integer | 64-bit signed, native endian (int64_t)
| |
S_, S! | Integer | unsigned short, native endian
I, I_, I! | Integer | unsigned int, native endian
L_, L! | Integer | unsigned long, native endian
Q_, Q! | Integer | unsigned long long, native endian (ArgumentError
| | if the platform has no long long type.)
| | (Q_ and Q! is available since Ruby 2.1.)
| |
s_, s! | Integer | signed short, native endian
i, i_, i! | Integer | signed int, native endian
l_, l! | Integer | signed long, native endian
q_, q! | Integer | signed long long, native endian (ArgumentError
| | if the platform has no long long type.)
| | (q_ and q! is available since Ruby 2.1.)
| |
S> L> Q> | Integer | same as the directives without ">" except
s> l> q> | | big endian
S!> I!> | | (available since Ruby 1.9.3)
L!> Q!> | | "S>" is same as "n"
s!> i!> | | "L>" is same as "N"
l!> q!> | |
| |
S< L< Q< | Integer | same as the directives without "<" except
s< l< q< | | little endian
S!< I!< | | (available since Ruby 1.9.3)
L!< Q!< | | "S<" is same as "v"
s!< i!< | | "L<" is same as "V"
l!< q!< | |
| |
n | Integer | 16-bit unsigned, network (big-endian) byte order
N | Integer | 32-bit unsigned, network (big-endian) byte order
v | Integer | 16-bit unsigned, VAX (little-endian) byte order
V | Integer | 32-bit unsigned, VAX (little-endian) byte order
| |
U | Integer | UTF-8 character
w | Integer | BER-compressed integer (see Array.pack)
Float | |
Directive | Returns | Meaning
-----------------------------------------------------------------
D, d | Float | double-precision, native format
F, f | Float | single-precision, native format
E | Float | double-precision, little-endian byte order
e | Float | single-precision, little-endian byte order
G | Float | double-precision, network (big-endian) byte order
g | Float | single-precision, network (big-endian) byte order
String | |
Directive | Returns | Meaning
-----------------------------------------------------------------
A | String | arbitrary binary string (remove trailing nulls and ASCII spaces)
a | String | arbitrary binary string
Z | String | null-terminated string
B | String | bit string (MSB first)
b | String | bit string (LSB first)
H | String | hex string (high nibble first)
h | String | hex string (low nibble first)
u | String | UU-encoded string
M | String | quoted-printable, MIME encoding (see RFC2045)
m | String | base64 encoded string (RFC 2045) (default)
| | base64 encoded string (RFC 4648) if followed by 0
P | String | pointer to a structure (fixed-length string)
p | String | pointer to a null-terminated string
Misc. | |
Directive | Returns | Meaning
-----------------------------------------------------------------
@ | --- | skip to the offset given by the length argument
X | --- | skip backward one byte
x | --- | skip forward one byte
@overload unpack(format)
@return [Array]; T;0;@}?; F; o; ; T; i;;!i;"@-;;I"static VALUE; T;AI"@;static VALUE
pack_unpack(VALUE str, VALUE fmt)
{
static const char hexdigits[] = "0123456789abcdef";
char *s, *send;
char *p, *pend;
VALUE ary;
char type;
long len, tmp_len;
int star;
#ifdef NATINT_PACK
int natint; /* native integer */
#endif
int block_p = rb_block_given_p();
int signed_p, integer_size, bigendian_p;
#define UNPACK_PUSH(item) do {\
VALUE item_val = (item);\
if (block_p) {\
rb_yield(item_val);\
}\
else {\
rb_ary_push(ary, item_val);\
}\
} while (0)
StringValue(str);
StringValue(fmt);
s = RSTRING_PTR(str);
send = s + RSTRING_LEN(str);
p = RSTRING_PTR(fmt);
pend = p + RSTRING_LEN(fmt);
ary = block_p ? Qnil : rb_ary_new();
while (p < pend) {
int explicit_endian = 0;
type = *p++;
#ifdef NATINT_PACK
natint = 0;
#endif
if (ISSPACE(type)) continue;
if (type == '#') {
while ((p < pend) && (*p != '\n')) {
p++;
}
continue;
}
star = 0;
{
modifiers:
switch (*p) {
case '_':
case '!':
if (strchr(natstr, type)) {
#ifdef NATINT_PACK
natint = 1;
#endif
p++;
}
else {
rb_raise(rb_eArgError, "'%c' allowed only after types %s", *p, natstr);
}
goto modifiers;
case '<':
case '>':
if (!strchr(endstr, type)) {
rb_raise(rb_eArgError, "'%c' allowed only after types %s", *p, endstr);
}
if (explicit_endian) {
rb_raise(rb_eRangeError, "Can't use both '<' and '>'");
}
explicit_endian = *p++;
goto modifiers;
}
}
if (p >= pend)
len = 1;
else if (*p == '*') {
star = 1;
len = send - s;
p++;
}
else if (ISDIGIT(*p)) {
errno = 0;
len = STRTOUL(p, (char**)&p, 10);
if (errno) {
rb_raise(rb_eRangeError, "pack length too big");
}
}
else {
len = (type != '@');
}
switch (type) {
case '%':
rb_raise(rb_eArgError, "%% is not supported");
break;
case 'A':
if (len > send - s) len = send - s;
{
long end = len;
char *t = s + len - 1;
while (t >= s) {
if (*t != ' ' && *t != '\0') break;
t--; len--;
}
UNPACK_PUSH(infected_str_new(s, len, str));
s += end;
}
break;
case 'Z':
{
char *t = s;
if (len > send-s) len = send-s;
while (t < s+len && *t) t++;
UNPACK_PUSH(infected_str_new(s, t-s, str));
if (t < send) t++;
s = star ? t : s+len;
}
break;
case 'a':
if (len > send - s) len = send - s;
UNPACK_PUSH(infected_str_new(s, len, str));
s += len;
break;
case 'b':
{
VALUE bitstr;
char *t;
int bits;
long i;
if (p[-1] == '*' || len > (send - s) * 8)
len = (send - s) * 8;
bits = 0;
UNPACK_PUSH(bitstr = rb_usascii_str_new(0, len));
t = RSTRING_PTR(bitstr);
for (i=0; iString object holds and manipulates an arbitrary sequence of
bytes, typically representing characters. String objects may be created
using String::new or as literals.
Because of aliasing issues, users of strings should be aware of the methods
that modify the contents of a String object. Typically,
methods with names ending in ``!'' modify their receiver, while those
without a ``!'' return a new String. However, there are
exceptions, such as String#[]=.; T;[ ;[ ;I"A String object holds and manipulates an arbitrary sequence of
bytes, typically representing characters. String objects may be created
using String::new or as literals.
Because of aliasing issues, users of strings should be aware of the methods
that modify the contents of a String object. Typically,
methods with names ending in ``!'' modify their receiver, while those
without a ``!'' return a new String. However, there are
exceptions, such as String#[]=.
; T;0;@-; F; o; ; T; i0";!i:";=i ;"@;#I" String; F;v@ ;;qo; ;IC;[o;1;2F;3;4;;
;#I" Bug::Exception#enc_raise; F;5[[I"
encoding; T0[I" mesg; T0; [[I"%ext/-test-/exception/enc_raise.c; Ti ;
T;:enc_raise;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@ @; F;>0;"@ @;;I"static VALUE; T;AI"static VALUE
enc_raise(VALUE exc, VALUE encoding, VALUE mesg)
{
rb_enc_raise(rb_to_encoding(encoding), exc, "%s", StringValueCStr(mesg));
UNREACHABLE;
}; T;BTo;1;2T;3;q;;;#I" Bug::Exception.enc_raise; F;5@!@; @&@;
T;;;0;@)@;{ ;IC;" ; T;[ ;[ ;@f;0;@1@;=i ;"@ @;;@/@;A@0@;BT;l@ @;mIC;[ ;l@ @;nIC;[ ;l@ @;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/exception/init.c; Ti;
F;;S;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@ @;"@);#I"Bug::Exception; F;vo; ;0;0;0;;K;"@;@(;;qo;1;2F;3;4;;
;#I")Bug#tracepoint_track_objspace_events; F;5[ ; [[I"'ext/-test-/tracepoint/tracepoint.c; Ti=;
T;:%tracepoint_track_objspace_events;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@H@; F;>0;"@);;I"static VALUE; T;AI"sstatic VALUE
tracepoint_track_objspace_events(VALUE self)
{
struct tracepoint_track track = {0, 0, 0, 0, 0,};
VALUE tpval = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ | RUBY_INTERNAL_EVENT_FREEOBJ |
RUBY_INTERNAL_EVENT_GC_START | RUBY_INTERNAL_EVENT_GC_END_MARK |
RUBY_INTERNAL_EVENT_GC_END_SWEEP,
tracepoint_track_objspace_events_i, &track);
VALUE result = rb_ary_new();
rb_tracepoint_enable(tpval);
rb_ensure(rb_yield, Qundef, rb_tracepoint_disable, tpval);
rb_ary_push(result, SIZET2NUM(track.newobj_count));
rb_ary_push(result, SIZET2NUM(track.free_count));
rb_ary_push(result, SIZET2NUM(track.gc_start_count));
rb_ary_push(result, SIZET2NUM(track.gc_end_mark_count));
rb_ary_push(result, SIZET2NUM(track.gc_end_sweep_count));
rb_ary_cat(result, track.objects, track.objects_count);
return result;
}; T;BTo;1;2T;3;q;;;#I")Bug.tracepoint_track_objspace_events; F;5@J@; @K@;
T;;;0;@N@;{ ;IC;" ; T;[ ;[ ;@f;0;@V@;=i ;"@);;@T@;A@U@;BTo;1;2F;3;4;;
;#I"6Bug#tracepoint_specify_normal_and_internal_events; F;5[ ; [[@M@iT;
T;:2tracepoint_specify_normal_and_internal_events;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@\@; F;>0;"@);;I"static VALUE; T;AI"static VALUE
tracepoint_specify_normal_and_internal_events(VALUE self)
{
VALUE tpval = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ | RUBY_EVENT_CALL, 0, 0);
rb_tracepoint_enable(tpval);
return Qnil; /* should not be reached */
}; T;BTo;1;2T;3;q;;;#I"6Bug.tracepoint_specify_normal_and_internal_events; F;5@^@; @_@;
T;;;0;@a@;{ ;IC;" ; T;[ ;[ ;@f;0;@i@;=i ;"@);;@g@;A@h@;BTo; ;IC;[o;1;2F;3;q;;;#I"Bug::TypedData.check; F;5[[I"obj; T0; [[I"%ext/-test-/typeddata/typeddata.c; Ti ;
T;:
check;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@q@;"@o@;;I"static VALUE; T;AI"pstatic VALUE
test_check(VALUE self, VALUE obj)
{
rb_check_typeddata(obj, &test_data);
return obj;
}; T;BT;l@o@;mIC;[ ;l@o@;nIC;[ ;l@o@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@x@i;
F;:TypedData;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@o@;"@);#I"Bug::TypedData; F;vo; ;0;0;0;: Data;"@;o; ;IC;[ ;l@@;mIC;[ ;l@@;nIC;[ ;l@@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@R
io
[@R
iu
;
T;;;;@;;;[ ;{ ;IC;"~This is a recommended base class for C extensions using Data_Make_Struct
or Data_Wrap_Struct, see README.EXT for details.
; T;[ ;[ ;I"{
This is a recommended base class for C extensions using Data_Make_Struct
or Data_Wrap_Struct, see README.EXT for details.
; T;0;@@; F; o; ; T; io
;!ir
;"@;#I" Data; F;v@ ;;qo; ;IC;[
o;1;2F;3;4;;;#I"Bug::String#coderange; F;5[ ; [[I""ext/-test-/string/coderange.c; Ti
;
T;:coderange;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@@;;I"static VALUE; T;AI"^static VALUE
str_coderange(VALUE str)
{
switch (ENC_CODERANGE(str)) {
case ENC_CODERANGE_7BIT:
return sym_7bit;
case ENC_CODERANGE_VALID:
return sym_valid;
case ENC_CODERANGE_UNKNOWN:
return sym_unknown;
case ENC_CODERANGE_BROKEN:
return sym_broken;
}
rb_bug("wrong condition of coderange");
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"Bug::String#set_len; F;5[[I"len; T0; [[I" ext/-test-/string/set_len.c; Ti;
T;: set_len;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@@;;I"static VALUE; T;AI"sstatic VALUE
bug_str_set_len(VALUE str, VALUE len)
{
rb_str_set_len(str, NUM2LONG(len));
return str;
}; T;BTo;1;2F;3;4;;;#I"Bug::String#qsort!; F;5[[@0; [[I" ext/-test-/string/qsort.c; Ti!;
T;: qsort!;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@@;;I"static VALUE; T;AI"static VALUE
bug_str_qsort_bang(int argc, VALUE *argv, VALUE str)
{
VALUE beg, len, size;
long l, b = 0, n, s = 1;
struct sort_data d;
rb_scan_args(argc, argv, "03", &beg, &len, &size);
l = RSTRING_LEN(str);
if (!NIL_P(beg) && (b = NUM2INT(beg)) < 0 && (b += l) < 0) {
rb_raise(rb_eArgError, "out of bounds");
}
if (!NIL_P(size) && (s = NUM2INT(size)) < 0) {
rb_raise(rb_eArgError, "negative size");
}
if (NIL_P(len) ||
(((n = NUM2INT(len)) < 0) ?
(rb_raise(rb_eArgError, "negative length"), 0) :
(b + n * s > l))) {
n = (l - b) / s;
}
rb_str_modify(str);
d.enc = rb_enc_get(str);
d.elsize = s;
ruby_qsort(RSTRING_PTR(str) + b, n, s,
rb_block_given_p() ? cmp_1 : cmp_2, &d);
return str;
}; T;BTo;;IC;[o;1;2F;3;4;;;#I"#Bug::String::Yield#yield_block; F;5[[@0; [[I" ext/-test-/iter/yield.c; Ti;
T;:yield_block;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@@;;I"static VALUE; T;AI"static VALUE
yield_block(int argc, VALUE *argv, VALUE self)
{
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
return rb_block_call(self, rb_to_id(argv[0]), argc-1, argv+1, rb_yield_block, 0);
}; T;BT;l@@;mIC;[ ;l@@;nIC;[ ;l@@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@@i;
F;:
Yield;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;=i ;"@@;#I"Bug::String::Yield; Fo;;IC;[ o;1;2F;3;4;;
;#I"&Bug::String::Breakable#iter_break; F;5[ ; [[I" ext/-test-/iter/break.c; Ti;
T;:iter_break;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@@; F;>0;"@@;;I"static VALUE; T;AI"Sstatic VALUE
iter_break(VALUE self)
{
rb_iter_break();
UNREACHABLE;
}; T;BTo;1;2T;3;q;;;#I"&Bug::String::Breakable.iter_break; F;5@@; @@;
T;;;0;@@;{ ;IC;" ; T;[ ;[ ;@f;0;@@;=i ;"@@;;@@;A@@;BTo;1;2F;3;4;;
;#I",Bug::String::Breakable#iter_break_value; F;5[[I"val; T0; [[@@i;
T;:iter_break_value;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@A; F;>0;"@@;;I"static VALUE; T;AI"mstatic VALUE
iter_break_value(VALUE self, VALUE val)
{
rb_iter_break_value(val);
UNREACHABLE;
}; T;BTo;1;2T;3;q;;;#I",Bug::String::Breakable.iter_break_value; F;5@A; @
A;
T;;;0;@ A;{ ;IC;" ; T;[ ;[ ;@f;0;@A;=i ;"@@;;@A;A@A;BT;l@@;mIC;[ ;l@@;nIC;[ ;l@@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@@i;
F;:Breakable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@@;#I"Bug::String::Breakable; F;l@@;mIC;[ ;l@@;nIC;[ ;l@@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/string/init.c; Ti;
F;;;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@@;"@);#I"Bug::String; F;v@-o;1;2F;3;4;;
;#I"Bug#start; F;5[[I" hash; T0; [[I" ext/-test-/bug-3571/bug.c; Ti;
T;:
start;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@9A; F;>0;"@);;I"static VALUE; T;AI"static VALUE
bug_start(VALUE self, VALUE hash)
{
VALUE ary = rb_ary_new3(1, Qnil);
rb_block_call(ary, rb_intern("map"), 0, 0, bug_i, self);
return ary;
}; T;BTo;1;2T;3;q;;;#I"Bug.start; F;5@;A; @>A;
T;;;0;@AA;{ ;IC;" ; T;[ ;[ ;@f;0;@IA;=i ;"@);;@GA;A@HA;BTo;;IC;[ ;l@OA;mIC;[ ;l@OA;nIC;[ ;l@OA;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I"ext/-test-/iter/init.c; Ti;
F;: Iter;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@OA;"@);#I"Bug::Iter; Fo;;IC;[o;1;2F;3;4;;;#I"Bug::Method#get; F;5[[I" name; T0; [[I" ext/-test-/struct/member.c; Ti;
T;:get;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@cA;"@aA;;I"static VALUE; T;AI"static VALUE
bug_struct_get(VALUE obj, VALUE name)
{
ID id = rb_check_id(&name);
if (!id) {
rb_name_error_str(name, "`%"PRIsVALUE"' is not a struct member", name);
}
return rb_struct_getmember(obj, id);
}; T;BT;l@aA;mIC;[ ;l@aA;nIC;[ ;l@aA;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/method/init.c; Ti;
F;: Method;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@aA;"@);#I"Bug::Method; Fo;;IC;[ ;l@A;mIC;[ ;l@A;nIC;[ ;l@A;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I"ext/-test-/file/init.c; Ti;
F;: File;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@A;"@);#I"Bug::File; Fo; ;IC;[o;1;2F;3;q;;;#I"Bug::Struct.class2name; F;5[[I"
klass; T0; [[I""ext/-test-/class/class2name.c; Ti;
T;:class2name;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@A;"@A;;I"static VALUE; T;AI"static VALUE
class2name(VALUE self, VALUE klass)
{
const char *name = rb_class2name(klass);
return name ? rb_str_new_cstr(name) : Qnil;
}; T;BTo;
; [[I" ext/win32ole/win32ole.c; Ti%
;
F;:CONSTANTS;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@A;"@A;#I"Bug::Struct::CONSTANTS; F;$I"
constant; To;1;2F;3;4;;;#I" Bug::Struct#modify_expand!; F;5[[I" expand; T0; [[I" ext/-test-/string/modify.c; Ti;
T;:modify_expand!;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@A;"@A;;I"
VALUE; T;AI"~VALUE
bug_str_modify_expand(VALUE str, VALUE expand)
{
rb_str_modify_expand(str, NUM2LONG(expand));
return str;
}; T;BT;l@A;mIC;[ ;l@A;nIC;[ ;l@A;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/struct/init.c; Ti;
F;: Struct;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@A;"@);#I"Bug::Struct; F;vo; ;IC;[ o;1;2F;3;q;;;#I"Struct.new; F;5[[@0; [[I"
struct.c; Ti;
T;;M;0;[ ;{ ;IC;"The first two forms are used to create a new Struct subclass +class_name+
that can contain a value for each +member_name+. This subclass can be
used to create instances of the structure like any other Class.
If the +class_name+ is omitted an anonymous structure class will be
created. Otherwise, the name of this struct will appear as a constant in
class Struct, so it must be unique for all Structs in the system and
must start with a capital letter. Assigning a structure class to a
constant also gives the class the name of the constant.
# Create a structure with a name under Struct
Struct.new("Customer", :name, :address)
#=> Struct::Customer
Struct::Customer.new("Dave", "123 Main")
#=> #<=> method, or by using
the results of the supplied block. The block should return -1, 0, or
+1 depending on the comparison between a and b. As of
Ruby 1.8, the method Enumerable#sort_by implements a
built-in Schwartzian Transform, useful when key computation or
comparison is expensive.
%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]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" sort; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@HE;[ ;I"@return [Array]; T;0;@HE; F;=i ;>0;5[ ;@HEo;7
;8I"
overload; F;90;;;:0;;I" sort; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"a; TI"b; T;@HEo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@HE;[ ;I""@yield [a, b]
@return [Array]; T;0;@HE; F;=i ;>0;5[ ;@HE;[ ;I"~Returns an array containing the items in enum sorted,
either according to their own <=> method, or by using
the results of the supplied block. The block should return -1, 0, or
+1 depending on the comparison between a and b. As of
Ruby 1.8, the method Enumerable#sort_by implements a
built-in Schwartzian Transform, useful when key computation or
comparison is expensive.
%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]
@overload sort
@return [Array]
@overload sort
@yield [a, b]
@return [Array]; T;0;@HE; F; o; ; T; i*;!i:;"@D;;I"static VALUE; T;AI"Xstatic VALUE
enum_sort(VALUE obj)
{
return rb_ary_sort(enum_to_a(0, 0, obj));
}; T;BTo;1;2F;3;4;;;#I"Enumerable#sort_by; F;5[ ; [[@Di;
T;: sort_by;0;[ ;{ ;IC;"Sorts enum using a set of keys generated by mapping the
values in enum through the given block.
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"]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" sort_by; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@vEo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@vE;[ ;I"!@yield [obj]
@return [Array]; T;0;@vE; F;=i ;>0;5[ ;@vEo;7
;8I"
overload; F;90;;;:0;;I" sort_by; T;IC;" ; T;[ ;[ ;I" ; T;0;@vE; F;=i ;>0;5[ ;@vE;[ ;I" Sorts enum using a set of keys generated by mapping the
values in enum through the given block.
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"]
@overload sort_by
@yield [obj]
@return [Array]
@overload sort_by; T;0;@vE; F; o; ; T; iu;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_sort_by(VALUE obj)
{
VALUE ary, buf;
NODE *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 = NEW_MEMO(0, 0, 0);
OBJ_INFECT(memo, obj);
data = (struct sort_by_data *)&memo->u1;
data->ary = ary;
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;7
;8I"
overload; F;90;;;:0;;I"grep(pattern); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@E;[ ;I"@return [Array]; T;0;@E; F;=i ;>0;5[[I" pattern; T0;@Eo;7
;8I"
overload; F;90;;;:0;;I"grep(pattern); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Eo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@E;[ ;I"!@yield [obj]
@return [Array]; T;0;@E; F;=i ;>0;5[[I" pattern; T0;@E;[ ;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;@E; F; o; ; T; iK;!i\;"@D;;I"static VALUE; T;AI"static VALUE
enum_grep(VALUE obj, VALUE pat)
{
VALUE ary = rb_ary_new();
NODE *memo = NEW_MEMO(pat, ary, 0);
rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)memo);
return ary;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#count; F;5[[@0; [[@Di;
T;;;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;7
;8I"
overload; F;90;;;:0;;I"
count; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@E;[ ;I"@return [Integer]; T;0;@E; F;=i ;>0;5[ ;@Eo;7
;8I"
overload; F;90;;;:0;;I"count(item); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@E;[ ;I"@return [Integer]; T;0;@E; F;=i ;>0;5[[I" item; T0;@Eo;7
;8I"
overload; F;90;;;:0;;I"
count; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Eo;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@E;[ ;I"#@yield [obj]
@return [Integer]; T;0;@E; F;=i ;>0;5[ ;@E;[ ;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;@E; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI" static VALUE
enum_count(int argc, VALUE *argv, VALUE obj)
{
VALUE item = Qnil;
NODE *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 = NEW_MEMO(item, 0, 0);
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
return INT2NUM(memo->u3.cnt);
}; T;BTo;1;2F;3;4;;;#I"Enumerable#find; F;5[[@0; [[@Di;
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..10).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).find { |i| i % 5 == 0 and i % 7 == 0 } #=> 35
; T;[ o;7
;8I"
overload; F;90;: detect;:0;;I"detect(ifnone = nil); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Fo;<
;8I" return; F;9I" ; T;0;:[I" Object; TI"nil; T;@F;[ ;I"'@yield [obj]
@return [Object, nil]; T;0;@F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@Fo;7
;8I"
overload; F;90;;;:0;;I"find(ifnone = nil); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Fo;<
;8I" return; F;9I" ; T;0;:[I" Object; TI"nil; T;@F;[ ;I"'@yield [obj]
@return [Object, nil]; T;0;@F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@Fo;7
;8I"
overload; F;90;;;:0;;I"detect(ifnone = nil); T;IC;" ; T;[ ;[ ;I" ; T;0;@F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@Fo;7
;8I"
overload; F;90;;;:0;;I"find(ifnone = nil); T;IC;" ; T;[ ;[ ;I" ; T;0;@F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@F;[ ;I"iPasses 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..10).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).find { |i| i % 5 == 0 and i % 7 == 0 } #=> 35
@overload detect(ifnone = nil)
@yield [obj]
@return [Object, nil]
@overload find(ifnone = nil)
@yield [obj]
@return [Object, nil]
@overload detect(ifnone = nil)
@overload find(ifnone = nil); T;0;@F; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_find(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
VALUE if_none;
rb_scan_args(argc, argv, "01", &if_none);
RETURN_ENUMERATOR(obj, argc, argv);
memo = NEW_MEMO(Qundef, 0, 0);
rb_block_call(obj, id_each, 0, 0, find_i, (VALUE)memo);
if (memo->u3.cnt) {
return memo->u1.value;
}
if (!NIL_P(if_none)) {
return rb_funcall(if_none, id_call, 0, 0);
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#detect; F;5[[@0; [[@Di;
T;;;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..10).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).find { |i| i % 5 == 0 and i % 7 == 0 } #=> 35
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"detect(ifnone = nil); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@_Fo;<
;8I" return; F;9I" ; T;0;:[I" Object; TI"nil; T;@_F;[ ;I"'@yield [obj]
@return [Object, nil]; T;0;@_F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@_Fo;7
;8I"
overload; F;90;;;:0;;I"find(ifnone = nil); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@_Fo;<
;8I" return; F;9I" ; T;0;:[I" Object; TI"nil; T;@_F;[ ;I"'@yield [obj]
@return [Object, nil]; T;0;@_F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@_Fo;7
;8I"
overload; F;90;;;:0;;I"detect(ifnone = nil); T;IC;" ; T;[ ;[ ;I" ; T;0;@_F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@_Fo;7
;8I"
overload; F;90;;;:0;;I"find(ifnone = nil); T;IC;" ; T;[ ;[ ;I" ; T;0;@_F; F;=i ;>0;5[[I" ifnone; TI"nil; T;@_F;[ ;@[F;0;@_F; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_find(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
VALUE if_none;
rb_scan_args(argc, argv, "01", &if_none);
RETURN_ENUMERATOR(obj, argc, argv);
memo = NEW_MEMO(Qundef, 0, 0);
rb_block_call(obj, id_each, 0, 0, find_i, (VALUE)memo);
if (memo->u3.cnt) {
return memo->u1.value;
}
if (!NIL_P(if_none)) {
return rb_funcall(if_none, id_call, 0, 0);
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#find_index; F;5[[@0; [[@Di;
T;:find_index;0;[ ;{ ;IC;"Compares 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 and i % 7 == 0 } #=> nil
(1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> 34
(1..100).find_index(50) #=> 49
; T;[o;7
;8I"
overload; F;90;;;:0;;I"find_index(value); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; TI"nil; T;@F;[ ;I"@return [Integer, nil]; T;0;@F; F;=i ;>0;5[[I"
value; T0;@Fo;7
;8I"
overload; F;90;;;:0;;I"find_index; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Fo;<
;8I" return; F;9I" ; T;0;:[I" Integer; TI"nil; T;@F;[ ;I"(@yield [obj]
@return [Integer, nil]; T;0;@F; F;=i ;>0;5[ ;@Fo;7
;8I"
overload; F;90;;;:0;;I"find_index; T;IC;" ; T;[ ;[ ;I" ; T;0;@F; F;=i ;>0;5[ ;@F;[ ;I"kCompares 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 and i % 7 == 0 } #=> nil
(1..100).find_index { |i| i % 5 == 0 and 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; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"Estatic VALUE
enum_find_index(int argc, VALUE *argv, VALUE obj)
{
NODE *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 = NEW_MEMO(Qnil, condition_value, 0);
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#find_all; F;5[ ; [[@DiT;
T;:
find_all;0;[ ;{ ;IC;"/Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
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]
See also Enumerable#reject.
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"
find_all; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Fo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@F;[ ;I"!@yield [obj]
@return [Array]; T;0;@F; F;=i ;>0;5[ ;@Fo;7
;8I"
overload; F;90;;;:0;;I" select; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Fo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@F;[ ;I"!@yield [obj]
@return [Array]; T;0;@F; F;=i ;>0;5[ ;@Fo;7
;8I"
overload; F;90;;;:0;;I"
find_all; T;IC;" ; T;[ ;[ ;I" ; T;0;@F; F;=i ;>0;5[ ;@Fo;7
;8I"
overload; F;90;;;:0;;I" select; T;IC;" ; T;[ ;[ ;I" ; T;0;@F; F;=i ;>0;5[ ;@F;[ ;I"Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
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]
See also Enumerable#reject.
@overload find_all
@yield [obj]
@return [Array]
@overload select
@yield [obj]
@return [Array]
@overload find_all
@overload select; T;0;@F; F; o; ; T; i@;!iT;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"Enumerable#select; F;5[ ; [[@DiT;
T;;;0;[ ;{ ;IC;"/Returns an array containing all elements of +enum+
for which the given +block+ returns a true value.
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]
See also Enumerable#reject.
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"
find_all; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@+Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@+G;[ ;I"!@yield [obj]
@return [Array]; T;0;@+G; F;=i ;>0;5[ ;@+Go;7
;8I"
overload; F;90;;;:0;;I" select; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@+Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@+G;[ ;I"!@yield [obj]
@return [Array]; T;0;@+G; F;=i ;>0;5[ ;@+Go;7
;8I"
overload; F;90;;;:0;;I"
find_all; T;IC;" ; T;[ ;[ ;I" ; T;0;@+G; F;=i ;>0;5[ ;@+Go;7
;8I"
overload; F;90;;;:0;;I" select; T;IC;" ; T;[ ;[ ;I" ; T;0;@+G; F;=i ;>0;5[ ;@+G;[ ;@'G;0;@+G; F; o; ; T; i@;!iT;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"Enumerable#reject; F;5[ ; [[@Di};
T;: reject;0;[ ;{ ;IC;"0Returns 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;7
;8I"
overload; F;90;;;:0;;I" reject; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@lGo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@lG;[ ;I"!@yield [obj]
@return [Array]; T;0;@lG; F;=i ;>0;5[ ;@lGo;7
;8I"
overload; F;90;;;:0;;I" reject; T;IC;" ; T;[ ;[ ;I" ; T;0;@lG; F;=i ;>0;5[ ;@lG;[ ;I"uReturns 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;@lG; F; o; ; T; il;!i{;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"Enumerable#collect; F;5[ ; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I" collect; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@G;[ ;I"!@yield [obj]
@return [Array]; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;:map;:0;;I"map; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@G;[ ;I"!@yield [obj]
@return [Array]; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;;;:0;;I" collect; T;IC;" ; T;[ ;[ ;I" ; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;;;:0;;I"map; T;IC;" ; T;[ ;[ ;I" ; T;0;@G; F;=i ;>0;5[ ;@G;[ ;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;@G; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_collect(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, collect_i, ary);
return ary;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#map; F;5[ ; [[@Di;
T;;;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;7
;8I"
overload; F;90;;;:0;;I" collect; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@G;[ ;I"!@yield [obj]
@return [Array]; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;;;:0;;I"map; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Go;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@G;[ ;I"!@yield [obj]
@return [Array]; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;;;:0;;I" collect; T;IC;" ; T;[ ;[ ;I" ; T;0;@G; F;=i ;>0;5[ ;@Go;7
;8I"
overload; F;90;;;:0;;I"map; T;IC;" ; T;[ ;[ ;I" ; T;0;@G; F;=i ;>0;5[ ;@G;[ ;@G;0;@G; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_collect(VALUE obj)
{
VALUE ary;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, collect_i, ary);
return ary;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#flat_map; F;5[ ; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I"
flat_map; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@H;[ ;I"!@yield [obj]
@return [Array]; T;0;@H; F;=i ;>0;5[ ;@Ho;7
;8I"
overload; F;90;:collect_concat;:0;;I"collect_concat; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@H;[ ;I"!@yield [obj]
@return [Array]; T;0;@H; F;=i ;>0;5[ ;@Ho;7
;8I"
overload; F;90;;;:0;;I"
flat_map; T;IC;" ; T;[ ;[ ;I" ; T;0;@H; F;=i ;>0;5[ ;@Ho;7
;8I"
overload; F;90;;;:0;;I"collect_concat; T;IC;" ; T;[ ;[ ;I" ; T;0;@H; F;=i ;>0;5[ ;@H;[ ;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;@H; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" Enumerable#collect_concat; F;5[ ; [[@Di;
T;;;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;7
;8I"
overload; F;90;;;:0;;I"
flat_map; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@YHo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@YH;[ ;I"!@yield [obj]
@return [Array]; T;0;@YH; F;=i ;>0;5[ ;@YHo;7
;8I"
overload; F;90;;;:0;;I"collect_concat; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@YHo;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@YH;[ ;I"!@yield [obj]
@return [Array]; T;0;@YH; F;=i ;>0;5[ ;@YHo;7
;8I"
overload; F;90;;;:0;;I"
flat_map; T;IC;" ; T;[ ;[ ;I" ; T;0;@YH; F;=i ;>0;5[ ;@YHo;7
;8I"
overload; F;90;;;:0;;I"collect_concat; T;IC;" ; T;[ ;[ ;I" ; T;0;@YH; F;=i ;>0;5[ ;@YH;[ ;@UH;0;@YH; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"Enumerable#inject; F;5[[@0; [[@Di{;
T;: inject;0;[ ;{ ;IC;"Combines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
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;7
;8I"
overload; F;90;;;:0;;I"inject(initial, sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"@return [Object]; T;0;@H; F;=i ;>0;5[[I" initial; T0[I"sym; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I"inject(sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"@return [Object]; T;0;@H; F;=i ;>0;5[[I"sym; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I"inject(initial); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@H; F;=i ;>0;5[[I" initial; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I" inject; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@H; F;=i ;>0;5[ ;@Ho;7
;8I"
overload; F;90;: reduce;:0;;I"reduce(initial, sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"@return [Object]; T;0;@H; F;=i ;>0;5[[I" initial; T0[I"sym; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I"reduce(sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"@return [Object]; T;0;@H; F;=i ;>0;5[[I"sym; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I"reduce(initial); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@H; F;=i ;>0;5[[I" initial; T0;@Ho;7
;8I"
overload; F;90;;;:0;;I" reduce; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@Ho;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@H;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@H; F;=i ;>0;5[ ;@H;[ ;I"Combines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
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;@H; F; o; ; T; iP;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_inject(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
VALUE init, op;
rb_block_call_func *iter = inject_i;
ID id;
switch (rb_scan_args(argc, argv, "02", &init, &op)) {
case 0:
break;
case 1:
if (rb_block_given_p()) {
break;
}
id = rb_check_id(&init);
op = id ? ID2SYM(id) : init;
argc = 0;
init = Qnil;
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;
}
memo = NEW_MEMO(init, argc, op);
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#reduce; F;5[[@0; [[@Di{;
T;;;0;[ ;{ ;IC;"Combines all elements of enum by applying a binary
operation, specified by a block or a symbol that names a
method or operator.
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;7
;8I"
overload; F;90;;;:0;;I"inject(initial, sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"@return [Object]; T;0;@9I; F;=i ;>0;5[[I" initial; T0[I"sym; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I"inject(sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"@return [Object]; T;0;@9I; F;=i ;>0;5[[I"sym; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I"inject(initial); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@9Io;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@9I; F;=i ;>0;5[[I" initial; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I" inject; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@9Io;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@9I; F;=i ;>0;5[ ;@9Io;7
;8I"
overload; F;90;;;:0;;I"reduce(initial, sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"@return [Object]; T;0;@9I; F;=i ;>0;5[[I" initial; T0[I"sym; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I"reduce(sym); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"@return [Object]; T;0;@9I; F;=i ;>0;5[[I"sym; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I"reduce(initial); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@9Io;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@9I; F;=i ;>0;5[[I" initial; T0;@9Io;7
;8I"
overload; F;90;;;:0;;I" reduce; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" memo; TI"obj; T;@9Io;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@9I;[ ;I"(@yield [memo, obj]
@return [Object]; T;0;@9I; F;=i ;>0;5[ ;@9I;[ ;@5I;0;@9I; F; o; ; T; iP;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_inject(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
VALUE init, op;
rb_block_call_func *iter = inject_i;
ID id;
switch (rb_scan_args(argc, argv, "02", &init, &op)) {
case 0:
break;
case 1:
if (rb_block_given_p()) {
break;
}
id = rb_check_id(&init);
op = id ? ID2SYM(id) : init;
argc = 0;
init = Qnil;
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;
}
memo = NEW_MEMO(init, argc, op);
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#partition; F;5[ ; [[@Di;
T;;;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;7
;8I"
overload; F;90;;;:0;;I"partition; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Io;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@I;[ ;I"!@yield [obj]
@return [Array]; T;0;@I; F;=i ;>0;5[ ;@Io;7
;8I"
overload; F;90;;;:0;;I"partition; T;IC;" ; T;[ ;[ ;I" ; T;0;@I; F;=i ;>0;5[ ;@I;[ ;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;@I; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI" static VALUE
enum_partition(VALUE obj)
{
NODE *memo;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
memo = NEW_MEMO(rb_ary_new(), rb_ary_new(), 0);
rb_block_call(obj, id_each, 0, 0, partition_i, (VALUE)memo);
return rb_assoc_new(memo->u1.value, memo->u2.value);
}; T;BTo;1;2F;3;4;;;#I"Enumerable#group_by; F;5[ ; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I"
group_by; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Io;<
;8I" return; F;9I" ; T;0;:[I" Hash; T;@I;[ ;I" @yield [obj]
@return [Hash]; T;0;@I; F;=i ;>0;5[ ;@Io;7
;8I"
overload; F;90;;;:0;;I"
group_by; T;IC;" ; T;[ ;[ ;I" ; T;0;@I; F;=i ;>0;5[ ;@I;[ ;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;@I; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_group_by(VALUE obj)
{
VALUE hash;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
hash = rb_hash_new();
rb_block_call(obj, id_each, 0, 0, group_by_i, hash);
OBJ_INFECT(hash, obj);
return hash;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#first; F;5[[@0; [[@Di;
T;:
first;0;[ ;{ ;IC;"iReturns 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
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
first; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; TI"nil; T;@'J;[ ;I"@return [Object, nil]; T;0;@'J; F;=i ;>0;5[ ;@'Jo;7
;8I"
overload; F;90;;;:0;;I"
first(n); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@'J;[ ;I"@return [Array]; T;0;@'J; F;=i ;>0;5[[I"n; T0;@'J;[ ;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
@overload first
@return [Object, nil]
@overload first(n)
@return [Array]; T;0;@'J; F; o; ; T; i
;!i;"@D;;I"static VALUE; T;AI")static VALUE
enum_first(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
rb_check_arity(argc, 0, 1);
if (argc > 0) {
return enum_take(obj, argv[0]);
}
else {
memo = NEW_MEMO(Qnil, 0, 0);
rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo);
return memo->u1.value;
}
}; T;BTo;1;2F;3;4;;;#I"Enumerable#all?; F;5[ ; [[@Di ;
T;: all?;0;[ ;{ ;IC;"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+.
%w[ant bear cat].all? { |word| word.length >= 3 } #=> true
%w[ant bear cat].all? { |word| word.length >= 4 } #=> false
[nil, true, 99].all? #=> false
; T;[o;7
;8I"
overload; F;90;;;:0;;I" all?; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@SJo;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@SJ;[ ;I"#@yield [obj]
@return [Boolean]; T;0;@SJ; F;=i ;>0;5[ ;@SJo;<
;8I" return; F;9@f;0;:[@h;@SJ;[ ;I"JPasses 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+.
%w[ant bear cat].all? { |word| word.length >= 3 } #=> true
%w[ant bear cat].all? { |word| word.length >= 4 } #=> false
[nil, true, 99].all? #=> false
@overload all?
@yield [obj]
@return [Boolean]; T;0;@SJ; F; o; ; T; i ;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_all(VALUE obj)
{
NODE *memo = NEW_MEMO(Qtrue, 0, 0);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(all), (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#any?; F;5[ ; [[@Di>;
T;: any?;0;[ ;{ ;IC;"-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+.
%w[ant bear cat].any? { |word| word.length >= 3 } #=> true
%w[ant bear cat].any? { |word| word.length >= 4 } #=> true
[nil, true, 99].any? #=> true
; T;[o;7
;8I"
overload; F;90;;;:0;;I" any?; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@vJo;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@vJ;[ ;I"#@yield [obj]
@return [Boolean]; T;0;@vJ; F;=i ;>0;5[ ;@vJo;<
;8I" return; F;9@f;0;:[@h;@vJ;[ ;I"bPasses 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+.
%w[ant bear cat].any? { |word| word.length >= 3 } #=> true
%w[ant bear cat].any? { |word| word.length >= 4 } #=> true
[nil, true, 99].any? #=> true
@overload any?
@yield [obj]
@return [Boolean]; T;0;@vJ; F; o; ; T; i-;!i<;"@D;;I"static VALUE; T;AI"static VALUE
enum_any(VALUE obj)
{
NODE *memo = NEW_MEMO(Qfalse, 0, 0);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(any), (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#one?; F;5[ ; [[@Dif;
T;: one?;0;[ ;{ ;IC;"TPasses 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.
%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
[ nil, true, 99 ].one? #=> false
[ nil, true, false ].one? #=> true
; T;[o;7
;8I"
overload; F;90;;;:0;;I" one?; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Jo;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@J;[ ;I"#@yield [obj]
@return [Boolean]; T;0;@J; F;=i ;>0;5[ ;@Jo;<
;8I" return; F;9@f;0;:[@h;@J;[ ;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.
%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
[ nil, true, 99 ].one? #=> false
[ nil, true, false ].one? #=> true
@overload one?
@yield [obj]
@return [Boolean]; T;0;@J; F; o; ; T; iT;!id;"@D;;I"static VALUE; T;AI"static VALUE
enum_one(VALUE obj)
{
NODE *memo = NEW_MEMO(Qundef, 0, 0);
VALUE result;
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(one), (VALUE)memo);
result = memo->u1.value;
if (result == Qundef) return Qfalse;
return result;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#none?; F;5[ ; [[@Di;
T;:
none?;0;[ ;{ ;IC;"VPasses 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.
%w{ant bear cat}.none? { |word| word.length == 5 } #=> true
%w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
[].none? #=> true
[nil].none? #=> true
[nil, false].none? #=> true
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
none?; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Jo;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@J;[ ;I"#@yield [obj]
@return [Boolean]; T;0;@J; F;=i ;>0;5[ ;@Jo;<
;8I" return; F;9@f;0;:[@h;@J;[ ;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.
%w{ant bear cat}.none? { |word| word.length == 5 } #=> true
%w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
[].none? #=> true
[nil].none? #=> true
[nil, false].none? #=> true
@overload none?
@yield [obj]
@return [Boolean]; T;0;@J; F; o; ; T; i{;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_none(VALUE obj)
{
NODE *memo = NEW_MEMO(Qtrue, 0, 0);
rb_block_call(obj, id_each, 0, 0, ENUMFUNC(none), (VALUE)memo);
return memo->u1.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#min; F;5[ ; [[@Di;
T;:min;0;[ ;{ ;IC;"EReturns 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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"min; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@J;[ ;I"@return [Object]; T;0;@J; F;=i ;>0;5[ ;@Jo;7
;8I"
overload; F;90;;;:0;;I"min; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"a; TI"b; T;@Jo;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@J;[ ;I"#@yield [a, b]
@return [Object]; T;0;@J; F;=i ;>0;5[ ;@J;[ ;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"
@overload min
@return [Object]
@overload min
@yield [a, b]
@return [Object]; T;0;@J; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"]static VALUE
enum_min(VALUE obj)
{
NODE *memo = NEW_MEMO(Qundef, 0, 0);
VALUE result;
if (rb_block_given_p()) {
rb_block_call(obj, id_each, 0, 0, min_ii, (VALUE)memo);
}
else {
rb_block_call(obj, id_each, 0, 0, min_i, (VALUE)memo);
}
result = memo->u1.value;
if (result == Qundef) return Qnil;
return result;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#max; F;5[ ; [[@Di;
T;:max;0;[ ;{ ;IC;"BReturns 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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"max; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@
K;[ ;I"@return [Object]; T;0;@
K; F;=i ;>0;5[ ;@
Ko;7
;8I"
overload; F;90;;;:0;;I"max; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"a; TI"b; T;@
Ko;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@
K;[ ;I"#@yield [a, b]
@return [Object]; T;0;@
K; F;=i ;>0;5[ ;@
K;[ ;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"
@overload max
@return [Object]
@overload max
@yield [a, b]
@return [Object]; T;0;@
K; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"]static VALUE
enum_max(VALUE obj)
{
NODE *memo = NEW_MEMO(Qundef, 0, 0);
VALUE result;
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 = memo->u1.value;
if (result == Qundef) return Qnil;
return result;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#minmax; F;5[ ; [[@Di;
T;: minmax;0;[ ;{ ;IC;"Returns two elements 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;7
;8I"
overload; F;90;;;:0;;I" minmax; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;K;[ ;I"@return [Array]; T;0;@;K; F;=i ;>0;5[ ;@;Ko;7
;8I"
overload; F;90;;;:0;;I" minmax; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"a; TI"b; T;@;Ko;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;K;[ ;I""@yield [a, b]
@return [Array]; T;0;@;K; F;=i ;>0;5[ ;@;K;[ ;I"Returns two elements 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;@;K; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_minmax(VALUE obj)
{
NODE *memo = NEW_MEMO(Qundef, Qundef, Qundef);
struct minmax_t *m = (struct minmax_t *)&memo->u1.value;
VALUE ary = rb_ary_new3(2, Qnil, Qnil);
m->min = Qundef;
m->last = Qundef;
if (rb_block_given_p()) {
rb_block_call(obj, id_each, 0, 0, minmax_ii, (VALUE)memo);
if (m->last != Qundef)
minmax_ii_update(m->last, m->last, m);
}
else {
rb_block_call(obj, id_each, 0, 0, minmax_i, (VALUE)memo);
if (m->last != Qundef)
minmax_i_update(m->last, m->last, m);
}
if (m->min != Qundef) {
rb_ary_store(ary, 0, m->min);
rb_ary_store(ary, 1, m->max);
}
return ary;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#min_by; F;5[ ; [[@Di;
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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" min_by; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@iKo;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@iK;[ ;I""@yield [obj]
@return [Object]; T;0;@iK; F;=i ;>0;5[ ;@iKo;7
;8I"
overload; F;90;;;:0;;I" min_by; T;IC;" ; T;[ ;[ ;I" ; T;0;@iK; F;=i ;>0;5[ ;@iK;[ ;I" 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"
@overload min_by
@yield [obj]
@return [Object]
@overload min_by; T;0;@iK; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_min_by(VALUE obj)
{
NODE *memo;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
memo = NEW_MEMO(Qundef, Qnil, 0);
rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo);
return memo->u2.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#max_by; F;5[ ; [[@Di
;
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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I" max_by; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Ko;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@K;[ ;I""@yield [obj]
@return [Object]; T;0;@K; F;=i ;>0;5[ ;@Ko;7
;8I"
overload; F;90;;;:0;;I" max_by; T;IC;" ; T;[ ;[ ;I" ; T;0;@K; F;=i ;>0;5[ ;@K;[ ;I"#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"
@overload max_by
@yield [obj]
@return [Object]
@overload max_by; T;0;@K; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_max_by(VALUE obj)
{
NODE *memo;
RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);
memo = NEW_MEMO(Qundef, Qnil, 0);
rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo);
return memo->u2.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#minmax_by; F;5[ ; [[@Dik;
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;7
;8I"
overload; F;90;;;:0;;I"minmax_by; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Ko;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@K;[ ;I"!@yield [obj]
@return [Array]; T;0;@K; F;=i ;>0;5[ ;@Ko;7
;8I"
overload; F;90;;;:0;;I"minmax_by; T;IC;" ; T;[ ;[ ;I" ; T;0;@K; F;=i ;>0;5[ ;@K;[ ;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;@K; F; o; ; T; i\;!ii;"@D;;I"static VALUE; T;AI".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;BTo;1;2F;3;4;;;#I"Enumerable#member?; F;5[[I"val; T0; [[@Di;
T;: member?;0;[ ;{ ;IC;"Returns true if any member of enum equals
obj. Equality is tested using ==.
IO.constants.include? :SEEK_SET #=> true
IO.constants.include? :SEEK_NO_FURTHER #=> false
; T;[o;7
;8I"
overload; F;90;;;:0;;I"include?(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@K;[ ;I"@return [Boolean]; T;0;@K; F;=i ;>0;5[[I"obj; T0;@Ko;7
;8I"
overload; F;90;; ;:0;;I"member?(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@K;[ ;I"@return [Boolean]; T;0;@K; F;=i ;>0;5[[I"obj; T0;@Ko;<
;8I" return; F;9@f;0;:[@h;@K;[ ;I"9Returns true if any member of enum equals
obj. Equality is tested using ==.
IO.constants.include? :SEEK_SET #=> true
IO.constants.include? :SEEK_NO_FURTHER #=> false
@overload include?(obj)
@return [Boolean]
@overload member?(obj)
@return [Boolean]; T;0;@K; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_member(VALUE obj, VALUE val)
{
NODE *memo = NEW_MEMO(val, Qfalse, 0);
rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
return memo->u2.value;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#include?; F;5[[I"val; T0; [[@Di;
T;;;0;[ ;{ ;IC;"Returns true if any member of enum equals
obj. Equality is tested using ==.
IO.constants.include? :SEEK_SET #=> true
IO.constants.include? :SEEK_NO_FURTHER #=> false
; T;[o;7
;8I"
overload; F;90;;;:0;;I"include?(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@L;[ ;I"@return [Boolean]; T;0;@L; F;=i ;>0;5[[I"obj; T0;@Lo;7
;8I"
overload; F;90;; ;:0;;I"member?(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@L;[ ;I"@return [Boolean]; T;0;@L; F;=i ;>0;5[[I"obj; T0;@Lo;<
;8I" return; F;9@f;0;:[@h;@L;[ ;@L;0;@L; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"static VALUE
enum_member(VALUE obj, VALUE val)
{
NODE *memo = NEW_MEMO(val, Qfalse, 0);
rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
return memo->u2.value;
}; T;BTo;1;2F;3;4;;;#I" Enumerable#each_with_index; F;5[[@0; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I"each_with_index(*args); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; TI"i; T;@BLo;<
;8I" return; F;9I" ; T;0;:[I"Enumerator; T;@BL;[ ;I")@yield [obj, i]
@return [Enumerator]; T;0;@BL; F;=i ;>0;5[[I"
*args; T0;@BLo;7
;8I"
overload; F;90;;;:0;;I"each_with_index(*args); T;IC;" ; T;[ ;[ ;I" ; T;0;@BL; F;=i ;>0;5[[I"
*args; T0;@BL;[ ;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;@BL; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"
static VALUE
enum_each_with_index(int argc, VALUE *argv, VALUE obj)
{
NODE *memo;
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
memo = NEW_MEMO(0, 0, 0);
rb_block_call(obj, id_each, argc, argv, each_with_index_i, (VALUE)memo);
return obj;
}; T;BTo;1;2F;3;4;;;#I" Enumerable#reverse_each; F;5[[@0; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I"reverse_each(*args); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" item; T;@pLo;<
;8I" return; F;9I" ; T;0;:[I"Enumerator; T;@pL;[ ;I"'@yield [item]
@return [Enumerator]; T;0;@pL; F;=i ;>0;5[[I"
*args; T0;@pLo;7
;8I"
overload; F;90;;;:0;;I"reverse_each(*args); T;IC;" ; T;[ ;[ ;I" ; T;0;@pL; F;=i ;>0;5[[I"
*args; T0;@pL;[ ;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;@pL; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"$static VALUE
enum_reverse_each(int argc, VALUE *argv, VALUE obj)
{
VALUE ary;
long i;
RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
ary = enum_to_a(argc, argv, obj);
for (i = RARRAY_LEN(ary); --i >= 0; ) {
rb_yield(RARRAY_AREF(ary, i));
}
return obj;
}; T;BTo;1;2F;3;4;;;#I"Enumerable#each_entry; F;5[[@0; [[@Di;
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;7
;8I"
overload; F;90;;;:0;;I"each_entry; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"obj; T;@Lo;<
;8I" return; F;9I" ; T;0;:[I"Enumerator; T;@L;[ ;I"&@yield [obj]
@return [Enumerator]; T;0;@L; F;=i ;>0;5[ ;@Lo;7
;8I"
overload; F;90;;;:0;;I"each_entry; T;IC;" ; T;[ ;[ ;I" ; T;0;@L; F;=i ;>0;5[ ;@L;[ ;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;@L; F; o; ; T; i;!i;"@D;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"Enumerable#each_slice; F;5[[I"n; T0; [[@DiL;
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 ]
[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]]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"zip(arg, ...); T;IC;" ; T;[ ;[ ;I" ; T;0;@MM; F;=i ;>0;5[[I"arg; T0[I"...; T0;@MMo;7
;8I"
overload; F;90;;;:0;;I"zip(arg, ...); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"arr; T;@MMo;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@MM;[ ;I" @yield [arr]
@return [nil]; T;0;@MM; F;=i ;>0;5[[I"arg; T0[I"...; T0;@MM;[ ;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 ]
[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]]
@overload zip(arg, ...)
@overload zip(arg, ...)
@yield [arr]
@return [nil]; T;0;@MM; F; o; ; T; i;!i%;"@D;;I"static VALUE; T;AI"static VALUE
enum_zip(int argc, VALUE *argv, VALUE obj)
{
int i;
ID conv;
NODE *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| ... }
enum.slice_before(initial_state) { |elt, state| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as 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:
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 are not appropriate to maintain state
if the result enumerator is used twice or more.
In such a case, the last state of the 1st +each+ is used in the 2nd +each+.
The _initial_state_ argument can be used to avoid this problem.
If non-nil value is given as _initial_state_,
it is duplicated for each +each+ method invocation of the enumerator.
The duplicated object is passed to 2nd argument of the block for
+slice_before+ method.
# Word wrapping. This assumes all characters have same width.
def wordwrap(words, maxwidth)
# if cols is a local variable, 2nd "each" may start with non-zero cols.
words.slice_before(cols: 0) { |w, h|
h[:cols] += 1 if h[:cols] != 0
h[:cols] += w.length
if maxwidth < h[:cols]
h[:cols] = w.length
true
else
false
end
}
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each { |ws| puts ws.join(" ") }
puts "-"*10
#=> ----------
# 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|
f.slice_before(emp: true) { |line, h|
prevemp = h[:emp]
h[:emp] = line == "\n"
prevemp && line.start_with?("From ")
}.each { |mail|
mail.pop if mail.last == "\n"
pp mail
}
}
; T;[o;7
;8I"
overload; F;90;;;:0;;I"slice_before(pattern); T;IC;" ; T;[ ;[ ;I" ; T;0;@gN; F;=i ;>0;5[[I" pattern; T0;@gNo;7
;8I"
overload; F;90;;;:0;;I"slice_before; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"elt; T;@gN;[ ;I"@yield [elt]; T;0;@gN; F;=i ;>0;5[ ;@gNo;7
;8I"
overload; F;90;;;:0;;I" slice_before(initial_state); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"elt; TI"
state; T;@gN;[ ;I"@yield [elt, state]; T;0;@gN; F;=i ;>0;5[[I"initial_state; T0;@gN;[ ;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| ... }
enum.slice_before(initial_state) { |elt, state| bool }.each { |ary| ... }
Other methods of the Enumerator class and Enumerable module,
such as 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:
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 are not appropriate to maintain state
if the result enumerator is used twice or more.
In such a case, the last state of the 1st +each+ is used in the 2nd +each+.
The _initial_state_ argument can be used to avoid this problem.
If non-nil value is given as _initial_state_,
it is duplicated for each +each+ method invocation of the enumerator.
The duplicated object is passed to 2nd argument of the block for
+slice_before+ method.
# Word wrapping. This assumes all characters have same width.
def wordwrap(words, maxwidth)
# if cols is a local variable, 2nd "each" may start with non-zero cols.
words.slice_before(cols: 0) { |w, h|
h[:cols] += 1 if h[:cols] != 0
h[:cols] += w.length
if maxwidth < h[:cols]
h[:cols] = w.length
true
else
false
end
}
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each { |ws| puts ws.join(" ") }
puts "-"*10
#=> ----------
# 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|
f.slice_before(emp: true) { |line, h|
prevemp = h[:emp]
h[: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]
@overload slice_before(initial_state)
@yield [elt, state]; T;0;@gN; F; o; ; T; i=
;!i
;"@D;;I"static VALUE; T;AI"Fstatic VALUE
enum_slice_before(int argc, VALUE *argv, VALUE enumerable)
{
VALUE enumerator;
if (rb_block_given_p()) {
VALUE initial_state;
rb_scan_args(argc, argv, "01", &initial_state);
enumerator = rb_obj_alloc(rb_cEnumerator);
rb_ivar_set(enumerator, rb_intern("slicebefore_sep_pred"), rb_block_proc());
rb_ivar_set(enumerator, rb_intern("slicebefore_initial_state"), initial_state);
}
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;BT;l@D;mIC;[ ;l@D;nIC;[ ;l@D;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@Di
;
F;:Enumerable;;@;;;[ ;{ ;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;@D; F; o; ; T; i
;!i
;"@;#I"Enumerable; F;l@A;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{@B;?;t[ ; [[@Ai.;
F;;;;@;;;[ ;{ ;IC;"A Struct is a convenient way to bundle a number of attributes together,
using accessor methods, without having to write an explicit class.
The Struct class generates new subclasses that hold a set of members and
their values. For each member a reader and writer method is created
similar to Module#attr_accessor.
Customer = Struct.new(:name, :address) do
def greeting
"Hello #{name}!"
end
end
dave = Customer.new("Dave", "123 Main")
dave.name #=> "Dave"
dave.greeting #=> "Hello Dave!"
See Struct::new for further examples of creating struct subclasses and
instances.
In the method descriptions that follow a "member" parameter refers to a
struct member which is either a quoted string ("name") or a
Symbol (:name).; T;[ ;[ ;I"A Struct is a convenient way to bundle a number of attributes together,
using accessor methods, without having to write an explicit class.
The Struct class generates new subclasses that hold a set of members and
their values. For each member a reader and writer method is created
similar to Module#attr_accessor.
Customer = Struct.new(:name, :address) do
def greeting
"Hello #{name}!"
end
end
dave = Customer.new("Dave", "123 Main")
dave.name #=> "Dave"
dave.greeting #=> "Hello Dave!"
See Struct::new for further examples of creating struct subclasses and
instances.
In the method descriptions that follow a "member" parameter refers to a
struct member which is either a quoted string ("name") or a
Symbol (:name).
; T;0;@A; F; o; ; T; i;!i);=i ;"@;#I" Struct; F;v@ o;1;2F;3;4;;
;#I"Bug#funcall_callback; F;5[[I"obj; T0; [[I" ext/-test-/bug-5832/bug.c; Ti;
T;:funcall_callback;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@N; F;>0;"@);;I"static VALUE; T;AI"wstatic VALUE
bug_funcall_callback(VALUE self, VALUE obj)
{
return rb_funcall(obj, rb_intern("callback"), 0);
}; T;BTo;1;2T;3;q;;;#I"Bug.funcall_callback; F;5@N; @N;
T;;;0;@N;{ ;IC;" ; T;[ ;[ ;@f;0;@N;=i ;"@);;@N;A@N;BTo;1;2F;3;4;;
;#I" Bug#postponed_job_register; F;5[[I"obj; T0; [[I"-ext/-test-/postponed_job/postponed_job.c; Ti;
T;:postponed_job_register;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@N; F;>0;"@);;I"static VALUE; T;AI"static VALUE
pjob_register(VALUE self, VALUE obj)
{
rb_postponed_job_register(0, pjob_callback, (void *)obj);
return self;
}; T;BTo;1;2T;3;q;;;#I" Bug.postponed_job_register; F;5@N; @N;
T;;;0;@N;{ ;IC;" ; T;[ ;[ ;@f;0;@N;=i ;"@);;@N;A@N;BTo;1;2F;3;4;;
;#I"#Bug#postponed_job_register_one; F;5[[I"obj; T0; [[@Ni";
T;: postponed_job_register_one;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@N; F;>0;"@);;I"static VALUE; T;AI" static VALUE
pjob_register_one(VALUE self, VALUE obj)
{
rb_postponed_job_register_one(0, pjob_one_callback, (void *)obj);
rb_postponed_job_register_one(0, pjob_one_callback, (void *)obj);
rb_postponed_job_register_one(0, pjob_one_callback, (void *)obj);
return self;
}; T;BTo;1;2T;3;q;;;#I"#Bug.postponed_job_register_one; F;5@N; @N;
T;;;0;@N;{ ;IC;" ; T;[ ;[ ;@f;0;@N;=i ;"@);;@N;A@N;BTo;1;2F;3;4;;
;#I""Bug#postponed_job_call_direct; F;5[[I"obj; T0; [[@Ni+;
T;: postponed_job_call_direct;0;[ ;{ ;IC;"
; T;[ ;[ ;I" ; F;0;@N; F;>0;"@);;I"static VALUE; T;AI"nstatic VALUE
pjob_call_direct(VALUE self, VALUE obj)
{
pjob_callback((void *)obj);
return self;
}; T;BTo;1;2T;3;q;;;#I""Bug.postponed_job_call_direct; F;5@ O; @O;
T;;;0;@O;{ ;IC;" ; T;[ ;[ ;@f;0;@
O;=i ;"@);;@ O;A@ O;BTo;;IC;[ ;l@O;mIC;[ ;l@O;nIC;[ ;l@O;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[I" ext/-test-/class/init.c; Ti;
F;:
Class;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@O;"@);#I"Bug::Class; F;l@);mIC;[ ;l@);nIC;[ ;l@);oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@)i
[@)i
[@q-i[@-i
[@@@i
[@M@ia[@x@i[@2Ai
[@@Ai[@ZAi
[@{Ai
[@Ai
[@Ai
[@Ni[@Ni5[@ Oi
;
F;:Bug;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@);"@;#I"Bug; Fo; ;IC;[Ho;1;2F;3;q;;;#I"
Time.now; F;5[ ; [[I" time.c; Ti ;
T;:now;0;[ ;{ ;IC;"jCreates a new Time object for the current time.
Time.now #=> 2009-06-24 12:39:54 +0900
; T;[o;7
;8I"
overload; F;90;;;:0;;I"now; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@EO;[ ;I"@return [Time]; T;0;@EO; F;=i ;>0;5[ ;@EO;[ ;I"Creates a new Time object for the current time.
Time.now #=> 2009-06-24 12:39:54 +0900
@overload now
@return [Time]; T;0;@EO; F; o; ; T; i ;!i ;"@CO;;I"static VALUE; T;AI"_static VALUE
time_s_now(VALUE klass)
{
return rb_class_new_instance(0, NULL, klass);
}; T;BTo;1;2F;3;q;;;#I" Time.at; F;5[[@0; [[@JOi ;
T;:at;0;[ ;{ ;IC;" Creates a new Time object with the value given by +time+,
the given number of +seconds_with_frac+, or
+seconds+ and +microseconds_with_frac+ since the Epoch.
+seconds_with_frac+ and +microseconds_with_frac+
can be an Integer, Float, Rational, or other Numeric.
non-portable feature allows the offset to be negative on some systems.
If a numeric argument is given, the result is in local time.
Time.at(0) #=> 1969-12-31 18:00:00 -0600
Time.at(Time.at(0)) #=> 1969-12-31 18:00:00 -0600
Time.at(946702800) #=> 1999-12-31 23:00:00 -0600
Time.at(-284061600) #=> 1960-12-31 00:00:00 -0600
Time.at(946684800.2).usec #=> 200000
Time.at(946684800, 123456.789).nsec #=> 123456789
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
at(time); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@aO;[ ;I"@return [Time]; T;0;@aO; F;=i ;>0;5[[I" time; T0;@aOo;7
;8I"
overload; F;90;;;:0;;I"at(seconds_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@aO;[ ;I"@return [Time]; T;0;@aO; F;=i ;>0;5[[I"seconds_with_frac; T0;@aOo;7
;8I"
overload; F;90;;;:0;;I"(at(seconds, microseconds_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@aO;[ ;I"@return [Time]; T;0;@aO; F;=i ;>0;5[[I" seconds; T0[I"microseconds_with_frac; T0;@aO;[ ;I"Creates a new Time object with the value given by +time+,
the given number of +seconds_with_frac+, or
+seconds+ and +microseconds_with_frac+ since the Epoch.
+seconds_with_frac+ and +microseconds_with_frac+
can be an Integer, Float, Rational, or other Numeric.
non-portable feature allows the offset to be negative on some systems.
If a numeric argument is given, the result is in local time.
Time.at(0) #=> 1969-12-31 18:00:00 -0600
Time.at(Time.at(0)) #=> 1969-12-31 18:00:00 -0600
Time.at(946702800) #=> 1999-12-31 23:00:00 -0600
Time.at(-284061600) #=> 1960-12-31 00:00:00 -0600
Time.at(946684800.2).usec #=> 200000
Time.at(946684800, 123456.789).nsec #=> 123456789
@overload at(time)
@return [Time]
@overload at(seconds_with_frac)
@return [Time]
@overload at(seconds, microseconds_with_frac)
@return [Time]; T;0;@aO; F; o; ; T; i ;!i ;"@CO;;I"static VALUE; T;AI"static VALUE
time_s_at(int argc, VALUE *argv, VALUE klass)
{
VALUE time, t;
wideval_t timew;
if (rb_scan_args(argc, argv, "11", &time, &t) == 2) {
time = num_exact(time);
t = num_exact(t);
timew = wadd(rb_time_magnify(v2w(time)), wmulquoll(v2w(t), TIME_SCALE, 1000000));
t = time_new_timew(klass, timew);
}
else if (IsTimeval(time)) {
struct time_object *tobj, *tobj2;
GetTimeval(time, tobj);
t = time_new_timew(klass, tobj->timew);
GetTimeval(t, tobj2);
TIME_COPY_GMT(tobj2, tobj);
}
else {
timew = rb_time_magnify(v2w(num_exact(time)));
t = time_new_timew(klass, timew);
}
return t;
}; T;BTo;1;2F;3;q;;;#I"
Time.utc; F;5[[@0; [[@JOi ;
T;:utc;0;[ ;{ ;IC;"Creates a Time object based on given values, interpreted as UTC (GMT). The
year must be specified. Other values default to the minimum value
for that field (and may be +nil+ or omitted). Months may
be specified by numbers from 1 to 12, or by the three-letter English
month names. Hours are specified on a 24-hour clock (0..23). Raises
an ArgumentError if any values are out of range. Will
also accept ten arguments in the order output by Time#to_a.
+sec_with_frac+ and +usec_with_frac+ can have a fractional part.
Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
; T;[o;7
;8I"
overload; F;90;;;:0;;I"utc(year); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"utc(year, month); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0[I"
month; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"utc(year, month, day); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0[I"
month; T0[I"day; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I" utc(year, month, day, hour); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"%utc(year, month, day, hour, min); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[
[I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"4utc(year, month, day, hour, min, sec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec_with_frac; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I":utc(year, month, day, hour, min, sec, usec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec; T0[I"usec_with_frac; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"Autc(sec, min, hour, day, month, year, wday, yday, isdst, tz); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I"sec; T0[I"min; T0[I" hour; T0[I"day; T0[I"
month; T0[I" year; T0[I" wday; T0[I" yday; T0[I"
isdst; T0[I"tz; T0;@Oo;7
;8I"
overload; F;90;:gm;:0;;I"
gm(year); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"gm(year, month); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0[I"
month; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"gm(year, month, day); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I" year; T0[I"
month; T0[I"day; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I" gm(year, month, day, hour); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"$gm(year, month, day, hour, min); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[
[I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"3gm(year, month, day, hour, min, sec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec_with_frac; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"9gm(year, month, day, hour, min, sec, usec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec; T0[I"usec_with_frac; T0;@Oo;7
;8I"
overload; F;90;;;:0;;I"@gm(sec, min, hour, day, month, year, wday, yday, isdst, tz); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@O;[ ;I"@return [Time]; T;0;@O; F;=i ;>0;5[[I"sec; T0[I"min; T0[I" hour; T0[I"day; T0[I"
month; T0[I" year; T0[I" wday; T0[I" yday; T0[I"
isdst; T0[I"tz; T0;@O;[ ;I"MCreates a Time object based on given values, interpreted as UTC (GMT). The
year must be specified. Other values default to the minimum value
for that field (and may be +nil+ or omitted). Months may
be specified by numbers from 1 to 12, or by the three-letter English
month names. Hours are specified on a 24-hour clock (0..23). Raises
an ArgumentError if any values are out of range. Will
also accept ten arguments in the order output by Time#to_a.
+sec_with_frac+ and +usec_with_frac+ can have a fractional part.
Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
@overload utc(year)
@return [Time]
@overload utc(year, month)
@return [Time]
@overload utc(year, month, day)
@return [Time]
@overload utc(year, month, day, hour)
@return [Time]
@overload utc(year, month, day, hour, min)
@return [Time]
@overload utc(year, month, day, hour, min, sec_with_frac)
@return [Time]
@overload utc(year, month, day, hour, min, sec, usec_with_frac)
@return [Time]
@overload utc(sec, min, hour, day, month, year, wday, yday, isdst, tz)
@return [Time]
@overload gm(year)
@return [Time]
@overload gm(year, month)
@return [Time]
@overload gm(year, month, day)
@return [Time]
@overload gm(year, month, day, hour)
@return [Time]
@overload gm(year, month, day, hour, min)
@return [Time]
@overload gm(year, month, day, hour, min, sec_with_frac)
@return [Time]
@overload gm(year, month, day, hour, min, sec, usec_with_frac)
@return [Time]
@overload gm(sec, min, hour, day, month, year, wday, yday, isdst, tz)
@return [Time]; T;0;@O; F; o; ; T; i ;!i+ ;"@CO;;I"static VALUE; T;AI"}static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, TRUE, klass);
}; T;BTo;1;2F;3;q;;;#I" Time.gm; F;5[[@0; [[@JOi ;
T;;;0;[ ;{ ;IC;"Creates a Time object based on given values, interpreted as UTC (GMT). The
year must be specified. Other values default to the minimum value
for that field (and may be +nil+ or omitted). Months may
be specified by numbers from 1 to 12, or by the three-letter English
month names. Hours are specified on a 24-hour clock (0..23). Raises
an ArgumentError if any values are out of range. Will
also accept ten arguments in the order output by Time#to_a.
+sec_with_frac+ and +usec_with_frac+ can have a fractional part.
Time.utc(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 UTC
; T;[o;7
;8I"
overload; F;90;;;:0;;I"utc(year); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"utc(year, month); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0[I"
month; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"utc(year, month, day); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0[I"
month; T0[I"day; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I" utc(year, month, day, hour); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"%utc(year, month, day, hour, min); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[
[I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"4utc(year, month, day, hour, min, sec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec_with_frac; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I":utc(year, month, day, hour, min, sec, usec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec; T0[I"usec_with_frac; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"Autc(sec, min, hour, day, month, year, wday, yday, isdst, tz); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I"sec; T0[I"min; T0[I" hour; T0[I"day; T0[I"
month; T0[I" year; T0[I" wday; T0[I" yday; T0[I"
isdst; T0[I"tz; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"
gm(year); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"gm(year, month); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0[I"
month; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"gm(year, month, day); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I" year; T0[I"
month; T0[I"day; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I" gm(year, month, day, hour); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"$gm(year, month, day, hour, min); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[
[I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"3gm(year, month, day, hour, min, sec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec_with_frac; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"9gm(year, month, day, hour, min, sec, usec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec; T0[I"usec_with_frac; T0;@Qo;7
;8I"
overload; F;90;;;:0;;I"@gm(sec, min, hour, day, month, year, wday, yday, isdst, tz); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@Q;[ ;I"@return [Time]; T;0;@Q; F;=i ;>0;5[[I"sec; T0[I"min; T0[I" hour; T0[I"day; T0[I"
month; T0[I" year; T0[I" wday; T0[I" yday; T0[I"
isdst; T0[I"tz; T0;@Q;[ ;@Q;0;@Q; F; o; ; T; i ;!i+ ;"@CO;;I"static VALUE; T;AI"}static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
return time_utc_or_local(argc, argv, TRUE, klass);
}; T;BTo;1;2F;3;q;;;#I"Time.local; F;5[[@0; [[@JOi= ;
T;:
local;0;[ ;{ ;IC;"Same as Time::gm, but interprets the values in the
local time zone.
Time.local(2000,"jan",1,20,15,1) #=> 2000-01-01 20:15:01 -0600
; T;[o;7
;8I"
overload; F;90;;;:0;;I"local(year); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[[I" year; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I"local(year, month); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[[I" year; T0[I"
month; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I" local(year, month, day); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[[I" year; T0[I"
month; T0[I"day; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I""local(year, month, day, hour); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I"'local(year, month, day, hour, min); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[
[I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I"6local(year, month, day, hour, min, sec_with_frac); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@R;[ ;I"@return [Time]; T;0;@R; F;=i ;>0;5[ [I" year; T0[I"
month; T0[I"day; T0[I" hour; T0[I"min; T0[I"sec_with_frac; T0;@Ro;7
;8I"
overload; F;90;;;:0;;I"Fixnum. Poking
around in these bits is platform dependent.
fork { exit 0xab } #=> 26566
Process.wait #=> 26566
sprintf('%04x', $?.to_i) #=> "ab00"
; T;[o;7
;8I"
overload; F;90;;\;:0;;I" to_i; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@N^;[ ;I"@return [Fixnum]; T;0;@N^; F;=i ;>0;5[ ;@N^o;7
;8I"
overload; F;90;;];:0;;I" to_int; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@N^;[ ;I"@return [Fixnum]; T;0;@N^; F;=i ;>0;5[ ;@N^;[ ;I")Returns the bits in _stat_ as a Fixnum. Poking
around in these bits is platform dependent.
fork { exit 0xab } #=> 26566
Process.wait #=> 26566
sprintf('%04x', $?.to_i) #=> "ab00"
@overload to_i
@return [Fixnum]
@overload to_int
@return [Fixnum]; T;0;@N^; F; o; ; T; iU;!i`;"@];;I"static VALUE; T;AI"Lstatic VALUE
pst_to_i(VALUE st)
{
return rb_iv_get(st, "status");
}; T;BTo;1;2F;3;4;;;#I"Process::Status#to_s; F;5[ ; [[@i;
T;;6;0;[ ;{ ;IC;"hShow pid and exit status as a string.
system("false")
p $?.to_s #=> "pid 12766 exit 1"
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@v^;[ ;I"@return [String]; T;0;@v^; F;=i ;>0;5[ ;@v^;[ ;I"Show pid and exit status as a string.
system("false")
p $?.to_s #=> "pid 12766 exit 1"
@overload to_s
@return [String]; T;0;@v^; F; o; ; T; i;!i;"@];;I"static VALUE; T;AI"static VALUE
pst_to_s(VALUE st)
{
rb_pid_t pid;
int status;
VALUE str;
pid = NUM2PIDT(pst_pid(st));
status = PST2INT(st);
str = rb_str_buf_new(0);
pst_message(str, pid, status);
return str;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#inspect; F;5[ ; [[@i;
T;;?;0;[ ;{ ;IC;"qOverride the inspection method.
system("false")
p $?.inspect #=> "#wait call had the
WUNTRACED flag set.
; T;[o;7
;8I"
overload; F;90;;L;:0;;I"
stopped?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@^;[ ;I"@return [Boolean]; T;0;@^; F;=i ;>0;5[ ;@^o;<
;8I" return; F;9@f;0;:[@h;@^;[ ;I"Returns +true+ if this process is stopped. This is only
returned if the corresponding wait call had the
WUNTRACED flag set.
@overload stopped?
@return [Boolean]; T;0;@^; F; o; ; T; i;!i;"@];;I"static VALUE; T;AI"static VALUE
pst_wifstopped(VALUE st)
{
int status = PST2INT(st);
if (WIFSTOPPED(status))
return Qtrue;
else
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#stopsig; F;5[ ; [[@i0;
T;: stopsig;0;[ ;{ ;IC;"cReturns the number of the signal that caused _stat_ to stop
(or +nil+ if self is not stopped).
; T;[o;7
;8I"
overload; F;90;;M;:0;;I" stopsig; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@^;[ ;I"@return [Fixnum, nil]; T;0;@^; F;=i ;>0;5[ ;@^;[ ;I"Returns the number of the signal that caused _stat_ to stop
(or +nil+ if self is not stopped).
@overload stopsig
@return [Fixnum, nil]; T;0;@^; F; o; ; T; i(;!i-;"@];;I"static VALUE; T;AI"static VALUE
pst_wstopsig(VALUE st)
{
int status = PST2INT(st);
if (WIFSTOPPED(status))
return INT2NUM(WSTOPSIG(status));
return Qnil;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#signaled?; F;5[ ; [[@iC;
T;:signaled?;0;[ ;{ ;IC;"GReturns +true+ if _stat_ terminated because of
an uncaught signal.
; T;[o;7
;8I"
overload; F;90;;N;:0;;I"signaled?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@_;[ ;I"@return [Boolean]; T;0;@_; F;=i ;>0;5[ ;@_o;<
;8I" return; F;9@f;0;:[@h;@_;[ ;I"qReturns +true+ if _stat_ terminated because of
an uncaught signal.
@overload signaled?
@return [Boolean]; T;0;@_; F; o; ; T; i;;!i@;"@];;I"static VALUE; T;AI"static VALUE
pst_wifsignaled(VALUE st)
{
int status = PST2INT(st);
if (WIFSIGNALED(status))
return Qtrue;
else
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#termsig; F;5[ ; [[@iX;
T;: termsig;0;[ ;{ ;IC;"}Returns the number of the signal that caused _stat_ to
terminate (or +nil+ if self was not terminated by an
uncaught signal).
; T;[o;7
;8I"
overload; F;90;;O;:0;;I" termsig; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@ _;[ ;I"@return [Fixnum, nil]; T;0;@ _; F;=i ;>0;5[ ;@ _;[ ;I"Returns the number of the signal that caused _stat_ to
terminate (or +nil+ if self was not terminated by an
uncaught signal).
@overload termsig
@return [Fixnum, nil]; T;0;@ _; F; o; ; T; iO;!iU;"@];;I"static VALUE; T;AI"static VALUE
pst_wtermsig(VALUE st)
{
int status = PST2INT(st);
if (WIFSIGNALED(status))
return INT2NUM(WTERMSIG(status));
return Qnil;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#exited?; F;5[ ; [[@il;
T;: exited?;0;[ ;{ ;IC;"wReturns +true+ if _stat_ exited normally (for
example using an exit() call or finishing the
program).
; T;[o;7
;8I"
overload; F;90;;P;:0;;I" exited?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;_;[ ;I"@return [Boolean]; T;0;@;_; F;=i ;>0;5[ ;@;_o;<
;8I" return; F;9@f;0;:[@h;@;_;[ ;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; ic;!ii;"@];;I"static VALUE; T;AI"static VALUE
pst_wifexited(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return Qtrue;
else
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#exitstatus; F;5[ ; [[@i;
T;:exitstatus;0;[ ;{ ;IC;"qReturns 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;7
;8I"
overload; F;90;;Q;:0;;I"exitstatus; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@Y_;[ ;I"@return [Fixnum, nil]; T;0;@Y_; F;=i ;>0;5[ ;@Y_;[ ;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 [Fixnum, nil]; T;0;@Y_; F; o; ; T; ix;!i;"@];;I"static VALUE; T;AI"static VALUE
pst_wexitstatus(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return INT2NUM(WEXITSTATUS(status));
return Qnil;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#success?; F;5[ ; [[@i;
T;:
success?;0;[ ;{ ;IC;"qReturns +true+ if _stat_ is successful, +false+ if not.
Returns +nil+ if exited? is not +true+.
; T;[o;7
;8I"
overload; F;90;;R;:0;;I"
success?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@u_;[ ;I" @return [true, false, nil]; T;0;@u_; F;=i ;>0;5[ ;@u_o;<
;8I" return; F;9@f;0;:[@h;@u_;[ ;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;@u_; F; o; ; T; i;!i;"@];;I"static VALUE; T;AI"static VALUE
pst_success_p(VALUE st)
{
int status = PST2INT(st);
if (!WIFEXITED(status))
return Qnil;
return WEXITSTATUS(status) == EXIT_SUCCESS ? Qtrue : Qfalse;
}; T;BTo;1;2F;3;4;;;#I" Process::Status#coredump?; F;5[ ; [[@i;
T;:coredump?;0;[ ;{ ;IC;"fReturns +true+ if _stat_ generated a coredump
when it terminated. Not available on all platforms.
; T;[o;7
;8I"
overload; F;90;;S;:0;;I"coredump?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@_;[ ;I"@return [Boolean]; T;0;@_; F;=i ;>0;5[ ;@_o;<
;8I" return; F;9@f;0;:[@h;@_;[ ;I"Returns +true+ if _stat_ generated a coredump
when it terminated. Not available on all platforms.
@overload coredump?
@return [Boolean]; T;0;@_; F; o; ; T; i;!i;"@];;I"static VALUE; T;AI"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;BT;l@];mIC;[ ;l@];nIC;[ ;l@];oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i [@i% ;
T;: Status;;@;;;[ ;{ ;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;;=i ;"o; ;0;0;0;: Process;"@;@];0;#I"Process::Status; F;v@ o; ;IC;[ ;l@_;mIC;[ ;l@_;nIC;[ ;l@_;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i;
T;:Sys;;@;;;[ ;{ ;IC;"{*******************************************************************
The Process::Sys module contains UID and GID
functions which provide direct bindings to the system calls of the
same names instead of the more-portable versions of the same
functionality found in the Process,
Process::UID, and Process::GID modules.
; T;[ ;[ ;I"|*******************************************************************
The Process::Sys module contains UID and GID
functions which provide direct bindings to the system calls of the
same names instead of the more-portable versions of the same
functionality found in the Process,
Process::UID, and Process::GID modules.
; T;0;@_; F; o; ; T; i;!i;"o; ;0;0;0;;U;"@;@];0;#I"Process::Sys; F;vo; ;0;0;0;;;"@;@ ;0o; ;IC;[ ;l@_;mIC;[ ;l@_;nIC;[ ;l@_;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@iV;
T;:UID;;@;;;[ ;{ ;IC;"******************************************************************
The Process::UID module contains a collection of
module functions which can be used to portably get, set, and
switch the current process's real, effective, and saved user IDs.
; T;[ ;[ ;I" ******************************************************************
The Process::UID module contains a collection of
module functions which can be used to portably get, set, and
switch the current process's real, effective, and saved user IDs.
; T;0;@_; F; o; ; T; iV;!i];"o; ;0;0;0;;U;"@;@];0;#I"Process::UID; F;vo; ;0;0;0;;;"@;@ ;0o; ;IC;[ ;l@_;mIC;[ ;l@_;nIC;[ ;l@_;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i;
T;:GID;;@;;;[ ;{ ;IC;"******************************************************************
The Process::GID module contains a collection of
module functions which can be used to portably get, set, and
switch the current process's real, effective, and saved group IDs.
; T;[ ;[ ;I"
******************************************************************
The Process::GID module contains a collection of
module functions which can be used to portably get, set, and
switch the current process's real, effective, and saved group IDs.
; T;0;@_; F; o; ; T; i;!i!;"o; ;0;0;0;;U;"@;@];0;#I"Process::GID; F;vo; ;0;0;0;;;"@;@ ;0o;
; [[@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;1;2F;3;q;;;#I"Process.exec; F;5[[@0; [[@i ;
T;;;0;[ ;{ ;IC;"A
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;7
;8I"
overload; F;90;;;:0;;I"'exec([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@ `; F;=i ;>0;5[[I"[env,][,options]; T0;@ `;[ ;@
;0;@ `; F; o; ; T; ii ;!i ;"@];;I"
VALUE; T;AI"VALUE
rb_f_exec(int argc, VALUE *argv)
{
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
#define CHILD_ERRMSG_BUFLEN 80
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
execarg_obj = rb_execarg_new(argc, argv, TRUE);
eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
#if defined(__APPLE__) || defined(__HAIKU__)
rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg));
#else
rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
#endif
RB_GC_GUARD(execarg_obj);
if (errmsg[0])
rb_sys_fail(errmsg);
rb_sys_fail_str(fail_str);
return Qnil; /* dummy */
}; T;BTo;1;2F;3;q;;;#I"Process.fork; F;5[ ; [[@i
;
T;;;0;[ ;{ ;IC;"Creates a subprocess. If a block is specified, that block is run
in the subprocess, and the subprocess terminates with a status of
zero. Otherwise, the +fork+ call returns twice, once in
the parent, returning the process ID of the child, and once in
the child, returning _nil_. The child process can exit using
Kernel.exit! to avoid running any
at_exit functions. The parent process should
use Process.wait to collect the termination statuses
of its children or use Process.detach to register
disinterest in their status; otherwise, the operating system
may accumulate zombie processes.
The thread calling fork is the only thread in the created child process.
fork doesn't copy other threads.
If fork is not usable, Process.respond_to?(:fork) returns false.
Note that fork(2) is not avaiable on some platforms like Windows and NetBSD 4.
Therefore you should use spawn() instead of fork().
; T;[o;7
;8I"
overload; F;90;;;:0;;I" fork; T;IC;" ; T;[o;<
;8I"
yield; F;9I"[]; T;0;:0;@7`o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@7`;[ ;I"$@yield []
@return [Fixnum, nil]; T;0;@7`; F;=i ;>0;5[ ;@7`o;7
;8I"
overload; F;90;;;:0;;I" fork; T;IC;" ; T;[o;<
;8I"
yield; F;9I"[]; T;0;:0;@7`o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@7`;[ ;I"$@yield []
@return [Fixnum, nil]; T;0;@7`; F;=i ;>0;5[ ;@7`;[ ;@:;0;@7`; F; o; ; T; i
;!i
;"@];;I"static VALUE; T;AI"|static VALUE
rb_f_fork(VALUE obj)
{
rb_pid_t pid;
rb_secure(2);
switch (pid = rb_fork_ruby(NULL)) {
case 0:
rb_thread_atfork();
if (rb_block_given_p()) {
int status;
rb_protect(rb_yield, Qundef, &status);
ruby_stop(status);
}
return Qnil;
case -1:
rb_sys_fail("fork(2)");
return Qnil;
default:
return PIDT2NUM(pid);
}
}; T;BTo;1;2F;3;q;;;#I"Process.spawn; F;5[[@0; [[@iU;
T;;;0;[ ;{ ;IC;"Y)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
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 to 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 => true : don't 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 or positive integer.
true and zero means the process should be a process leader of a new
process group.
Other values specifies a process group to be belongs.
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, a fixnum, 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, 3=>"/dev/null") # read mode
For stdout and stderr,
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 true 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;7
;8I"
overload; F;90;;;:0;;I"(spawn([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@f`; F;=i ;>0;5[[I"[env,][,options]; T0;@f`o;7
;8I"
overload; F;90;;;:0;;I"(spawn([env,] command... [,options]); T;IC;" ; T;[ ;[ ;I" ; T;0;@f`; F;=i ;>0;5[[I"[env,][,options]; T0;@f`;[ ;@;0;@f`; F; o; ; T; iL;!iQ;"@];;I"static VALUE; T;AI"static VALUE
rb_f_spawn(int argc, VALUE *argv)
{
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);
eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg));
RB_GC_GUARD(execarg_obj);
if (pid == -1) {
const char *prog = errmsg;
if (!prog[0]) {
rb_sys_fail_str(fail_str);
}
rb_sys_fail(prog);
}
#if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;q;;;#I"Process.exit!; F;5[[@0; [[@i6;
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;7
;8I"
overload; F;90;;;:0;;I"exit!(status=false); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I" status; TI"
false; T;@`;[ ;@T;0;@`; F; o; ; T; i+;!i2;"@];;I"static VALUE; T;AI"$static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
VALUE status;
int istatus;
if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) {
istatus = exit_status_code(status);
}
else {
istatus = EXIT_FAILURE;
}
_exit(istatus);
UNREACHABLE;
}; T;BTo;1;2F;3;q;;;#I"Process.exit; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I"exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I" status; TI" true; T;@`o;7
;8I"
overload; F;90;;;:0;;I" Kernel::exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I" status; TI" true; T;@`o;7
;8I"
overload; F;90;;;:0;;I" Process::exit(status=true); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I" status; TI" true; T;@`;[ ;@;0;@`; F; o; ; T; iV;!i{;"@];;I"
VALUE; T;AI"VALUE
rb_f_exit(int argc, VALUE *argv)
{
VALUE status;
int istatus;
if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) {
istatus = exit_status_code(status);
}
else {
istatus = EXIT_SUCCESS;
}
rb_exit(istatus);
UNREACHABLE;
}; T;BTo;1;2F;3;q;;;#I"Process.abort; F;5[[@0; [[@i;
T;;;0;[ ;{ ;IC;"Terminate execution immediately, effectively by calling
Kernel.exit(false). If _msg_ is given, it is written
to STDERR prior to terminating.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
abort; T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[ ;@`o;7
;8I"
overload; F;90;;;:0;;I"Kernel::abort([msg]); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I"
[msg]; T0;@`o;7
;8I"
overload; F;90;;;:0;;I"Process::abort([msg]); T;IC;" ; T;[ ;[ ;I" ; T;0;@`; F;=i ;>0;5[[I"
[msg]; T0;@`;[ ;@ ;0;@`; F; o; ; T; i;!i;"@];;I"
VALUE; T;AI"VALUE
rb_f_abort(int argc, VALUE *argv)
{
if (argc == 0) {
if (!NIL_P(GET_THREAD()->errinfo)) {
ruby_error_print();
}
rb_exit(EXIT_FAILURE);
}
else {
VALUE args[2];
rb_scan_args(argc, argv, "1", &args[1]);
StringValue(argv[0]);
rb_io_puts(argc, argv, rb_stderr);
args[0] = INT2NUM(EXIT_FAILURE);
rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
}
UNREACHABLE;
}; T;BTo;1;2F;3;4;;
;#I"Process#kill; F;5[[@0; [[@i;
T;: kill;0;[ ;{ ;IC;" Sends the given signal to the specified process id(s) if _pid_ is positive.
If _pid_ is zero _signal_ is sent to all processes whose group ID is equal
to the group ID of the process. _signal_ may be an integer signal number or
a POSIX signal name (either with or without a +SIG+ prefix). If _signal_ is
negative (or starts with a minus sign), kills process groups instead of
processes. Not all signals are available on all platforms.
pid = fork do
Signal.trap("HUP") { puts "Ouch!"; exit }
# ... do some work ...
end
# ...
Process.kill("HUP", pid)
Process.wait
produces:
Ouch!
If _signal_ is an integer but wrong for signal,
Errno::EINVAL or +RangeError+ will be raised.
Otherwise unless _signal_ is a +String+ or a +Symbol+, and a known
signal name, +ArgumentError+ will be raised.
Also, Errno::ESRCH or +RangeError+ for invalid _pid_,
Errno::EPERM when failed because of no privilege,
will be raised. In these cases, signals may have been sent to
preceding processes.
; T;[o;7
;8I"
overload; F;90;;[;:0;;I"kill(signal, pid, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@`;[ ;I"@return [Fixnum]; T;0;@`; F;=i ;>0;5[[I" signal; T0[I"pid; T0[I"...; T0;@`;[ ;I"RSends the given signal to the specified process id(s) if _pid_ is positive.
If _pid_ is zero _signal_ is sent to all processes whose group ID is equal
to the group ID of the process. _signal_ may be an integer signal number or
a POSIX signal name (either with or without a +SIG+ prefix). If _signal_ is
negative (or starts with a minus sign), kills process groups instead of
processes. Not all signals are available on all platforms.
pid = fork do
Signal.trap("HUP") { puts "Ouch!"; exit }
# ... do some work ...
end
# ...
Process.kill("HUP", pid)
Process.wait
produces:
Ouch!
If _signal_ is an integer but wrong for signal,
Errno::EINVAL or +RangeError+ will be raised.
Otherwise unless _signal_ is a +String+ or a +Symbol+, and a known
signal name, +ArgumentError+ will be raised.
Also, Errno::ESRCH or +RangeError+ for invalid _pid_,
Errno::EPERM when failed because of no privilege,
will be raised. In these cases, signals may have been sent to
preceding processes.
@overload kill(signal, pid, ...)
@return [Fixnum]; T;0;@`; F;>0;"@];;I"
VALUE; T;AI"KVALUE
rb_f_kill(int argc, VALUE *argv)
{
#ifndef HAVE_KILLPG
#define killpg(pg, sig) kill(-(pg), (sig))
#endif
int negative = 0;
int sig;
int i;
volatile VALUE str;
const char *s;
rb_secure(2);
rb_check_arity(argc, 2, UNLIMITED_ARGUMENTS);
switch (TYPE(argv[0])) {
case T_FIXNUM:
sig = FIX2INT(argv[0]);
break;
case T_SYMBOL:
s = rb_id2name(SYM2ID(argv[0]));
if (!s) rb_raise(rb_eArgError, "bad signal");
goto str_signal;
case T_STRING:
s = RSTRING_PTR(argv[0]);
str_signal:
if (s[0] == '-') {
negative++;
s++;
}
if (strncmp("SIG", s, 3) == 0)
s += 3;
if ((sig = signm2signo(s)) == 0)
rb_raise(rb_eArgError, "unsupported name `SIG%s'", s);
if (negative)
sig = -sig;
break;
default:
str = rb_check_string_type(argv[0]);
if (!NIL_P(str)) {
s = RSTRING_PTR(str);
goto str_signal;
}
rb_raise(rb_eArgError, "bad signal type %s",
rb_obj_classname(argv[0]));
break;
}
if (argc <= 1) return INT2FIX(0);
if (sig < 0) {
sig = -sig;
for (i=1; iErrno::EINVAL or +RangeError+ will be raised.
Otherwise unless _signal_ is a +String+ or a +Symbol+, and a known
signal name, +ArgumentError+ will be raised.
Also, Errno::ESRCH or +RangeError+ for invalid _pid_,
Errno::EPERM when failed because of no privilege,
will be raised. In these cases, signals may have been sent to
preceding processes.; T;[o;7
;8I"
overload; F;90;;[;:0;;I"kill(signal, pid, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@a;[ ;I"@return [Fixnum]; T;0;@a; F;=i ;>0;5[[I" signal; T0[I"pid; T0[I"...; T0;@a;[ ;I"SSends the given signal to the specified process id(s) if _pid_ is positive.
If _pid_ is zero _signal_ is sent to all processes whose group ID is equal
to the group ID of the process. _signal_ may be an integer signal number or
a POSIX signal name (either with or without a +SIG+ prefix). If _signal_ is
negative (or starts with a minus sign), kills process groups instead of
processes. Not all signals are available on all platforms.
pid = fork do
Signal.trap("HUP") { puts "Ouch!"; exit }
# ... do some work ...
end
# ...
Process.kill("HUP", pid)
Process.wait
produces:
Ouch!
If _signal_ is an integer but wrong for signal,
Errno::EINVAL or +RangeError+ will be raised.
Otherwise unless _signal_ is a +String+ or a +Symbol+, and a known
signal name, +ArgumentError+ will be raised.
Also, Errno::ESRCH or +RangeError+ for invalid _pid_,
Errno::EPERM when failed because of no privilege,
will be raised. In these cases, signals may have been sent to
preceding processes.
@overload kill(signal, pid, ...)
@return [Fixnum]; T;0;@a; F; o; ; T; i^;!i};=i ;"@];;@a;A@a;BTo;1;2F;3;4;;
;#I"Process#wait; F;5[[@0; [[@it;
T;: wait;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;7
;8I"
overload; F;90;;\;:0;;I" wait(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@6a;[ ;I"@return [Fixnum]; T;0;@6a; F;=i ;>0;5[ ;@6ao;7
;8I"
overload; F;90;;\;:0;;I"wait(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@6a;[ ;I"@return [Fixnum]; T;0;@6a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@6ao;7
;8I"
overload; F;90;: waitpid;:0;;I" waitpid(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@6a;[ ;I"@return [Fixnum]; T;0;@6a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@6a;[ ;I"MWaits 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 [Fixnum]
@overload wait(pid=-1, flags=0)
@return [Fixnum]
@overload waitpid(pid=-1, flags=0)
@return [Fixnum]; T;0;@6a; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_wait(int argc, VALUE *argv)
{
VALUE vpid, vflags;
rb_pid_t pid;
int flags, status;
rb_secure(2);
flags = 0;
if (argc == 0) {
pid = -1;
}
else {
rb_scan_args(argc, argv, "02", &vpid, &vflags);
pid = NUM2PIDT(vpid);
if (argc == 2 && !NIL_P(vflags)) {
flags = NUM2UINT(vflags);
}
}
if ((pid = rb_waitpid(pid, &status, flags)) < 0)
rb_sys_fail(0);
if (pid == 0) {
rb_last_status_clear();
return Qnil;
}
return PIDT2NUM(pid);
}; T;BTo;1;2T;3;q;;;#I"Process.wait; F;5@8a; @:a;
T;;\;0;@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;7
;8I"
overload; F;90;;\;:0;;I" wait(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@wa;[ ;I"@return [Fixnum]; T;0;@wa; F;=i ;>0;5[ ;@wao;7
;8I"
overload; F;90;;\;:0;;I"wait(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@wa;[ ;I"@return [Fixnum]; T;0;@wa; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@wao;7
;8I"
overload; F;90;;];:0;;I" waitpid(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@wa;[ ;I"@return [Fixnum]; T;0;@wa; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@wa;[ ;I"LWaits 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 [Fixnum]
@overload wait(pid=-1, flags=0)
@return [Fixnum]
@overload waitpid(pid=-1, flags=0)
@return [Fixnum]; T;0;@wa; F; o; ; T; iH;!is;=i ;"@];;@ua;A@va;BTo;1;2F;3;4;;
;#I"Process#wait2; F;5[[@0; [[@i;
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;7
;8I"
overload; F;90;;^;:0;;I"wait2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@a;[ ;I"@return [Array]; T;0;@a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@ao;7
;8I"
overload; F;90;:
waitpid2;:0;;I" waitpid2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@a;[ ;I"@return [Array]; T;0;@a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@a;[ ;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;@a; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_wait2(int argc, VALUE *argv)
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status_get());
}; T;BTo;1;2T;3;q;;;#I"Process.wait2; F;5@a; @a;
T;;^;0;@a;{ ;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;7
;8I"
overload; F;90;;^;:0;;I"wait2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@a;[ ;I"@return [Array]; T;0;@a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@ao;7
;8I"
overload; F;90;;_;:0;;I" waitpid2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@a;[ ;I"@return [Array]; T;0;@a; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@a;[ ;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;@a; F; o; ; T; i;!i;=i ;"@];;@a;A@a;BTo;1;2F;3;4;;
;#I"Process#waitpid; F;5[[@0; [[@it;
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;7
;8I"
overload; F;90;;\;:0;;I" wait(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@b;[ ;I"@return [Fixnum]; T;0;@b; F;=i ;>0;5[ ;@bo;7
;8I"
overload; F;90;;\;:0;;I"wait(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@b;[ ;I"@return [Fixnum]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@bo;7
;8I"
overload; F;90;;];:0;;I" waitpid(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@b;[ ;I"@return [Fixnum]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@b;[ ;I"MWaits 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 [Fixnum]
@overload wait(pid=-1, flags=0)
@return [Fixnum]
@overload waitpid(pid=-1, flags=0)
@return [Fixnum]; T;0;@b; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_wait(int argc, VALUE *argv)
{
VALUE vpid, vflags;
rb_pid_t pid;
int flags, status;
rb_secure(2);
flags = 0;
if (argc == 0) {
pid = -1;
}
else {
rb_scan_args(argc, argv, "02", &vpid, &vflags);
pid = NUM2PIDT(vpid);
if (argc == 2 && !NIL_P(vflags)) {
flags = NUM2UINT(vflags);
}
}
if ((pid = rb_waitpid(pid, &status, flags)) < 0)
rb_sys_fail(0);
if (pid == 0) {
rb_last_status_clear();
return Qnil;
}
return PIDT2NUM(pid);
}; T;BTo;1;2T;3;q;;;#I"Process.waitpid; F;5@b; @b;
T;;];0;@b;{ ;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;7
;8I"
overload; F;90;;\;:0;;I" wait(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Ub;[ ;I"@return [Fixnum]; T;0;@Ub; F;=i ;>0;5[ ;@Ubo;7
;8I"
overload; F;90;;\;:0;;I"wait(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Ub;[ ;I"@return [Fixnum]; T;0;@Ub; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@Ubo;7
;8I"
overload; F;90;;];:0;;I" waitpid(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Ub;[ ;I"@return [Fixnum]; T;0;@Ub; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@Ub;[ ;@a;0;@Ub; F; o; ; T; iH;!is;=i ;"@];;@Sb;A@Tb;BTo;1;2F;3;4;;
;#I"Process#waitpid2; F;5[[@0; [[@i;
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;7
;8I"
overload; F;90;;^;:0;;I"wait2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@b;[ ;I"@return [Array]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@bo;7
;8I"
overload; F;90;;_;:0;;I" waitpid2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@b;[ ;I"@return [Array]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@b;[ ;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;@b; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_wait2(int argc, VALUE *argv)
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status_get());
}; T;BTo;1;2T;3;q;;;#I"Process.waitpid2; F;5@b; @b;
T;;_;0;@b;{ ;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;7
;8I"
overload; F;90;;^;:0;;I"wait2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@b;[ ;I"@return [Array]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@bo;7
;8I"
overload; F;90;;_;:0;;I" waitpid2(pid=-1, flags=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@b;[ ;I"@return [Array]; T;0;@b; F;=i ;>0;5[[I"pid; TI"-1; T[I"
flags; TI"0; T;@b;[ ;@b;0;@b; F; o; ; T; i;!i;=i ;"@];;@b;A@b;BTo;1;2F;3;4;;
;#I"Process#waitall; F;5[ ; [[@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, #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, #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, #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 intent 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;7
;8I"
overload; F;90;;a;:0;;I"detach(pid); T;IC;" ; T;[ ;[ ;I" ; T;0;@ c; F;=i ;>0;5[[I"pid; T0;@ c;[ ;I"wSome 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 intent 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;@ c; F;>0;"@];;I"static VALUE; T;AI"vstatic VALUE
proc_detach(VALUE obj, VALUE pid)
{
rb_secure(2);
return rb_detach_process(NUM2PIDT(pid));
}; T;BTo;1;2T;3;q;;;#I"Process.detach; F;5@!c; @$c;
T;;a;0;@&c;{ ;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 intent 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;7
;8I"
overload; F;90;;a;:0;;I"detach(pid); T;IC;" ; T;[ ;[ ;I" ; T;0;@8c; F;=i ;>0;5[[I"pid; T0;@8c;[ ;I"xSome 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 intent 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;@8c; F; o; ; T; i ;!i7;=i ;"@];;@6c;A@7c;BTo;1;2F;3;4;;
;#I"Process#pid; F;5[ ; [[@i ;
T;;K;0;[ ;{ ;IC;"hReturns the process id of this process. Not available on all
platforms.
Process.pid #=> 27415
; T;[o;7
;8I"
overload; F;90;;K;:0;;I"pid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Jc;[ ;I"@return [Fixnum]; T;0;@Jc; F;=i ;>0;5[ ;@Jc;[ ;I"Returns the process id of this process. Not available on all
platforms.
Process.pid #=> 27415
@overload pid
@return [Fixnum]; T;0;@Jc; F;>0;"@];;I"static VALUE; T;AI"Tstatic VALUE
get_pid(void)
{
rb_secure(2);
return PIDT2NUM(getpid());
}; T;BTo;1;2T;3;q;;;#I"Process.pid; F;5@Lc; @Mc;
T;;K;0;@Oc;{ ;IC;"hReturns the process id of this process. Not available on all
platforms.
Process.pid #=> 27415; T;[o;7
;8I"
overload; F;90;;K;:0;;I"pid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@dc;[ ;I"@return [Fixnum]; T;0;@dc; F;=i ;>0;5[ ;@dc;[ ;I"Returns the process id of this process. Not available on all
platforms.
Process.pid #=> 27415
@overload pid
@return [Fixnum]; T;0;@dc; F; o; ; T; i;!i;=i ;"@];;@bc;A@cc;BTo;1;2F;3;4;;
;#I"Process#ppid; F;5[ ; [[@i;
T;: ppid;0;[ ;{ ;IC;"Returns the process id of the parent of this process. Returns
untrustworthy value on Win32/64. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417
; T;[o;7
;8I"
overload; F;90;;b;:0;;I" ppid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@yc;[ ;I"@return [Fixnum]; T;0;@yc; F;=i ;>0;5[ ;@yc;[ ;I"%Returns the process id of the parent of this process. Returns
untrustworthy value on Win32/64. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417
@overload ppid
@return [Fixnum]; T;0;@yc; F;>0;"@];;I"static VALUE; T;AI"Vstatic VALUE
get_ppid(void)
{
rb_secure(2);
return PIDT2NUM(getppid());
}; T;BTo;1;2T;3;q;;;#I"Process.ppid; F;5@{c; @|c;
T;;b;0;@~c;{ ;IC;"Returns the process id of the parent of this process. Returns
untrustworthy value on Win32/64. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417; T;[o;7
;8I"
overload; F;90;;b;:0;;I" ppid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@c;[ ;I"@return [Fixnum]; T;0;@c; F;=i ;>0;5[ ;@c;[ ;I"&Returns the process id of the parent of this process. Returns
untrustworthy value on Win32/64. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417
@overload ppid
@return [Fixnum]; T;0;@c; F; o; ; T; i;!i;=i ;"@];;@c;A@c;BTo;1;2F;3;4;;
;#I"Process#getpgrp; F;5[ ; [[@i;
T;: getpgrp;0;[ ;{ ;IC;"Returns the process group ID for this process. Not available on
all platforms.
Process.getpgid(0) #=> 25527
Process.getpgrp #=> 25527
; T;[o;7
;8I"
overload; F;90;;c;:0;;I" getpgrp; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@c;[ ;I"@return [Integer]; T;0;@c; F;=i ;>0;5[ ;@c;[ ;I"Returns the process group ID for this process. Not available on
all platforms.
Process.getpgid(0) #=> 25527
Process.getpgrp #=> 25527
@overload getpgrp
@return [Integer]; T;0;@c; F;>0;"@];;I"static VALUE; T;AI"Lstatic VALUE
proc_getpgrp(void)
{
rb_pid_t pgrp;
rb_secure(2);
#if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)
pgrp = getpgrp();
if (pgrp < 0) rb_sys_fail(0);
return PIDT2NUM(pgrp);
#else /* defined(HAVE_GETPGID) */
pgrp = getpgid(0);
if (pgrp < 0) rb_sys_fail(0);
return PIDT2NUM(pgrp);
#endif
}; T;BTo;1;2T;3;q;;;#I"Process.getpgrp; F;5@c; @c;
T;;c;0;@c;{ ;IC;"Returns the process group ID for this process. Not available on
all platforms.
Process.getpgid(0) #=> 25527
Process.getpgrp #=> 25527; T;[o;7
;8I"
overload; F;90;;c;:0;;I" getpgrp; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@c;[ ;I"@return [Integer]; T;0;@c; F;=i ;>0;5[ ;@c;[ ;I"Returns the process group ID for this process. Not available on
all platforms.
Process.getpgid(0) #=> 25527
Process.getpgrp #=> 25527
@overload getpgrp
@return [Integer]; T;0;@c; F; o; ; T; i;!i;=i ;"@];;@c;A@c;BTo;1;2F;3;4;;
;#I"Process#setpgrp; F;5[ ; [[@i;
T;: setpgrp;0;[ ;{ ;IC;"MEquivalent to setpgid(0,0). Not available on all
platforms.
; T;[o;7
;8I"
overload; F;90;;d;:0;;I" setpgrp; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@c;[ ;I"@return [0]; T;0;@c; F;=i ;>0;5[ ;@c;[ ;I"nEquivalent to setpgid(0,0). Not available on all
platforms.
@overload setpgrp
@return [0]; T;0;@c; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_setpgrp(void)
{
rb_secure(2);
/* 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;BTo;1;2T;3;q;;;#I"Process.setpgrp; F;5@c; @c;
T;;d;0;@c;{ ;IC;"MEquivalent to setpgid(0,0). Not available on all
platforms.; T;[o;7
;8I"
overload; F;90;;d;:0;;I" setpgrp; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@c;[ ;I"@return [0]; T;0;@c; F;=i ;>0;5[ ;@c;[ ;I"oEquivalent to setpgid(0,0). Not available on all
platforms.
@overload setpgrp
@return [0]; T;0;@c; F; o; ; T; i;!i;=i ;"@];;@c;A@c;BTo;1;2F;3;4;;
;#I"Process#getpgid; F;5[[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;7
;8I"
overload; F;90;;e;:0;;I"getpgid(pid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@d;[ ;I"@return [Integer]; T;0;@d; F;=i ;>0;5[[I"pid; T0;@d;[ ;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;@d; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_getpgid(VALUE obj, VALUE pid)
{
rb_pid_t i;
rb_secure(2);
i = getpgid(NUM2PIDT(pid));
if (i < 0) rb_sys_fail(0);
return PIDT2NUM(i);
}; T;BTo;1;2T;3;q;;;#I"Process.getpgid; F;5@d; @ d;
T;;e;0;@
d;{ ;IC;"Returns the process group ID for the given process id. Not
available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527; T;[o;7
;8I"
overload; F;90;;e;:0;;I"getpgid(pid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@$d;[ ;I"@return [Integer]; T;0;@$d; F;=i ;>0;5[[I"pid; T0;@$d;[ ;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;@$d; F; o; ; T; i;!i;=i ;"@];;@"d;A@#d;BTo;1;2F;3;4;;
;#I"Process#setpgid; F;5[[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;7
;8I"
overload; F;90;;f;:0;;I"setpgid(pid, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;d;[ ;I"@return [0]; T;0;@;d; F;=i ;>0;5[[I"pid; T0[I" integer; T0;@;d;[ ;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;@;d; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
{
rb_pid_t ipid, ipgrp;
rb_secure(2);
ipid = NUM2PIDT(pid);
ipgrp = NUM2PIDT(pgrp);
if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0);
return INT2FIX(0);
}; T;BTo;1;2T;3;q;;;#I"Process.setpgid; F;5@=d; @Bd;
T;;f;0;@Dd;{ ;IC;"wSets the process group ID of _pid_ (0 indicates this
process) to integer. Not available on all platforms.; T;[o;7
;8I"
overload; F;90;;f;:0;;I"setpgid(pid, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@]d;[ ;I"@return [0]; T;0;@]d; F;=i ;>0;5[[I"pid; T0[I" integer; T0;@]d;[ ;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;@]d; F; o; ; T; i;!i;=i ;"@];;@[d;A@\d;BTo;1;2F;3;4;;
;#I"Process#getsid; F;5[[@0; [[@i;
T;: getsid;0;[ ;{ ;IC;"Returns the session ID for for the given process id. If not give,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422
; T;[o;7
;8I"
overload; F;90;;g;:0;;I"
getsid(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@vd;[ ;I"@return [Integer]; T;0;@vd; F;=i ;>0;5[ ;@vdo;7
;8I"
overload; F;90;;g;:0;;I"getsid(pid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@vd;[ ;I"@return [Integer]; T;0;@vd; F;=i ;>0;5[[I"pid; T0;@vd;[ ;I"XReturns the session ID for for the given process id. If not give,
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;@vd; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_getsid(int argc, VALUE *argv)
{
rb_pid_t sid;
VALUE pid;
rb_secure(2);
rb_scan_args(argc, argv, "01", &pid);
if (NIL_P(pid))
pid = INT2FIX(0);
sid = getsid(NUM2PIDT(pid));
if (sid < 0) rb_sys_fail(0);
return PIDT2NUM(sid);
}; T;BTo;1;2T;3;q;;;#I"Process.getsid; F;5@xd; @zd;
T;;g;0;@|d;{ ;IC;"Returns the session ID for for the given process id. If not give,
return current process sid. Not available on all platforms.
Process.getsid() #=> 27422
Process.getsid(0) #=> 27422
Process.getsid(Process.pid()) #=> 27422; T;[o;7
;8I"
overload; F;90;;g;:0;;I"
getsid(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@d;[ ;I"@return [Integer]; T;0;@d; F;=i ;>0;5[ ;@do;7
;8I"
overload; F;90;;g;:0;;I"getsid(pid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@d;[ ;I"@return [Integer]; T;0;@d; F;=i ;>0;5[[I"pid; T0;@d;[ ;I"XReturns the session ID for for the given process id. If not give,
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;@d; F; o; ; T; i ;!i;=i ;"@];;@d;A@d;BTo;1;2F;3;4;;
;#I"Process#setsid; F;5[ ; [[@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;7
;8I"
overload; F;90;;h;:0;;I" setsid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@d;[ ;I"@return [Fixnum]; T;0;@d; F;=i ;>0;5[ ;@d;[ ;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 [Fixnum]; T;0;@d; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_setsid(void)
{
rb_pid_t pid;
rb_secure(2);
pid = setsid();
if (pid < 0) rb_sys_fail(0);
return PIDT2NUM(pid);
}; T;BTo;1;2T;3;q;;;#I"Process.setsid; F;5@d; @d;
T;;h;0;@d;{ ;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;7
;8I"
overload; F;90;;h;:0;;I" setsid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@d;[ ;I"@return [Fixnum]; T;0;@d; F;=i ;>0;5[ ;@d;[ ;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 [Fixnum]; T;0;@d; F; o; ; T; i1;!i9;=i ;"@];;@d;A@d;BTo;1;2F;3;4;;
;#I"Process#getpriority; F;5[[I"
which; T0[I"who; T0; [[@iy;
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;7
;8I"
overload; F;90;;i;:0;;I" getpriority(kind, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@d;[ ;I"@return [Fixnum]; T;0;@d; F;=i ;>0;5[[I" kind; T0[I" integer; T0;@d;[ ;I"\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
@overload getpriority(kind, integer)
@return [Fixnum]; T;0;@d; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_getpriority(VALUE obj, VALUE which, VALUE who)
{
int prio, iwhich, iwho;
rb_secure(2);
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
errno = 0;
prio = getpriority(iwhich, iwho);
if (errno) rb_sys_fail(0);
return INT2FIX(prio);
}; T;BTo;1;2T;3;q;;;#I"Process.getpriority; F;5@d; @d;
T;;i;0;@d;{ ;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;7
;8I"
overload; F;90;;i;:0;;I" getpriority(kind, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@e;[ ;I"@return [Fixnum]; T;0;@e; F;=i ;>0;5[[I" kind; T0[I" integer; T0;@e;[ ;I"]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
@overload getpriority(kind, integer)
@return [Fixnum]; T;0;@e; F; o; ; T; ih;!iv;=i ;"@];;@e;A@e;BTo;1;2F;3;4;;
;#I"Process#setpriority; F;5[[I"
which; T0[I"who; T0[I" prio; T0; [[@i;
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;7
;8I"
overload; F;90;;j;:0;;I")setpriority(kind, integer, priority); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@.e;[ ;I"@return [0]; T;0;@.e; F;=i ;>0;5[[I" kind; T0[I" integer; T0[I"
priority; T0;@.e;[ ;I"ZSee 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;@.e; F;>0;"@];;I"static VALUE; T;AI"+static VALUE
proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio)
{
int iwhich, iwho, iprio;
rb_secure(2);
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
iprio = NUM2INT(prio);
if (setpriority(iwhich, iwho, iprio) < 0)
rb_sys_fail(0);
return INT2FIX(0);
}; T;BTo;1;2T;3;q;;;#I"Process.setpriority; F;5@0e; @7e;
T;;j;0;@9e;{ ;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;7
;8I"
overload; F;90;;j;:0;;I")setpriority(kind, integer, priority); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@Te;[ ;I"@return [0]; T;0;@Te; F;=i ;>0;5[[I" kind; T0[I" integer; T0[I"
priority; T0;@Te;[ ;I"[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
@overload setpriority(kind, integer, priority)
@return [0]; T;0;@Te; F; o; ; T; i;!i;=i ;"@];;@Re;A@Se;BTo;
; [[@iJ ;
F;:PRIO_PROCESS;;;;;[ ;{ ;IC;" see Process.setpriority
; T;[ ;[ ;I" see Process.setpriority; T;0;@oe; F; o; ; T; iI ;!iI ;"@];#I"Process::PRIO_PROCESS; F;$I"INT2FIX(PRIO_PROCESS); To;
; [[@iL ;
F;:PRIO_PGRP;;;;;[ ;{ ;IC;" see Process.setpriority
; T;[ ;[ ;I" see Process.setpriority; T;0;@{e; F; o; ; T; iK ;!iK ;"@];#I"Process::PRIO_PGRP; F;$I"INT2FIX(PRIO_PGRP); To;
; [[@iN ;
F;:PRIO_USER;;;;;[ ;{ ;IC;" see Process.setpriority
; T;[ ;[ ;I" see Process.setpriority; T;0;@e; F; o; ; T; iM ;!iM ;"@];#I"Process::PRIO_USER; F;$I"INT2FIX(PRIO_USER); To;1;2F;3;4;;
;#I"Process#getrlimit; F;5[[I"
resource; T0; [[@i;
T;:getrlimit;0;[ ;{ ;IC;"EGets 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;7
;8I"
overload; F;90;;n;:0;;I"getrlimit(resource); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@e;[ ;I"@return [Array]; T;0;@e; F;=i ;>0;5[[I"
resource; T0;@e;[ ;I"vGets 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;@e; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_getrlimit(VALUE obj, VALUE resource)
{
struct rlimit rlim;
rb_secure(2);
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;BTo;1;2T;3;q;;;#I"Process.getrlimit; F;5@e; @e;
T;;n;0;@e;{ ;IC;"EGets 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;7
;8I"
overload; F;90;;n;:0;;I"getrlimit(resource); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@e;[ ;I"@return [Array]; T;0;@e; F;=i ;>0;5[[I"
resource; T0;@e;[ ;I"wGets 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;@e; F; o; ; T; is;!i;=i ;"@];;@e;A@e;BTo;1;2F;3;4;;
;#I"Process#setrlimit; F;5[[@0; [[@i;
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;7
;8I"
overload; F;90;;o;:0;;I".setrlimit(resource, cur_limit, max_limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@e;[ ;I"@return [nil]; T;0;@e; F;=i ;>0;5[[I"
resource; T0[I"cur_limit; T0[I"max_limit; T0;@eo;7
;8I"
overload; F;90;;o;:0;;I"#setrlimit(resource, cur_limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@e;[ ;I"@return [nil]; T;0;@e; F;=i ;>0;5[[I"
resource; T0[I"cur_limit; T0;@e;[ ;I"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])
@overload setrlimit(resource, cur_limit, max_limit)
@return [nil]
@overload setrlimit(resource, cur_limit)
@return [nil]; T;0;@e; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_setrlimit(int argc, VALUE *argv, VALUE obj)
{
VALUE resource, rlim_cur, rlim_max;
struct rlimit rlim;
rb_secure(2);
rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max);
if (rlim_max == Qnil)
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;BTo;1;2T;3;q;;;#I"Process.setrlimit; F;5@e; @e;
T;;o;0;@e;{ ;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;7
;8I"
overload; F;90;;o;:0;;I".setrlimit(resource, cur_limit, max_limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@e;[ ;I"@return [nil]; T;0;@e; F;=i ;>0;5[[I"
resource; T0[I"cur_limit; T0[I"max_limit; T0;@eo;7
;8I"
overload; F;90;;o;:0;;I"#setrlimit(resource, cur_limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@e;[ ;I"@return [nil]; T;0;@e; F;=i ;>0;5[[I"
resource; T0[I"cur_limit; T0;@e;[ ;I"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])
@overload setrlimit(resource, cur_limit, max_limit)
@return [nil]
@overload setrlimit(resource, cur_limit)
@return [nil]; T;0;@e; F; o; ; T; i;!i;=i ;"@];;@e;A@e;BTo;
; [[@iZ ;
F;:RLIM_SAVED_MAX;;;;;[ ;{ ;IC;"see Process.setrlimit
; T;[ ;[ ;I"see Process.setrlimit; T;0;@&f; F; o; ; T; iY ;!iY ;"@];#I" Process::RLIM_SAVED_MAX; F;$I"v; To;
; [[@i^ ;
F;:RLIM_INFINITY;;;;;[ ;{ ;IC;"see Process.setrlimit
; T;[ ;[ ;I"see Process.setrlimit; T;0;@2f; F; o; ; T; i] ;!i] ;"@];#I"Process::RLIM_INFINITY; F;$I"inf; To;
; [[@ic ;
F;:RLIM_SAVED_CUR;;;;;[ ;{ ;IC;"see Process.setrlimit
; T;[ ;[ ;I"see Process.setrlimit; T;0;@>f; F; o; ; T; ib ;!ib ;"@];#I" Process::RLIM_SAVED_CUR; F;$I"v; To;
; [[@il ;
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;@Jf; F; o; ; T; ih ;!ik ;"@];#I"Process::RLIMIT_AS; F;$I"INT2FIX(RLIMIT_AS); To;
; [[@is ;
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;@Vf; F; o; ; T; io ;!ir ;"@];#I"Process::RLIMIT_CORE; F;$I"INT2FIX(RLIMIT_CORE); To;
; [[@iz ;
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;@bf; F; o; ; T; iv ;!iy ;"@];#I"Process::RLIMIT_CPU; F;$I"INT2FIX(RLIMIT_CPU); To;
; [[@i ;
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;@nf; F; o; ; T; i} ;!i ;"@];#I"Process::RLIMIT_DATA; F;$I"INT2FIX(RLIMIT_DATA); To;
; [[@i ;
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;@zf; F; o; ; T; i ;!i ;"@];#I"Process::RLIMIT_FSIZE; F;$I"INT2FIX(RLIMIT_FSIZE); To;
; [[@i ;
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;@f; F; o; ; T; i ;!i ;"@];#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; F; o; ; T; i ;!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;@f; 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;@f; 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; 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; 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; 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; 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; 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; 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; F; o; ; T; i ;!i ;"@];#I"Process::RLIMIT_STACK; F;$I"INT2FIX(RLIMIT_STACK); To;1;2F;3;4;;
;#I"Process#uid; F;5[ ; [[@i&;
T;:uid;0;[ ;{ ;IC;"JReturns the (real) user ID of this process.
Process.uid #=> 501
; T;[o;7
;8I"
overload; F;90;;;:0;;I"uid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@
g;[ ;I"@return [Fixnum]; T;0;@
g; F;=i ;>0;5[ ;@
go;7
;8I"
overload; F;90;:Process::UID.rid;:0;;I"Process::UID.rid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@
g;[ ;I"@return [Fixnum]; T;0;@
g; F;=i ;>0;5[ ;@
go;7
;8I"
overload; F;90;:Process::Sys.getuid;:0;;I"Process::Sys.getuid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@
g;[ ;I"@return [Fixnum]; T;0;@
g; F;=i ;>0;5[ ;@
g;[ ;I"Returns the (real) user ID of this process.
Process.uid #=> 501
@overload uid
@return [Fixnum]
@overload Process::UID.rid
@return [Fixnum]
@overload Process::Sys.getuid
@return [Fixnum]; T;0;@
g; F;>0;"@];;I"static VALUE; T;AI"cstatic VALUE
proc_getuid(VALUE obj)
{
rb_uid_t uid = getuid();
return UIDT2NUM(uid);
}; T;BTo;1;2T;3;q;;;#I"Process.uid; F;5@ g; @
g;
T;;;0;@g;{ ;IC;"JReturns the (real) user ID of this process.
Process.uid #=> 501; T;[o;7
;8I"
overload; F;90;;;:0;;I"uid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@>g;[ ;I"@return [Fixnum]; T;0;@>g; F;=i ;>0;5[ ;@>go;7
;8I"
overload; F;90;;;:0;;I"Process::UID.rid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@>g;[ ;I"@return [Fixnum]; T;0;@>g; F;=i ;>0;5[ ;@>go;7
;8I"
overload; F;90;;;:0;;I"Process::Sys.getuid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@>g;[ ;I"@return [Fixnum]; T;0;@>g; F;=i ;>0;5[ ;@>g;[ ;I"Returns the (real) user ID of this process.
Process.uid #=> 501
@overload uid
@return [Fixnum]
@overload Process::UID.rid
@return [Fixnum]
@overload Process::Sys.getuid
@return [Fixnum]; T;0;@>g; F; o; ; T; i;!i%;=i ;"@];;@Array of the
gids of all the groups in the supplementary group access list. Not
available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" initgroups(username, gid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;i;[ ;I"@return [Array]; T;0;@;i; F;=i ;>0;5[[I"
username; T0[I"gid; T0;@;i;[ ;I">Initializes the supplemental group access list by reading the
system group database and using all groups of which the given user
is a member. The group with the specified gid is also
added to the list. Returns the resulting Array of the
gids of all the groups in the supplementary group access list. Not
available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]
@overload initgroups(username, gid)
@return [Array]; T;0;@;i; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp)
{
if (initgroups(StringValuePtr(uname), OBJ2GID(base_grp)) != 0) {
rb_sys_fail(0);
}
return proc_getgroups(obj);
}; T;BTo;1;2T;3;q;;;#I"Process.initgroups; F;5@=i; @Bi;
T;;;0;@Di;{ ;IC;"Initializes the supplemental group access list by reading the
system group database and using all groups of which the given user
is a member. The group with the specified gid is also
added to the list. Returns the resulting Array of the
gids of all the groups in the supplementary group access list. Not
available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]; T;[o;7
;8I"
overload; F;90;;;:0;;I" initgroups(username, gid); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@]i;[ ;I"@return [Array]; T;0;@]i; F;=i ;>0;5[[I"
username; T0[I"gid; T0;@]i;[ ;I"@Initializes the supplemental group access list by reading the
system group database and using all groups of which the given user
is a member. The group with the specified gid is also
added to the list. Returns the resulting Array of the
gids of all the groups in the supplementary group access list. Not
available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]
@overload initgroups(username, gid)
@return [Array]; T;0;@]i; F; o; ; T; i};!i;=i ;"@];;@[i;A@\i;BTo;1;2F;3;4;;
;#I"Process#groups; F;5[ ; [[@i-;
T;: groups;0;[ ;{ ;IC;"Get an Array of the gids of groups in the
supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" groups; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@vi;[ ;I"@return [Array]; T;0;@vi; F;=i ;>0;5[ ;@vi;[ ;I"Get an Array of the gids of groups in the
supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
@overload groups
@return [Array]; T;0;@vi; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_getgroups(VALUE obj)
{
VALUE ary, tmp;
int i, ngroups;
rb_gid_t *groups;
ngroups = getgroups(0, NULL);
if (ngroups == -1)
rb_sys_fail(0);
groups = ALLOCV_N(rb_gid_t, tmp, ngroups);
ngroups = getgroups(ngroups, groups);
if (ngroups == -1)
rb_sys_fail(0);
ary = rb_ary_new();
for (i = 0; i < ngroups; i++)
rb_ary_push(ary, GIDT2NUM(groups[i]));
ALLOCV_END(tmp);
return ary;
}; T;BTo;1;2T;3;q;;;#I"Process.groups; F;5@xi; @yi;
T;;;0;@{i;{ ;IC;"Get an Array of the gids of groups in the
supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]; T;[o;7
;8I"
overload; F;90;;;:0;;I" groups; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@i;[ ;I"@return [Array]; T;0;@i; F;=i ;>0;5[ ;@i;[ ;I"Get an Array of the gids of groups in the
supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
@overload groups
@return [Array]; T;0;@i; F; o; ; T; i";!i*;=i ;"@];;@i;A@i;BTo;1;2F;3;4;;
;#I"Process#groups=; F;5[[I"ary; T0; [[@iY;
T;: groups=;0;[ ;{ ;IC;"Set the supplemental group access list to the given
Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"groups=(array); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@i;[ ;I"@return [Array]; T;0;@i; F;=i ;>0;5[[I"
array; T0;@i;[ ;I""Set the supplemental group access list to the given
Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]
@overload groups=(array)
@return [Array]; T;0;@i; F;>0;"@];;I"static VALUE; T;AI"_static VALUE
proc_setgroups(VALUE obj, VALUE ary)
{
int ngroups, i;
rb_gid_t *groups;
VALUE tmp;
PREPARE_GETGRNAM;
Check_Type(ary, T_ARRAY);
ngroups = RARRAY_LENINT(ary);
if (ngroups > maxgroups())
rb_raise(rb_eArgError, "too many groups, %d max", maxgroups());
groups = ALLOCV_N(rb_gid_t, tmp, ngroups);
for (i = 0; i < ngroups; i++) {
VALUE g = RARRAY_AREF(ary, i);
groups[i] = OBJ2GID1(g);
}
FINISH_GETGRNAM;
if (setgroups(ngroups, groups) == -1) /* ngroups <= maxgroups */
rb_sys_fail(0);
ALLOCV_END(tmp);
return proc_getgroups(obj);
}; T;BTo;1;2T;3;q;;;#I"Process.groups=; F;5@i; @i;
T;;;0;@i;{ ;IC;"Set the supplemental group access list to the given
Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]; T;[o;7
;8I"
overload; F;90;;;:0;;I"groups=(array); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@i;[ ;I"@return [Array]; T;0;@i; F;=i ;>0;5[[I"
array; T0;@i;[ ;I"$Set the supplemental group access list to the given
Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]
@overload groups=(array)
@return [Array]; T;0;@i; F; o; ; T; iL;!iV;=i ;"@];;@i;A@i;BTo;1;2F;3;4;;
;#I"Process#maxgroups; F;5[ ; [[@i;
T;:maxgroups;0;[ ;{ ;IC;"uReturns the maximum number of gids allowed in the supplemental
group access list.
Process.maxgroups #=> 32
; T;[o;7
;8I"
overload; F;90;;;:0;;I"maxgroups; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@i;[ ;I"@return [Fixnum]; T;0;@i; F;=i ;>0;5[ ;@i;[ ;I"Returns the maximum number of gids allowed in the supplemental
group access list.
Process.maxgroups #=> 32
@overload maxgroups
@return [Fixnum]; T;0;@i; F;>0;"@];;I"static VALUE; T;AI"Sstatic VALUE
proc_getmaxgroups(VALUE obj)
{
return INT2FIX(maxgroups());
}; T;BTo;1;2T;3;q;;;#I"Process.maxgroups; F;5@i; @i;
T;;;0;@i;{ ;IC;"uReturns the maximum number of gids allowed in the supplemental
group access list.
Process.maxgroups #=> 32; T;[o;7
;8I"
overload; F;90;;;:0;;I"maxgroups; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@i;[ ;I"@return [Fixnum]; T;0;@i; F;=i ;>0;5[ ;@i;[ ;I"Returns the maximum number of gids allowed in the supplemental
group access list.
Process.maxgroups #=> 32
@overload maxgroups
@return [Fixnum]; T;0;@i; F; o; ; T; i;!i;=i ;"@];;@i;A@i;BTo;1;2F;3;4;;
;#I"Process#maxgroups=; F;5[[I"val; T0; [[@i;
T;:maxgroups=;0;[ ;{ ;IC;"SSets the maximum number of gids allowed in the supplemental group
access list.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"maxgroups=(fixnum); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@ j;[ ;I"@return [Fixnum]; T;0;@ j; F;=i ;>0;5[[I" fixnum; T0;@ j;[ ;I"Sets the maximum number of gids allowed in the supplemental group
access list.
@overload maxgroups=(fixnum)
@return [Fixnum]; T;0;@ j; F;>0;"@];;I"static VALUE; T;AI"static VALUE
proc_setmaxgroups(VALUE obj, VALUE val)
{
int ngroups = FIX2INT(val);
int ngroups_max = get_sc_ngroups_max();
if (ngroups <= 0)
rb_raise(rb_eArgError, "maxgroups %d shold be positive", ngroups);
if (ngroups > RB_MAX_GROUPS)
ngroups = RB_MAX_GROUPS;
if (ngroups_max > 0 && ngroups > ngroups_max)
ngroups = ngroups_max;
_maxgroups = ngroups;
return INT2FIX(_maxgroups);
}; T;BTo;1;2T;3;q;;;#I"Process.maxgroups=; F;5@ j; @j;
T;;;0;@j;{ ;IC;"SSets the maximum number of gids allowed in the supplemental group
access list.; T;[o;7
;8I"
overload; F;90;;;:0;;I"maxgroups=(fixnum); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@'j;[ ;I"@return [Fixnum]; T;0;@'j; F;=i ;>0;5[[I" fixnum; T0;@'j;[ ;I"Sets the maximum number of gids allowed in the supplemental group
access list.
@overload maxgroups=(fixnum)
@return [Fixnum]; T;0;@'j; F; o; ; T; i;!i;=i ;"@];;@%j;A@&j;BTo;1;2F;3;4;;
;#I"Process#daemon; F;5[[@0; [[@i;
T;: daemon;0;[ ;{ ;IC;"zDetach the process from controlling terminal and run in
the background as system daemon. Unless the argument
nochdir is true (i.e. non false), it changes the current
working directory to the root ("/"). Unless the argument
noclose is true, daemon() will redirect standard input,
standard output and standard error to /dev/null.
Return zero on success, or raise one of Errno::*.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
daemon(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@>j;[ ;I"@return [0]; T;0;@>j; F;=i ;>0;5[ ;@>jo;7
;8I"
overload; F;90;;;:0;;I"$daemon(nochdir=nil,noclose=nil); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@>j;[ ;I"@return [0]; T;0;@>j; F;=i ;>0;5[[I" nochdir; TI"nil; T[I" noclose; TI"nil; T;@>j;[ ;I"Detach the process from controlling terminal and run in
the background as system daemon. Unless the argument
nochdir is true (i.e. non false), it changes the current
working directory to the root ("/"). Unless the argument
noclose is true, daemon() will redirect standard input,
standard output and standard error to /dev/null.
Return zero on success, or raise one of Errno::*.
@overload daemon()
@return [0]
@overload daemon(nochdir=nil,noclose=nil)
@return [0]; T;0;@>j; F;>0;"@];;I"static VALUE; T;AI"%static VALUE
proc_daemon(int argc, VALUE *argv)
{
VALUE nochdir, noclose;
int n;
rb_secure(2);
rb_scan_args(argc, argv, "02", &nochdir, &noclose);
prefork();
n = rb_daemon(RTEST(nochdir), RTEST(noclose));
if (n < 0) rb_sys_fail("daemon");
return INT2FIX(n);
}; T;BTo;1;2T;3;q;;;#I"Process.daemon; F;5@@j; @Bj;
T;;;0;@Dj;{ ;IC;"zDetach the process from controlling terminal and run in
the background as system daemon. Unless the argument
nochdir is true (i.e. non false), it changes the current
working directory to the root ("/"). Unless the argument
noclose is true, daemon() will redirect standard input,
standard output and standard error to /dev/null.
Return zero on success, or raise one of Errno::*.; T;[o;7
;8I"
overload; F;90;;;:0;;I"
daemon(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@lj;[ ;I"@return [0]; T;0;@lj; F;=i ;>0;5[ ;@ljo;7
;8I"
overload; F;90;;;:0;;I"$daemon(nochdir=nil,noclose=nil); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@lj;[ ;I"@return [0]; T;0;@lj; F;=i ;>0;5[[I" nochdir; TI"nil; T[I" noclose; TI"nil; T;@lj;[ ;I"Detach the process from controlling terminal and run in
the background as system daemon. Unless the argument
nochdir is true (i.e. non false), it changes the current
working directory to the root ("/"). Unless the argument
noclose is true, daemon() will redirect standard input,
standard output and standard error to /dev/null.
Return zero on success, or raise one of Errno::*.
@overload daemon()
@return [0]
@overload daemon(nochdir=nil,noclose=nil)
@return [0]; T;0;@lj; F; o; ; T; i;!i;=i ;"@];;@jj;A@kj;BTo;1;2F;3;4;;
;#I"Process#times; F;5[ ; [[@ia;
T;;;0;[ ;{ ;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;7
;8I"
overload; F;90;;;:0;;I"
times; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"aProcessTms; T;@j;[ ;I"@return [aProcessTms]; T;0;@j; F;=i ;>0;5[ ;@j;[ ;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;@j; F;>0;"@];;I"
VALUE; T;AI"
VALUE
rb_proc_times(VALUE obj)
{
const double hertz = get_clk_tck();
struct tms buf;
VALUE utime, stime, cutime, cstime, ret;
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);
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;BTo;1;2T;3;q;;;#I"Process.times; F;5@j; @j;
T;;;0;@j;{ ;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;7
;8I"
overload; F;90;;;:0;;I"
times; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"aProcessTms; T;@j;[ ;I"@return [aProcessTms]; T;0;@j; F;=i ;>0;5[ ;@j;[ ;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;@j; F; o; ; T; iU;!i^;=i ;"@];;@j;A@j;BTo;
; [[@i [@i ;
F;:CLOCK_REALTIME;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I" Process::CLOCK_REALTIME; F;$I"+RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME; To;
; [[@i [@i ;
F;:CLOCK_MONOTONIC;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I" Process::CLOCK_MONOTONIC; F;$I"2RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC; To;
; [[@i [@i ;
F;: CLOCK_PROCESS_CPUTIME_ID;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I"&Process::CLOCK_PROCESS_CPUTIME_ID; F;$I"2RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID; To;
; [[@i ;
F;: CLOCK_THREAD_CPUTIME_ID;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I"%Process::CLOCK_THREAD_CPUTIME_ID; F;$I")CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID); To;
; [[@i ;
F;:CLOCK_VIRTUAL;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I"Process::CLOCK_VIRTUAL; F;$I" CLOCKID2NUM(CLOCK_VIRTUAL); To;
; [[@i ;
F;:CLOCK_PROF;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@j;"@];#I"Process::CLOCK_PROF; F;$I" CLOCKID2NUM(CLOCK_PROF); To;
; [[@i ;
F;:CLOCK_REALTIME_FAST;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@k;"@];#I"!Process::CLOCK_REALTIME_FAST; F;$I"%CLOCKID2NUM(CLOCK_REALTIME_FAST); To;
; [[@i
;
F;:CLOCK_REALTIME_PRECISE;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@ k;"@];#I"$Process::CLOCK_REALTIME_PRECISE; F;$I"(CLOCKID2NUM(CLOCK_REALTIME_PRECISE); To;
; [[@i
;
F;:CLOCK_REALTIME_COARSE;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@k;"@];#I"#Process::CLOCK_REALTIME_COARSE; F;$I"'CLOCKID2NUM(CLOCK_REALTIME_COARSE); To;
; [[@i ;
F;:CLOCK_REALTIME_ALARM;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@ k;"@];#I""Process::CLOCK_REALTIME_ALARM; F;$I"&CLOCKID2NUM(CLOCK_REALTIME_ALARM); To;
; [[@i ;
F;:CLOCK_MONOTONIC_FAST;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@*k;"@];#I""Process::CLOCK_MONOTONIC_FAST; F;$I"&CLOCKID2NUM(CLOCK_MONOTONIC_FAST); To;
; [[@i ;
F;: CLOCK_MONOTONIC_PRECISE;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@4k;"@];#I"%Process::CLOCK_MONOTONIC_PRECISE; F;$I")CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE); To;
; [[@i ;
F;:CLOCK_MONOTONIC_RAW;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@>k;"@];#I"!Process::CLOCK_MONOTONIC_RAW; F;$I"%CLOCKID2NUM(CLOCK_MONOTONIC_RAW); To;
; [[@i ;
F;:CLOCK_MONOTONIC_COARSE;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@Hk;"@];#I"$Process::CLOCK_MONOTONIC_COARSE; F;$I"(CLOCKID2NUM(CLOCK_MONOTONIC_COARSE); To;
; [[@i ;
F;:CLOCK_BOOTTIME;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@Rk;"@];#I" Process::CLOCK_BOOTTIME; F;$I" CLOCKID2NUM(CLOCK_BOOTTIME); To;
; [[@i" ;
F;:CLOCK_BOOTTIME_ALARM;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@\k;"@];#I""Process::CLOCK_BOOTTIME_ALARM; F;$I"&CLOCKID2NUM(CLOCK_BOOTTIME_ALARM); To;
; [[@i% ;
F;:CLOCK_UPTIME;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@fk;"@];#I"Process::CLOCK_UPTIME; F;$I" CLOCKID2NUM(CLOCK_UPTIME); To;
; [[@i( ;
F;:CLOCK_UPTIME_FAST;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@pk;"@];#I" Process::CLOCK_UPTIME_FAST; F;$I"#CLOCKID2NUM(CLOCK_UPTIME_FAST); To;
; [[@i+ ;
F;:CLOCK_UPTIME_PRECISE;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@zk;"@];#I""Process::CLOCK_UPTIME_PRECISE; F;$I"&CLOCKID2NUM(CLOCK_UPTIME_PRECISE); To;
; [[@i. ;
F;:CLOCK_SECOND;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@k;"@];#I"Process::CLOCK_SECOND; F;$I" CLOCKID2NUM(CLOCK_SECOND); To;1;2F;3;4;;
;#I"Process#clock_gettime; F;5[[@0; [[@i;
T;:clock_gettime;0;[ ;{ ;IC;"uReturns 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 specifed 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
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1
[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
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
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;7
;8I"
overload; F;90;;;:0;;I"%clock_gettime(clock_id [, unit]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@k;[ ;I"@return [Numeric]; T;0;@k; F;=i ;>0;5[[I"clock_id[, unit]; T0;@k;[ ;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 specifed 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
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1
[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
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
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;@k; F;>0;"@];;I"
VALUE; T;AI"VALUE
rb_clock_gettime(int argc, VALUE *argv)
{
VALUE clk_id, unit;
int ret;
struct timetick tt;
timetick_int_t numerators[2];
timetick_int_t denominators[2];
int num_numerators = 0;
int num_denominators = 0;
rb_scan_args(argc, argv, "11", &clk_id, &unit);
if (SYMBOL_P(clk_id)) {
/*
* Non-clock_gettime clocks are provided by symbol clk_id.
*
* gettimeofday is always available on platforms supported by Ruby.
* GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for
* CLOCK_REALTIME if clock_gettime is not available.
*/
#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(rb_intern("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;
}
#define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(rb_intern("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(rb_intern("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(rb_intern("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(rb_intern("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(rb_intern("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(rb_intern("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC"))
if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
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. */
errno = EINVAL;
rb_sys_fail(0);
success:
return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
}; T;BTo;1;2T;3;q;;;#I"Process.clock_gettime; F;5@k; @k;
T;;;0;@k;{ ;IC;"uReturns 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 specifed 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
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1
[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
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
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;7
;8I"
overload; F;90;;;:0;;I"%clock_gettime(clock_id [, unit]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@k;[ ;I"@return [Numeric]; T;0;@k; F;=i ;>0;5[[I"clock_id[, unit]; T0;@k;[ ;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 specifed 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
[CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4
[CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63
[CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1
[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
[CLOCK_BOOTTIME] Linux 2.6.39
[CLOCK_BOOTTIME_ALARM] Linux 3.0
[CLOCK_UPTIME] FreeBSD 7.0
[CLOCK_UPTIME_FAST] FreeBSD 8.1
[CLOCK_UPTIME_PRECISE] FreeBSD 8.1
[CLOCK_SECOND] FreeBSD 8.1
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;@k; F; o; ; T; iA;!i;=i ;"@];;@k;A@k;BTo;1;2F;3;4;;
;#I"Process#clock_getres; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I"$clock_getres(clock_id [, unit]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@k;[ ;I"@return [Numeric]; T;0;@k; F;=i ;>0;5[[I"clock_id[, unit]; T0;@k;[ ;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;@k; F;>0;"@];;I"
VALUE; T;AI" VALUE
rb_clock_getres(int argc, VALUE *argv)
{
VALUE clk_id, unit;
struct timetick tt;
timetick_int_t numerators[2];
timetick_int_t denominators[2];
int num_numerators = 0;
int num_denominators = 0;
rb_scan_args(argc, argv, "11", &clk_id, &unit);
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) {
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. */
errno = EINVAL;
rb_sys_fail(0);
success:
if (unit == ID2SYM(rb_intern("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;BTo;1;2T;3;q;;;#I"Process.clock_getres; F;5@k; @k;
T;;;0;@k;{ ;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;7
;8I"
overload; F;90;;;:0;;I"$clock_getres(clock_id [, unit]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@k;[ ;I"@return [Numeric]; T;0;@k; F;=i ;>0;5[[I"clock_id[, unit]; T0;@k;[ ;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;@k; F; o; ; T; iZ ;!i~ ;=i ;"@];;@k;A@k;BT;l@];mIC;[ ;l@];nIC;[ ;l@];oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i ;
F;;U;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@];=i ;"@;#I" Process; Fo;
; [[@]i;
F;: ARGV;;;;;[ ;{ ;IC;"ARGV contains the command line arguments used to run ruby with the
first value containing the name of the executable.
A library like OptionParser can be used to process command-line
arguments.
; T;[ ;[ ;I"ARGV contains the command line arguments used to run ruby with the
first value containing the name of the executable.
A library like OptionParser can be used to process command-line
arguments.
; T;0;@l; F; o; ; T; i;!i;"@;#I" ARGV; F;$I" rb_argv; To; ;IC;[ ;l@l;mIC;[ ;l@l;nIC;[ ;l@l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i;
T;:
FileTest;;@;;;[ ;{ ;IC;"FileTest implements file test operations similar to
those used in File::Stat. It exists as a standalone
module, and its methods are also insinuated into the File
class. (Note that this is not done by inclusion: the interpreter cheats).
; T;[ ;[ ;I"
FileTest implements file test operations similar to
those used in File::Stat. It exists as a standalone
module, and its methods are also insinuated into the File
class. (Note that this is not done by inclusion: the interpreter cheats).
; T;0;@l; F; o; ; T; i;!i;"@;#I"
FileTest; F;vo; ;0;0;0;;;"@;@ ;0@ o; ;IC;[~o;1;2F;3;q;;;#I"IO.wait_for_single_fd; F;5[[I"fd; T0[I" events; T0[I" timeout; T0; [[@ i ;
T;:wait_for_single_fd;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@'l;"@%l;;I"static VALUE; T;AI"{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;BTo;;IC;[ ;l@9l;mIC;[ ;l@9l;nIC;[ ;l@9l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;:WaitReadable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@9l;"@%l;#I"IO::WaitReadable; Fo;;IC;[ ;l@Jl;mIC;[ ;l@Jl;nIC;[ ;l@Jl;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;:WaitWritable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@Jl;"@%l;#I"IO::WaitWritable; Fo; ;IC;[ ;l@[l;mIC;[ ;l@[l;nIC;[@9l;l@[l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;:EAGAINWaitReadable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@[l;"@%l;#I"IO::EAGAINWaitReadable; F;vo; ;0;0;0;: EAGAIN;"@;0;;qo; ;IC;[ ;l@ml;mIC;[ ;l@ml;nIC;[@Jl;l@ml;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;:EAGAINWaitWritable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@ml;"@%l;#I"IO::EAGAINWaitWritable; F;vo; ;0;0;0;;;"@;0;;qo;
; [[@i.;
F;: EWOULDBLOCKWaitReadable;;;;;[ ;{ ;IC;":EAGAINWaitReadable
; T;[ ;[ ;I":EAGAINWaitReadable; T;0;@l; F; o; ; T; i.;!i.;"@%l;#I" IO::EWOULDBLOCKWaitReadable; F;$I"same as IO; To;
; [[@i.;
F;: EWOULDBLOCKWaitWritable;;;;;[ ;{ ;IC;":EAGAINWaitWritable
; T;[ ;[ ;I":EAGAINWaitWritable; T;0;@l; F; o; ; T; i.;!i.;"@%l;#I" IO::EWOULDBLOCKWaitWritable; F;$I"same as IO; To; ;IC;[ ;l@l;mIC;[ ;l@l;nIC;[@9l;l@l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;: EINPROGRESSWaitReadable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@l;"@%l;#I" IO::EINPROGRESSWaitReadable; F;vo; ;0;0;0;:EINPROGRESS;"@;0;;qo; ;IC;[ ;l@l;mIC;[ ;l@l;nIC;[@Jl;l@l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i.;
F;: EINPROGRESSWaitWritable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@l;"@%l;#I" IO::EINPROGRESSWaitWritable; F;vo; ;0;0;0;;;"@;0;;qo;1;2F;3;q;;;#I" IO.new; F;5[[@0; [[@ij ;
T;;M;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@l; F; o; ; T; ii ;!ii ;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_s_new(int argc, VALUE *argv, VALUE klass)
{
if (rb_block_given_p()) {
const char *cname = rb_class2name(klass);
rb_warn("%s::new() does not take block; use %s::open() instead",
cname, cname);
}
return rb_class_new_instance(argc, argv, klass);
}; T;BTo;1;2F;3;q;;;#I" IO.open; F;5[[@0; [[@i;
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;@l; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE io = rb_class_new_instance(argc, argv, klass);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
}; T;BTo;1;2F;3;q;;;#I"IO.sysopen; F;5[[@0; [[@i;
T;: sysopen;0;[ ;{ ;IC;"{Opens the given path, returning the underlying file descriptor as a
Fixnum.
IO.sysopen("testfile") #=> 3
; T;[o;7
;8I"
overload; F;90;;;:0;;I""sysopen(path, [mode, [perm]]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@l;[ ;I"@return [Fixnum]; T;0;@l; F;=i ;>0;5[[I" path; T0[I"[mode, [perm]]; T0;@l;[ ;I"Opens the given path, returning the underlying file descriptor as a
Fixnum.
IO.sysopen("testfile") #=> 3
@overload sysopen(path, [mode, [perm]])
@return [Fixnum]; T;0;@l; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_s_sysopen(int argc, VALUE *argv)
{
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;BTo;1;2F;3;q;;;#I"IO.for_fd; F;5[[@0; [[@i ;
T;: for_fd;0;[ ;{ ;IC;"%Synonym for IO.new.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" for_fd(fd, mode [, opt]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@l;[ ;I"@return [IO]; T;0;@l; F;=i ;>0;5[[I"fd; T0[I"mode[, opt]; T0;@l;[ ;I"ZSynonym for IO.new.
@overload for_fd(fd, mode [, opt])
@return [IO]; T;0;@l; F; o; ; T; iw ;!i| ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;q;;;#I"
IO.popen; F;5[[@0; [[@i;
T;:
popen;0;[ ;{ ;IC;" 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 contains 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 close 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|^|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 contains 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 close 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|^|IO.read for detail.
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"(foreach(name, sep=$/ [, open_args]); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Qmo;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@Qm;[ ;I" @yield [line]
@return [nil]; T;0;@Qm; F;=i ;>0;5[[I" name; T0[I"sep; TI"$/[, open_args]; T;@Qmo;7
;8I"
overload; F;90;;;:0;;I"'foreach(name, limit [, open_args]); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Qmo;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@Qm;[ ;I" @yield [line]
@return [nil]; T;0;@Qm; F;=i ;>0;5[[I" name; T0[I"limit[, open_args]; T0;@Qmo;7
;8I"
overload; F;90;;;:0;;I",foreach(name, sep, limit [, open_args]); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Qmo;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@Qm;[ ;I" @yield [line]
@return [nil]; T;0;@Qm; F;=i ;>0;5[[I" name; T0[I"sep; T0[I"limit[, open_args]; T0;@Qmo;7
;8I"
overload; F;90;;;:0;;I"foreach(...); T;IC;" ; T;[ ;[ ;I" ; T;0;@Qm; F;=i ;>0;5[[I"...; T0;@Qm;[ ;I"Executes the block for every line in the named I/O port, where lines
are separated by sep.
If no block is given, an enumerator is returned instead.
IO.foreach("testfile") {|x| print "GOT ", x }
produces:
GOT This is line one
GOT This is line two
GOT This is line three
GOT And so on...
If the last argument is a hash, it's the keyword argument to open.
See IO.read for detail.
@overload foreach(name, sep=$/ [, open_args])
@yield [line]
@return [nil]
@overload foreach(name, limit [, open_args])
@yield [line]
@return [nil]
@overload foreach(name, sep, limit [, open_args])
@yield [line]
@return [nil]
@overload foreach(...); T;0;@Qm; F; o; ; T; i=%;!iY%;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_s_foreach(int argc, VALUE *argv, VALUE self)
{
VALUE opt;
int orig_argc = argc;
struct foreach_arg arg;
argc = rb_scan_args(argc, argv, "13:", NULL, NULL, NULL, NULL, &opt);
RETURN_ENUMERATOR(self, orig_argc, argv);
open_key_args(argc, argv, opt, &arg);
if (NIL_P(arg.io)) return Qnil;
return rb_ensure(io_s_foreach, (VALUE)&arg, rb_io_close, arg.io);
}; T;BTo;1;2F;3;q;;;#I"IO.readlines; F;5[[@0; [[@i}%;
T;;;0;[ ;{ ;IC;"8Reads the entire file specified by name as individual
lines, and returns those lines in an array. Lines are separated by
sep.
a = IO.readlines("testfile")
a[0] #=> "This is line one\n"
If the last argument is a hash, it's the keyword argument to open.
See IO.read for detail.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"*readlines(name, sep=$/ [, open_args]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@m;[ ;I"@return [Array]; T;0;@m; F;=i ;>0;5[[I" name; T0[I"sep; TI"$/[, open_args]; T;@mo;7
;8I"
overload; F;90;;;:0;;I")readlines(name, limit [, open_args]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@m;[ ;I"@return [Array]; T;0;@m; F;=i ;>0;5[[I" name; T0[I"limit[, open_args]; T0;@mo;7
;8I"
overload; F;90;;;:0;;I".readlines(name, sep, limit [, open_args]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@m;[ ;I"@return [Array]; T;0;@m; F;=i ;>0;5[[I" name; T0[I"sep; T0[I"limit[, open_args]; T0;@m;[ ;I"Reads the entire file specified by name as individual
lines, and returns those lines in an array. Lines are separated by
sep.
a = IO.readlines("testfile")
a[0] #=> "This is line one\n"
If the last argument is a hash, it's the keyword argument to open.
See IO.read for detail.
@overload readlines(name, sep=$/ [, open_args])
@return [Array]
@overload readlines(name, limit [, open_args])
@return [Array]
@overload readlines(name, sep, limit [, open_args])
@return [Array]; T;0;@m; F; o; ; T; ik%;!i|%;"@%l;;I"static VALUE; T;AI"Ostatic VALUE
rb_io_s_readlines(int argc, VALUE *argv, VALUE io)
{
VALUE opt;
struct foreach_arg arg;
argc = rb_scan_args(argc, argv, "13:", NULL, NULL, NULL, NULL, &opt);
open_key_args(argc, argv, opt, &arg);
if (NIL_P(arg.io)) return Qnil;
return rb_ensure(io_s_readlines, (VALUE)&arg, rb_io_close, arg.io);
}; T;BTo;1;2F;3;q;;;#I" IO.read; F;5[[@0; [[@i%;
T;: read;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 the last argument is a hash, it specifies option for internal
open(). The key would be the following. open_args: is exclusive
to others.
encoding::
string or encoding
specifies encoding of the read string. +encoding+ will be ignored
if length is specified.
mode::
string
specifies mode argument for open(). It should start with "r"
otherwise it will cause an error.
open_args:: array of strings
specifies arguments for open() as an array.
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 "
; T;[o;7
;8I"
overload; F;90;;;:0;;I"%read(name, [length [, offset]] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@m;[ ;I"@return [String]; T;0;@m; F;=i ;>0;5[[I" name; T0[I"[length [, offset]]; T0;@mo;7
;8I"
overload; F;90;;;:0;;I"/read(name, [length [, offset]], open_args); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@m;[ ;I"@return [String]; T;0;@m; F;=i ;>0;5[[I" name; T0[I"[length [, offset]]; T0[I"open_args; T0;@m;[ ;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 the last argument is a hash, it specifies option for internal
open(). The key would be the following. open_args: is exclusive
to others.
encoding::
string or encoding
specifies encoding of the read string. +encoding+ will be ignored
if length is specified.
mode::
string
specifies mode argument for open(). It should start with "r"
otherwise it will cause an error.
open_args:: array of strings
specifies arguments for open() as an array.
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 "
@overload read(name, [length [, offset]] )
@return [String]
@overload read(name, [length [, offset]], open_args)
@return [String]; T;0;@m; F; o; ; T; i%;!i%;"@%l;;I"static VALUE; T;AI"ustatic 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(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;BTo;1;2F;3;q;;;#I"IO.binread; F;5[[@0; [[@i%;
T;: binread;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;7
;8I"
overload; F;90;;;:0;;I"(binread(name, [length [, offset]] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@'n;[ ;I"@return [String]; T;0;@'n; F;=i ;>0;5[[I" name; T0[I"[length [, offset]]; T0;@'n;[ ;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;@'n; F; o; ; T; i%;!i%;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_s_binread(int argc, VALUE *argv, VALUE io)
{
VALUE offset;
struct foreach_arg arg;
rb_scan_args(argc, argv, "12", NULL, NULL, &offset);
FilePathValue(argv[0]);
arg.io = rb_io_open(argv[0], rb_str_new_cstr("rb:ASCII-8BIT"), Qnil, Qnil);
if (NIL_P(arg.io)) return Qnil;
arg.argv = argv+1;
arg.argc = (argc > 1) ? 1 : 0;
if (!NIL_P(offset)) {
rb_io_seek(arg.io, offset, SEEK_SET);
}
return rb_ensure(io_s_read, (VALUE)&arg, rb_io_close, arg.io);
}; T;BTo;1;2F;3;q;;;#I"
IO.write; F;5[[@0; [[@iW&;
T;:
write;0;[ ;{ ;IC;"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, the file is truncated. Otherwise,
it is not truncated.
If the last argument is a hash, it specifies option for internal
open(). The key would be the following. open_args: is exclusive
to others.
encoding: string or encoding
specifies encoding of the read string. encoding will be ignored
if length is specified.
mode: string
specifies mode argument for open(). it should start with "w" or "a" or "r+"
otherwise it would cause error.
perm: fixnum
specifies perm argument for open().
open_args: array
specifies arguments for open() as an array.
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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"#write(name, string, [offset] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Gn;[ ;I"@return [Fixnum]; T;0;@Gn; F;=i ;>0;5[[I" name; T0[I" string; T0[I"
[offset]; T0;@Gno;7
;8I"
overload; F;90;;;:0;;I".write(name, string, [offset], open_args ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@Gn;[ ;I"@return [Fixnum]; T;0;@Gn; F;=i ;>0;5[ [I" name; T0[I" string; T0[I"
[offset]; T0[I"open_args; T0;@Gn;[ ;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, the file is truncated. Otherwise,
it is not truncated.
If the last argument is a hash, it specifies option for internal
open(). The key would be the following. open_args: is exclusive
to others.
encoding: string or encoding
specifies encoding of the read string. encoding will be ignored
if length is specified.
mode: string
specifies mode argument for open(). it should start with "w" or "a" or "r+"
otherwise it would cause error.
perm: fixnum
specifies perm argument for open().
open_args: array
specifies arguments for open() as an array.
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"
@overload write(name, string, [offset] )
@return [Fixnum]
@overload write(name, string, [offset], open_args )
@return [Fixnum]; T;0;@Gn; F; o; ; T; i0&;!iU&;"@%l;;I"static VALUE; T;AI"jstatic VALUE
rb_io_s_write(int argc, VALUE *argv, VALUE io)
{
return io_s_write(argc, argv, 0);
}; T;BTo;1;2F;3;q;;;#I"IO.binwrite; F;5[[@0; [[@ig&;
T;:
binwrite;0;[ ;{ ;IC;"tSame as IO.write except opening the file in binary mode
and ASCII-8BIT encoding ("wb:ASCII-8BIT").
; T;[o;7
;8I"
overload; F;90;;;:0;;I"&binwrite(name, string, [offset] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@~n;[ ;I"@return [Fixnum]; T;0;@~n; F;=i ;>0;5[[I" name; T0[I" string; T0[I"
[offset]; T0;@~no;7
;8I"
overload; F;90;;;:0;;I"1binwrite(name, string, [offset], open_args ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@~n;[ ;I"@return [Fixnum]; T;0;@~n; F;=i ;>0;5[ [I" name; T0[I" string; T0[I"
[offset]; T0[I"open_args; T0;@~n;[ ;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 [Fixnum]
@overload binwrite(name, string, [offset], open_args )
@return [Fixnum]; T;0;@~n; F; o; ; T; i]&;!ie&;"@%l;;I"static VALUE; T;AI"mstatic VALUE
rb_io_s_binwrite(int argc, VALUE *argv, VALUE io)
{
return io_s_write(argc, argv, 1);
}; T;BTo;1;2F;3;q;;;#I"IO.select; F;5[[@0; [[@i!;
T;;;0;[ ;{ ;IC;"[, error_array
[, timeout]]]) -> array or nil
Calls select(2) system call.
It monitors given arrays of IO objects, waits one or more
of IO objects 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 notify readability.
This "peek" is only happen for IO objects.
It is 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 raises 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.
Most possible situation is 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 situation exists.
SSL is a protocol which is sequence of records.
The record consists 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 blocks.
Also, the remote side can request SSL renegotiation which forces
the local SSL engine writes some data.
This means OpenSSL::SSL::SSLSocket#readpartial may
invoke write system call and it can block.
In such 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 process read form a stream.
Finally, Linux kernel developers doesn't guarantee that
readability of select(2) means readability of following read(2) even
for single process.
See select(2) manual on GNU/Linux system.
Invoking IO.select before IO#readpartial works well in usual.
However it is not the best way to use IO.select.
The writability notified by select(2) doesn't show
how many bytes 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;7
;8I"
overload; F;90;;;:0;;I"select(read_array; T;IC;" ; T;[ ;[ ;I" ; T;0;@n; F;=i ;>0;5[[I"read_array; T0;@n;[ ;@;0;@n; F; o; ; T; i[!;!i!;"@%l;;I"static VALUE; T;AI"
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;BTo;1;2F;3;q;;;#I" IO.pipe; F;5[[@0; [[@i$;
T;: pipe;0;[ ;{ ;IC;"=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: ; T;[ o;7 ;8I" overload; F;90;;;:0;;I" pipe; T;IC;" ; T;[o;< ;8I" return; F;9I" ; T;0;:[I" Array; T;@n;[ ;I"@return [Array]; T;0;@n; F;=i ;>0;5[ ;@no;7 ;8I" overload; F;90;;;:0;;I"pipe(ext_enc); T;IC;" ; T;[o;< ;8I" return; F;9I" ; T;0;:[I" Array; T;@n;[ ;I"@return [Array]; T;0;@n; F;=i ;>0;5[[I" ext_enc; T0;@no;7 ;8I" overload; F;90;;;:0;;I"$pipe("ext_enc:int_enc" [, opt]); T;IC;" ; T;[o;< ;8I" return; F;9I" ; T;0;:[I" Array; T;@n;[ ;I"@return [Array]; T;0;@n; F;=i ;>0;5[[""ext_enc:"int_enc"[, opt];@no;7 ;8I" overload; F;90;;;:0;;I"#pipe(ext_enc, int_enc [, opt]); T;IC;" ; T;[o;< ;8I" return; F;9I" ; T;0;:[I" Array; T;@n;[ ;I"@return [Array]; T;0;@n; F;=i ;>0;5[[I" ext_enc; T0[I"int_enc[, opt]; T0;@n;[ ;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;@n; F; o; ; T; i$;!i$;"@%l;;I"static VALUE; T;AI"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; int fmode = 0; VALUE ret; argc = rb_scan_args(argc, argv, "02:", &v1, &v2, &opt); if (rb_pipe(pipes) == -1) 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); io_encoding_set(fptr, v1, v2, opt); 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 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;BTo;1;2F;3;q;;;#I"IO.try_convert; F;5[[I"io; T0; [[@i; T;;u;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;7
;8I"
overload; F;90;;u;:0;;I"try_convert(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; TI"nil; T;@o;[ ;I"@return [IO, nil]; T;0;@o; F;=i ;>0;5[[I"obj; T0;@o;[ ;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;@o; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"_static VALUE
rb_io_s_try_convert(VALUE dummy, VALUE io)
{
return rb_io_check_io(io);
}; T;BTo;1;2F;3;q;;;#I"IO.copy_stream; F;5[[@0; [[@i(;
T;:copy_stream;0;[ ;{ ;IC;"iIO.copy_stream copies src to dst.
src and dst is either a filename or an IO.
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;7
;8I"
overload; F;90;;;:0;;I"copy_stream(src, dst); T;IC;" ; T;[ ;[ ;I" ; T;0;@9o; F;=i ;>0;5[[I"src; T0[I"dst; T0;@9oo;7
;8I"
overload; F;90;;;:0;;I"'copy_stream(src, dst, copy_length); T;IC;" ; T;[ ;[ ;I" ; T;0;@9o; F;=i ;>0;5[[I"src; T0[I"dst; T0[I"copy_length; T0;@9oo;7
;8I"
overload; F;90;;;:0;;I"3copy_stream(src, dst, copy_length, src_offset); T;IC;" ; T;[ ;[ ;I" ; T;0;@9o; F;=i ;>0;5[ [I"src; T0[I"dst; T0[I"copy_length; T0[I"src_offset; T0;@9o;[ ;I"IO.copy_stream copies src to dst.
src and dst is either a filename or an IO.
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;@9o; F; o; ; T; i(;!i(;"@%l;;I"static VALUE; T;AI"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_fd_init(&st.fds);
rb_ensure(copy_stream_body, (VALUE)&st, copy_stream_finalize, (VALUE)&st);
return OFFT2NUM(st.total);
}; T;BTo;1;2F;3;4;;;#I"IO#initialize; F;5[[@0; [[@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+, +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
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
:\external_encoding ::
External encoding for the IO. "-" is a synonym for the default external
encoding.
:\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
f2.readlines[0] #=> "This is line one\n"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"reopen(other_IO); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@o;[ ;I"@return [IO]; T;0;@o; F;=i ;>0;5[[I"
other_IO; T0;@oo;7
;8I"
overload; F;90;;;:0;;I"reopen(path, mode_str); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@o;[ ;I"@return [IO]; T;0;@o; F;=i ;>0;5[[I" path; T0[I"
mode_str; T0;@o;[ ;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.
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_str)
@return [IO]; T;0;@o; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI" 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 = ALLOC(rb_io_t);
MEMZERO(fptr, rb_io_t, 1);
}
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 = rb_str_new_frozen(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) {
if (freopen(RSTRING_PTR(fptr->pathv), rb_io_oflags_modestr(oflags), fptr->stdio_file) == 0) {
rb_sys_fail_path(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;BTo;1;2F;3;4;;;#I"
IO#print; F;5[[@0; [[@i;
T;;;0;[ ;{ ;IC;"~Writes the given object(s) to ios. The stream must be
opened for writing. If the output field separator (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;BTo;1;2F;3;4;;;#I" IO#putc; F;5[[I"ch; T0; [[@i;
T;;;0;[ ;{ ;IC;"kIf obj is ios, converting parameters under
control of the format string. See
checksum #=> 12
; T;[o;7
;8I"
overload; F;90;;;:0;;I"each_byte; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" byte; T;@qo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@q;[ ;I" @yield [byte]
@return [IO]; T;0;@q; F;=i ;>0;5[ ;@qo;7
;8I"
overload; F;90;;;:0;;I"each_byte; T;IC;" ; T;[ ;[ ;I" ; T;0;@q; F;=i ;>0;5[ ;@q;[ ;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
checksum #=> 12
@overload each_byte
@yield [byte]
@return [IO]
@overload each_byte; T;0;@q; F; o; ; T; iG
;!iV
;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#each_char; F;5[ ; [[@i
;
T;;;0;[ ;{ ;IC;"FCalls the given block once for each character in ios,
passing the character as an argument. The stream must be opened for
reading or an
; T;[o;7
;8I"
overload; F;90;;;:0;;I"each_char; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"c; T;@0qo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@0q;[ ;I" @yield [c]
@return [IO]; T;0;@0q; F;=i ;>0;5[ ;@0qo;7
;8I"
overload; F;90;;;:0;;I"each_char; T;IC;" ; T;[ ;[ ;I" ; T;0;@0q; F;=i ;>0;5[ ;@0q;[ ;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
@overload each_char
@yield [c]
@return [IO]
@overload each_char; T;0;@0q; F; o; ; T; i
;!i
;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#each_codepoint; F;5[ ; [[@i$;
T;;;0;[ ;{ ;IC;"Passes the each_line.
; T;0;@q; F; o; ; T; i:
;!i;
;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_lines(int argc, VALUE *argv, VALUE io)
{
rb_warn("IO#lines is deprecated; use #each_line instead");
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;BTo;1;2F;3;4;;;#I"
IO#bytes; F;5[ ; [[@iq
;
T;;;0;[ ;{ ;IC;";This is a deprecated alias for each_byte.
; T;0;@q; F; o; ; T; im
;!in
;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_bytes(VALUE io)
{
rb_warn("IO#bytes is deprecated; use #each_byte instead");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_byte")), 0, 0);
return rb_io_each_byte(io);
}; T;BTo;1;2F;3;4;;;#I"
IO#chars; F;5[ ; [[@i ;
T;;;0;[ ;{ ;IC;";This is a deprecated alias for each_char.
; T;0;@q; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_chars(VALUE io)
{
rb_warn("IO#chars is deprecated; use #each_char instead");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_char")), 0, 0);
return rb_io_each_char(io);
}; T;BTo;1;2F;3;4;;;#I"IO#codepoints; F;5[ ; [[@i;
T;;;0;[ ;{ ;IC;"@This is a deprecated alias for fptr;
int fd;
rb_io_check_closed(fptr);
fd = fptr->fd;
return INT2FIX(fd);
}; T;BT@5ro;1;2F;3;4;;;#I"
IO#to_io; F;5[ ; [[@i;
T;:
to_io;0;[ ;{ ;IC;"Returns ios.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
to_io; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@@r;[ ;I"@return [IO]; T;0;@@r; F;=i ;>0;5[ ;@@r;[ ;I";Returns ios.
@overload to_io
@return [IO]; T;0;@@r; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI":static VALUE
rb_io_to_io(VALUE io)
{
return io;
}; T;BTo;1;2F;3;4;;;#I"
IO#fsync; F;5[ ; [[@i,;
T;:
fsync;0;[ ;{ ;IC;"Immediately writes all buffered data in ios to disk.
Note that
b = f.getbyte #=> 0x38
f.ungetbyte(b) #=> nil
f.getbyte #=> 0x38
; T;[o;7
;8I"
overload; F;90;;;:0;;I"ungetbyte(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@t;[ ;I"@return [nil]; T;0;@t; F;=i ;>0;5[[I" string; T0;@to;7
;8I"
overload; F;90;;;:0;;I"ungetbyte(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@t;[ ;I"@return [nil]; T;0;@t; F;=i ;>0;5[[I" integer; T0;@t;[ ;I"^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
b = f.getbyte #=> 0x38
f.ungetbyte(b) #=> nil
f.getbyte #=> 0x38
@overload ungetbyte(string)
@return [nil]
@overload ungetbyte(integer)
@return [nil]; T;0;@t; F; o; ; T; i;!i
;"@%l;;I"
VALUE; T;AI">VALUE
rb_io_ungetbyte(VALUE io, VALUE b)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
if (NIL_P(b)) return Qnil;
if (FIXNUM_P(b)) {
char cc = FIX2INT(b);
b = rb_str_new(&cc, 1);
}
else {
SafeStringValue(b);
}
io_ungetbyte(b, fptr);
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#ungetc; F;5[[I"c; T0; [[@i2;
T;: ungetc;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
c = f.getc #=> "8"
f.ungetc(c) #=> nil
f.getc #=> "8"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"ungetc(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@u;[ ;I"@return [nil]; T;0;@u; F;=i ;>0;5[[I" string; T0;@u;[ ;I"HPushes 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
c = f.getc #=> "8"
f.ungetc(c) #=> nil
f.getc #=> "8"
@overload ungetc(string)
@return [nil]; T;0;@u; F; o; ; T; i";!i/;"@%l;;I"
VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#<<; F;5[[I"str; T0; [[@i;
T;;E;0;[ ;{ ;IC;"String Output---Writes obj to ios.
obj will be converted to a string using
]; T;0;@z; F;=i ;>0;5[ ;@z;[ ;I"Returns an File instance opened console.
You must require 'io/console' to use this method.
@overload console
@return [#]; T;0;@z; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"Cstatic VALUE
console_dev(VALUE klass)
{
VALUE con = 0;
rb_io_t *fptr;
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)) {
if ((fptr = RFILE(con)->fptr) && GetReadFD(fptr) != -1)
return con;
}
rb_const_remove(klass, id_console);
}
{
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);
#ifdef HAVE_RUBY_IO_H
fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE));
#else
fptr->path = ruby_strdup(CONSOLE_DEVICE);
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
GetOpenFile(out, ofptr);
# ifdef HAVE_RB_IO_GET_WRITE_IO
ofptr->pathv = fptr->pathv;
fptr->tied_io_for_writing = out;
# else
fptr->f2 = ofptr->f;
ofptr->f = 0;
# endif
ofptr->mode |= FMODE_SYNC;
#endif
fptr->mode |= FMODE_SYNC;
rb_const_set(klass, id_console, con);
}
return con;
}; T;BTo;;IC;[ o;1;2F;3;4;;;#I" IO::generic_readable#getch; F;5[[@0; [[@yi;
T;;;0;[ ;{ ;IC;"See IO#getch.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" getch(min: nil, time: nil); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@z;[ ;I"@return [String]; T;0;@z; F;=i ;>0;5[[I" min:; TI"nil; T[I"
time:; TI"nil; T;@z;[ ;I"LSee IO#getch.
@overload getch(min: nil, time: nil)
@return [String]; T;0;@z; F; o; ; T; i;!i;"@z;;I"static VALUE; T;AI"zstatic VALUE
io_getch(int argc, VALUE *argv, VALUE io)
{
return rb_funcall2(io, rb_intern("getc"), argc, argv);
}; T;BTo;1;2F;3;4;;;#I""IO::generic_readable#readchar; F;5[ ; [[I" ext/stringio/stringio.c; TiF;
T;;;0;[ ;{ ;IC;"See IO#readchar.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
readchar; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[ ;@{;[ ;I"=See IO#readchar.
@overload readchar
@return [String]; T;0;@{; F; o; ; T; i@;!iD;"@z;;I"static VALUE; T;AI"static VALUE
strio_readchar(VALUE self)
{
VALUE c = rb_funcall2(self, rb_intern("getc"), 0, 0);
if (NIL_P(c)) rb_eof_error();
return c;
}; T;BTo;1;2F;3;4;;;#I""IO::generic_readable#readbyte; F;5[ ; [[@{iT;
T;;;0;[ ;{ ;IC;"See IO#readbyte.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
readbyte; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@.{;[ ;I"@return [Fixnum]; T;0;@.{; F;=i ;>0;5[ ;@.{;[ ;I"=See IO#readbyte.
@overload readbyte
@return [Fixnum]; T;0;@.{; F; o; ; T; iN;!iR;"@z;;I"static VALUE; T;AI"static VALUE
strio_readbyte(VALUE self)
{
VALUE c = rb_funcall2(self, rb_intern("getbyte"), 0, 0);
if (NIL_P(c)) rb_eof_error();
return c;
}; T;BTo;1;2F;3;4;;;#I""IO::generic_readable#readline; F;5[[@0; [[@{i?;
T;;;0;[ ;{ ;IC;"See IO#readline.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"readline(sep=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@I{;[ ;I"@return [String]; T;0;@I{; F;=i ;>0;5[[I"sep; TI"$/; T;@I{o;7
;8I"
overload; F;90;;;:0;;I"readline(limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@I{;[ ;I"@return [String, nil]; T;0;@I{; F;=i ;>0;5[[I"
limit; T0;@I{o;7
;8I"
overload; F;90;;;:0;;I"readline(sep, limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@I{;[ ;I"@return [String, nil]; T;0;@I{; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@I{;[ ;I"See IO#readline.
@overload readline(sep=$/)
@return [String]
@overload readline(limit)
@return [String, nil]
@overload readline(sep, limit)
@return [String, nil]; T;0;@I{; F; o; ; T; i7;!i?;"@z;;I"static VALUE; T;AI"static VALUE
strio_readline(int argc, VALUE *argv, VALUE self)
{
VALUE line = rb_funcall2(self, rb_intern("gets"), argc, argv);
if (NIL_P(line)) rb_eof_error();
return line;
}; T;BTo;1;2F;3;4;;;#I"!IO::generic_readable#sysread; F;5[[@0; [[@{iJ;
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;7
;8I"
overload; F;90;;;:0;;I" sysread(integer[, outbuf]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[[I"integer[, outbuf]; T0;@{o;7
;8I"
overload; F;90;;;:0;;I"#readpartial(integer[, outbuf]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[[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; iB;!iI;"@z;;I"static VALUE; T;AI"static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
VALUE val = rb_funcall2(self, rb_intern("read"), argc, argv);
if (NIL_P(val)) {
rb_eof_error();
}
return val;
}; T;BTo;1;2F;3;4;;;#I"%IO::generic_readable#readpartial; F;5[[@0; [[@{iJ;
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;7
;8I"
overload; F;90;;;:0;;I" sysread(integer[, outbuf]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[[I"integer[, outbuf]; T0;@{o;7
;8I"
overload; F;90;;;:0;;I"#readpartial(integer[, outbuf]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[[I"integer[, outbuf]; T0;@{;[ ;@{;0;@{; F; o; ; T; iB;!iI;"@z;;I"static VALUE; T;AI"static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
VALUE val = rb_funcall2(self, rb_intern("read"), argc, argv);
if (NIL_P(val)) {
rb_eof_error();
}
return val;
}; T;BTo;1;2F;3;4;;;#I"'IO::generic_readable#read_nonblock; F;5[[@0; [[@{i[;
T;;;0;[ ;{ ;IC;"pSimilar to #read, but raises +EOFError+ at end of string unless the
+exception: false+ option is passed in.
; T;[o;7
;8I"
overload; F;90;;;:0;;I".read_nonblock(integer[, outbuf [, opts]]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@{;[ ;I"@return [String]; T;0;@{; F;=i ;>0;5[[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; iT;!iY;"@z;;I"static VALUE; T;AI"static VALUE
strio_read_nonblock(int argc, VALUE *argv, VALUE self)
{
VALUE opts = Qnil, val;
int no_exception = 0;
rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);
if (!NIL_P(opts)) {
argc--;
if (Qfalse == rb_hash_aref(opts, sym_exception))
no_exception = 1;
}
val = strio_read(argc, argv, self);
if (NIL_P(val)) {
if (no_exception)
return Qnil;
else
rb_eof_error();
}
return val;
}; T;BT;l@z;mIC;[ ;l@z;nIC;[ ;l@z;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@yi[@{i@;
F;:generic_readable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@z;=i ;"@%l;#I"IO::generic_readable; Fo;1;2F;3;4;;;#I"
IO#nread; F;5[ ; [[I"ext/io/wait/wait.c; Ti<;
T;:
nread;0;[ ;{ ;IC;"iReturns number of bytes that can be read without blocking.
Returns zero if no information available.
; T;[o;7
;8I"
overload; F;90;; ;:0;;I"
nread; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@|;[ ;I"@return [Integer]; T;0;@|; F;=i ;>0;5[ ;@|;[ ;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; i4;!i9;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#ready?; F;5[ ; [[@|iU;
T;: ready?;0;[ ;{ ;IC;"iReturns true if input available without blocking, or false.
Returns nil if no information available.
; T;[o;7
;8I"
overload; F;90;;
;:0;;I" ready?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@-|;[ ;I" @return [true, false, nil]; T;0;@-|; F;=i ;>0;5[ ;@-|o;<
;8I" return; F;9@f;0;:[@h;@-|;[ ;I"Returns true if input available without blocking, or false.
Returns nil if no information available.
@overload ready?
@return [true, false, nil]; T;0;@-|; F; o; ; T; iM;!iR;"@%l;;I"static VALUE; T;AI"Nstatic VALUE
io_ready_p(VALUE io)
{
rb_io_t *fptr;
ioctl_arg n;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
if (rb_io_read_pending(fptr)) return Qtrue;
if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qnil;
if (ioctl(fptr->fd, FIONREAD, &n)) return Qnil;
if (n > 0) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I" IO#wait; F;5[[@0; [[@|io;
T;;\;0;[ ;{ ;IC;"]Waits until input is available or times out and returns self or nil when
EOF is reached.
; T;[ o;7
;8I"
overload; F;90;;\;:0;;I" wait; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@M|;[ ;I" @return [true, false, nil]; T;0;@M|; F;=i ;>0;5[ ;@M|o;7
;8I"
overload; F;90;;\;:0;;I"wait(timeout); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@M|;[ ;I" @return [true, false, nil]; T;0;@M|; F;=i ;>0;5[[I" timeout; T0;@M|o;7
;8I"
overload; F;90;:wait_readable;:0;;I"wait_readable; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@M|;[ ;I" @return [true, false, nil]; T;0;@M|; F;=i ;>0;5[ ;@M|o;7
;8I"
overload; F;90;; ;:0;;I"wait_readable(timeout); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@M|;[ ;I" @return [true, false, nil]; T;0;@M|; F;=i ;>0;5[[I" timeout; T0;@M|;[ ;I".Waits until input is available or times out and returns self or nil when
EOF is reached.
@overload wait
@return [true, false, nil]
@overload wait(timeout)
@return [true, false, nil]
@overload wait_readable
@return [true, false, nil]
@overload wait_readable(timeout)
@return [true, false, nil]; T;0;@M|; F; o; ; T; id;!io;"@%l;;I"static VALUE; T;AI"static VALUE
io_wait_readable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
int i;
ioctl_arg n;
VALUE timeout;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
rb_scan_args(argc, argv, "01", &timeout);
if (NIL_P(timeout)) {
tv = NULL;
}
else {
timerec = rb_time_interval(timeout);
tv = &timerec;
}
if (rb_io_read_pending(fptr)) return Qtrue;
if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qfalse;
i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, tv);
if (i < 0)
rb_sys_fail(0);
rb_io_check_closed(fptr);
if (ioctl(fptr->fd, FIONREAD, &n)) rb_sys_fail(0);
if (n > 0) return io;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#wait_readable; F;5[[@0; [[@|io;
T;; ;0;[ ;{ ;IC;"]Waits until input is available or times out and returns self or nil when
EOF is reached.
; T;[ o;7
;8I"
overload; F;90;;\;:0;;I" wait; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@|;[ ;I" @return [true, false, nil]; T;0;@|; F;=i ;>0;5[ ;@|o;7
;8I"
overload; F;90;;\;:0;;I"wait(timeout); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@|;[ ;I" @return [true, false, nil]; T;0;@|; F;=i ;>0;5[[I" timeout; T0;@|o;7
;8I"
overload; F;90;; ;:0;;I"wait_readable; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@|;[ ;I" @return [true, false, nil]; T;0;@|; F;=i ;>0;5[ ;@|o;7
;8I"
overload; F;90;; ;:0;;I"wait_readable(timeout); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; TI"
false; TI"nil; T;@|;[ ;I" @return [true, false, nil]; T;0;@|; F;=i ;>0;5[[I" timeout; T0;@|;[ ;@|;0;@|; F; o; ; T; id;!io;"@%l;;I"static VALUE; T;AI"static VALUE
io_wait_readable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
int i;
ioctl_arg n;
VALUE timeout;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
rb_scan_args(argc, argv, "01", &timeout);
if (NIL_P(timeout)) {
tv = NULL;
}
else {
timerec = rb_time_interval(timeout);
tv = &timerec;
}
if (rb_io_read_pending(fptr)) return Qtrue;
if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qfalse;
i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, tv);
if (i < 0)
rb_sys_fail(0);
rb_io_check_closed(fptr);
if (ioctl(fptr->fd, FIONREAD, &n)) rb_sys_fail(0);
if (n > 0) return io;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#wait_writable; F;5[[@0; [[@|i;
T;:wait_writable;0;[ ;{ ;IC;"cWaits until IO writable is available or times out and returns self or
nil when EOF is reached.
; T;[o;7
;8I"
overload; F;90;; ;:0;;I"wait_writable; T;IC;" ; T;[ ;[ ;I" ; T;0;@|; F;=i ;>0;5[ ;@|o;7
;8I"
overload; F;90;; ;:0;;I"wait_writable(timeout); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@|;[ ;I"@return [nil]; T;0;@|; F;=i ;>0;5[[I" timeout; T0;@|;[ ;I"Waits until IO writable is available or times out and returns self or
nil when EOF is reached.
@overload wait_writable
@overload wait_writable(timeout)
@return [nil]; T;0;@|; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"7static VALUE
io_wait_writable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
int i;
VALUE timeout;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
rb_scan_args(argc, argv, "01", &timeout);
if (NIL_P(timeout)) {
tv = NULL;
}
else {
timerec = rb_time_interval(timeout);
tv = &timerec;
}
i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_OUT, tv);
if (i < 0)
rb_sys_fail(0);
rb_io_check_closed(fptr);
if (i & RB_WAITFD_OUT)
return io;
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#nonblock?; F;5[ ; [[I" ext/io/nonblock/nonblock.c; Ti,;
T;:nonblock?;0;[ ;{ ;IC;"0;5[ ;@}o;<
;8I" return; F;9@f;0;:[@h;@};[ ;I"fReturns +true+ if an IO object is in non-blocking mode.
@overload nonblock?
@return [Boolean]; T;0;@}; F; o; ; T; i&;!i*;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#nonblock=; F;5[[I"nb; T0; [[@}iR;
T;:nonblock=;0;[ ;{ ;IC;"eEnables non-blocking mode on a stream when set to
+true+, and blocking mode when set to +false+.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"nonblock=(boolean); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@/};[ ;I"@return [Boolean]; T;0;@/}; F;=i ;>0;5[[I" boolean; T0;@/};[ ;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;@/}; F; o; ; T; iK;!iP;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_nonblock_set(VALUE io, VALUE nb)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
io_nonblock_set(fptr->fd, io_nonblock_mode(fptr->fd), RTEST(nb));
return io;
}; T;BTo;1;2F;3;4;;;#I"IO#nonblock; F;5[[@0; [[@}in;
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;7
;8I"
overload; F;90;;;:0;;I"
nonblock; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"io; T;@N}o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@N};[ ;I" @yield [io]
@return [IO]; T;0;@N}; F;=i ;>0;5[ ;@N}o;7
;8I"
overload; F;90;;;:0;;I"nonblock(boolean); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"io; T;@N}o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@N};[ ;I" @yield [io]
@return [IO]; T;0;@N}; F;=i ;>0;5[[I" boolean; T0;@N};[ ;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;@N}; F; o; ; T; id;!io;"@%l;;I"static VALUE; T;AI"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;
io_nonblock_set(fptr->fd, f, nb);
return rb_ensure(rb_yield, io, io_nonblock_restore, (VALUE)restore);
}; T;BTo;;IC;[ o;1;2F;3;4;;;#I" IO::generic_writable#<<; F;5[ ; [ ;
F;;E;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};BTo;1;2F;3;4;;;#I" IO::generic_writable#print; F;5[ ; [ ;
F;;;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};BTo;1;2F;3;4;;;#I" IO::generic_writable#printf; F;5[ ; [ ;
F;;;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};BTo;1;2F;3;4;;;#I" IO::generic_writable#puts; F;5[ ; [ ;
F;;;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};BTo;1;2F;3;4;;;#I""IO::generic_writable#syswrite; F;5[ ; [ ;
F;;;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};BTo;1;2F;3;4;;;#I"(IO::generic_writable#write_nonblock; F;5[[@0; [[@{iw;
T;;;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@};;I"static VALUE; T;AI"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;BT;l@};mIC;[ ;l@};nIC;[ ;l@};oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@{iJ;
F;:generic_writable;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@};"@%l;#I"IO::generic_writable; Fo;1;2F;3;4;;;#I" IO#stat; F;5[ ; [[@ i;
T;: stat;0;[ ;{ ;IC;"Returns status information for ios as an object of type
"
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Produce a nicely formatted description of stat.
File.stat("/etc/passwd").inspect
#=> "#"
@overload inspect
@return [String]; T;0;@; F; o; ; T; iG;!iR;"@;;I"static VALUE; T;AI"jstatic 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},
};
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, ">");
OBJ_INFECT(str, self);
return str;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#ftype; T;5[ ; [[@ is;
T;:
ftype;0;[ ;{ ;IC;"RIdentifies the type of stat. The return string is one of:
``/~oracle/bin"
; T;[o;7
;8I"
overload; F;90;;\;:0;;I"-absolute_path(file_name [, dir_string] ); T;IC;" ; T;[ ;[ ;I" ; T;0;@K; F;=i ;>0;5[[I" file_name[, dir_string]; T0;@K;[ ;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;@K; F; o; ; T; i
;!i
;"@~;;I"
VALUE; T;AI"VALUE
rb_file_s_absolute_path(int argc, VALUE *argv)
{
VALUE fname, dname;
if (argc == 1) {
return rb_file_absolute_path(argv[0], Qnil);
}
rb_scan_args(argc, argv, "11", &fname, &dname);
return rb_file_absolute_path(fname, dname);
}; T;BTo;1;2F;3;q;;;#I"File.realpath; F;5[[@0; [[@ i|;
T;:
realpath;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;7
;8I"
overload; F;90;;];:0;;I"&realpath(pathname [, dir_string]); T;IC;" ; T;[ ;[ ;I" ; T;0;@d; F;=i ;>0;5[[I"pathname[, dir_string]; T0;@d;[ ;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;@d; F; o; ; T; io;!iy;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_realpath(int argc, VALUE *argv, VALUE klass)
{
VALUE path, basedir;
rb_scan_args(argc, argv, "11", &path, &basedir);
return rb_realpath_internal(basedir, path, 1);
}; T;BTo;1;2F;3;q;;;#I"File.realdirpath; F;5[[@0; [[@ i;
T;:realdirpath;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;7
;8I"
overload; F;90;;^;:0;;I")realdirpath(pathname [, dir_string]); T;IC;" ; T;[ ;[ ;I" ; T;0;@}; F;=i ;>0;5[[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; T;AI"static VALUE
rb_file_s_realdirpath(int argc, VALUE *argv, VALUE klass)
{
VALUE path, basedir;
rb_scan_args(argc, argv, "11", &path, &basedir);
return rb_realpath_internal(basedir, path, 0);
}; T;BTo;1;2F;3;q;;;#I"File.basename; F;5[[@0; [[@ i
;
T;:
basename;0;[ ;{ ;IC;"Returns the last component of the filename given in file_name,
which can be formed using both "
Encoding::ISO_2022_JP.inspect #=> "#"
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ߑ;[ ;I"@return [String]; T;0;@ߑ; F;=i ;>0;5[ ;@ߑ;[ ;I"Returns a string which represents the encoding for programmers.
Encoding::UTF_8.inspect #=> "#"
Encoding::ISO_2022_JP.inspect #=> "#"
@overload inspect
@return [String]; T;0;@ߑ; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
enc_inspect(VALUE self)
{
rb_encoding *enc;
if (!is_data_encoding(self)) {
not_encoding(self);
}
if (!(enc = DATA_PTR(self)) || rb_enc_from_index(rb_enc_to_index(enc)) != enc) {
rb_raise(rb_eTypeError, "broken Encoding");
}
return rb_enc_sprintf(rb_usascii_encoding(),
"#<%"PRIsVALUE":%s%s%s>", rb_obj_class(self),
rb_enc_name(enc),
(ENC_DUMMY_P(enc) ? " (dummy)" : ""),
enc_autoload_p(enc) ? " (autoload)" : "");
}; T;BTo;1;2F;3;4;;;#I"Encoding#name; F;5[ ; [[@>i6;
T;;w;0;[ ;{ ;IC;"OReturns the name of the encoding.
Encoding::UTF_8.name #=> "UTF-8"
; T;[o;7
;8I"
overload; F;90;;w;:0;;I" name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;@ۑ;0;@; F; o; ; T; i-;!i5;"@;;I"static VALUE; T;AI"ustatic VALUE
enc_name(VALUE self)
{
return rb_usascii_str_new2(rb_enc_name((rb_encoding*)DATA_PTR(self)));
}; T;BTo;1;2F;3;4;;;#I"Encoding#names; F;5[ ; [[@>iQ;
T;:
names;0;[ ;{ ;IC;"Returns the list of name and aliases of the encoding.
Encoding::WINDOWS_31J.names #=> ["Windows-31J", "CP932", "csWindows31J"]
; T;[o;7
;8I"
overload; F;90;;x;:0;;I"
names; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@!;[ ;I"@return [Array]; T;0;@!; F;=i ;>0;5[ ;@!;[ ;I"Returns the list of name and aliases of the encoding.
Encoding::WINDOWS_31J.names #=> ["Windows-31J", "CP932", "csWindows31J"]
@overload names
@return [Array]; T;0;@!; F; o; ; T; iI;!iO;"@;;I"static VALUE; T;AI"static VALUE
enc_names(VALUE self)
{
VALUE args[2];
args[0] = (VALUE)rb_to_encoding_index(self);
args[1] = rb_ary_new2(0);
st_foreach(enc_table.names, enc_names_i, (st_data_t)args);
return args[1];
}; T;BTo;1;2F;3;4;;;#I"Encoding#dummy?; F;5[ ; [[@>i;
T;: dummy?;0;[ ;{ ;IC;"Returns true for dummy encodings.
A dummy encoding is an encoding for which character handling is not properly
implemented.
It is used for stateful encodings.
Encoding::ISO_2022_JP.dummy? #=> true
Encoding::UTF_8.dummy? #=> false
; T;[o;7
;8I"
overload; F;90;;y;:0;;I" dummy?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@<;[ ;I"@return [Boolean]; T;0;@<; F;=i ;>0;5[ ;@ true
Encoding::UTF_8.dummy? #=> false
@overload dummy?
@return [Boolean]; T;0;@<; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"istatic VALUE
enc_dummy_p(VALUE enc)
{
return ENC_DUMMY_P(must_encoding(enc)) ? Qtrue : Qfalse;
}; T;BTo;1;2F;3;4;;;#I" Encoding#ascii_compatible?; F;5[ ; [[@>i;
T;:ascii_compatible?;0;[ ;{ ;IC;"Returns whether ASCII-compatible or not.
Encoding::UTF_8.ascii_compatible? #=> true
Encoding::UTF_16BE.ascii_compatible? #=> false
; T;[o;7
;8I"
overload; F;90;;z;:0;;I"ascii_compatible?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Z;[ ;I"@return [Boolean]; T;0;@Z; F;=i ;>0;5[ ;@Zo;<
;8I" return; F;9@f;0;:[@h;@Z;[ ;I"Returns whether ASCII-compatible or not.
Encoding::UTF_8.ascii_compatible? #=> true
Encoding::UTF_16BE.ascii_compatible? #=> false
@overload ascii_compatible?
@return [Boolean]; T;0;@Z; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"{static VALUE
enc_ascii_compatible_p(VALUE enc)
{
return rb_enc_asciicompat(must_encoding(enc)) ? Qtrue : Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Encoding#replicate; F;5[[I" name; T0; [[@>i;
T;:replicate;0;[ ;{ ;IC;"Returns a replicated encoding of _enc_ whose name is _name_.
The new encoding should have the same byte structure of _enc_.
If _name_ is used by another encoding, raise ArgumentError.
; T;[o;7
;8I"
overload; F;90;;{;:0;;I"replicate(name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@x;[ ;I"@return [Encoding]; T;0;@x; F;=i ;>0;5[[I" name; T0;@x;[ ;I"Returns a replicated encoding of _enc_ whose name is _name_.
The new encoding should have the same byte structure of _enc_.
If _name_ is used by another encoding, raise ArgumentError.
@overload replicate(name)
@return [Encoding]; T;0;@x; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
enc_replicate(VALUE encoding, VALUE name)
{
return rb_enc_from_encoding_index(
rb_enc_replicate(StringValueCStr(name),
rb_to_encoding(encoding)));
}; T;BTo;1;2F;3;q;;;#I"Encoding.list; F;5[ ; [[@>in;
T;: list;0;[ ;{ ;IC;"KReturns the list of loaded encodings.
Encoding.list
#=> [#, #,
#]
Encoding.find("US-ASCII")
#=> #
Encoding.list
#=> [#, #,
#, #]
; T;[o;7
;8I"
overload; F;90;;|;:0;;I" list; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;[ ;I"@return [Array]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"oReturns the list of loaded encodings.
Encoding.list
#=> [#, #,
#]
Encoding.find("US-ASCII")
#=> #
Encoding.list
#=> [#, #,
#, #]
@overload list
@return [Array]; T;0;@; F; o; ; T; i\;!il;"@;;I"static VALUE; T;AI"static VALUE
enc_list(VALUE klass)
{
VALUE ary = rb_ary_new2(0);
rb_ary_replace(ary, rb_encoding_list);
return ary;
}; T;BTo;1;2F;3;q;;;#I"Encoding.name_list; F;5[ ; [[@>ia;
T;:name_list;0;[ ;{ ;IC;"Returns the list of available encoding names.
Encoding.name_list
#=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
"ISO-8859-1", "Shift_JIS", "EUC-JP",
"Windows-31J",
"BINARY", "CP932", "eucJP"]
; T;[o;7
;8I"
overload; F;90;;};:0;;I"name_list; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;[ ;I"@return [Array]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the list of available encoding names.
Encoding.name_list
#=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
"ISO-8859-1", "Shift_JIS", "EUC-JP",
"Windows-31J",
"BINARY", "CP932", "eucJP"]
@overload name_list
@return [Array]; T;0;@; F; o; ; T; iS;!i^;"@;;I"static VALUE; T;AI"static VALUE
rb_enc_name_list(VALUE klass)
{
VALUE ary = rb_ary_new2(enc_table.names->num_entries);
st_foreach(enc_table.names, rb_enc_name_list_i, (st_data_t)ary);
return ary;
}; T;BTo;1;2F;3;q;;;#I"Encoding.aliases; F;5[ ; [[@>i;
T;: aliases;0;[ ;{ ;IC;"Returns the hash of available encoding alias and original encoding name.
Encoding.aliases
#=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
"SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
; T;[o;7
;8I"
overload; F;90;;~;:0;;I" aliases; T;IC;" ; T;[ ;[ ;I" ; T;0;@͒; F;=i ;>0;5[ ;@͒;[ ;I" Returns the hash of available encoding alias and original encoding name.
Encoding.aliases
#=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
"SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
@overload aliases; T;0;@͒; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_enc_aliases(VALUE klass)
{
VALUE aliases[2];
aliases[0] = rb_hash_new();
aliases[1] = rb_ary_new();
st_foreach(enc_table.names, rb_enc_aliases_enc_i, (st_data_t)aliases);
return aliases[0];
}; T;BTo;1;2F;3;q;;;#I"Encoding.find; F;5[[I"enc; T0; [[@>i;
T;;;0;[ ;{ ;IC;"\Search the encoding with specified name.
name should be a string.
Encoding.find("US-ASCII") #=> #
Names which this method accept are encoding names and aliases
including following special aliases
"external":: default external encoding
"internal":: default internal encoding
"locale":: locale encoding
"filesystem":: filesystem encoding
An ArgumentError is raised when no encoding with name.
Only
Names which this method accept are encoding names and aliases
including following special aliases
"external":: default external encoding
"internal":: default internal encoding
"locale":: locale encoding
"filesystem":: filesystem encoding
An ArgumentError is raised when no encoding with name.
Only
Encoding.compatible?(
"\xa1".force_encoding("iso-8859-1"),
"\xa1\xa1".force_encoding("euc-jp"))
#=> nil
If the objects are non-strings their encodings are compatible when they
have an encoding and:
* Either encoding is US-ASCII compatible
* One of the encodings is a 7-bit encoding
; T;[o;7
;8I"
overload; F;90;;;:0;;I" compatible?(obj1, obj2); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@;[ ;I"@return [nil]; T;0;@; F;=i ;>0;5[[I" obj1; T0[I" obj2; T0;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I"Checks the compatibility of two objects.
If the objects are both strings they are compatible when they are
concatenatable. The encoding of the concatenated string will be returned
if they are compatible, nil if they are not.
Encoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b")
#=> #
Encoding.compatible?(
"\xa1".force_encoding("iso-8859-1"),
"\xa1\xa1".force_encoding("euc-jp"))
#=> nil
If the objects are non-strings their encodings are compatible when they
have an encoding and:
* Either encoding is US-ASCII compatible
* One of the encodings is a 7-bit encoding
@overload compatible?(obj1, obj2)
@return [nil]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
enc_compatible_p(VALUE klass, VALUE str1, VALUE str2)
{
rb_encoding *enc;
if (!enc_capable(str1)) return Qnil;
if (!enc_capable(str2)) return Qnil;
enc = rb_enc_compatible(str1, str2);
if (!enc) return Qnil;
return rb_enc_from_encoding(enc);
}; T;BTo;1;2F;3;4;;;#I"Encoding#_dump; F;5[[@0; [[@>i;
T;;B;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@#; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"~static VALUE
enc_dump(int argc, VALUE *argv, VALUE self)
{
rb_scan_args(argc, argv, "01", 0);
return enc_name(self);
}; T;BTo;1;2F;3;q;;;#I"Encoding._load; F;5[[I"str; T0; [[@>i;
T;:
_load;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@2; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"Fstatic VALUE
enc_load(VALUE klass, VALUE str)
{
return str;
}; T;BTo;1;2F;3;q;;;#I" Encoding.default_external; F;5[ ; [[@>i;
T;:default_external;0;[ ;{ ;IC;"7Returns default external encoding.
The default external encoding is used by default for strings created from
the following locations:
* CSV
* File data read from disk
* SDBM
* StringIO
* Zlib::GzipReader
* Zlib::GzipWriter
* String#inspect
* Regexp#inspect
While strings created from these locations will have this encoding, the
encoding may not be valid. Be sure to check String#valid_encoding?.
File data written to disk will be transcoded to the default external
encoding when written.
The default external encoding is initialized by the locale or -E option.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"default_external; T;IC;" ; T;[ ;[ ;I" ; T;0;@B; F;=i ;>0;5[ ;@B;[ ;I"TReturns default external encoding.
The default external encoding is used by default for strings created from
the following locations:
* CSV
* File data read from disk
* SDBM
* StringIO
* Zlib::GzipReader
* Zlib::GzipWriter
* String#inspect
* Regexp#inspect
While strings created from these locations will have this encoding, the
encoding may not be valid. Be sure to check String#valid_encoding?.
File data written to disk will be transcoded to the default external
encoding when written.
The default external encoding is initialized by the locale or -E option.
@overload default_external; T;0;@B; F; o; ; T; ii;!i;"@;;I"static VALUE; T;AI"]static VALUE
get_default_external(VALUE klass)
{
return rb_enc_default_external();
}; T;BTo;1;2F;3;q;;;#I" Encoding.default_external=; F;5[[I"
encoding; T0; [[@>i;
T;:default_external=;0;[ ;{ ;IC;"Sets default external encoding. You should not set
Encoding::default_external in ruby code as strings created before changing
the value may have a different encoding from strings created after the value
was changed., instead you should use ruby -E to invoke ruby with
the correct default_external.
See Encoding::default_external for information on how the default external
encoding is used.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"default_external=(enc); T;IC;" ; T;[ ;[ ;I" ; T;0;@X; F;=i ;>0;5[[I"enc; T0;@X;[ ;I"Sets default external encoding. You should not set
Encoding::default_external in ruby code as strings created before changing
the value may have a different encoding from strings created after the value
was changed., instead you should use ruby -E to invoke ruby with
the correct default_external.
See Encoding::default_external for information on how the default external
encoding is used.
@overload default_external=(enc); T;0;@X; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
set_default_external(VALUE klass, VALUE encoding)
{
rb_warning("setting Encoding.default_external");
rb_enc_set_default_external(encoding);
return encoding;
}; T;BTo;1;2F;3;q;;;#I" Encoding.default_internal; F;5[ ; [[@>i;
T;:default_internal;0;[ ;{ ;IC;"Returns default internal encoding. Strings will be transcoded to the
default internal encoding in the following places if the default internal
encoding is not nil:
* CSV
* Etc.sysconfdir and Etc.systmpdir
* File data read from disk
* File names from Dir
* Integer#chr
* String#inspect and Regexp#inspect
* Strings returned from Readline
* Strings returned from SDBM
* Time#zone
* Values from ENV
* Values in ARGV including $PROGRAM_NAME
* __FILE__
Additionally String#encode and String#encode! use the default internal
encoding if no encoding is given.
The locale encoding (__ENCODING__), not default_internal, is used as the
encoding of created strings.
Encoding::default_internal is initialized by the source file's
internal_encoding or -E option.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"default_internal; T;IC;" ; T;[ ;[ ;I" ; T;0;@r; F;=i ;>0;5[ ;@r;[ ;I"Returns default internal encoding. Strings will be transcoded to the
default internal encoding in the following places if the default internal
encoding is not nil:
* CSV
* Etc.sysconfdir and Etc.systmpdir
* File data read from disk
* File names from Dir
* Integer#chr
* String#inspect and Regexp#inspect
* Strings returned from Readline
* Strings returned from SDBM
* Time#zone
* Values from ENV
* Values in ARGV including $PROGRAM_NAME
* __FILE__
Additionally String#encode and String#encode! use the default internal
encoding if no encoding is given.
The locale encoding (__ENCODING__), not default_internal, is used as the
encoding of created strings.
Encoding::default_internal is initialized by the source file's
internal_encoding or -E option.
@overload default_internal; T;0;@r; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"]static VALUE
get_default_internal(VALUE klass)
{
return rb_enc_default_internal();
}; T;BTo;1;2F;3;q;;;#I" Encoding.default_internal=; F;5[[I"
encoding; T0; [[@>i;
T;:default_internal=;0;[ ;{ ;IC;"Sets default internal encoding or removes default internal encoding when
passed nil. You should not set Encoding::default_internal in ruby code as
strings created before changing the value may have a different encoding
from strings created after the change. Instead you should use
ruby -E to invoke ruby with the correct default_internal.
See Encoding::default_internal for information on how the default internal
encoding is used.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"default_internal=(enc); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"enc; T0;@;[ ;I"Sets default internal encoding or removes default internal encoding when
passed nil. You should not set Encoding::default_internal in ruby code as
strings created before changing the value may have a different encoding
from strings created after the change. Instead you should use
ruby -E to invoke ruby with the correct default_internal.
See Encoding::default_internal for information on how the default internal
encoding is used.
@overload default_internal=(enc); T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
set_default_internal(VALUE klass, VALUE encoding)
{
rb_warning("setting Encoding.default_internal");
rb_enc_set_default_internal(encoding);
return encoding;
}; T;BTo;1;2F;3;q;;;#I" Encoding.locale_charmap; F;5[ ; [[@>i;
T;:locale_charmap;0;[ ;{ ;IC;" Returns the locale charmap name.
It returns nil if no appropriate information.
Debian GNU/Linux
LANG=C
Encoding.locale_charmap #=> "ANSI_X3.4-1968"
LANG=ja_JP.EUC-JP
Encoding.locale_charmap #=> "EUC-JP"
SunOS 5
LANG=C
Encoding.locale_charmap #=> "646"
LANG=ja
Encoding.locale_charmap #=> "eucJP"
The result is highly platform dependent.
So Encoding.find(Encoding.locale_charmap) may cause an error.
If you need some encoding object even for unknown locale,
Encoding.find("locale") can be used.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"locale_charmap; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"OReturns the locale charmap name.
It returns nil if no appropriate information.
Debian GNU/Linux
LANG=C
Encoding.locale_charmap #=> "ANSI_X3.4-1968"
LANG=ja_JP.EUC-JP
Encoding.locale_charmap #=> "EUC-JP"
SunOS 5
LANG=C
Encoding.locale_charmap #=> "646"
LANG=ja
Encoding.locale_charmap #=> "eucJP"
The result is highly platform dependent.
So Encoding.find(Encoding.locale_charmap) may cause an error.
If you need some encoding object even for unknown locale,
Encoding.find("locale") can be used.
@overload locale_charmap
@return [String]; T;0;@; F; o; ; T; i;!i;"@;;I"
VALUE; T;AI"*VALUE
rb_locale_charmap(VALUE klass);; T;BTo; ;IC;[
o;1;2F;3;4;;;#I"0;5[ ;@;[ ;I"fReturns the source encoding name as a string.
@overload source_encoding_name
@return [String]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"}static VALUE
ecerr_source_encoding_name(VALUE self)
{
return rb_attr_get(self, rb_intern("source_encoding_name"));
}; T;BTo;1;2F;3;4;;;#I"AEncoding::UndefinedConversionError#destination_encoding_name; F;5[ ; [[@?i;
T;: destination_encoding_name;0;[ ;{ ;IC;"7Returns the destination encoding name as a string.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" destination_encoding_name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ړ;[ ;I"@return [String]; T;0;@ړ; F;=i ;>0;5[ ;@ړ;[ ;I"pReturns the destination encoding name as a string.
@overload destination_encoding_name
@return [String]; T;0;@ړ; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
ecerr_destination_encoding_name(VALUE self)
{
return rb_attr_get(self, rb_intern("destination_encoding_name"));
}; T;BTo;1;2F;3;4;;;#I"7Encoding::UndefinedConversionError#source_encoding; F;5[ ; [[@?i;
T;:source_encoding;0;[ ;{ ;IC;"oReturns the source encoding as an encoding object.
Note that the result may not be equal to the source encoding of
the encoding converter if the conversion has multiple steps.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP
begin
ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP.
rescue Encoding::UndefinedConversionError
p $!.source_encoding #=> #
p $!.destination_encoding #=> #
p $!.source_encoding_name #=> "UTF-8"
p $!.destination_encoding_name #=> "EUC-JP"
end
; T;[o;7
;8I"
overload; F;90;;;:0;;I"source_encoding; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@;[ ;I"@return [Encoding]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the source encoding as an encoding object.
Note that the result may not be equal to the source encoding of
the encoding converter if the conversion has multiple steps.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP
begin
ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP.
rescue Encoding::UndefinedConversionError
p $!.source_encoding #=> #
p $!.destination_encoding #=> #
p $!.source_encoding_name #=> "UTF-8"
p $!.destination_encoding_name #=> "EUC-JP"
end
@overload source_encoding
@return [Encoding]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"sstatic VALUE
ecerr_source_encoding(VALUE self)
{
return rb_attr_get(self, rb_intern("source_encoding"));
}; T;BTo;1;2F;3;4;;;#I"0;5[ ;@;[ ;I"pReturns the destination encoding as an encoding object.
@overload destination_encoding
@return [String]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"}static VALUE
ecerr_destination_encoding(VALUE self)
{
return rb_attr_get(self, rb_intern("destination_encoding"));
}; T;BTo;1;2F;3;4;;;#I"2Encoding::UndefinedConversionError#error_char; F;5[ ; [[@?i;
T;:error_char;0;[ ;{ ;IC;"3Returns the one-character string which cause Encoding::UndefinedConversionError.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP")
begin
ec.convert("\xa0")
rescue Encoding::UndefinedConversionError
puts $!.error_char.dump #=> "\xC2\xA0"
p $!.error_char.encoding #=> #
end
; T;[o;7
;8I"
overload; F;90;;;:0;;I"error_char; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@+;[ ;I"@return [String]; T;0;@+; F;=i ;>0;5[ ;@+;[ ;I"^Returns the one-character string which cause Encoding::UndefinedConversionError.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP")
begin
ec.convert("\xa0")
rescue Encoding::UndefinedConversionError
puts $!.error_char.dump #=> "\xC2\xA0"
p $!.error_char.encoding #=> #
end
@overload error_char
@return [String]; T;0;@+; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"istatic VALUE
ecerr_error_char(VALUE self)
{
return rb_attr_get(self, rb_intern("error_char"));
}; T;BT;l@;mIC;[ ;l@;nIC;[ ;l@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@?i[@?i0;
T;: UndefinedConversionError;;@;;;[ ;{ ;IC;"NRaised by Encoding and String methods when a transcoding operation
fails.; T;[ ;[ ;I"P
Raised by Encoding and String methods when a transcoding operation
fails.
; T;0;@; F; o; ; T; i;!i;=i ;"o; ;0;0;0;:
Encoding;"@;@;0;#I"'Encoding::UndefinedConversionError; F;vo; ;0;0;0;:EncodingError;"@;o; ;IC;[ ;l@Z;mIC;[ ;l@Z;nIC;[ ;l@Z;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i[@ i%;
T;;;;@;;;[ ;{ ;IC;"9EncodingError is the base class for encoding errors.
; T;[ ;[ ;I";
EncodingError is the base class for encoding errors.
; T;0;@Z; F; o; ; T; i;!i;"@;#I"EncodingError; F;v@(;;qo; ;IC;[ o;1;2F;3;4;;;#I"0;5[ ;@p;[ ;@֓;0;@p; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"}static VALUE
ecerr_source_encoding_name(VALUE self)
{
return rb_attr_get(self, rb_intern("source_encoding_name"));
}; T;BTo;1;2F;3;4;;;#I"AEncoding::InvalidByteSequenceError#destination_encoding_name; F;5[ ; [[@?i;
T;;;0;[ ;{ ;IC;"7Returns the destination encoding name as a string.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" destination_encoding_name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;@;0;@; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"static VALUE
ecerr_destination_encoding_name(VALUE self)
{
return rb_attr_get(self, rb_intern("destination_encoding_name"));
}; T;BTo;1;2F;3;4;;;#I"7Encoding::InvalidByteSequenceError#source_encoding; F;5[ ; [[@?i;
T;;;0;[ ;{ ;IC;"oReturns the source encoding as an encoding object.
Note that the result may not be equal to the source encoding of
the encoding converter if the conversion has multiple steps.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP
begin
ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP.
rescue Encoding::UndefinedConversionError
p $!.source_encoding #=> #
p $!.destination_encoding #=> #
p $!.source_encoding_name #=> "UTF-8"
p $!.destination_encoding_name #=> "EUC-JP"
end
; T;[o;7
;8I"
overload; F;90;;;:0;;I"source_encoding; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@;[ ;I"@return [Encoding]; T;0;@; F;=i ;>0;5[ ;@;[ ;@ ;0;@; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"sstatic VALUE
ecerr_source_encoding(VALUE self)
{
return rb_attr_get(self, rb_intern("source_encoding"));
}; T;BTo;1;2F;3;4;;;#I"0;5[ ;@;[ ;@';0;@; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"}static VALUE
ecerr_destination_encoding(VALUE self)
{
return rb_attr_get(self, rb_intern("destination_encoding"));
}; T;BTo;1;2F;3;4;;;#I"3Encoding::InvalidByteSequenceError#error_bytes; F;5[ ; [[@?i;
T;:error_bytes;0;[ ;{ ;IC;"Returns the discarded bytes when Encoding::InvalidByteSequenceError occurs.
ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
begin
ec.convert("abc\xA1\xFFdef")
rescue Encoding::InvalidByteSequenceError
p $! #=> #
puts $!.error_bytes.dump #=> "\xA1"
puts $!.readagain_bytes.dump #=> "\xFF"
end
; T;[o;7
;8I"
overload; F;90;;;:0;;I"error_bytes; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ؔ;[ ;I"@return [String]; T;0;@ؔ; F;=i ;>0;5[ ;@ؔ;[ ;I"Returns the discarded bytes when Encoding::InvalidByteSequenceError occurs.
ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
begin
ec.convert("abc\xA1\xFFdef")
rescue Encoding::InvalidByteSequenceError
p $! #=> #
puts $!.error_bytes.dump #=> "\xA1"
puts $!.readagain_bytes.dump #=> "\xFF"
end
@overload error_bytes
@return [String]; T;0;@ؔ; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"kstatic VALUE
ecerr_error_bytes(VALUE self)
{
return rb_attr_get(self, rb_intern("error_bytes"));
}; T;BTo;1;2F;3;4;;;#I"7Encoding::InvalidByteSequenceError#readagain_bytes; F;5[ ; [[@?i;
T;:readagain_bytes;0;[ ;{ ;IC;"WReturns the bytes to be read again when Encoding::InvalidByteSequenceError occurs.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"readagain_bytes; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the bytes to be read again when Encoding::InvalidByteSequenceError occurs.
@overload readagain_bytes
@return [String]; T;0;@; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"sstatic VALUE
ecerr_readagain_bytes(VALUE self)
{
return rb_attr_get(self, rb_intern("readagain_bytes"));
}; T;BTo;1;2F;3;4;;;#I"9Encoding::InvalidByteSequenceError#incomplete_input?; F;5[ ; [[@?i;
T;:incomplete_input?;0;[ ;{ ;IC;"6Returns true if the invalid byte sequence error is caused by
premature end of string.
ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
begin
ec.convert("abc\xA1z")
rescue Encoding::InvalidByteSequenceError
p $! #=> #
p $!.incomplete_input? #=> false
end
begin
ec.convert("abc\xA1")
ec.finish
rescue Encoding::InvalidByteSequenceError
p $! #=> #
p $!.incomplete_input? #=> true
end
; T;[o;7
;8I"
overload; F;90;;;:0;;I"incomplete_input?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I"hReturns true if the invalid byte sequence error is caused by
premature end of string.
ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
begin
ec.convert("abc\xA1z")
rescue Encoding::InvalidByteSequenceError
p $! #=> #
p $!.incomplete_input? #=> false
end
begin
ec.convert("abc\xA1")
ec.finish
rescue Encoding::InvalidByteSequenceError
p $! #=> #
p $!.incomplete_input? #=> true
end
@overload incomplete_input?
@return [Boolean]; T;0;@; F; o; ; T; i;!i;"@n;;I"static VALUE; T;AI"ustatic VALUE
ecerr_incomplete_input(VALUE self)
{
return rb_attr_get(self, rb_intern("incomplete_input"));
}; T;BT;l@n;mIC;[ ;l@n;nIC;[ ;l@n;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@?i [@?i1;
T;: InvalidByteSequenceError;;@;;;[ ;{ ;IC;"Raised by Encoding and String methods when the string being
transcoded contains a byte invalid for the either the source or
target encoding.; T;[ ;[ ;I"
Raised by Encoding and String methods when the string being
transcoded contains a byte invalid for the either the source or
target encoding.
; T;0;@n; F; o; ; T; i ;!i";=i ;"o; ;0;0;0;;;"@;@;0;#I"'Encoding::InvalidByteSequenceError; F;vo; ;0;0;0;;;"@;@Z;;qo; ;IC;[ ;l@@;mIC;[ ;l@@;nIC;[ ;l@@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@?i&[@?i2;
T;:ConverterNotFoundError;;@;;;[ ;{ ;IC;"dRaised by transcoding methods when a named encoding does not
correspond with a known converter.
; T;[ ;[ ;I"f
Raised by transcoding methods when a named encoding does not
correspond with a known converter.
; T;0;@@; F; o; ; T; i&;!i);"o; ;0;0;0;;;"@;@;0;#I"%Encoding::ConverterNotFoundError; F;vo; ;0;0;0;;;"@;@Z;;qo; ;IC;[#o;1;2F;3;q;;;#I"-Encoding::Converter.asciicompat_encoding; F;5[[I"arg; T0; [[@?i ;
T;:asciicompat_encoding;0;[ ;{ ;IC;"VReturns the corresponding ASCII compatible encoding.
Returns nil if the argument is an ASCII compatible encoding.
"corresponding ASCII compatible encoding" is an ASCII compatible encoding which
can represents exactly the same characters as the given ASCII incompatible encoding.
So, no conversion undefined error occurs when converting between the two encodings.
Encoding::Converter.asciicompat_encoding("ISO-2022-JP") #=> #
Encoding::Converter.asciicompat_encoding("UTF-16BE") #=> #
Encoding::Converter.asciicompat_encoding("UTF-8") #=> nil
; T;[o;7
;8I"
overload; F;90;:-Encoding::Converter.asciicompat_encoding;:0;;I"5Encoding::Converter.asciicompat_encoding(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; TI"nil; T;@X;[ ;I" @return [Encoding, nil]; T;0;@X; F;=i ;>0;5[[I" string; T0;@Xo;7
;8I"
overload; F;90;;;:0;;I"7Encoding::Converter.asciicompat_encoding(encoding); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; TI"nil; T;@X;[ ;I" @return [Encoding, nil]; T;0;@X; F;=i ;>0;5[[I"
encoding; T0;@X;[ ;I"Returns the corresponding ASCII compatible encoding.
Returns nil if the argument is an ASCII compatible encoding.
"corresponding ASCII compatible encoding" is an ASCII compatible encoding which
can represents exactly the same characters as the given ASCII incompatible encoding.
So, no conversion undefined error occurs when converting between the two encodings.
Encoding::Converter.asciicompat_encoding("ISO-2022-JP") #=> #
Encoding::Converter.asciicompat_encoding("UTF-16BE") #=> #
Encoding::Converter.asciicompat_encoding("UTF-8") #=> nil
@overload Encoding::Converter.asciicompat_encoding(string)
@return [Encoding, nil]
@overload Encoding::Converter.asciicompat_encoding(encoding)
@return [Encoding, nil]; T;0;@X; F; o; ; T; i ;!i ;"@V;;I"static VALUE; T;AI"static VALUE
econv_s_asciicompat_encoding(VALUE klass, VALUE arg)
{
const char *arg_name, *result_name;
rb_encoding *arg_enc, *result_enc;
enc_arg(&arg, &arg_name, &arg_enc);
result_name = rb_econv_asciicompat_encoding(arg_name);
if (result_name == NULL)
return Qnil;
result_enc = make_encoding(result_name);
return rb_enc_from_encoding(result_enc);
}; T;BTo;1;2F;3;q;;;#I"(Encoding::Converter.search_convpath; F;5[[@0; [[@?iB ;
T;:search_convpath;0;[ ;{ ;IC;"-Returns a conversion path.
p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP")
#=> [[#, #],
# [#, # puts to CR.
; T;[o;7
;8I"
overload; F;90;;M;:0;;I" new(fd [, mode] [, opt]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@ro;[ ;I"@return [IO]; T;0;@ro; F;=i ;>0;5[[I"fd[, mode][, opt]; T0;@ro;[ ;I"&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+, +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
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
:\external_encoding ::
External encoding for the IO. "-" is a synonym for the default external
encoding.
:\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;@ro; F; o; ; T; it ;!i ;"@%l;;I"static VALUE; T;AI"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) == -1) 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;BTo;1;2F;3;4;;;#I"IO#initialize_copy; F;5[[I"io; T0; [[@iK;
T;;x;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@o; F; o; ; T; iJ;!iJ;"@%l;;I"static VALUE; T;AI"Gstatic 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->finalize = orig->finalize;
#if defined (__CYGWIN__) || !defined(HAVE_FORK)
if (fptr->finalize == pipe_finalize)
pipe_add_fptr(fptr);
#endif
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;BTo;1;2F;3;4;;;#I"IO#reopen; F;5[[@0; [[@i;
T;: reopen;0;[ ;{ ;IC;"nReassociates 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.
f1 = File.new("testfile")
f2 = File.new("testfile")
f2.readlines[0] #=> "This is line one\n"
f2.reopen(f1) #=> #$,)
is not nil, it will be inserted between each object.
If the output record separator ($\\)
is not nil, it will be appended to the output. If no
arguments are given, prints $_. Objects that aren't
strings will be converted by calling their to_s method.
With no argument, prints the contents of the variable $_.
Returns nil.
$stdout.print("This is ", 100, " percent.\n")
produces:
This is 100 percent.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" print(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@o;[ ;I"@return [nil]; T;0;@o; F;=i ;>0;5[ ;@oo;7
;8I"
overload; F;90;;;:0;;I"print(obj, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@o;[ ;I"@return [nil]; T;0;@o; F;=i ;>0;5[[I"obj; T0[I"...; T0;@o;[ ;I"Writes the given object(s) to ios. The stream must be
opened for writing. If the output field separator ($,)
is not nil, it will be inserted between each object.
If the output record separator ($\\)
is not nil, it will be appended to the output. If no
arguments are given, prints $_. Objects that aren't
strings will be converted by calling their to_s method.
With no argument, prints the contents of the variable $_.
Returns nil.
$stdout.print("This is ", 100, " percent.\n")
produces:
This is 100 percent.
@overload print()
@return [nil]
@overload print(obj, ...)
@return [nil]; T;0;@o; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"VALUE
rb_io_print(int argc, 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; iNumeric, write the character whose code is
the least-significant byte of obj, otherwise write the first byte
of the string representation of obj to ios. Note: This
method is not safe for use with multi-byte characters as it will truncate
them.
$stdout.putc "A"
$stdout.putc 65
produces:
AA
; T;[o;7
;8I"
overload; F;90;;;:0;;I"putc(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Object; T;@o;[ ;I"@return [Object]; T;0;@o; F;=i ;>0;5[[I"obj; T0;@o;[ ;I"If obj is Numeric, write the character whose code is
the least-significant byte of obj, otherwise write the first byte
of the string representation of obj to ios. Note: This
method is not safe for use with multi-byte characters as it will truncate
them.
$stdout.putc "A"
$stdout.putc 65
produces:
AA
@overload putc(obj)
@return [Object]; T;0;@o; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#puts; F;5[[@0; [[@ib;
T;;;0;[ ;{ ;IC;"Writes the given objects to ios as with
IO#print. Writes a record separator (typically a
newline) after any that do not already end with a newline sequence.
If called with an array argument, writes each element on a new line.
If called without arguments, outputs a single record separator.
$stdout.puts("this", "is", "a", "test")
produces:
this
is
a
test
; T;[o;7
;8I"
overload; F;90;;;:0;;I"puts(obj, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@p;[ ;I"@return [nil]; T;0;@p; F;=i ;>0;5[[I"obj; T0[I"...; T0;@p;[ ;I"Writes the given objects to ios as with
IO#print. Writes a record separator (typically a
newline) after any that do not already end with a newline sequence.
If called with an array argument, writes each element on a new line.
If called without arguments, outputs a single record separator.
$stdout.puts("this", "is", "a", "test")
produces:
this
is
a
test
@overload puts(obj, ...)
@return [nil]; T;0;@p; F; o; ; T; iN;!i_;"@%l;;I"
VALUE; T;AI"\VALUE
rb_io_puts(int argc, VALUE *argv, VALUE out)
{
int i;
VALUE line;
/* if no argument given, print newline. */
if (argc == 0) {
rb_io_write(out, rb_default_rs);
return Qnil;
}
for (i=0; iKernel#sprintf
for details.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"'printf(format_string [, obj, ...]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@;p;[ ;I"@return [nil]; T;0;@;p; F;=i ;>0;5[[I" format_string[, obj, ...]; T0;@;p;[ ;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;@;p; F; o; ; T; iy;!i;"@%l;;I"
VALUE; T;AI"~VALUE
rb_io_printf(int argc, VALUE *argv, VALUE out)
{
rb_io_write(out, rb_f_sprintf(argc, argv));
return Qnil;
}; T;BTo;1;2F;3;4;;;#I" IO#each; F;5[[@0; [[@i*
;
T;;;0;[ ;{ ;IC;"xios.each_line(sep=$/) {|line| block } -> ios
ios.each_line(limit) {|line| block } -> ios
ios.each_line(sep,limit) {|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...
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"each(sep=$/); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Ypo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Yp;[ ;I" @yield [line]
@return [IO]; T;0;@Yp; F;=i ;>0;5[[I"sep; TI"$/; T;@Ypo;7
;8I"
overload; F;90;;;:0;;I"each(limit); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Ypo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Yp;[ ;I" @yield [line]
@return [IO]; T;0;@Yp; F;=i ;>0;5[[I"
limit; T0;@Ypo;7
;8I"
overload; F;90;;;:0;;I"each(sep,limit); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@Ypo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Yp;[ ;I" @yield [line]
@return [IO]; T;0;@Yp; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@Ypo;7
;8I"
overload; F;90;;;:0;;I"each(...); T;IC;" ; T;[ ;[ ;I" ; T;0;@Yp; F;=i ;>0;5[[I"...; T0;@Yp;[ ;I"5 ios.each_line(sep=$/) {|line| block } -> ios
ios.each_line(limit) {|line| block } -> ios
ios.each_line(sep,limit) {|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...
@overload each(sep=$/)
@yield [line]
@return [IO]
@overload each(limit)
@yield [line]
@return [IO]
@overload each(sep,limit)
@yield [line]
@return [IO]
@overload each(...); T;0;@Yp; F; o; ; T; i
;!i,
;"@%l;;I"static VALUE; T;AI"rstatic VALUE
rb_io_each_line(int argc, VALUE *argv, VALUE io)
{
VALUE str, rs;
long limit;
RETURN_ENUMERATOR(io, argc, argv);
prepare_getline_args(argc, argv, &rs, &limit, io);
if (limit == 0)
rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
while (!NIL_P(str = rb_io_getline_1(rs, limit, io))) {
rb_yield(str);
}
return io;
}; T;BTo;1;2F;3;4;;;#I"IO#each_line; F;5[[@0; [[@i*
;
T;;;0;[ ;{ ;IC;"xios.each_line(sep=$/) {|line| block } -> ios
ios.each_line(limit) {|line| block } -> ios
ios.each_line(sep,limit) {|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...
; T;[ o;7
;8I"
overload; F;90;;;:0;;I"each(sep=$/); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@po;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@p;[ ;I" @yield [line]
@return [IO]; T;0;@p; F;=i ;>0;5[[I"sep; TI"$/; T;@po;7
;8I"
overload; F;90;;;:0;;I"each(limit); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@po;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@p;[ ;I" @yield [line]
@return [IO]; T;0;@p; F;=i ;>0;5[[I"
limit; T0;@po;7
;8I"
overload; F;90;;;:0;;I"each(sep,limit); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I" line; T;@po;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@p;[ ;I" @yield [line]
@return [IO]; T;0;@p; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@po;7
;8I"
overload; F;90;;;:0;;I"each(...); T;IC;" ; T;[ ;[ ;I" ; T;0;@p; F;=i ;>0;5[[I"...; T0;@p;[ ;@p;0;@p; F; o; ; T; i
;!i,
;"@%l;;I"static VALUE; T;AI"rstatic VALUE
rb_io_each_line(int argc, VALUE *argv, VALUE io)
{
VALUE str, rs;
long limit;
RETURN_ENUMERATOR(io, argc, argv);
prepare_getline_args(argc, argv, &rs, &limit, io);
if (limit == 0)
rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
while (!NIL_P(str = rb_io_getline_1(rs, limit, io))) {
rb_yield(str);
}
return io;
}; T;BTo;1;2F;3;4;;;#I"IO#each_byte; F;5[ ; [[@iX
;
T;;;0;[ ;{ ;IC;"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 } #=> #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 } #=> #IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each_char {|c| print c, ' ' } #=> #IOError will be raised.
If no block is given, an enumerator is returned instead.
f = File.new("testfile")
f.each_char {|c| print c, ' ' } #=> #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;7
;8I"
overload; F;90;;;:0;;I"each_codepoint; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"c; T;@Xqo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Xq;[ ;I" @yield [c]
@return [IO]; T;0;@Xq; F;=i ;>0;5[ ;@Xqo;7
;8I"
overload; F;90;;;:0;;I"codepoints; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"c; T;@Xqo;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Xq;[ ;I" @yield [c]
@return [IO]; T;0;@Xq; F;=i ;>0;5[ ;@Xqo;7
;8I"
overload; F;90;;;:0;;I"each_codepoint; T;IC;" ; T;[ ;[ ;I" ; T;0;@Xq; F;=i ;>0;5[ ;@Xqo;7
;8I"
overload; F;90;;;:0;;I"codepoints; T;IC;" ; T;[ ;[ ;I" ; T;0;@Xq; F;=i ;>0;5[ ;@Xq;[ ;I"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.
@overload each_codepoint
@yield [c]
@return [IO]
@overload codepoints
@yield [c]
@return [IO]
@overload each_codepoint
@overload codepoints; T;0;@Xq; F; o; ; T; i;!i$;"@%l;;I"static VALUE; T;AI"
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;BTo;1;2F;3;4;;;#I"
IO#lines; F;5[[@0; [[@i>
;
T;;;0;[ ;{ ;IC;";This is a deprecated alias for each_line.
; T;[ ;[ ;I"each_byte.
; T;[ ;[ ;I"each_char.
; T;[ ;[ ;I"each_codepoint.
; T;[ ;[ ;I"AThis is a deprecated alias for each_codepoint.
; T;0;@q; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_codepoints(VALUE io)
{
rb_warn("IO#codepoints is deprecated; use #each_codepoint instead");
if (!rb_block_given_p())
return rb_enumeratorize(io, ID2SYM(rb_intern("each_codepoint")), 0, 0);
return rb_io_each_codepoint(io);
}; T;BTo;1;2F;3;4;;;#I"IO#syswrite; F;5[[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;7
;8I"
overload; F;90;;;:0;;I"syswrite(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@q;[ ;I"@return [Integer]; T;0;@q; F;=i ;>0;5[[I" string; T0;@q;[ ;I"`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
@overload syswrite(string)
@return [Integer]; T;0;@q; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_syswrite(VALUE io, VALUE str)
{
rb_io_t *fptr;
long n;
if (!RB_TYPE_P(str, T_STRING))
str = rb_obj_as_string(str);
io = GetWriteIO(io);
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
str = rb_str_new_frozen(str);
if (fptr->wbuf.len) {
rb_warn("syswrite for buffered IO");
}
n = rb_write_internal(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str));
RB_GC_GUARD(str);
if (n == -1) rb_sys_fail_path(fptr->pathv);
return LONG2FIX(n);
}; T;BTo;1;2F;3;4;;;#I"IO#sysread; F;5[[@0; [[@i';
T;: sysread;0;[ ;{ ;IC;"AReads 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;7
;8I"
overload; F;90;;;:0;;I" sysread(maxlen[, outbuf]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@q;[ ;I"@return [String]; T;0;@q; F;=i ;>0;5[[I"maxlen[, outbuf]; T0;@q;[ ;I"zReads 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;@q; F; o; ; T; i;!i$;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_sysread(int argc, VALUE *argv, VALUE io)
{
VALUE len, str;
rb_io_t *fptr;
long n, ilen;
struct read_internal_arg arg;
rb_scan_args(argc, argv, "11", &len, &str);
ilen = NUM2LONG(len);
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");
}
n = fptr->fd;
/*
* 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);
rb_str_locktmp(str);
arg.fd = fptr->fd;
arg.str_ptr = RSTRING_PTR(str);
arg.len = ilen;
rb_ensure(read_internal_call, (VALUE)&arg, rb_str_unlocktmp, str);
n = arg.len;
if (n == -1) {
rb_sys_fail_path(fptr->pathv);
}
io_set_read_length(str, n);
if (n == 0 && ilen > 0) {
rb_eof_error();
}
OBJ_TAINT(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"IO#fileno; F;5[ ; [[@i|;
T;: fileno;0;[ ;{ ;IC;"Returns an integer representing the numeric file descriptor for
ios.
$stdin.fileno #=> 0
$stdout.fileno #=> 1
; T;[o;7
;8I"
overload; F;90;;;:0;;I" fileno; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@r;[ ;I"@return [Fixnum]; T;0;@r; F;=i ;>0;5[ ;@ro;7
;8I"
overload; F;90;;\;:0;;I" to_i; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@r;[ ;I"@return [Fixnum]; T;0;@r; F;=i ;>0;5[ ;@r;[ ;I"Returns an integer representing the numeric file descriptor for
ios.
$stdin.fileno #=> 0
$stdout.fileno #=> 1
@overload fileno
@return [Fixnum]
@overload to_i
@return [Fixnum]; T;0;o;1;2F;3;4;;;#I" IO#to_i; F;5[ ; [[@i/;
F;;\;;@;[ ;{ ;@r;"@%l;;I"static VALUE; T;AI"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; F; o; ; T; ip;!iz;"@%l;;@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;7
;8I"
overload; F;90;;;:0;;I"
fsync; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; TI"nil; T;@[r;[ ;I"@return [0, nil]; T;0;@[r; F;=i ;>0;5[ ;@[r;[ ;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;@[r; F; o; ; T; i ;!i);"@%l;;I"static VALUE; T;AI"cstatic 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);
# ifndef _WIN32 /* already called in io_fflush() */
if ((int)rb_thread_io_blocking_region(nogvl_fsync, fptr, fptr->fd) < 0)
rb_sys_fail_path(fptr->pathv);
# endif
return INT2FIX(0);
}; T;BTo;1;2F;3;4;;;#I"IO#fdatasync; F;5[ ; [[@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;7
;8I"
overload; F;90;;;:0;;I"fdatasync; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; TI"nil; T;@wr;[ ;I"@return [0, nil]; T;0;@wr; F;=i ;>0;5[ ;@wr;[ ;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;@wr; F; o; ; T; iP;!iX;"@%l;;I"static VALUE; T;AI"?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;BTo;1;2F;3;4;;;#I" IO#sync; F;5[ ; [[@i;
T;: sync;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;7
;8I"
overload; F;90;;;:0;;I" sync; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@r;[ ;I"@return [Boolean]; T;0;@r; F;=i ;>0;5[ ;@r;[ ;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;@r; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#sync=; F;5[[I" sync; T0; [[@i?;
T;:
sync=;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@r;"@%l;;I"static VALUE; T;AI"bstatic VALUE
rb_io_set_sync(VALUE io, VALUE sync)
{
rb_notimplement();
UNREACHABLE;
}; T;BTo;1;2F;3;4;;;#I"IO#lineno; F;5[ ; [[@i ;
T;: lineno;0;[ ;{ ;IC;"VReturns 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
; T;[o;7
;8I"
overload; F;90;;;:0;;I" lineno; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@r;[ ;I"@return [Integer]; T;0;@r; F;=i ;>0;5[ ;@r;[ ;I"}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 $/ 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;@r; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#lineno=; F;5[[I" lineno; T0; [[@i ;
T;: lineno=;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;7
;8I"
overload; F;90;;;:0;;I"lineno=(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@r;[ ;I"@return [Integer]; T;0;@r; F;=i ;>0;5[[I" integer; T0;@r;[ ;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;@r; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#readlines; F;5[[@0; [[@i ;
T;;;0;[ ;{ ;IC;"Reads all of the lines in ios, and returns them in
anArray. 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
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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"readlines(sep=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@r;[ ;I"@return [Array]; T;0;@r; F;=i ;>0;5[[I"sep; TI"$/; T;@ro;7
;8I"
overload; F;90;;;:0;;I"readlines(limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@r;[ ;I"@return [Array]; T;0;@r; F;=i ;>0;5[[I"
limit; T0;@ro;7
;8I"
overload; F;90;;;:0;;I"readlines(sep, limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@r;[ ;I"@return [Array]; T;0;@r; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@r;[ ;I"Reads all of the lines in ios, and returns them in
anArray. 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
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"
@overload readlines(sep=$/)
@return [Array]
@overload readlines(limit)
@return [Array]
@overload readlines(sep, limit)
@return [Array]; T;0;@r; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"tstatic VALUE
rb_io_readlines(int argc, VALUE *argv, VALUE io)
{
VALUE line, ary, rs;
long limit;
prepare_getline_args(argc, argv, &rs, &limit, io);
if (limit == 0)
rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
ary = rb_ary_new();
while (!NIL_P(line = rb_io_getline_1(rs, limit, io))) {
rb_ary_push(ary, line);
}
return ary;
}; T;BTo;1;2F;3;4;;;#I"IO#read_nonblock; F;5[[@0; [[@i
;
T;:read_nonblock;0;[ ;{ ;IC;"@Reads at most maxlen bytes from ios using
the read(2) system call after O_NONBLOCK is set for
the underlying file descriptor.
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.
read_nonblock just calls the read(2) system call.
It causes all errors the read(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
The caller should care such errors.
If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
it is extended by IO::WaitReadable.
So IO::WaitReadable can be used to rescue the exceptions for retrying read_nonblock.
read_nonblock causes EOFError on EOF.
If the read byte buffer is not empty,
read_nonblock reads from the buffer like readpartial.
In this case, the read(2) system call is not called.
When read_nonblock raises an exception kind of IO::WaitReadable,
read_nonblock should not be called
until io is readable for avoiding busy loop.
This can be done as follows.
# emulates blocking read (readpartial).
begin
result = io.read_nonblock(maxlen)
rescue IO::WaitReadable
IO.select([io])
retry
end
Although IO#read_nonblock doesn't raise IO::WaitWritable.
OpenSSL::Buffering#read_nonblock can raise IO::WaitWritable.
If IO and SSL should be used polymorphically,
IO::WaitWritable should be rescued too.
See the document of OpenSSL::Buffering#read_nonblock for sample code.
Note that this method is identical to readpartial
except the non-blocking flag is set.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"read_nonblock(maxlen); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@5s;[ ;I"@return [String]; T;0;@5s; F;=i ;>0;5[[I" maxlen; T0;@5so;7
;8I"
overload; F;90;;;:0;;I""read_nonblock(maxlen, outbuf); T;IC;" ; T;[ ;[ ;I" ; T;0;@5s; F;=i ;>0;5[[I" maxlen; T0[I" outbuf; T0;@5s;[ ;I"Reads at most maxlen bytes from ios using
the read(2) system call after O_NONBLOCK is set for
the underlying file descriptor.
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.
read_nonblock just calls the read(2) system call.
It causes all errors the read(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
The caller should care such errors.
If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
it is extended by IO::WaitReadable.
So IO::WaitReadable can be used to rescue the exceptions for retrying read_nonblock.
read_nonblock causes EOFError on EOF.
If the read byte buffer is not empty,
read_nonblock reads from the buffer like readpartial.
In this case, the read(2) system call is not called.
When read_nonblock raises an exception kind of IO::WaitReadable,
read_nonblock should not be called
until io is readable for avoiding busy loop.
This can be done as follows.
# emulates blocking read (readpartial).
begin
result = io.read_nonblock(maxlen)
rescue IO::WaitReadable
IO.select([io])
retry
end
Although IO#read_nonblock doesn't raise IO::WaitWritable.
OpenSSL::Buffering#read_nonblock can raise IO::WaitWritable.
If IO and SSL should be used polymorphically,
IO::WaitWritable should be rescued too.
See the document of OpenSSL::Buffering#read_nonblock for sample code.
Note that this method is identical to readpartial
except the non-blocking flag is set.
@overload read_nonblock(maxlen)
@return [String]
@overload read_nonblock(maxlen, outbuf); T;0;@5s; F; o; ; T; i ;!i
;"@%l;;I"static VALUE; T;AI"static VALUE
io_read_nonblock(int argc, VALUE *argv, VALUE io)
{
VALUE ret;
VALUE opts = Qnil;
int no_exception = 0;
rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);
if (!NIL_P(opts) && Qfalse == rb_hash_aref(opts, sym_exception)) {
no_exception = 1;
argc--;
}
ret = io_getpartial(argc, argv, io, 1, no_exception);
if (NIL_P(ret)) {
if (no_exception)
return Qnil;
else
rb_eof_error();
}
return ret;
}; T;BTo;1;2F;3;4;;;#I"IO#write_nonblock; F;5[[@0; [[@i
;
T;:write_nonblock;0;[ ;{ ;IC;"3Writes the given string to ios using
the write(2) system call after O_NONBLOCK is set for
the underlying file descriptor.
It returns the number of bytes written.
write_nonblock just calls the write(2) system call.
It causes all errors the write(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
The result may also be smaller than string.length (partial write).
The caller should care such errors and partial write.
If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
it is extended by IO::WaitWritable.
So IO::WaitWritable can be used to rescue the exceptions for retrying write_nonblock.
# Creates a pipe.
r, w = IO.pipe
# write_nonblock writes only 65536 bytes and return 65536.
# (The pipe size is 65536 bytes on this environment.)
s = "a" * 100000
p w.write_nonblock(s) #=> 65536
# write_nonblock cannot write a byte and raise EWOULDBLOCK (EAGAIN).
p w.write_nonblock("b") # Resource temporarily unavailable (Errno::EAGAIN)
If the write buffer is not empty, it is flushed at first.
When write_nonblock raises an exception kind of IO::WaitWritable,
write_nonblock should not be called
until io is writable for avoiding busy loop.
This can be done as follows.
begin
result = io.write_nonblock(string)
rescue IO::WaitWritable, Errno::EINTR
IO.select(nil, [io])
retry
end
Note that this doesn't guarantee to write all data in string.
The length written is reported as result and it should be checked later.
On some platforms such as Windows, write_nonblock is not supported
according to the kind of the IO object.
In such cases, write_nonblock raises Errno::EBADF.
By specifying `exception: false`, the options hash allows you to indicate
that write_nonblock should not raise an IO::WaitWritable exception, but
return the symbol :wait_writable instead.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"write_nonblock(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@_s;[ ;I"@return [Integer]; T;0;@_s; F;=i ;>0;5[[I" string; T0;@_so;7
;8I"
overload; F;90;;;:0;;I"'write_nonblock(string [, options]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@_s;[ ;I"@return [Integer]; T;0;@_s; F;=i ;>0;5[[I"string[, options]; T0;@_s;[ ;I"Writes the given string to ios using
the write(2) system call after O_NONBLOCK is set for
the underlying file descriptor.
It returns the number of bytes written.
write_nonblock just calls the write(2) system call.
It causes all errors the write(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
The result may also be smaller than string.length (partial write).
The caller should care such errors and partial write.
If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
it is extended by IO::WaitWritable.
So IO::WaitWritable can be used to rescue the exceptions for retrying write_nonblock.
# Creates a pipe.
r, w = IO.pipe
# write_nonblock writes only 65536 bytes and return 65536.
# (The pipe size is 65536 bytes on this environment.)
s = "a" * 100000
p w.write_nonblock(s) #=> 65536
# write_nonblock cannot write a byte and raise EWOULDBLOCK (EAGAIN).
p w.write_nonblock("b") # Resource temporarily unavailable (Errno::EAGAIN)
If the write buffer is not empty, it is flushed at first.
When write_nonblock raises an exception kind of IO::WaitWritable,
write_nonblock should not be called
until io is writable for avoiding busy loop.
This can be done as follows.
begin
result = io.write_nonblock(string)
rescue IO::WaitWritable, Errno::EINTR
IO.select(nil, [io])
retry
end
Note that this doesn't guarantee to write all data in string.
The length written is reported as result and it should be checked later.
On some platforms such as Windows, write_nonblock is not supported
according to the kind of the IO object.
In such cases, write_nonblock raises Errno::EBADF.
By specifying `exception: false`, the options hash allows you to indicate
that write_nonblock should not raise an IO::WaitWritable exception, but
return the symbol :wait_writable instead.
@overload write_nonblock(string)
@return [Integer]
@overload write_nonblock(string [, options])
@return [Integer]; T;0;@_s; F; o; ; T; iZ
;!i
;"@%l;;I"static VALUE; T;AI"Kstatic VALUE
rb_io_write_nonblock(int argc, VALUE *argv, VALUE io)
{
VALUE str;
VALUE opts = Qnil;
int no_exceptions = 0;
rb_scan_args(argc, argv, "10:", &str, &opts);
if (!NIL_P(opts) && Qfalse == rb_hash_aref(opts, sym_exception))
no_exceptions = 1;
return io_write_nonblock(io, str, no_exceptions);
}; T;BTo;1;2F;3;4;;;#I"IO#readpartial; F;5[[@0; [[@i ;
T;:readpartial;0;[ ;{ ;IC;"
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 later 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;7
;8I"
overload; F;90;;;:0;;I"readpartial(maxlen); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@s;[ ;I"@return [String]; T;0;@s; F;=i ;>0;5[[I" maxlen; T0;@so;7
;8I"
overload; F;90;;;:0;;I" readpartial(maxlen, outbuf); T;IC;" ; T;[ ;[ ;I" ; T;0;@s; F;=i ;>0;5[[I" maxlen; T0[I" outbuf; T0;@s;[ ;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 later 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;@s; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"static VALUE
io_readpartial(int argc, VALUE *argv, VALUE io)
{
VALUE ret;
ret = io_getpartial(argc, argv, io, 0, 0);
if (NIL_P(ret))
rb_eof_error();
return ret;
}; T;BTo;1;2F;3;4;;;#I" IO#read; F;5[[@0; [[@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,
it try to read length bytes without any conversion (binary mode).
It returns nil or a string whose length is 1 to length bytes.
nil means it met EOF at beginning.
The 1 to length-1 bytes string means it met EOF after reading the result.
The length bytes string means it doesn't meet EOF.
The resulted string is always ASCII-8BIT encoding.
If length is omitted or is nil,
it reads until EOF and the encoding conversion is applied.
It returns a string even if EOF is met at beginning.
If length is zero, it returns "".
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.
At end of file, it returns nil or ""
depend on length.
ios.read() and
ios.read(nil) returns "".
ios.read(positive-integer) returns nil.
f = File.new("testfile")
f.read(16) #=> "This is line one"
# reads whole file
open("file") {|f|
data = f.read # This returns a string even if the file is empty.
...
}
# iterate over fixed length records.
open("fixed-record-file") {|f|
while record = f.read(256)
...
end
}
# iterate over variable length records.
# record is prefixed by 32-bit length.
open("variable-record-file") {|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
}
Note that this method behaves like fread() function in C.
This means it retry to invoke read(2) system call to read data with the specified length (or until EOF).
This behavior is preserved even if ios is non-blocking mode.
(This method is non-blocking flag insensitive as other methods.)
If you need the behavior like single read(2) system call,
consider readpartial, read_nonblock and sysread.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" read([length [, outbuf]]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@s;[ ;I"@return [String, nil]; T;0;@s; F;=i ;>0;5[[I"[length [, outbuf]]; T0;@s;[ ;I" Reads length bytes from the I/O stream.
length must be a non-negative integer or nil.
If length is a positive integer,
it try to read length bytes without any conversion (binary mode).
It returns nil or a string whose length is 1 to length bytes.
nil means it met EOF at beginning.
The 1 to length-1 bytes string means it met EOF after reading the result.
The length bytes string means it doesn't meet EOF.
The resulted string is always ASCII-8BIT encoding.
If length is omitted or is nil,
it reads until EOF and the encoding conversion is applied.
It returns a string even if EOF is met at beginning.
If length is zero, it returns "".
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.
At end of file, it returns nil or ""
depend on length.
ios.read() and
ios.read(nil) returns "".
ios.read(positive-integer) returns nil.
f = File.new("testfile")
f.read(16) #=> "This is line one"
# reads whole file
open("file") {|f|
data = f.read # This returns a string even if the file is empty.
...
}
# iterate over fixed length records.
open("fixed-record-file") {|f|
while record = f.read(256)
...
end
}
# iterate over variable length records.
# record is prefixed by 32-bit length.
open("variable-record-file") {|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
}
Note that this method behaves like fread() function in C.
This means it retry to invoke read(2) system call to read data with the specified length (or until EOF).
This behavior is preserved even if ios is non-blocking mode.
(This method is non-blocking flag insensitive as other methods.)
If you need the behavior like single read(2) system call,
consider readpartial, read_nonblock and sysread.
@overload read([length [, outbuf]])
@return [String, nil]; T;0;@s; F; o; ; T; i
;!i
;"@%l;;I"static VALUE; T;AI"=static VALUE
io_read(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
long n, len;
VALUE length, str;
#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);
}
io_setstrbuf(&str,len);
GetOpenFile(io, fptr);
rb_io_check_byte_readable(fptr);
if (len == 0) {
io_set_read_length(str, 0);
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);
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
if (previous_mode == O_TEXT) {
setmode(fptr->fd, O_TEXT);
}
#endif
if (n == 0) return Qnil;
OBJ_TAINT(str);
return str;
}; T;BTo;1;2F;3;4;;;#I"
IO#write; F;5[[I"str; T0; [[@i;
T;;;0;[ ;{ ;IC;"kWrites the given string to ios. The stream must be opened
for writing. If the argument is not a string, it will be converted
to a string using to_s. Returns the number of bytes
written.
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;7
;8I"
overload; F;90;;;:0;;I"write(string); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@s;[ ;I"@return [Integer]; T;0;@s; F;=i ;>0;5[[I" string; T0;@s;[ ;I"Writes the given string to ios. The stream must be opened
for writing. If the argument is not a string, it will be converted
to a string using to_s. Returns the number of bytes
written.
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;@s; F; o; ; T; iz;!i;"@%l;;I"static VALUE; T;AI"Vstatic VALUE
io_write_m(VALUE io, VALUE str)
{
return io_write(io, str, 0);
}; T;BTo;1;2F;3;4;;;#I" IO#gets; F;5[[@0; [[@i ;
T;;;0;[ ;{ ;IC;"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"
; T;[o;7
;8I"
overload; F;90;;;:0;;I"gets(sep=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@s;[ ;I"@return [String, nil]; T;0;@s; F;=i ;>0;5[[I"sep; TI"$/; T;@so;7
;8I"
overload; F;90;;;:0;;I"gets(limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@s;[ ;I"@return [String, nil]; T;0;@s; F;=i ;>0;5[[I"
limit; T0;@so;7
;8I"
overload; F;90;;;:0;;I"gets(sep, limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@s;[ ;I"@return [String, nil]; T;0;@s; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@s;[ ;I"kReads 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"
@overload gets(sep=$/)
@return [String, nil]
@overload gets(limit)
@return [String, nil]
@overload gets(sep, limit)
@return [String, nil]; T;0;@s; F; o; ; T; iz ;!i ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#readline; F;5[[@0; [[@i ;
T;;;0;[ ;{ ;IC;"cReads a line as with IO#gets, but raises an
EOFError on end of file.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"readline(sep=$/); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@6t;[ ;I"@return [String]; T;0;@6t; F;=i ;>0;5[[I"sep; TI"$/; T;@6to;7
;8I"
overload; F;90;;;:0;;I"readline(limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@6t;[ ;I"@return [String]; T;0;@6t; F;=i ;>0;5[[I"
limit; T0;@6to;7
;8I"
overload; F;90;;;:0;;I"readline(sep, limit); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@6t;[ ;I"@return [String]; T;0;@6t; F;=i ;>0;5[[I"sep; T0[I"
limit; T0;@6t;[ ;I"Reads a line as with IO#gets, but raises an
EOFError on end of file.
@overload readline(sep=$/)
@return [String]
@overload readline(limit)
@return [String]
@overload readline(sep, limit)
@return [String]; T;0;@6t; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#getc; F;5[ ; [[@i;
T;: getc;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;7
;8I"
overload; F;90;;;:0;;I" getc; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; TI"nil; T;@ut;[ ;I"@return [String, nil]; T;0;@ut; F;=i ;>0;5[ ;@ut;[ ;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;@ut; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#getbyte; F;5[ ; [[@i;
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;7
;8I"
overload; F;90;;;:0;;I" getbyte; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@t;[ ;I"@return [Fixnum, nil]; T;0;@t; F;=i ;>0;5[ ;@t;[ ;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 [Fixnum, nil]; T;0;@t; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#readchar; F;5[ ; [[@i;
T;:
readchar;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;7
;8I"
overload; F;90;;;:0;;I"
readchar; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@t;[ ;I"@return [String]; T;0;@t; F;=i ;>0;5[ ;@t;[ ;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;@t; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_readchar(VALUE io)
{
VALUE c = rb_io_getc(io);
if (NIL_P(c)) {
rb_eof_error();
}
return c;
}; T;BTo;1;2F;3;4;;;#I"IO#readbyte; F;5[ ; [[@i;
T;:
readbyte;0;[ ;{ ;IC;"fReads a byte as with IO#getbyte, but raises an
EOFError on end of file.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
readbyte; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@t;[ ;I"@return [Fixnum]; T;0;@t; F;=i ;>0;5[ ;@t;[ ;I"Reads a byte as with IO#getbyte, but raises an
EOFError on end of file.
@overload readbyte
@return [Fixnum]; T;0;@t; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_readbyte(VALUE io)
{
VALUE c = rb_io_getbyte(io);
if (NIL_P(c)) {
rb_eof_error();
}
return c;
}; T;BTo;1;2F;3;4;;;#I"IO#ungetbyte; F;5[[I"b; T0; [[@i;
T;:ungetbyte;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") #=> #IO#sysread).
f = File.new("testfile") #=> #IO#sysread).
f = File.new("testfile") #=> #IO#sysread).
f = File.new("testfile") #=> #to_s.
$stdout << "Hello " << "world!\n"
produces:
Hello world!
; T;[o;7
;8I"
overload; F;90;;E;:0;;I" <<(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@0u;[ ;I"@return [IO]; T;0;@0u; F;=i ;>0;5[[I"obj; T0;@0u;[ ;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;@0u; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"YVALUE
rb_io_addstr(VALUE io, VALUE str)
{
rb_io_write(io, str);
return io;
}; T;BTo;1;2F;3;4;;;#I"
IO#flush; F;5[ ; [[@i;
T;:
flush;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;7
;8I"
overload; F;90;;;:0;;I"
flush; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@Ou;[ ;I"@return [IO]; T;0;@Ou; F;=i ;>0;5[ ;@Ou;[ ;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;@Ou; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"GVALUE
rb_io_flush(VALUE io)
{
return rb_io_flush_raw(io, 1);
}; T;BTo;1;2F;3;4;;;#I" IO#tell; F;5[ ; [[@i;
T;: tell;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;7
;8I"
overload; F;90;:pos;:0;;I"pos; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@ju;[ ;I"@return [Integer]; T;0;@ju; F;=i ;>0;5[ ;@juo;7
;8I"
overload; F;90;;;:0;;I" tell; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@ju;[ ;I"@return [Integer]; T;0;@ju; F;=i ;>0;5[ ;@ju;[ ;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;@ju; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#seek; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I"&seek(amount, whence=IO::SEEK_SET); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@u;[ ;I"@return [ 0]; T;0;@u; F;=i ;>0;5[[I" amount; T0[I" whence; TI"IO::SEEK_SET; T;@u;[ ;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;@u; F; o; ; T; i';!i9;"@%l;;I"static VALUE; T;AI"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;BTo;
; [[@i$/;
F;:
SEEK_SET;;;;;[ ;{ ;IC;"(Set I/O position from the beginning
; T;[ ;[ ;I"(Set I/O position from the beginning; T;0;@u; F; o; ; T; i#/;!i#/;"@%l;#I"IO::SEEK_SET; F;$I"INT2FIX(SEEK_SET); To;
; [[@i&/;
F;:
SEEK_CUR;;;;;[ ;{ ;IC;"/Set I/O position from the current position
; T;[ ;[ ;I"/Set I/O position from the current position; T;0;@u; F; o; ; T; i%/;!i%/;"@%l;#I"IO::SEEK_CUR; F;$I"INT2FIX(SEEK_CUR); To;
; [[@i(/;
F;:
SEEK_END;;;;;[ ;{ ;IC;""Set I/O position from the end
; T;[ ;[ ;I""Set I/O position from the end; T;0;@u; F; o; ; T; i'/;!i'/;"@%l;#I"IO::SEEK_END; F;$I"INT2FIX(SEEK_END); To;
; [[@i+/;
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;@u; F; o; ; T; i*/;!i*/;"@%l;#I"IO::SEEK_DATA; F;$I"INT2FIX(SEEK_DATA); To;
; [[@i//;
F;:SEEK_HOLE;;;;;[ ;{ ;IC;"&Set I/O position to the next hole
; T;[ ;[ ;I"&Set I/O position to the next hole; T;0;@u; F; o; ; T; i./;!i./;"@%l;#I"IO::SEEK_HOLE; F;$I"INT2FIX(SEEK_HOLE); To;1;2F;3;4;;;#I"IO#rewind; F;5[ ; [[@iv;
T;: rewind;0;[ ;{ ;IC;"?Positions 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;7
;8I"
overload; F;90;;;:0;;I" rewind; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@u;[ ;I"@return [0]; T;0;@u; F;=i ;>0;5[ ;@u;[ ;I"`Positions 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;@u; F; o; ; T; if;!is;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#pos; F;5[ ; [[@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;7
;8I"
overload; F;90;;;:0;;I"pos; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@
v;[ ;I"@return [Integer]; T;0;@
v; F;=i ;>0;5[ ;@
vo;7
;8I"
overload; F;90;;;:0;;I" tell; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@
v;[ ;I"@return [Integer]; T;0;@
v; F;=i ;>0;5[ ;@
v;[ ;@u;0;@
v; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#pos=; F;5[[I" offset; T0; [[@iV;
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;7
;8I"
overload; F;90;;;:0;;I"pos=(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@1v;[ ;I"@return [Integer]; T;0;@1v; F;=i ;>0;5[[I" integer; T0;@1v;[ ;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;@1v; F; o; ; T; iI;!iS;"@%l;;I"static VALUE; T;AI" 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;BTo;1;2F;3;4;;;#I" IO#eof; F;5[ ; [[@i;
T;:eof;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;7
;8I"
overload; F;90;;;:0;;I"eof; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Pv;[ ;I"@return [Boolean]; T;0;@Pv; F;=i ;>0;5[ ;@Pvo;7
;8I"
overload; F;90;: eof?;:0;;I" eof?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Pv;[ ;I"@return [Boolean]; T;0;@Pv; F;=i ;>0;5[ ;@Pv;[ ;I"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).
@overload eof
@return [Boolean]
@overload eof?
@return [Boolean]; T;0;@Pv; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#eof?; F;5[ ; [[@i;
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;7
;8I"
overload; F;90;;;:0;;I"eof; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@xv;[ ;I"@return [Boolean]; T;0;@xv; F;=i ;>0;5[ ;@xvo;7
;8I"
overload; F;90;;;:0;;I" eof?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@xv;[ ;I"@return [Boolean]; T;0;@xv; F;=i ;>0;5[ ;@xvo;<
;8I" return; F;9@f;0;:[@h;@xv;[ ;@tv;0;@xv; F; o; ; T; i;!i;"@%l;;I"
VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#close_on_exec?; F;5[ ; [[@i;
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;7
;8I"
overload; F;90;;;:0;;I"close_on_exec?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@v;[ ;I"@return [Boolean]; T;0;@v; F;=i ;>0;5[ ;@vo;<
;8I" return; F;9@f;0;:[@h;@v;[ ;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;@v; F; o; ; T; iw;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#close_on_exec=; F;5[[I"arg; T0; [[@i;
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;7
;8I"
overload; F;90;;;:0;;I"close_on_exec=(bool); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@v;[ ;I"@return [Boolean]; T;0;@v; F;=i ;>0;5[[I" bool; T0;@v;[ ;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;@v; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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 == -1) 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 == -1) rb_sys_fail_path(fptr->pathv);
}
}
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"
IO#close; F;5[ ; [[@i ;
T;:
close;0;[ ;{ ;IC;"wCloses 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 $?.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
close; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@v;[ ;I"@return [nil]; T;0;@v; F;=i ;>0;5[ ;@v;[ ;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 $?.
@overload close
@return [nil]; T;0;@v; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"|static VALUE
rb_io_close_m(VALUE io)
{
rb_io_check_closed(RFILE(io)->fptr);
rb_io_close(io);
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#closed?; F;5[ ; [[@iB;
T;: closed?;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;7
;8I"
overload; F;90;;;:0;;I" closed?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@v;[ ;I"@return [Boolean]; T;0;@v; F;=i ;>0;5[ ;@vo;<
;8I" return; F;9@f;0;:[@h;@v;[ ;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;@v; F; o; ; T; i/;!i>;"@%l;;I"static VALUE; T;AI"static 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 = RFILE(io)->fptr;
rb_io_check_initialized(fptr);
return 0 <= fptr->fd ? Qfalse : Qtrue;
}; T;BTo;1;2F;3;4;;;#I"IO#close_read; F;5[ ; [[@ih;
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
; T;[o;7
;8I"
overload; F;90;;;:0;;I"close_read; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@w;[ ;I"@return [nil]; T;0;@w; F;=i ;>0;5[ ;@w;[ ;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
@overload close_read
@return [nil]; T;0;@w; F; o; ; T; iV;!ie;"@%l;;I"static VALUE; T;AI"
static VALUE
rb_io_close_read(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
GetOpenFile(io, fptr);
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;
GetOpenFile(write_io, wfptr);
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;
fptr->mode &= ~FMODE_DUPLEX;
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_WRITABLE) {
rb_raise(rb_eIOError, "closing non-duplex IO for reading");
}
return rb_io_close(io);
}; T;BTo;1;2F;3;4;;;#I"IO#close_write; F;5[ ; [[@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
; T;[o;7
;8I"
overload; F;90;;;:0;;I"close_write; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@3w;[ ;I"@return [nil]; T;0;@3w; F;=i ;>0;5[ ;@3w;[ ;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
@overload close_write
@return [nil]; T;0;@3w; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_close_write(VALUE io)
{
rb_io_t *fptr;
VALUE write_io;
write_io = GetWriteIO(io);
GetOpenFile(write_io, fptr);
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_READABLE) {
rb_raise(rb_eIOError, "closing non-duplex IO for writing");
}
if (io != write_io) {
GetOpenFile(io, fptr);
fptr->tied_io_for_writing = 0;
fptr->mode &= ~FMODE_DUPLEX;
}
rb_io_close(write_io);
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"IO#isatty; F;5[ ; [[@ik;
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;7
;8I"
overload; F;90;;;:0;;I" isatty; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Nw;[ ;I"@return [Boolean]; T;0;@Nw; F;=i ;>0;5[ ;@Nwo;7
;8I"
overload; F;90;: tty?;:0;;I" tty?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Nw;[ ;I"@return [Boolean]; T;0;@Nw; F;=i ;>0;5[ ;@Nw;[ ;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;@Nw; F; o; ; T; i_;!ii;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_isatty(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (isatty(fptr->fd) == 0)
return Qfalse;
return Qtrue;
}; T;BTo;1;2F;3;4;;;#I" IO#tty?; F;5[ ; [[@ik;
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;7
;8I"
overload; F;90;;;:0;;I" isatty; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@vw;[ ;I"@return [Boolean]; T;0;@vw; F;=i ;>0;5[ ;@vwo;7
;8I"
overload; F;90;;;:0;;I" tty?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@vw;[ ;I"@return [Boolean]; T;0;@vw; F;=i ;>0;5[ ;@vwo;<
;8I" return; F;9@f;0;:[@h;@vw;[ ;@rw;0;@vw; F; o; ; T; i_;!ii;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_isatty(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (isatty(fptr->fd) == 0)
return Qfalse;
return Qtrue;
}; T;BTo;1;2F;3;4;;;#I"IO#binmode; F;5[ ; [[@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;7
;8I"
overload; F;90;;;:0;;I" binmode; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@w;[ ;I"@return [IO]; T;0;@w; F;=i ;>0;5[ ;@w;[ ;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;@w; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#binmode?; F;5[ ; [[@i;
T;:
binmode?;0;[ ;{ ;IC;":Returns true if ios is binmode.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
binmode?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@w;[ ;I"@return [Boolean]; T;0;@w; F;=i ;>0;5[ ;@wo;<
;8I" return; F;9@f;0;:[@h;@w;[ ;I"cReturns true if ios is binmode.
@overload binmode?
@return [Boolean]; T;0;@w; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_binmode_p(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
return fptr->mode & FMODE_BINMODE ? Qtrue : Qfalse;
}; T;BTo;1;2F;3;4;;;#I"IO#sysseek; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I")sysseek(offset, whence=IO::SEEK_SET); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@w;[ ;I"@return [Integer]; T;0;@w; F;=i ;>0;5[[I" offset; T0[I" whence; TI"IO::SEEK_SET; T;@w;[ ;I"pSeeks 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;@w; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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 == -1 && errno) rb_sys_fail_path(fptr->pathv);
return OFFT2NUM(pos);
}; T;BTo;1;2F;3;4;;;#I"IO#advise; F;5[[@0; [[@iC!;
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;7
;8I"
overload; F;90;;;:0;;I"$advise(advice, offset=0, len=0); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"nil; T;@w;[ ;I"@return [nil]; T;0;@w; F;=i ;>0;5[[I" advice; T0[I" offset; TI"0; T[I"len; TI"0; T;@w;[ ;I"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.
@overload advise(advice, offset=0, len=0)
@return [nil]; T;0;@w; F; o; ; T; i!;!iA!;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#ioctl; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I" ioctl(integer_cmd, arg); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@ x;[ ;I"@return [Integer]; T;0;@ x; F;=i ;>0;5[[I"integer_cmd; T0[I"arg; T0;@ x;[ ;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;@ x; F; o; ; T; i #;!i'#;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#fcntl; F;5[[@0; [[@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;7
;8I"
overload; F;90;;;:0;;I" fcntl(integer_cmd, arg); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@>x;[ ;I"@return [Integer]; T;0;@>x; F;=i ;>0;5[[I"integer_cmd; T0[I"arg; T0;@>x;[ ;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;@>x; F; o; ; T; i{#;!i#;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" IO#pid; F;5[ ; [[@i;
T;;K;0;[ ;{ ;IC;"XReturns 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;7
;8I"
overload; F;90;;K;:0;;I"pid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@^x;[ ;I"@return [Fixnum]; T;0;@^x; F;=i ;>0;5[ ;@^x;[ ;I"{Returns 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 [Fixnum]; T;0;@^x; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
rb_io_pid(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (!fptr->pid)
return Qnil;
return PIDT2NUM(fptr->pid);
}; T;BTo;1;2F;3;4;;;#I"IO#inspect; F;5[ ; [[@i;
T;;?;0;[ ;{ ;IC;"/Return a string describing this IO object.
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@yx;[ ;I"@return [String]; T;0;@yx; F;=i ;>0;5[ ;@yx;[ ;I"VReturn a string describing this IO object.
@overload inspect
@return [String]; T;0;@yx; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#external_encoding; F;5[ ; [[@i);
T;:external_encoding;0;[ ;{ ;IC;"Returns the Encoding object that represents the encoding of the file.
If io is write mode and no encoding is specified, returns nil.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"external_encoding; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@x;[ ;I"@return [Encoding]; T;0;@x; F;=i ;>0;5[ ;@x;[ ;I"Returns the Encoding object that represents the encoding of the file.
If io is write mode and no encoding is specified, returns nil.
@overload external_encoding
@return [Encoding]; T;0;@x; F; o; ; T; i );!i);"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#internal_encoding; F;5[ ; [[@i,);
T;:internal_encoding;0;[ ;{ ;IC;"dReturns the Encoding of the internal string if conversion is
specified. Otherwise returns nil.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"internal_encoding; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Encoding; T;@x;[ ;I"@return [Encoding]; T;0;@x; F;=i ;>0;5[ ;@x;[ ;I"Returns the Encoding of the internal string if conversion is
specified. Otherwise returns nil.
@overload internal_encoding
@return [Encoding]; T;0;@x; F; o; ; T; i$);!i));"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#set_encoding; F;5[[@0; [[@iI);
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;7
;8I"
overload; F;90;;;:0;;I"set_encoding(ext_enc); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@x;[ ;I"@return [IO]; T;0;@x; F;=i ;>0;5[[I" ext_enc; T0;@xo;7
;8I"
overload; F;90;;;:0;;I"$set_encoding("ext_enc:int_enc"); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@x;[ ;I"@return [IO]; T;0;@x; F;=i ;>0;5[[""ext_enc:"
int_enc";@xo;7
;8I"
overload; F;90;;;:0;;I"#set_encoding(ext_enc, int_enc); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@x;[ ;I"@return [IO]; T;0;@x; F;=i ;>0;5[[I" ext_enc; T0[I" int_enc; T0;@xo;7
;8I"
overload; F;90;;;:0;;I")set_encoding("ext_enc:int_enc", opt); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@x;[ ;I"@return [IO]; T;0;@x; F;=i ;>0;5[[""ext_enc:"
int_enc"[I"opt; T0;@xo;7
;8I"
overload; F;90;;;:0;;I"(set_encoding(ext_enc, int_enc, opt); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"IO; T;@x;[ ;I"@return [IO]; T;0;@x; F;=i ;>0;5[[I" ext_enc; T0[I" int_enc; T0[I"opt; T0;@x;[ ;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;@x; F; o; ; T; i6);!iJ);"@%l;;I"static VALUE; T;AI"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_funcall2(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;BTo;1;2F;3;4;;;#I"IO#autoclose?; F;5[ ; [[@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;7
;8I"
overload; F;90;;;:0;;I"autoclose?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@.y;[ ;I"@return [Boolean]; T;0;@.y; F;=i ;>0;5[ ;@.yo;<
;8I" return; F;9@f;0;:[@h;@.y;[ ;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;@.y; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#autoclose=; F;5[[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 IOError
f = open("/dev/null")
IO.for_fd(f.fileno).autoclose = true
# ...
f.gets # won't cause IOError
; T;[o;7
;8I"
overload; F;90;;;:0;;I"autoclose=(bool); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@Ly;[ ;I"@return [Boolean]; T;0;@Ly; F;=i ;>0;5[[I" bool; T0;@Ly;[ ;I" Sets auto-close flag.
f = open("/dev/null")
IO.for_fd(f.fileno)
# ...
f.gets # may cause IOError
f = open("/dev/null")
IO.for_fd(f.fileno).autoclose = true
# ...
f.gets # won't cause IOError
@overload autoclose=(bool)
@return [Boolean]; T;0;@Ly; F; o; ; T; i ;!i ;"@%l;;I"static VALUE; T;AI"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 io;
}; T;BTo;1;2F;3;q;;;#I"IO.old_thread_select; F;5[ [I"r; T0[I"w; T0[I"e; T0[I" timeout; T0; [[I"5ext/-test-/old_thread_select/old_thread_select.c; Ti-;
T;:old_thread_select;0;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@ky;"@%l;;I"static VALUE; T;AI"static VALUE
old_thread_select(VALUE klass, VALUE r, VALUE w, VALUE e, VALUE timeout)
{
struct timeval tv;
struct timeval *tvp = NULL;
fd_set rfds, wfds, efds;
fd_set *rp, *wp, *ep;
int rc;
int max = 0;
if (!NIL_P(timeout)) {
tv = rb_time_timeval(timeout);
tvp = &tv;
}
rp = array2fdset(&rfds, r, &max);
wp = array2fdset(&wfds, w, &max);
ep = array2fdset(&efds, e, &max);
rc = rb_thread_select(max, rp, wp, ep, tvp);
if (rc == -1)
rb_sys_fail("rb_wait_for_single_fd");
if (rp)
fdset2array(r, &rfds, max);
if (wp)
fdset2array(w, &wfds, max);
if (ep)
fdset2array(e, &efds, max);
return INT2NUM(rc);
}; T;BTo;1;2F;3;4;;;#I" IO#raw; F;5[[@0; [[I" ext/io/console/console.c; TiG;
T;:raw;0;[ ;{ ;IC;"Yields +self+ within raw mode.
STDIN.raw(&:gets)
will read and return a line without echo back and line editing.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" raw(min: nil, time: nil); T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"io; T;@y;[ ;I"@yield [io]; T;0;@y; F;=i ;>0;5[[I" min:; TI"nil; T[I"
time:; TI"nil; T;@y;[ ;I"Yields +self+ within raw mode.
STDIN.raw(&:gets)
will read and return a line without echo back and line editing.
You must require 'io/console' to use this method.
@overload raw(min: nil, time: nil)
@yield [io]; T;0;@y; F; o; ; T; i;;!iE;"@%l;;I"static VALUE; T;AI"static VALUE
console_raw(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(argc, argv, &opts);
return ttymode(io, rb_yield, set_rawmode, optp);
}; T;BTo;1;2F;3;4;;;#I" IO#raw!; F;5[[@0; [[@yiX;
T;: raw!;0;[ ;{ ;IC;"Enables raw mode.
If the terminal mode needs to be back, use io.raw { ... }.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" raw!(min: nil, time: nil); T;IC;" ; T;[ ;[ ;I" ; T;0;@y; F;=i ;>0;5[[I" min:; TI"nil; T[I"
time:; TI"nil; T;@y;[ ;I"Enables raw mode.
If the terminal mode needs to be back, use io.raw { ... }.
You must require 'io/console' to use this method.
@overload raw!(min: nil, time: nil); T;0;@y; F; o; ; T; iN;!iU;"@%l;;I"static VALUE; T;AI"cstatic 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, &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;BTo;1;2F;3;4;;;#I"IO#cooked; F;5[ ; [[@yit;
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;7
;8I"
overload; F;90;;;:0;;I" cooked; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"io; T;@y;[ ;I"@yield [io]; T;0;@y; F;=i ;>0;5[ ;@y;[ ;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;@y; F; o; ; T; ih;!ir;"@%l;;I"static VALUE; T;AI"fstatic VALUE
console_cooked(VALUE io)
{
return ttymode(io, rb_yield, set_cookedmode, NULL);
}; T;BTo;1;2F;3;4;;;#I"IO#cooked!; F;5[ ; [[@yi;
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;7
;8I"
overload; F;90;;;:0;;I" cooked!; T;IC;" ; T;[ ;[ ;I" ; T;0;@y; F;=i ;>0;5[ ;@y;[ ;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;@y; F; o; ; T; iz;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#getch; F;5[[@0; [[@yi;
T;:
getch;0;[ ;{ ;IC;"bReads and returns a character in raw mode.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" getch(min: nil, time: nil); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@y;[ ;I"@return [String]; T;0;@y; F;=i ;>0;5[[I" min:; TI"nil; T[I"
time:; TI"nil; T;@y;[ ;I"Reads and returns a character in raw mode.
You must require 'io/console' to use this method.
@overload getch(min: nil, time: nil)
@return [String]; T;0;@y; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"static VALUE
console_getch(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(argc, argv, &opts);
return ttymode(io, getc_call, set_rawmode, optp);
}; T;BTo;1;2F;3;4;;;#I"
IO#echo=; F;5[[I"f; T0; [[@yi;
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;7
;8I"
overload; F;90;;;:0;;I"echo=(flag); T;IC;" ; T;[ ;[ ;I" ; T;0;@z; F;=i ;>0;5[[I" flag; T0;@z;[ ;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;@z; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"
IO#echo?; F;5[ ; [[@yi;
T;:
echo?;0;[ ;{ ;IC;"_Returns +true+ if echo back is enabled.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;; ;:0;;I"
echo?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@-z;[ ;I"@return [Boolean]; T;0;@-z; F;=i ;>0;5[ ;@-zo;<
;8I" return; F;9@f;0;:[@h;@-z;[ ;I"Returns +true+ if echo back is enabled.
You must require 'io/console' to use this method.
@overload echo?
@return [Boolean]; T;0;@-z; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#noecho; F;5[ ; [[@yi;
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;7
;8I"
overload; F;90;;;:0;;I" noecho; T;IC;" ; T;[o;<
;8I"
yield; F;9I" ; T;0;:[I"io; T;@Kz;[ ;I"@yield [io]; T;0;@Kz; F;=i ;>0;5[ ;@Kz;[ ;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;@Kz; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"bstatic VALUE
console_noecho(VALUE io)
{
return ttymode(io, rb_yield, set_noecho, NULL);
}; T;BTo;1;2F;3;4;;;#I"IO#winsize; F;5[ ; [[@yi;
T;: winsize;0;[ ;{ ;IC;"MReturns console size.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" winsize; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@fz;[ ;I"@return [Array]; T;0;@fz; F;=i ;>0;5[ ;@fz;[ ;I"sReturns console size.
You must require 'io/console' to use this method.
@overload winsize
@return [Array]; T;0;@fz; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#winsize=; F;5[[I" size; T0; [[@yi ;
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;@z; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;
#endif
VALUE row, col, xpixel, ypixel;
#if defined TIOCSWINSZ
int fd;
#endif
GetOpenFile(io, fptr);
size = rb_Array(size);
rb_scan_args((int)RARRAY_LEN(size), RARRAY_PTR(size), "22",
&row, &col, &xpixel, &ypixel);
#if defined TIOCSWINSZ
fd = GetWriteFD(fptr);
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(GetReadFD(fptr));
newrow = (SHORT)NUM2UINT(row);
newcol = (SHORT)NUM2UINT(col);
if (!getwinsize(GetReadFD(fptr), &ws)) {
rb_sys_fail("GetConsoleScreenBufferInfo");
}
if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) ||
(ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) {
if (!(SetConsoleScreenBufferSize(wh, ws.dwSize) || SET_LAST_ERROR)) {
rb_sys_fail("SetConsoleScreenBufferInfo");
}
}
ws.srWindow.Left = 0;
ws.srWindow.Top = 0;
ws.srWindow.Right = newcol;
ws.srWindow.Bottom = newrow;
if (!(SetConsoleWindowInfo(wh, FALSE, &ws.srWindow) || SET_LAST_ERROR)) {
rb_sys_fail("SetConsoleWindowInfo");
}
#endif
return io;
}; T;BTo;1;2F;3;4;;;#I"IO#iflush; F;5[ ; [[@yiZ;
T;: iflush;0;[ ;{ ;IC;"WFlushes input buffer in kernel.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" iflush; T;IC;" ; T;[ ;[ ;I" ; T;0;@z; F;=i ;>0;5[ ;@z;[ ;I"jFlushes input buffer in kernel.
You must require 'io/console' to use this method.
@overload iflush; T;0;@z; F; o; ; T; iR;!iW;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#oflush; F;5[ ; [[@yiq;
T;: oflush;0;[ ;{ ;IC;"XFlushes output buffer in kernel.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" oflush; T;IC;" ; T;[ ;[ ;I" ; T;0;@z; F;=i ;>0;5[ ;@z;[ ;I"kFlushes output buffer in kernel.
You must require 'io/console' to use this method.
@overload oflush; T;0;@z; F; o; ; T; ii;!in;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"IO#ioflush; F;5[ ; [[@yi;
T;: ioflush;0;[ ;{ ;IC;"cFlushes input and output buffers in kernel.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" ioflush; T;IC;" ; T;[ ;[ ;I" ; T;0;@z; F;=i ;>0;5[ ;@z;[ ;I"wFlushes input and output buffers in kernel.
You must require 'io/console' to use this method.
@overload ioflush; T;0;@z; F; o; ; T; i;!i;"@%l;;I"static VALUE; T;AI"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;BTo;1;2F;3;q;;;#I"IO.console; F;5[ ; [[@yi;
T;: console;0;[ ;{ ;IC;"`Returns an File instance opened console.
You must require 'io/console' to use this method.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" console; T;IC;" ; T;[o;<
;8I" return; F;9I"]; T;0;:[I"#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;7
;8I"
overload; F;90;;;:0;;I" stat; T;IC;" ; T;[ ;[ ;I" ; T;0;@}; F;=i ;>0;5[ ;@};[ ;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; i;!i;"@%l;;I"static VALUE; T;AI"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;BT;l@%l;mIC;[ ;l@%l;nIC;[o; ;0;0;0;;;"@;@D;0o;;IC;[o;
; [[@ ij;
F;: RDONLY;;;;;[ ;{ ;IC;"open for reading only
; T;[ ;[ ;I"open for reading only; T;0;@}; F; o; ; T; ii;!ii;"@};#I" File::Constants::RDONLY; F;$I"INT2FIX(O_RDONLY); To;
; [[@ il;
F;: WRONLY;;;;;[ ;{ ;IC;"open for writing only
; T;[ ;[ ;I"open for writing only; T;0;@}; F; o; ; T; ik;!ik;"@};#I" File::Constants::WRONLY; F;$I"INT2FIX(O_WRONLY); To;
; [[@ in;
F;: RDWR;;;;;[ ;{ ;IC;"!open for reading and writing
; T;[ ;[ ;I"!open for reading and writing; T;0;@~; F; o; ; T; im;!im;"@};#I"File::Constants::RDWR; F;$I"INT2FIX(O_RDWR); To;
; [[@ ip;
F;: APPEND;;;;;[ ;{ ;IC;"append on each write
; T;[ ;[ ;I"append on each write; T;0;@
~; F; o; ; T; io;!io;"@};#I" File::Constants::APPEND; F;$I"INT2FIX(O_APPEND); To;
; [[@ ir;
F;:
CREAT;;;;;[ ;{ ;IC;"%create file if it does not exist
; T;[ ;[ ;I"%create file if it does not exist; T;0;@~; F; o; ; T; iq;!iq;"@};#I"File::Constants::CREAT; F;$I"INT2FIX(O_CREAT); To;
; [[@ it;
F;: EXCL;;;;;[ ;{ ;IC;"'error if CREAT and the file exists
; T;[ ;[ ;I"'error if CREAT and the file exists; T;0;@%~; F; o; ; T; is;!is;"@};#I"File::Constants::EXCL; F;$I"INT2FIX(O_EXCL); To;
; [[@ iz;
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;@1~; F; o; ; T; iy;!iy;"@};#I" File::Constants::NONBLOCK; F;$I"INT2FIX(O_NONBLOCK); To;
; [[@ i};
F;:
TRUNC;;;;;[ ;{ ;IC;"truncate size to 0
; T;[ ;[ ;I"truncate size to 0; T;0;@=~; F; o; ; T; i|;!i|;"@};#I"File::Constants::TRUNC; F;$I"INT2FIX(O_TRUNC); To;
; [[@ i;
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;@I~; F; o; ; T; i;!i;"@};#I" File::Constants::NOCTTY; F;$I"INT2FIX(O_NOCTTY); To;
; [[@ i;
F;: BINARY;;;;;[ ;{ ;IC;"!disable line code conversion
; T;[ ;[ ;I"!disable line code conversion; T;0;@U~; F; o; ; T; i;!i;"@};#I" File::Constants::BINARY; F;$I"INT2FIX(O_BINARY); To;
; [[@ i;
F;: SYNC;;;;;[ ;{ ;IC;".any write operation perform synchronously
; T;[ ;[ ;I".any write operation perform synchronously; T;0;@a~; F; o; ; T; i;!i;"@};#I"File::Constants::SYNC; F;$I"INT2FIX(O_SYNC); To;
; [[@ i;
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;@m~; F; o; ; T; i;!i;"@};#I"File::Constants::DSYNC; F;$I"INT2FIX(O_DSYNC); To;
; [[@ i;
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;@y~; F; o; ; T; i;!i;"@};#I"File::Constants::RSYNC; F;$I"INT2FIX(O_RSYNC); To;
; [[@ i;
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;
; [[@ i;
F;: NOATIME;;;;;[ ;{ ;IC;"
Linux
; T;[ ;[ ;I"
Linux; T;0;@~; F; o; ; T; i;!i;"@};#I" File::Constants::NOATIME; F;$I"INT2FIX(O_NOATIME); To;
; [[@ i;
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;
; [[@ i;
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;
; [[@ i;
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;
; [[@ i;
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;
; [[@ i;
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;
; [[@ i;
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"4rb_obj_freeze(rb_usascii_str_new2(null_device)); T;l@};mIC;[ ;l@};nIC;[ ;l@};oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ iY[@ if;
T;:Constants;;@;;;[ ;{ ;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; iY;!ic;"o; ;IC;[7o;1;2F;3;q;;;#I"File.open; F;5[[@0; [[@i;
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;[ ;[ ;@l;0;@~; F; o; ; T; i;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_io_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE io = rb_class_new_instance(argc, argv, klass);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, io, io_close, io);
}
return io;
}; T;BTo;1;2F;3;4;;;#I"File#initialize; F;5[[@0; [[@iV ;
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.
=== Examples
f = File.new("testfile", "r")
f = File.new("newfile", "w+")
f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
; T;[o;7
;8I"
overload; F;90;;M;:0;;I"$new(filename, mode="r" [, opt]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" File; T;@;[ ;I"@return [File]; T;0;@; F;=i ;>0;5[[I"
filename; T0[I" mode; TI""r"[, opt]; T;@o;7
;8I"
overload; F;90;;M;:0;;I",new(filename [, mode [, perm]] [, opt]); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" File; T;@;[ ;I"@return [File]; T;0;@; F;=i ;>0;5[[I"%filename[, mode [, perm]][, opt]; T0;@;[ ;I"dOpens 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.
=== 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;@; F; o; ; T; iA ;!iT ;"@~;;I"static VALUE; T;AI"static 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_convert_type(argv[0], T_FIXNUM, "Fixnum", "to_int");
if (!NIL_P(fd)) {
argv[0] = fd;
return rb_io_initialize(argc, argv, io);
}
}
rb_open_file(argc, argv, io);
return io;
}; T;BTo;1;2F;3;q;;;#I"File.fnmatch; F;5[[@0; [[I"
dir.c; Ti*;
T;: fnmatch;0;[ ;{ ;IC;"GReturns 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('?', '/', 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;7
;8I"
overload; F;90;;(;:0;;I"&fnmatch( pattern, path, [flags] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@6;[ ;I"@return [Boolean]; T;0;@6; F;=i ;>0;5[[I" pattern; T0[I" path; T0[I" [flags]; T0;@6o;7
;8I"
overload; F;90;:
fnmatch?;:0;;I"'fnmatch?( pattern, path, [flags] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@6;[ ;I"@return [Boolean]; T;0;@6; F;=i ;>0;5[[I" pattern; T0[I" path; T0[I" [flags]; T0;@6;[ ;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('?', '/', 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;@6; F; o; ; T; i;!i);"@~;;I"static VALUE; T;AI"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;
StringValue(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)) > 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;BTo;1;2F;3;q;;;#I"File.fnmatch?; F;5[[@0; [[@<i*;
T;;);0;[ ;{ ;IC;"GReturns 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('?', '/', 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;7
;8I"
overload; F;90;;(;:0;;I"&fnmatch( pattern, path, [flags] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@l;[ ;I"@return [Boolean]; T;0;@l; F;=i ;>0;5[[I" pattern; T0[I" path; T0[I" [flags]; T0;@lo;7
;8I"
overload; F;90;;);:0;;I"'fnmatch?( pattern, path, [flags] ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@l;[ ;I"@return [Boolean]; T;0;@l; F;=i ;>0;5[[I" pattern; T0[I" path; T0[I" [flags]; T0;@lo;<
;8I" return; F;9@f;0;:[@h;@l;[ ;@h;0;@l; F; o; ; T; i;!i);"@~;;I"static VALUE; T;AI"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;
StringValue(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)) > 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;BTo; ;IC;[1o;1;2F;3;4;;;#I"File::Stat#initialize; T;5[[I"
fname; T0; [[@ i;;
T;; ;0;[ ;{ ;IC;"iCreate a File::Stat object for the given file name (raising an
exception if the file doesn't exist).
; T;[o;7
;8I"
overload; F;90;:File::Stat.new;:0;;I" File::Stat.new(file_name); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[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; i2;!i6;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_init(VALUE obj, VALUE fname)
{
struct stat st, *nst;
rb_secure(2);
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;BTo;1;2F;3;4;;;#I" File::Stat#initialize_copy; T;5[[I" orig; T0; [[@ iR;
T;;x;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@; F; o; ; T; iQ;!iQ;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File::Stat#<=>; T;5[[I"
other; T0; [[@ i;
T;;Q;0;[ ;{ ;IC;"Compares File::Stat objects by comparing their respective modification
times.
+nil+ is returned if the two values are incomparable.
f1 = File.new("f1", "w")
sleep 1
f2 = File.new("f2", "w")
f1.stat <=> f2.stat #=> -1
; T;[o;7
;8I"
overload; F;90;;Q;:0;;I"<=>(other_stat); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[ I"-1; TI"0; TI"1; TI"nil; T;@;[ ;I" @return [-1, 0, 1, nil]; T;0;@; F;=i ;>0;5[[I"other_stat; T0;@;[ ;I" Compares File::Stat objects by comparing their respective modification
times.
+nil+ is returned if the two values are incomparable.
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;!i;"@;;I"static VALUE; T;AI"$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;BTo;1;2F;3;4;;;#I"File::Stat#dev; T;5[ ; [[@ i;
T;:dev;0;[ ;{ ;IC;"uReturns an integer representing the device on which stat
resides.
File.stat("testfile").dev #=> 774
; T;[o;7
;8I"
overload; F;90;;+;:0;;I"dev; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns an integer representing the device on which stat
resides.
File.stat("testfile").dev #=> 774
@overload dev
@return [Fixnum]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"Zstatic VALUE
rb_stat_dev(VALUE self)
{
return DEVT2NUM(get_stat(self)->st_dev);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#dev_major; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;,;:0;;I"dev_major; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@ ;[ ;I"@return [Fixnum]; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;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 [Fixnum]; T;0;@ ; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_dev_major(VALUE self)
{
#if defined(major)
return INT2NUM(major(get_stat(self)->st_dev));
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#dev_minor; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;-;:0;;I"dev_minor; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@';[ ;I"@return [Fixnum]; T;0;@'; F;=i ;>0;5[ ;@';[ ;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 [Fixnum]; T;0;@'; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_dev_minor(VALUE self)
{
#if defined(minor)
return INT2NUM(minor(get_stat(self)->st_dev));
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#ino; T;5[ ; [[@ i;
T;:ino;0;[ ;{ ;IC;"ZReturns the inode number for stat.
File.stat("testfile").ino #=> 1083669
; T;[o;7
;8I"
overload; F;90;;.;:0;;I"ino; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@B;[ ;I"@return [Fixnum]; T;0;@B; F;=i ;>0;5[ ;@B;[ ;I"~Returns the inode number for stat.
File.stat("testfile").ino #=> 1083669
@overload ino
@return [Fixnum]; T;0;@B; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_ino(VALUE self)
{
#if SIZEOF_STRUCT_STAT_ST_INO > SIZEOF_LONG
return ULL2NUM(get_stat(self)->st_ino);
#else
return ULONG2NUM(get_stat(self)->st_ino);
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#mode; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;/;:0;;I" mode; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@];[ ;I"@return [Fixnum]; T;0;@]; F;=i ;>0;5[ ;@];[ ;I"6Returns 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 [Fixnum]; T;0;@]; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"estatic VALUE
rb_stat_mode(VALUE self)
{
return UINT2NUM(ST2UINT(get_stat(self)->st_mode));
}; T;BTo;1;2F;3;4;;;#I"File::Stat#nlink; T;5[ ; [[@ i';
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;7
;8I"
overload; F;90;;0;:0;;I"
nlink; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@x;[ ;I"@return [Fixnum]; T;0;@x; F;=i ;>0;5[ ;@x;[ ;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 [Fixnum]; T;0;@x; F; o; ; T; i;!i$;"@;;I"static VALUE; T;AI"^static VALUE
rb_stat_nlink(VALUE self)
{
return UINT2NUM(get_stat(self)->st_nlink);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#uid; T;5[ ; [[@ i7;
T;;;0;[ ;{ ;IC;"eReturns the numeric user id of the owner of stat.
File.stat("testfile").uid #=> 501
; T;[o;7
;8I"
overload; F;90;;;:0;;I"uid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the numeric user id of the owner of stat.
File.stat("testfile").uid #=> 501
@overload uid
@return [Fixnum]; T;0;@; F; o; ; T; i-;!i4;"@;;I"static VALUE; T;AI"Zstatic VALUE
rb_stat_uid(VALUE self)
{
return UIDT2NUM(get_stat(self)->st_uid);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#gid; T;5[ ; [[@ iG;
T;;;0;[ ;{ ;IC;"fReturns the numeric group id of the owner of stat.
File.stat("testfile").gid #=> 500
; T;[o;7
;8I"
overload; F;90;;;:0;;I"gid; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the numeric group id of the owner of stat.
File.stat("testfile").gid #=> 500
@overload gid
@return [Fixnum]; T;0;@; F; o; ; T; i=;!iD;"@;;I"static VALUE; T;AI"Zstatic VALUE
rb_stat_gid(VALUE self)
{
return GIDT2NUM(get_stat(self)->st_gid);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#rdev; T;5[ ; [[@ iY;
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;7
;8I"
overload; F;90;;1;:0;;I" rdev; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@ɀ;[ ;I"@return [Fixnum, nil]; T;0;@ɀ; F;=i ;>0;5[ ;@ɀ;[ ;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 [Fixnum, nil]; T;0;@ɀ; F; o; ; T; iM;!iV;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File::Stat#rdev_major; T;5[ ; [[@ in;
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;7
;8I"
overload; F;90;;2;:0;;I"rdev_major; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[ ;@;[ ;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 [Fixnum]; T;0;@; F; o; ; T; ic;!ik;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_rdev_major(VALUE self)
{
#if defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(major)
return DEVT2NUM(major(get_stat(self)->st_rdev));
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#rdev_minor; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;3;:0;;I"rdev_minor; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@ ;[ ;I"@return [Fixnum]; T;0;@ ; F;=i ;>0;5[ ;@ ;[ ;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 [Fixnum]; T;0;@ ; F; o; ; T; ix;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_rdev_minor(VALUE self)
{
#if defined(HAVE_STRUCT_STAT_ST_RDEV) && defined(minor)
return DEVT2NUM(minor(get_stat(self)->st_rdev));
#else
return Qnil;
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#size; T;5[ ; [[@ i;
T;;G;0;[ ;{ ;IC;"VReturns the size of stat in bytes.
File.stat("testfile").size #=> 66
; T;[o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; T;@;[ ;I"@return [Fixnum]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"zReturns the size of stat in bytes.
File.stat("testfile").size #=> 66
@overload size
@return [Fixnum]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"\static VALUE
rb_stat_size(VALUE self)
{
return OFFT2NUM(get_stat(self)->st_size);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#blksize; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;4;:0;;I" blksize; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; TI"nil; T;@6;[ ;I"@return [Integer, nil]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;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;@6; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File::Stat#blocks; T;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;5;:0;;I" blocks; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; TI"nil; T;@R;[ ;I"@return [Integer, nil]; T;0;@R; F;=i ;>0;5[ ;@R;[ ;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;@R; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"
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;BTo;1;2F;3;4;;;#I"File::Stat#atime; T;5[ ; [[@ i ;
T;:
atime;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;7
;8I"
overload; F;90;;6;:0;;I"
atime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@n;[ ;I"@return [Time]; T;0;@n; F;=i ;>0;5[ ;@n;[ ;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;@n; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"Vstatic VALUE
rb_stat_atime(VALUE self)
{
return stat_atime(get_stat(self));
}; T;BTo;1;2F;3;4;;;#I"File::Stat#mtime; T;5[ ; [[@ i-;
T;:
mtime;0;[ ;{ ;IC;"uReturns the modification time of stat.
File.stat("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
; T;[o;7
;8I"
overload; F;90;;7;:0;;I"
mtime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
aTime; T;@;[ ;I"@return [ aTime]; T;0;@; F;=i ;>0;5[ ;@;[ ;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"static VALUE; T;AI"Vstatic VALUE
rb_stat_mtime(VALUE self)
{
return stat_mtime(get_stat(self));
}; T;BTo;1;2F;3;4;;;#I"File::Stat#ctime; T;5[ ; [[@ iA;
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;7
;8I"
overload; F;90;;";:0;;I"
ctime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
aTime; T;@;[ ;I"@return [ aTime]; T;0;@; F;=i ;>0;5[ ;@;[ ;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; i3;!i>;"@;;I"static VALUE; T;AI"Vstatic VALUE
rb_stat_ctime(VALUE self)
{
return stat_ctime(get_stat(self));
}; T;BTo;1;2F;3;4;;;#I"File::Stat#inspect; T;5[ ; [[@ iU;
T;;?;0;[ ;{ ;IC;"tProduce 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;7
;8I"
overload; F;90;;8;:0;;I"
ftype; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ځ;[ ;I"@return [String]; T;0;@ځ; F;=i ;>0;5[ ;@ځ;[ ;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; ie;!ip;"@;;I"static VALUE; T;AI"Wstatic VALUE
rb_stat_ftype(VALUE obj)
{
return rb_file_ftype(get_stat(obj));
}; T;BTo;1;2F;3;4;;;#I"File::Stat#directory?; T;5[ ; [[@ i;
T;:directory?;0;[ ;{ ;IC;"Returns true if stat is a directory,
false otherwise.
File.stat("testfile").directory? #=> false
File.stat(".").directory? #=> true
; T;[o;7
;8I"
overload; F;90;;9;:0;;I"directory?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;@; F; o; ; T; iy;!i;"@;;I"static VALUE; T;AI"tstatic VALUE
rb_stat_d(VALUE obj)
{
if (S_ISDIR(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#readable?; T;5[ ; [[@ i2;
T;:readable?;0;[ ;{ ;IC;"Returns true if stat is readable by the
effective user id of this process.
File.stat("testfile").readable? #=> true
; T;[o;7
;8I"
overload; F;90;;:;:0;;I"readable?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;@; F; o; ; T; i';!i/;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" File::Stat#readable_real?; T;5[ ; [[@ iS;
T;:readable_real?;0;[ ;{ ;IC;"Returns true if stat is readable by the real
user id of this process.
File.stat("testfile").readable_real? #=> true
; T;[o;7
;8I"
overload; F;90;;;;:0;;I"readable_real?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@1;[ ;I"@return [Boolean]; T;0;@1; F;=i ;>0;5[ ;@1o;<
;8I" return; F;9@f;0;:[@h;@1;[ ;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;@1; F; o; ; T; iH;!iP;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" File::Stat#world_readable?; T;5[ ; [[@ iv;
T;:world_readable?;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;7
;8I"
overload; F;90;;<;:0;;I"world_readable?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@O;[ ;I"@return [Fixnum, nil]; T;0;@O; F;=i ;>0;5[ ;@Oo;<
;8I" return; F;9@f;0;:[@h;@O;[ ;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 [Fixnum, nil]; T;0;@O; F; o; ; T; ii;!is;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_wr(VALUE obj)
{
#ifdef S_IROTH
if ((get_stat(obj)->st_mode & (S_IROTH)) == S_IROTH) {
return UINT2NUM(get_stat(obj)->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
else {
return Qnil;
}
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#writable?; T;5[ ; [[@ i;
T;:writable?;0;[ ;{ ;IC;"Returns true if stat is writable by the
effective user id of this process.
File.stat("testfile").writable? #=> true
; T;[o;7
;8I"
overload; F;90;;=;:0;;I"writable?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@n;[ ;I"@return [Boolean]; T;0;@n; F;=i ;>0;5[ ;@no;<
;8I" return; F;9@f;0;:[@h;@n;[ ;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;@n; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" File::Stat#writable_real?; T;5[ ; [[@ i;
T;:writable_real?;0;[ ;{ ;IC;"Returns true if stat is writable by the real
user id of this process.
File.stat("testfile").writable_real? #=> true
; T;[o;7
;8I"
overload; F;90;;>;:0;;I"writable_real?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" File::Stat#world_writable?; T;5[ ; [[@ i;
T;:world_writable?;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;7
;8I"
overload; F;90;;?;:0;;I"world_writable?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Fixnum; TI"nil; T;@;[ ;I"@return [Fixnum, nil]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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 [Fixnum, nil]; T;0;@; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_ww(VALUE obj)
{
#ifdef S_IROTH
if ((get_stat(obj)->st_mode & (S_IWOTH)) == S_IWOTH) {
return UINT2NUM(get_stat(obj)->st_mode & (S_IRUGO|S_IWUGO|S_IXUGO));
}
else {
return Qnil;
}
#endif
}; T;BTo;1;2F;3;4;;;#I"File::Stat#executable?; T;5[ ; [[@ i;
T;:executable?;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;7
;8I"
overload; F;90;;@;:0;;I"executable?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@ɂ;[ ;I"@return [Boolean]; T;0;@ɂ; F;=i ;>0;5[ ;@ɂo;<
;8I" return; F;9@f;0;:[@h;@ɂ;[ ;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;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I" File::Stat#executable_real?; T;5[ ; [[@ i ;
T;:executable_real?;0;[ ;{ ;IC;"USame as executable?, but tests using the real owner of
the process.
; T;[o;7
;8I"
overload; F;90;;A;:0;;I"executable_real?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I"Same as executable?, but tests using the real owner of
the process.
@overload executable_real?
@return [Boolean]; T;0;@; F; o; ; T; i;!i ;"@;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File::Stat#file?; T;5[ ; [[@ i/;
T;:
file?;0;[ ;{ ;IC;"Returns true if stat is a regular file (not
a device file, pipe, socket, etc.).
File.stat("testfile").file? #=> true
; T;[o;7
;8I"
overload; F;90;;B;:0;;I"
file?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;@; F; o; ; T; i$;!i,;"@;;I"static VALUE; T;AI"tstatic VALUE
rb_stat_f(VALUE obj)
{
if (S_ISREG(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#zero?; T;5[ ; [[@ iA;
T;;[;0;[ ;{ ;IC;"Returns true if stat is a zero-length file;
false otherwise.
File.stat("testfile").zero? #=> false
; T;[o;7
;8I"
overload; F;90;;[;:0;;I"
zero?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@#;[ ;I"@return [Boolean]; T;0;@#; F;=i ;>0;5[ ;@#o;<
;8I" return; F;9@f;0;:[@h;@#;[ ;I"Returns true if stat is a zero-length file;
false otherwise.
File.stat("testfile").zero? #=> false
@overload zero?
@return [Boolean]; T;0;@#; F; o; ; T; i6;!i>;"@;;I"static VALUE; T;AI"pstatic VALUE
rb_stat_z(VALUE obj)
{
if (get_stat(obj)->st_size == 0) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#size?; T;5[ ; [[@ iR;
T;:
size?;0;[ ;{ ;IC;"VReturns the size of stat in bytes.
File.stat("testfile").size #=> 66
; T;[o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@A;[ ;I"@return [Integer]; T;0;@A; F;=i ;>0;5[ ;@Ao;<
;8I" return; F;9@f;0;:[@h;@A;[ ;I"|Returns the size of stat in bytes.
File.stat("testfile").size #=> 66
@overload size
@return [Integer]; T;0;@A; F; o; ; T; iH;!iO;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_s(VALUE obj)
{
off_t size = get_stat(obj)->st_size;
if (size == 0) return Qnil;
return OFFT2NUM(size);
}; T;BTo;1;2F;3;4;;;#I"File::Stat#owned?; T;5[ ; [[@ i;
T;: owned?;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;7
;8I"
overload; F;90;;D;:0;;I" owned?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@_;[ ;I"@return [Boolean]; T;0;@_; F;=i ;>0;5[ ;@_o;<
;8I" return; F;9@f;0;:[@h;@_;[ ;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;"@;;I"static VALUE; T;AI"{static VALUE
rb_stat_owned(VALUE obj)
{
if (get_stat(obj)->st_uid == geteuid()) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#grpowned?; T;5[ ; [[@ i ;
T;:grpowned?;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;7
;8I"
overload; F;90;;E;:0;;I"grpowned?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@};[ ;I"@return [Boolean]; T;0;@}; F;=i ;>0;5[ ;@}o;<
;8I" return; F;9@f;0;:[@h;@};[ ;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;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_grpowned(VALUE obj)
{
#ifndef _WIN32
if (rb_group_member(get_stat(obj)->st_gid)) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#pipe?; T;5[ ; [[@ i;
T;:
pipe?;0;[ ;{ ;IC;"~Returns true if the operating system supports pipes and
stat is a pipe; false otherwise.
; T;[o;7
;8I"
overload; F;90;;F;:0;;I"
pipe?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_p(VALUE obj)
{
#ifdef S_IFIFO
if (S_ISFIFO(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#symlink?; T;5[ ; [[@ i;
T;:
symlink?;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;7
;8I"
overload; F;90;;G;:0;;I"
symlink?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_l(VALUE obj)
{
#ifdef S_ISLNK
if (S_ISLNK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#socket?; T;5[ ; [[@ i;
T;: socket?;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;7
;8I"
overload; F;90;;H;:0;;I" socket?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@׃;[ ;I"@return [Boolean]; T;0;@׃; F;=i ;>0;5[ ;@׃o;<
;8I" return; F;9@f;0;:[@h;@׃;[ ;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;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_S(VALUE obj)
{
#ifdef S_ISSOCK
if (S_ISSOCK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#blockdev?; T;5[ ; [[@ i;
T;:blockdev?;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;7
;8I"
overload; F;90;;I;:0;;I"blockdev?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_b(VALUE obj)
{
#ifdef S_ISBLK
if (S_ISBLK(get_stat(obj)->st_mode)) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#chardev?; T;5[ ; [[@ i;
T;:
chardev?;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;7
;8I"
overload; F;90;;J;:0;;I"
chardev?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;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;"@;;I"static VALUE; T;AI"ustatic VALUE
rb_stat_c(VALUE obj)
{
if (S_ISCHR(get_stat(obj)->st_mode)) return Qtrue;
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#setuid?; T;5[ ; [[@ if;
T;: setuid?;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;7
;8I"
overload; F;90;;K;:0;;I" setuid?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@1;[ ;I"@return [Boolean]; T;0;@1; F;=i ;>0;5[ ;@1o;<
;8I" return; F;9@f;0;:[@h;@1;[ ;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;@1; F; o; ; T; i[;!ic;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_suid(VALUE obj)
{
#ifdef S_ISUID
if (get_stat(obj)->st_mode & S_ISUID) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#setgid?; T;5[ ; [[@ i{;
T;: setgid?;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;7
;8I"
overload; F;90;;L;:0;;I" setgid?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@O;[ ;I"@return [Boolean]; T;0;@O; F;=i ;>0;5[ ;@Oo;<
;8I" return; F;9@f;0;:[@h;@O;[ ;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;@O; F; o; ; T; io;!ix;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_sgid(VALUE obj)
{
#ifdef S_ISGID
if (get_stat(obj)->st_mode & S_ISGID) return Qtrue;
#endif
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"File::Stat#sticky?; T;5[ ; [[@ i;
T;: sticky?;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;7
;8I"
overload; F;90;;M;:0;;I" sticky?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@m;[ ;I"@return [Boolean]; T;0;@m; F;=i ;>0;5[ ;@mo;<
;8I" return; F;9@f;0;:[@h;@m;[ ;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;@m; F; o; ; T; i;!i;"@;;I"static VALUE; T;AI"static VALUE
rb_stat_sticky(VALUE obj)
{
#ifdef S_ISVTX
if (get_stat(obj)->st_mode & S_ISVTX) return Qtrue;
#endif
return Qfalse;
}; T;BT;l@;mIC;[ ;l@;nIC;[@ ;l@;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i [@ i;
T;: Stat;;@;;;[ ;{ ;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; i ;!i(;=i ;"o; ;0;0;0;;;"@;@~;0;#I"File::Stat; T;v@ o;1;2F;3;q;;;#I"File.stat; F;5[[I"
fname; T0; [[@ i;
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;7
;8I"
overload; F;90;;;:0;;I"stat(file_name); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[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; T;AI"static VALUE
rb_file_s_stat(VALUE klass, VALUE fname)
{
struct stat st;
FilePathValue(fname);
if (rb_stat(fname, &st) < 0) {
rb_sys_fail_path(fname);
}
return rb_stat_new(&st);
}; T;BTo;1;2F;3;q;;;#I"File.lstat; F;5[[I"
fname; T0; [[@ i
;
T;:
lstat;0;[ ;{ ;IC;"8Same 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;7
;8I"
overload; F;90;;O;:0;;I"lstat(file_name); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"file_name; T0;@;[ ;I"VSame 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; i;!i ;"@~;;I"static VALUE; T;AI"]static VALUE
rb_file_s_lstat(VALUE klass, VALUE fname)
{
#ifdef HAVE_LSTAT
struct stat st;
rb_secure(2);
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (lstat(StringValueCStr(fname), &st) == -1) {
rb_sys_fail_path(fname);
}
return rb_stat_new(&st);
#else
return rb_file_s_stat(klass, fname);
#endif
}; T;BTo;1;2F;3;q;;;#I"File.ftype; F;5[[I"
fname; T0; [[@ i;
T;;8;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;7
;8I"
overload; F;90;;8;:0;;I"ftype(file_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@҄;[ ;I"@return [String]; T;0;@҄; F;=i ;>0;5[[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; is;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_ftype(VALUE klass, VALUE fname)
{
struct stat st;
rb_secure(2);
FilePathValue(fname);
fname = rb_str_encode_ospath(fname);
if (lstat(StringValueCStr(fname), &st) == -1) {
rb_sys_fail_path(fname);
}
return rb_file_ftype(&st);
}; T;BTo;1;2F;3;q;;;#I"File.atime; F;5[[I"
fname; T0; [[@ i;
T;;6;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;7
;8I"
overload; F;90;;6;:0;;I"atime(file_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@;[ ;I"@return [Time]; T;0;@; F;=i ;>0;5[[I"file_name; T0;@;[ ;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;@; F; o; ; T; i;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_atime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
FilePathValue(fname);
rb_sys_fail_path(fname);
}
return stat_atime(&st);
}; T;BTo;1;2F;3;q;;;#I"File.mtime; F;5[[I"
fname; T0; [[@ i;
T;;7;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;7
;8I"
overload; F;90;;7;:0;;I"mtime(file_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@;[ ;I"@return [Time]; T;0;@; F;=i ;>0;5[[I"file_name; T0;@;[ ;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;@; F; o; ; T; i;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_mtime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
FilePathValue(fname);
rb_sys_fail_path(fname);
}
return stat_mtime(&st);
}; T;BTo;1;2F;3;q;;;#I"File.ctime; F;5[[I"
fname; T0; [[@ i ;
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;7
;8I"
overload; F;90;;";:0;;I"ctime(file_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@/;[ ;I"@return [Time]; T;0;@/; F;=i ;>0;5[[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; i;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_ctime(VALUE klass, VALUE fname)
{
struct stat st;
if (rb_stat(fname, &st) < 0) {
FilePathValue(fname);
rb_sys_fail_path(fname);
}
return stat_ctime(&st);
}; T;BTo;1;2F;3;q;;;#I"File.utime; F;5[[@0; [[@ i ;
T;:
utime;0;[ ;{ ;IC;"Sets the access and modification times of each
named file to the first two arguments. Returns
the number of file names in the argument list.
; T;[o;7
;8I"
overload; F;90;;P;:0;;I"'utime(atime, mtime, file_name,...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@N;[ ;I"@return [Integer]; T;0;@N; F;=i ;>0;5[ [I"
atime; T0[I"
mtime; T0[I"file_name; T0[I"...; T0;@N;[ ;I"Sets the access and modification times of each
named file to the first two arguments. Returns
the number of file names in the argument list.
@overload utime(atime, mtime, file_name,...)
@return [Integer]; T;0;@N; F; o; ; T; i ;!i ;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_utime(int argc, VALUE *argv)
{
VALUE rest;
struct utime_args args;
struct timespec tss[2], *tsp = NULL;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "2*", &args.atime, &args.mtime, &rest);
if (!NIL_P(args.atime) || !NIL_P(args.mtime)) {
tsp = tss;
tsp[0] = rb_time_timespec(args.atime);
tsp[1] = rb_time_timespec(args.mtime);
}
args.tsp = tsp;
n = apply2files(utime_internal, rest, &args);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.chmod; F;5[[@0; [[@ iT;
T;:
chmod;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;7
;8I"
overload; F;90;;Q;:0;;I"%chmod(mode_int, file_name, ... ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@r;[ ;I"@return [Integer]; T;0;@r; F;=i ;>0;5[[I"
mode_int; T0[I"file_name; T0[I"...; T0;@r;[ ;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;@r; F; o; ; T; iG;!iQ;"@~;;I"static VALUE; T;AI" static VALUE
rb_file_s_chmod(int argc, VALUE *argv)
{
VALUE vmode;
VALUE rest;
int mode;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "1*", &vmode, &rest);
mode = NUM2INT(vmode);
n = apply2files(chmod_internal, rest, &mode);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.chown; F;5[[@0; [[@ i;
T;:
chown;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;7
;8I"
overload; F;90;;R;:0;;I"0chown(owner_int, group_int, file_name,... ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[ [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; T;AI"static VALUE
rb_file_s_chown(int argc, VALUE *argv)
{
VALUE o, g, rest;
struct chown_args arg;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "2*", &o, &g, &rest);
if (NIL_P(o)) {
arg.owner = -1;
}
else {
arg.owner = NUM2UIDT(o);
}
if (NIL_P(g)) {
arg.group = -1;
}
else {
arg.group = NUM2GIDT(g);
}
n = apply2files(chown_internal, rest, &arg);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.lchmod; F;5[[@0; [[@ i;
T;: lchmod;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;7
;8I"
overload; F;90;;S;:0;;I"%lchmod(mode_int, file_name, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[[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; i;!i;"@~;;I"static VALUE; T;AI"%static VALUE
rb_file_s_lchmod(int argc, VALUE *argv)
{
VALUE vmode;
VALUE rest;
long mode, n;
rb_secure(2);
rb_scan_args(argc, argv, "1*", &vmode, &rest);
mode = NUM2INT(vmode);
n = apply2files(lchmod_internal, rest, (void *)(long)mode);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.lchown; F;5[[@0; [[@ i" ;
T;: lchown;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;7
;8I"
overload; F;90;;T;:0;;I"/lchown(owner_int, group_int, file_name,..); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@څ;[ ;I"@return [Integer]; T;0;@څ; F;=i ;>0;5[ [I"owner_int; T0[I"group_int; T0[I"file_name; T0[I"..; T0;@څ;[ ;I"6Equivalent 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;@څ; F; o; ; T; i ;!i ;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_lchown(int argc, VALUE *argv)
{
VALUE o, g, rest;
struct chown_args arg;
long n;
rb_secure(2);
rb_scan_args(argc, argv, "2*", &o, &g, &rest);
if (NIL_P(o)) {
arg.owner = -1;
}
else {
arg.owner = NUM2UIDT(o);
}
if (NIL_P(g)) {
arg.group = -1;
}
else {
arg.group = NUM2GIDT(g);
}
n = apply2files(lchown_internal, rest, &arg);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.link; F;5[[I" from; T0[I"to; T0; [[@ i ;
T;: link;0;[ ;{ ;IC;"8Creates 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;7
;8I"
overload; F;90;;U;:0;;I" link(old_name, new_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;[ ;I"@return [0]; T;0;@; F;=i ;>0;5[[I"
old_name; T0[I"
new_name; T0;@;[ ;I"kCreates 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"static VALUE; T;AI"Bstatic VALUE
rb_file_s_link(VALUE klass, VALUE from, VALUE to)
{
rb_secure(2);
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;BTo;1;2F;3;q;;;#I"File.symlink; F;5[[I" from; T0[I"to; T0; [[@ i
;
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;7
;8I"
overload; F;90;;V;:0;;I" symlink(old_name, new_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@!;[ ;I"@return [0]; T;0;@!; F;=i ;>0;5[[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"static VALUE; T;AI"Hstatic VALUE
rb_file_s_symlink(VALUE klass, VALUE from, VALUE to)
{
rb_secure(2);
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;BTo;1;2F;3;q;;;#I"File.readlink; F;5[[I" path; T0; [[@ i&
;
T;:
readlink;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;7
;8I"
overload; F;90;;W;:0;;I"readlink(link_name); T;IC;" ; T;[ ;[ ;I" ; T;0;@D; F;=i ;>0;5[[I"link_name; T0;@D;[ ;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;@D; F; o; ; T; i
;!i"
;"@~;;I"static VALUE; T;AI"_static VALUE
rb_file_s_readlink(VALUE klass, VALUE path)
{
return rb_readlink(path);
}; T;BTo;1;2F;3;q;;;#I"File.unlink; F;5[[I" args; T0; [[@ i]
;
T;: unlink;0;[ ;{ ;IC;"Deletes the named files, returning the number of names
passed as arguments. Raises an exception on any error.
See also Dir::rmdir.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"delete(file_name, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@^;[ ;I"@return [Integer]; T;0;@^; F;=i ;>0;5[[I"file_name; T0[I"...; T0;@^o;7
;8I"
overload; F;90;;X;:0;;I"unlink(file_name, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@^;[ ;I"@return [Integer]; T;0;@^; F;=i ;>0;5[[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.
See also Dir::rmdir.
@overload delete(file_name, ...)
@return [Integer]
@overload unlink(file_name, ...)
@return [Integer]; T;0;@^; F; o; ; T; iS
;!i[
;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_unlink(VALUE klass, VALUE args)
{
long n;
rb_secure(2);
n = apply2files(unlink_internal, args, 0);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.delete; F;5[[I" args; T0; [[@ i]
;
T;;;0;[ ;{ ;IC;"Deletes the named files, returning the number of names
passed as arguments. Raises an exception on any error.
See also Dir::rmdir.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"delete(file_name, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[[I"file_name; T0[I"...; T0;@o;7
;8I"
overload; F;90;;X;:0;;I"unlink(file_name, ...); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[[I"file_name; T0[I"...; T0;@;[ ;@;0;@; F; o; ; T; iS
;!i[
;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_unlink(VALUE klass, VALUE args)
{
long n;
rb_secure(2);
n = apply2files(unlink_internal, args, 0);
return LONG2FIX(n);
}; T;BTo;1;2F;3;q;;;#I"File.rename; F;5[[I" from; T0[I"to; T0; [[@ iq
;
T;: rename;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;7
;8I"
overload; F;90;;Y;:0;;I" rename(old_name, new_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;[ ;I"@return [0]; T;0;@; F;=i ;>0;5[[I"
old_name; T0[I"
new_name; T0;@;[ ;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;@; F; o; ; T; ig
;!in
;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_rename(VALUE klass, VALUE from, VALUE to)
{
const char *src, *dst;
VALUE f, t;
rb_secure(2);
FilePathValue(from);
FilePathValue(to);
f = rb_str_encode_ospath(from);
t = rb_str_encode_ospath(to);
src = StringValueCStr(f);
dst = StringValueCStr(t);
#if defined __CYGWIN__
errno = 0;
#endif
if (rename(src, dst) < 0) {
#if defined DOSISH
switch (errno) {
case EEXIST:
#if defined (__EMX__)
case EACCES:
#endif
if (chmod(dst, 0666) == 0 &&
unlink(dst) == 0 &&
rename(src, dst) == 0)
return INT2FIX(0);
}
#endif
sys_fail2(from, to);
}
return INT2FIX(0);
}; T;BTo;1;2F;3;q;;;#I"File.umask; F;5[[@0; [[@ i
;
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;7
;8I"
overload; F;90;;Z;:0;;I" umask(); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;Z;:0;;I"umask(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[[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"static VALUE; T;AI"%static VALUE
rb_file_s_umask(int argc, VALUE *argv)
{
int omask = 0;
rb_secure(2);
if (argc == 0) {
omask = umask(0);
umask(omask);
}
else if (argc == 1) {
omask = umask(NUM2INT(argv[0]));
}
else {
rb_check_arity(argc, 0, 1);
}
return INT2FIX(omask);
}; T;BTo;1;2F;3;q;;;#I"File.truncate; F;5[[I" path; T0[I"len; T0; [[@ iv;
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;7
;8I"
overload; F;90;;^;:0;;I"!truncate(file_name, integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;[ ;I"@return [0]; T;0;@; F;=i ;>0;5[[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; ig;!is;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
{
#ifdef HAVE_TRUNCATE
#define NUM2POS(n) NUM2OFFT(n)
off_t pos;
#else
#define NUM2POS(n) NUM2LONG(n)
long pos;
#endif
rb_secure(2);
pos = NUM2POS(len);
FilePathValue(path);
path = rb_str_encode_ospath(path);
#ifdef HAVE_TRUNCATE
if (truncate(StringValueCStr(path), pos) < 0)
rb_sys_fail_path(path);
#else /* defined(HAVE_CHSIZE) */
{
int tmpfd;
if ((tmpfd = rb_cloexec_open(StringValueCStr(path), 0, 0)) < 0) {
rb_sys_fail_path(path);
}
rb_update_max_fd(tmpfd);
if (chsize(tmpfd, pos) < 0) {
close(tmpfd);
rb_sys_fail_path(path);
}
close(tmpfd);
}
#endif
return INT2FIX(0);
#undef NUM2POS
}; T;BTo;1;2F;3;q;;;#I"File.expand_path; F;5[[@0; [[@ i
;
T;:expand_path;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;7
;8I"
overload; F;90;;[;:0;;I"+expand_path(file_name [, dir_string] ); T;IC;" ; T;[ ;[ ;I" ; T;0;@2; F;=i ;>0;5[[I" file_name[, dir_string]; T0;@2;[ ;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;@2; F; o; ; T; ij
;!i
;"@~;;I"
VALUE; T;AI"VALUE
rb_file_s_expand_path(int argc, VALUE *argv)
{
VALUE fname, dname;
if (argc == 1) {
return rb_file_expand_path(argv[0], Qnil);
}
rb_scan_args(argc, argv, "11", &fname, &dname);
return rb_file_expand_path(fname, dname);
}; T;BTo;1;2F;3;q;;;#I"File.absolute_path; F;5[[@0; [[@ i
;
T;:absolute_path;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") #=> "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.
File.basename("/home/gumby/work/ruby.rb") #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb") #=> "ruby"
; T;[o;7
;8I"
overload; F;90;;_;:0;;I"$basename(file_name [, suffix] ); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"file_name[, suffix]; T0;@;[ ;I"Returns the last component of the filename given in file_name,
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.
File.basename("/home/gumby/work/ruby.rb") #=> "ruby.rb"
File.basename("/home/gumby/work/ruby.rb", ".rb") #=> "ruby"
@overload basename(file_name [, suffix] ); T;0;@; F; o; ; T; i;!i;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_s_basename(int argc, VALUE *argv)
{
VALUE fname, fext, basename;
const char *name, *p;
long f, n;
rb_encoding *enc;
if (rb_scan_args(argc, argv, "11", &fname, &fext) == 2) {
StringValue(fext);
enc = check_path_encoding(fext);
}
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);
OBJ_INFECT(basename, fname);
return basename;
}; T;BTo;1;2F;3;q;;;#I"File.dirname; F;5[[I"
fname; T0; [[@ i@;
T;: dirname;0;[ ;{ ;IC;"SReturns all components of the filename given in file_name
except the last one. 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;7
;8I"
overload; F;90;;`;:0;;I"dirname(file_name); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"file_name; T0;@;[ ;I"rReturns all components of the filename given in file_name
except the last one. 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; i4;!i<;"@~;;I"static VALUE; T;AI"dstatic VALUE
rb_file_s_dirname(VALUE klass, VALUE fname)
{
return rb_file_dirname(fname);
}; T;BTo;1;2F;3;q;;;#I"File.extname; F;5[[I"
fname; T0; [[@ i;
T;: extname;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+.
File.extname("test.rb") #=> ".rb"
File.extname("a/b/d/test.rb") #=> ".rb"
File.extname("foo.") #=> ""
File.extname("test") #=> ""
File.extname(".profile") #=> ""
File.extname(".profile.sh") #=> ".sh"
; T;[o;7
;8I"
overload; F;90;;a;:0;;I"extname(path); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@ɇ;[ ;I"@return [String]; T;0;@ɇ; F;=i ;>0;5[[I" path; T0;@ɇ;[ ;I"WReturns 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+.
File.extname("test.rb") #=> ".rb"
File.extname("a/b/d/test.rb") #=> ".rb"
File.extname("foo.") #=> ""
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; T;AI"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! */
OBJ_INFECT(extname, fname);
return extname;
}; T;BTo;1;2F;3;q;;;#I"File.path; F;5[[I"
fname; T0; [[@ i;
T;: path;0;[ ;{ ;IC;"Returns the string representation of the path
File.path("/dev/null") #=> "/dev/null"
File.path(Pathname.new("/tmp")) #=> "/tmp"
; T;[o;7
;8I"
overload; F;90;;b;:0;;I"path(path); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[[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; T;AI"]static VALUE
rb_file_s_path(VALUE klass, VALUE fname)
{
return rb_get_path(fname);
}; T;BTo;
; [[@ i=;
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;
; [[@ i>;
F;:SEPARATOR;;;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@;"@~;#I"File::SEPARATOR; F;$I"separator; To;1;2F;3;q;;;#I"File.split; F;5[[I" path; T0; [[@ i;
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;7
;8I"
overload; F;90;;;:0;;I"split(file_name); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@ ;[ ;I"@return [Array]; T;0;@ ; F;=i ;>0;5[[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; T;AI"static VALUE
rb_file_s_split(VALUE klass, VALUE path)
{
FilePathStringValue(path); /* get rid of converting twice */
return rb_assoc_new(rb_file_s_dirname(Qnil, path), rb_file_s_basename(1,&path));
}; T;BTo;1;2F;3;q;;;#I"File.join; F;5[[I" args; T0; [[@ i`;
T;: join;0;[ ;{ ;IC;"Returns a new string formed by joining the strings using
File::SEPARATOR.
File.join("usr", "mail", "gumby") #=> "usr/mail/gumby"
; T;[o;7
;8I"
overload; F;90;;e;:0;;I"join(string, ...); T;IC;" ; T;[ ;[ ;I" ; T;0;@<; F;=i ;>0;5[[I" string; T0[I"...; T0;@<;[ ;I"Returns a new string formed by joining the strings using
File::SEPARATOR.
File.join("usr", "mail", "gumby") #=> "usr/mail/gumby"
@overload join(string, ...); T;0;@<; F; o; ; T; iU;!i\;"@~;;I"static VALUE; T;AI"gstatic VALUE
rb_file_s_join(VALUE klass, VALUE args)
{
return rb_file_join(args, separator);
}; T;BTo;
; [[@ iD[@ iF;
F;:ALT_SEPARATOR;;;;;[ ;{ ;IC;",platform specific alternative separator
; T;[ ;[ ;I",platform specific alternative separator; T;0;@X; F; o; ; T; iC;!iC;"@~;#I"File::ALT_SEPARATOR; F;$I" Qnil; To;
; [[@ iI;
F;:PATH_SEPARATOR;;;;;[ ;{ ;IC;"path list separator
; T;[ ;[ ;I"path list separator; T;0;@e; F; o; ; T; iH;!iH;"@~;#I"File::PATH_SEPARATOR; F;$I")rb_obj_freeze(rb_str_new2(PATH_SEP)); To;1;2F;3;4;;;#I"File#lstat; F;5[ ; [[@ i-;
T;;O;0;[ ;{ ;IC;"RSame 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;7
;8I"
overload; F;90;;O;:0;;I"
lstat; T;IC;" ; T;[ ;[ ;I" ; T;0;@q; F;=i ;>0;5[ ;@q;[ ;I"dSame 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;@q; F; o; ; T; i ;!i);"@~;;I"static VALUE; T;AI"static VALUE
rb_file_lstat(VALUE obj)
{
#ifdef HAVE_LSTAT
rb_io_t *fptr;
struct stat st;
VALUE path;
rb_secure(2);
GetOpenFile(obj, fptr);
if (NIL_P(fptr->pathv)) return Qnil;
path = rb_str_encode_ospath(fptr->pathv);
if (lstat(RSTRING_PTR(path), &st) == -1) {
rb_sys_fail_path(fptr->pathv);
}
return rb_stat_new(&st);
#else
return rb_io_stat(obj);
#endif
}; T;BTo;1;2F;3;4;;;#I"File#atime; F;5[ ; [[@ i;
T;;6;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;7
;8I"
overload; F;90;;6;:0;;I"
atime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@;[ ;I"@return [Time]; T;0;@; F;=i ;>0;5[ ;@;[ ;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;@; F; o; ; T; i;!i;"@~;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File#mtime; F;5[ ; [[@ i;
T;;7;0;[ ;{ ;IC;"uReturns the modification time for file.
File.new("testfile").mtime #=> Wed Apr 09 08:53:14 CDT 2003
; T;[o;7
;8I"
overload; F;90;;7;:0;;I"
mtime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@;[ ;I"@return [Time]; T;0;@; F;=i ;>0;5[ ;@;[ ;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;!i;"@~;;I"static VALUE; T;AI"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;BTo;1;2F;3;4;;;#I"File#ctime; F;5[ ; [[@ i;
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;7
;8I"
overload; F;90;;";:0;;I"
ctime; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Time; T;@;[ ;I"@return [Time]; T;0;@; F;=i ;>0;5[ ;@;[ ;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; T;AI"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;BTo;1;2F;3;4;;;#I"File#size; F;5[ ; [[@ i0;
T;;G;0;[ ;{ ;IC;"UReturns the size of file in bytes.
File.new("testfile").size #=> 66
; T;[o;7
;8I"
overload; F;90;;G;:0;;I" size; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@؈;[ ;I"@return [Integer]; T;0;@؈; F;=i ;>0;5[ ;@؈;[ ;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; T;AI" 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;BTo;1;2F;3;4;;;#I"File#chmod; F;5[[I"
vmode; T0; [[@ iq;
T;;Q;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;7
;8I"
overload; F;90;;Q;:0;;I"chmod(mode_int); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;[ ;I"@return [0]; T;0;@; F;=i ;>0;5[[I"
mode_int; T0;@;[ ;I"TChanges 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; id;!in;"@~;;I"static VALUE; T;AI"static VALUE
rb_file_chmod(VALUE obj, VALUE vmode)
{
rb_io_t *fptr;
int mode;
#ifndef HAVE_FCHMOD
VALUE path;
#endif
rb_secure(2);
mode = NUM2INT(vmode);
GetOpenFile(obj, fptr);
#ifdef HAVE_FCHMOD
if (fchmod(fptr->fd, mode) == -1)
rb_sys_fail_path(fptr->pathv);
#else
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;BTo;1;2F;3;4;;;#I"File#chown; F;5[[I"
owner; T0[I"
group; T0; [[@ i;
T;;R;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;7
;8I"
overload; F;90;;R;:0;;I"!chown(owner_int, group_int ); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@;[ ;I"@return [0]; T;0;@; F;=i ;>0;5[[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; T;AI":static VALUE
rb_file_chown(VALUE obj, VALUE owner, VALUE group)
{
rb_io_t *fptr;
int o, g;
#ifndef HAVE_FCHOWN
VALUE path;
#endif
rb_secure(2);
o = NIL_P(owner) ? -1 : NUM2INT(owner);
g = NIL_P(group) ? -1 : NUM2INT(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;BTo;1;2F;3;4;;;#I"File#truncate; F;5[[I"len; T0; [[@ i;
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;7
;8I"
overload; F;90;;^;:0;;I"truncate(integer); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@5;[ ;I"@return [0]; T;0;@5; F;=i ;>0;5[[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; T;AI"static VALUE
rb_file_truncate(VALUE obj, VALUE len)
{
rb_io_t *fptr;
#if defined(HAVE_FTRUNCATE)
#define NUM2POS(n) NUM2OFFT(n)
off_t pos;
#else
#define NUM2POS(n) NUM2LONG(n)
long pos;
#endif
rb_secure(2);
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);
#ifdef HAVE_FTRUNCATE
if (ftruncate(fptr->fd, pos) < 0)
rb_sys_fail_path(fptr->pathv);
#else /* defined(HAVE_CHSIZE) */
if (chsize(fptr->fd, pos) < 0)
rb_sys_fail_path(fptr->pathv);
#endif
return INT2FIX(0);
#undef NUM2POS
}; T;BTo;1;2F;3;4;;;#I"File#flock; F;5[[I"operation; T0; [[@ i ;
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;7
;8I"
overload; F;90;;h;:0;;I" flock(locking_constant); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; TI"
false; T;@T;[ ;I"@return [0, false]; T;0;@T; F;=i ;>0;5[[I"locking_constant; T0;@T;[ ;I"RLocks 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;!i;"@~;;I"static VALUE; T;AI"Ustatic VALUE
rb_file_flock(VALUE obj, VALUE operation)
{
rb_io_t *fptr;
int op[2], op1;
struct timeval time;
rb_secure(2);
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) {
switch (errno) {
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_sys_fail_path(fptr->pathv);
}
}
return INT2FIX(0);
}; T;BT@}o;1;2F;3;4;;;#I"File#path; F;5[ ; [[@ iZ;
T;;b;0;[ ;{ ;IC;"Returns the pathname used to create file as a string. Does
not normalize the name.
File.new("testfile").path #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
; T;[o;7
;8I"
overload; F;90;;b;:0;;I" path; T;IC;" ; T;[ ;[ ;I" ; T;0;@t; F;=i ;>0;5[ ;@to;7
;8I"
overload; F;90;: to_path;:0;;I" to_path; T;IC;" ; T;[ ;[ ;I" ; T;0;@t; F;=i ;>0;5[ ;@t;[ ;I"Returns the pathname used to create file as a string. Does
not normalize the name.
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; iM;!iV;"@~;;I"static VALUE; T;AI"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)) return Qnil;
return rb_obj_taint(rb_str_dup(fptr->pathv));
}; T;BTo;1;2F;3;4;;;#I"File#to_path; F;5[ ; [[@ iZ;
T;;i;0;[ ;{ ;IC;"Returns the pathname used to create file as a string. Does
not normalize the name.
File.new("testfile").path #=> "testfile"
File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
; T;[o;7
;8I"
overload; F;90;;b;:0;;I" path; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;i;:0;;I" to_path; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;@;0;@; F; o; ; T; iM;!iV;"@~;;I"static VALUE; T;AI"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)) return Qnil;
return rb_obj_taint(rb_str_dup(fptr->pathv));
}; T;BT;l@~;mIC;[ ;l@~;nIC;[ ;l@~;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ i;
F;;;;@;;;[ ;{ ;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;=i ;"@;#I" File; F;v@%l;#I"File::Constants; F;l@%l;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{@5r;;t[ ; [[@i.;
F;:IO;;@;;;[ ;{ ;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 = $stdin.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 = $stdin.winsize
puts "Your screen is #{columns} wide and #{rows} tall"
; T;0;@%l; F; o; ; T; i0.;!i|.;=i ;"@;#I"IO; F;v@ @lo; ;IC;[o;1;2F;3;4;;;#I"Random#initialize; F;5[[@0; [[@i;
T;; ;0;[ ;{ ;IC;"Creates a new PRNG using +seed+ to set the initial state. If +seed+ is
omitted, the generator is initialized with Random.new_seed.
See Random.srand for more information on the use of seed values.
; T;[o;7
;8I"
overload; F;90;;M;:0;;I" new(seed = Random.new_seed); T;IC;" ; T;[ ;[ ;I" ; T;0;@҉; F;=i ;>0;5[[I" seed; TI"Random.new_seed; T;@҉;[ ;I"Creates a new PRNG using +seed+ to set the initial state. If +seed+ is
omitted, the generator is initialized with Random.new_seed.
See Random.srand for more information on the use of seed values.
@overload new(seed = Random.new_seed); T;0;@҉; F; o; ; T; i;!i;"@Љ;;I"static VALUE; T;AI"Ustatic VALUE
random_init(int argc, VALUE *argv, VALUE obj)
{
VALUE vseed;
rb_random_t *rnd = get_rnd(obj);
if (argc == 0) {
rb_check_frozen(obj);
vseed = random_seed();
}
else {
rb_scan_args(argc, argv, "01", &vseed);
rb_check_copyable(obj, vseed);
}
rnd->seed = rand_init(&rnd->mt, vseed);
return obj;
}; T;BTo;1;2F;3;4;;;#I"Random#rand; F;5[[@0; [[@i9;
T;;;0;[ ;{ ;IC;"When +max+ is an Integer, +rand+ returns a random integer greater than
or equal to zero and less than +max+. Unlike Kernel.rand, when +max+
is a negative integer or zero, +rand+ raises an ArgumentError.
prng = Random.new
prng.rand(100) # => 42
When +max+ is a Float, +rand+ returns a random floating point number
between 0.0 and +max+, including 0.0 and excluding +max+.
prng.rand(1.5) # => 1.4600282860034115
When +max+ is a Range, +rand+ returns a random number where
range.member?(number) == true.
prng.rand(5..9) # => one of [5, 6, 7, 8, 9]
prng.rand(5...9) # => one of [5, 6, 7, 8]
prng.rand(5.0..9.0) # => between 5.0 and 9.0, including 9.0
prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
Both the beginning and ending values of the range must respond to subtract
(-) and add (+)methods, or rand will raise an
ArgumentError.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rand; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@;[ ;I"@return [Float]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;;:0;;I"rand(max); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@;[ ;I"@return [Numeric]; T;0;@; F;=i ;>0;5[[I"max; T0;@;[ ;I"When +max+ is an Integer, +rand+ returns a random integer greater than
or equal to zero and less than +max+. Unlike Kernel.rand, when +max+
is a negative integer or zero, +rand+ raises an ArgumentError.
prng = Random.new
prng.rand(100) # => 42
When +max+ is a Float, +rand+ returns a random floating point number
between 0.0 and +max+, including 0.0 and excluding +max+.
prng.rand(1.5) # => 1.4600282860034115
When +max+ is a Range, +rand+ returns a random number where
range.member?(number) == true.
prng.rand(5..9) # => one of [5, 6, 7, 8, 9]
prng.rand(5...9) # => one of [5, 6, 7, 8]
prng.rand(5.0..9.0) # => between 5.0 and 9.0, including 9.0
prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
Both the beginning and ending values of the range must respond to subtract
(-) and add (+)methods, or rand will raise an
ArgumentError.
@overload rand
@return [Float]
@overload rand(max)
@return [Numeric]; T;0;@; F; o; ; T; i ;!i8;"@Љ;;I"static VALUE; T;AI"ustatic VALUE
random_rand(int argc, VALUE *argv, VALUE obj)
{
return rand_random(argc, argv, get_rnd(obj));
}; T;BTo;1;2F;3;4;;;#I"Random#bytes; F;5[[I"len; T0; [[@if;
T;;;0;[ ;{ ;IC;"Returns a random binary string containing +size+ bytes.
random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
random_string.size # => 10
; T;[o;7
;8I"
overload; F;90;;;:0;;I"bytes(size); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[[I" size; T0;@;[ ;I"Returns a random binary string containing +size+ bytes.
random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
random_string.size # => 10
@overload bytes(size)
@return [String]; T;0;@; F; o; ; T; i^;!ie;"@Љ;;I"static VALUE; T;AI"sstatic VALUE
random_bytes(VALUE obj, VALUE len)
{
return rb_random_bytes(obj, NUM2LONG(rb_to_int(len)));
}; T;BTo;1;2F;3;4;;;#I"Random#seed; F;5[ ; [[@i ;
T;: seed;0;[ ;{ ;IC;"PReturns the seed value used to initialize the generator. This may be used to
initialize another generator with the same state at a later time, causing it
to produce the same sequence of numbers.
prng1 = Random.new(1234)
prng1.seed #=> 1234
prng1.rand(100) #=> 47
prng2 = Random.new(prng1.seed)
prng2.rand(100) #=> 47
; T;[o;7
;8I"
overload; F;90;;k;:0;;I" seed; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@6;[ ;I"@return [Integer]; T;0;@6; F;=i ;>0;5[ ;@6;[ ;I"uReturns the seed value used to initialize the generator. This may be used to
initialize another generator with the same state at a later time, causing it
to produce the same sequence of numbers.
prng1 = Random.new(1234)
prng1.seed #=> 1234
prng1.rand(100) #=> 47
prng2 = Random.new(prng1.seed)
prng2.rand(100) #=> 47
@overload seed
@return [Integer]; T;0;@6; F; o; ; T; i;!i ;"@Љ;;I"static VALUE; T;AI"Ostatic VALUE
random_get_seed(VALUE obj)
{
return get_rnd(obj)->seed;
}; T;BTo;1;2F;3;4;;;#I"Random#initialize_copy; F;5[[I" orig; T0; [[@i%;
T;;x;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@Q; F; o; ; T; i$;!i$;"@Љ;;I"static VALUE; T;AI"?static VALUE
random_copy(VALUE obj, VALUE orig)
{
rb_random_t *rnd1, *rnd2;
struct MT *mt;
if (!OBJ_INIT_COPY(obj, orig)) return obj;
rnd1 = get_rnd(obj);
rnd2 = get_rnd(orig);
mt = &rnd1->mt;
*rnd1 = *rnd2;
mt->next = mt->state + numberof(mt->state) - mt->left + 1;
return obj;
}; T;BTo;1;2F;3;4;;
;#I"Random#marshal_dump; F;5[ ; [[@i];
T;;C;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@a; F; o; ; T; i\;!i\;"@Љ;;I"static VALUE; T;AI"static VALUE
random_dump(VALUE obj)
{
rb_random_t *rnd = get_rnd(obj);
VALUE dump = rb_ary_new2(3);
rb_ary_push(dump, mt_state(&rnd->mt));
rb_ary_push(dump, INT2FIX(rnd->mt.left));
rb_ary_push(dump, rnd->seed);
return dump;
}; T;BTo;1;2F;3;4;;
;#I"Random#marshal_load; F;5[[I" dump; T0; [[@ik;
T;;D;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@o; F; o; ; T; ij;!ij;"@Љ;;I"static VALUE; T;AI"static VALUE
random_load(VALUE obj, VALUE dump)
{
rb_random_t *rnd = get_rnd(obj);
struct MT *mt = &rnd->mt;
VALUE state, left = INT2FIX(1), seed = INT2FIX(0);
const VALUE *ary;
unsigned long x;
rb_check_copyable(obj, dump);
Check_Type(dump, T_ARRAY);
ary = RARRAY_CONST_PTR(dump);
switch (RARRAY_LEN(dump)) {
case 3:
seed = ary[2];
case 2:
left = ary[1];
case 1:
state = ary[0];
break;
default:
rb_raise(rb_eArgError, "wrong dump data");
}
rb_integer_pack(state, mt->state, numberof(mt->state),
sizeof(*mt->state), 0,
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
x = NUM2ULONG(left);
if (x > numberof(mt->state)) {
rb_raise(rb_eArgError, "wrong value");
}
mt->left = (unsigned int)x;
mt->next = mt->state + numberof(mt->state) - x + 1;
rnd->seed = rb_to_int(seed);
return obj;
}; T;BTo;1;2F;3;4;;
;#I"Random#state; F;5[ ; [[@i?;
T;:
state;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@; F; o; ; T; i>;!i>;"@Љ;;I"static VALUE; T;AI"qstatic VALUE
random_state(VALUE obj)
{
rb_random_t *rnd = get_rnd(obj);
return mt_state(&rnd->mt);
}; T;BTo;1;2F;3;4;;
;#I"Random#left; F;5[ ; [[@iN;
T;: left;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@; F; o; ; T; iM;!iM;"@Љ;;I"static VALUE; T;AI"sstatic VALUE
random_left(VALUE obj)
{
rb_random_t *rnd = get_rnd(obj);
return INT2FIX(rnd->mt.left);
}; T;BTo;1;2F;3;4;;;#I"Random#==; F;5[[I"
other; T0; [[@i;
T;;O;0;[ ;{ ;IC;"lReturns true if the two generators have the same internal state, otherwise
false. Equivalent generators will return the same sequence of
pseudo-random numbers. Two generators will generally have the same state
only if they were initialized with the same seed
Random.new == Random.new # => false
Random.new(1234) == Random.new(1234) # => true
and have the same invocation history.
prng1 = Random.new(1234)
prng2 = Random.new(1234)
prng1 == prng2 # => true
prng1.rand # => 0.1915194503788923
prng1 == prng2 # => false
prng2.rand # => 0.1915194503788923
prng1 == prng2 # => true
; T;[o;7
;8I"
overload; F;90;;O;:0;;I"==(prng2); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[[I"
prng2; T0;@;[ ;I"Returns true if the two generators have the same internal state, otherwise
false. Equivalent generators will return the same sequence of
pseudo-random numbers. Two generators will generally have the same state
only if they were initialized with the same seed
Random.new == Random.new # => false
Random.new(1234) == Random.new(1234) # => true
and have the same invocation history.
prng1 = Random.new(1234)
prng2 = Random.new(1234)
prng1 == prng2 # => true
prng1.rand # => 0.1915194503788923
prng1 == prng2 # => false
prng2.rand # => 0.1915194503788923
prng1 == prng2 # => true
@overload ==(prng2)
@return [Boolean]; T;0;@; F; o; ; T; ih;!i~;"@Љ;;I"static VALUE; T;AI"static VALUE
random_equal(VALUE self, VALUE other)
{
rb_random_t *r1, *r2;
if (rb_obj_class(self) != rb_obj_class(other)) return Qfalse;
r1 = get_rnd(self);
r2 = get_rnd(other);
if (!RTEST(rb_funcall2(r1->seed, rb_intern("=="), 1, &r2->seed))) return Qfalse;
if (memcmp(r1->mt.state, r2->mt.state, sizeof(r1->mt.state))) return Qfalse;
if ((r1->mt.next - r1->mt.state) != (r2->mt.next - r2->mt.state)) return Qfalse;
if (r1->mt.left != r2->mt.left) return Qfalse;
return Qtrue;
}; T;BTo;
; [[@ib;
F;: DEFAULT;;;;;[ ;{ ;IC;"BDirect access to Ruby's Pseudorandom number generator (PRNG).
; T;[ ;[ ;I"BDirect access to Ruby's Pseudorandom number generator (PRNG).; T;0;@; F; o; ; T; ia;!ia;"@Љ;#I"Random::DEFAULT; F;$I"rand_default; To;1;2F;3;q;;;#I"Random.srand; F;5[[@0; [[@i;
T;;;0;[ ;{ ;IC;"zSeeds the system pseudo-random number generator, Random::DEFAULT, with
+number+. The previous seed value is returned.
If +number+ is omitted, seeds the generator using a source of entropy
provided by the operating system, if available (/dev/urandom on Unix systems
or the RSA cryptographic provider on Windows), which is then combined with
the time, the process id, and a sequence number.
srand may be used to ensure repeatable sequences of pseudo-random numbers
between different runs of the program. By setting the seed to a known value,
programs can be made deterministic during testing.
srand 1234 # => 268519324636777531569100071560086917274
[ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
[ rand(10), rand(1000) ] # => [4, 664]
srand 1234 # => 1234
[ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"$srand(number = Random.new_seed); T;IC;" ; T;[ ;[ ;I" ; T;0;@Ɗ; F;=i ;>0;5[[I" number; TI"Random.new_seed; T;@Ɗ;[ ;@;0;@Ɗ; F; o; ; T; i;!i;"@Љ;;I"static VALUE; T;AI"-static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
VALUE seed, old;
rb_random_t *r = &default_rand;
if (argc == 0) {
seed = random_seed();
}
else {
rb_scan_args(argc, argv, "01", &seed);
}
old = r->seed;
r->seed = rand_init(&r->mt, seed);
return old;
}; T;BTo;1;2F;3;q;;;#I"Random.rand; F;5[[@0; [[@i;
T;;;0;[ ;{ ;IC;"#Alias of Random::DEFAULT.rand.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rand; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@ߊ;[ ;I"@return [Float]; T;0;@ߊ; F;=i ;>0;5[ ;@ߊo;7
;8I"
overload; F;90;;;:0;;I"rand(max); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@ߊ;[ ;I"@return [Numeric]; T;0;@ߊ; F;=i ;>0;5[[I"max; T0;@ߊ;[ ;I"nAlias of Random::DEFAULT.rand.
@overload rand
@return [Float]
@overload rand(max)
@return [Numeric]; T;0;@ߊ; F; o; ; T; i;!i;"@Љ;;I"static VALUE; T;AI"static VALUE
random_s_rand(int argc, VALUE *argv, VALUE obj)
{
return rand_random(argc, argv, rand_start(&default_rand));
}; T;BTo;1;2F;3;q;;;#I"Random.new_seed; F;5[ ; [[@i;
T;:
new_seed;0;[ ;{ ;IC;"Returns an arbitrary seed value. This is used by Random.new
when no seed value is specified as an argument.
Random.new_seed #=> 115032730400174366788466674494640623225
; T;[o;7
;8I"
overload; F;90;;o;:0;;I"
new_seed; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@
;[ ;I"@return [Integer]; T;0;@
; F;=i ;>0;5[ ;@
;[ ;I"Returns an arbitrary seed value. This is used by Random.new
when no seed value is specified as an argument.
Random.new_seed #=> 115032730400174366788466674494640623225
@overload new_seed
@return [Integer]; T;0;@
; F; o; ; T; i ;!i;"@Љ;;I"static VALUE; T;AI"static VALUE
random_seed(void)
{
uint32_t buf[DEFAULT_SEED_CNT];
fill_random_seed(buf);
return make_seed_value(buf);
}; T;BT;l@Љ;mIC;[ ;l@Љ;nIC;[ ;l@Љ;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@i2[@iQ;
T;: Random;;@;;;[ ;{ ;IC;"Random provides an interface to Ruby's pseudo-random number generator, or
PRNG. The PRNG produces a deterministic sequence of bits which approximate
true randomness. The sequence may be represented by integers, floats, or
binary strings.
The generator may be initialized with either a system-generated or
user-supplied seed value by using Random.srand.
The class method Random.rand provides the base functionality of Kernel.rand
along with better handling of floating point values. These are both
interfaces to Random::DEFAULT, the Ruby system PRNG.
Random.new will create a new PRNG with a state independent of
Random::DEFAULT, allowing multiple generators with different seed values or
sequence positions to exist simultaneously. Random objects can be
marshaled, allowing sequences to be saved and resumed.
PRNGs are currently implemented as a modified Mersenne Twister with a period
of 2**19937-1.; T;[ ;[ ;I"
Random provides an interface to Ruby's pseudo-random number generator, or
PRNG. The PRNG produces a deterministic sequence of bits which approximate
true randomness. The sequence may be represented by integers, floats, or
binary strings.
The generator may be initialized with either a system-generated or
user-supplied seed value by using Random.srand.
The class method Random.rand provides the base functionality of Kernel.rand
along with better handling of floating point values. These are both
interfaces to Random::DEFAULT, the Ruby system PRNG.
Random.new will create a new PRNG with a state independent of
Random::DEFAULT, allowing multiple generators with different seed values or
sequence positions to exist simultaneously. Random objects can be
marshaled, allowing sequences to be saved and resumed.
PRNGs are currently implemented as a modified Mersenne Twister with a period
of 2**19937-1.
; T;0;@Љ; F; o; ; T; i2;!iF;=i ;"@;#I" Random; F;v@ @-o; ;IC;[3o;1;2F;3;q;;;#I"Complex.rectangular; F;5[[@0; [[@ei;
T;;;0;[ ;{ ;IC;"qReturns a complex object which denotes the given rectangular form.
Complex.rectangular(1, 2) #=> (1+2i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I"rect(real[, imag]); T;IC;" ; T;[ ;[ ;I" ; T;0;@9; F;=i ;>0;5[[I"real[, imag]; T0;@9o;7
;8I"
overload; F;90;;;:0;;I" rectangular(real[, imag]); T;IC;" ; T;[ ;[ ;I" ; T;0;@9; F;=i ;>0;5[[I"real[, imag]; T0;@9;[ ;I"Returns a complex object which denotes the given rectangular form.
Complex.rectangular(1, 2) #=> (1+2i)
@overload rect(real[, imag])
@overload rectangular(real[, imag]); T;0;@9; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"bstatic VALUE
nucomp_s_new(int argc, VALUE *argv, VALUE klass)
{
VALUE real, imag;
switch (rb_scan_args(argc, argv, "11", &real, &imag)) {
case 1:
nucomp_real_check(real);
imag = ZERO;
break;
default:
nucomp_real_check(real);
nucomp_real_check(imag);
break;
}
return nucomp_s_canonicalize_internal(klass, real, imag);
}; T;BTo;1;2F;3;q;;;#I"Complex.rect; F;5[[@0; [[@ei;
T;;;0;[ ;{ ;IC;"qReturns a complex object which denotes the given rectangular form.
Complex.rectangular(1, 2) #=> (1+2i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I"rect(real[, imag]); T;IC;" ; T;[ ;[ ;I" ; T;0;@\; F;=i ;>0;5[[I"real[, imag]; T0;@\o;7
;8I"
overload; F;90;;;:0;;I" rectangular(real[, imag]); T;IC;" ; T;[ ;[ ;I" ; T;0;@\; F;=i ;>0;5[[I"real[, imag]; T0;@\;[ ;@X;0;@\; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"bstatic VALUE
nucomp_s_new(int argc, VALUE *argv, VALUE klass)
{
VALUE real, imag;
switch (rb_scan_args(argc, argv, "11", &real, &imag)) {
case 1:
nucomp_real_check(real);
imag = ZERO;
break;
default:
nucomp_real_check(real);
nucomp_real_check(imag);
break;
}
return nucomp_s_canonicalize_internal(klass, real, imag);
}; T;BTo;1;2F;3;q;;;#I"Complex.polar; F;5[[@0; [[@ei?;
T;;;0;[ ;{ ;IC;"8Returns a complex object which denotes the given polar form.
Complex.polar(3, 0) #=> (3.0+0.0i)
Complex.polar(3, Math::PI/2) #=> (1.836909530733566e-16+3.0i)
Complex.polar(3, Math::PI) #=> (-3.0+3.673819061467132e-16i)
Complex.polar(3, -Math::PI/2) #=> (1.836909530733566e-16-3.0i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I"polar(abs[, arg]); T;IC;" ; T;[ ;[ ;I" ; T;0;@~; F;=i ;>0;5[[I"abs[, arg]; T0;@~;[ ;I"VReturns a complex object which denotes the given polar form.
Complex.polar(3, 0) #=> (3.0+0.0i)
Complex.polar(3, Math::PI/2) #=> (1.836909530733566e-16+3.0i)
Complex.polar(3, Math::PI) #=> (-3.0+3.673819061467132e-16i)
Complex.polar(3, -Math::PI/2) #=> (1.836909530733566e-16-3.0i)
@overload polar(abs[, arg]); T;0;@~; F; o; ; T; i4;!i<;"@7;;I"static VALUE; T;AI"Jstatic VALUE
nucomp_s_polar(int argc, VALUE *argv, VALUE klass)
{
VALUE abs, arg;
switch (rb_scan_args(argc, argv, "11", &abs, &arg)) {
case 1:
nucomp_real_check(abs);
arg = ZERO;
break;
default:
nucomp_real_check(abs);
nucomp_real_check(arg);
break;
}
return f_complex_polar(klass, abs, arg);
}; T;BTo;1;2F;3;4;;;#I"Complex#real; F;5[ ; [[@eiZ;
T;;};0;[ ;{ ;IC;"XReturns the real part.
Complex(7).real #=> 7
Complex(9, -4).real #=> 9
; T;[o;7
;8I"
overload; F;90;;};:0;;I" real; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"iReturns the real part.
Complex(7).real #=> 7
Complex(9, -4).real #=> 9
@overload real; T;0;@; F; o; ; T; iQ;!iW;"@7;;I"static VALUE; T;AI"Wstatic VALUE
nucomp_real(VALUE self)
{
get_dat1(self);
return dat->real;
}; T;BTo;1;2F;3;4;;;#I"Complex#imaginary; F;5[ ; [[@eik;
T;;~;0;[ ;{ ;IC;"hReturns the imaginary part.
Complex(7).imaginary #=> 0
Complex(9, -4).imaginary #=> -4
; T;[o;7
;8I"
overload; F;90;;;:0;;I" imag; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;~;:0;;I"imaginary; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the imaginary part.
Complex(7).imaginary #=> 0
Complex(9, -4).imaginary #=> -4
@overload imag
@overload imaginary; T;0;@; F; o; ; T; ia;!ih;"@7;;I"static VALUE; T;AI"Wstatic VALUE
nucomp_imag(VALUE self)
{
get_dat1(self);
return dat->imag;
}; T;BTo;1;2F;3;4;;;#I"Complex#imag; F;5[ ; [[@eik;
T;;;0;[ ;{ ;IC;"hReturns the imaginary part.
Complex(7).imaginary #=> 0
Complex(9, -4).imaginary #=> -4
; T;[o;7
;8I"
overload; F;90;;;:0;;I" imag; T;IC;" ; T;[ ;[ ;I" ; T;0;@ˋ; F;=i ;>0;5[ ;@ˋo;7
;8I"
overload; F;90;;~;:0;;I"imaginary; T;IC;" ; T;[ ;[ ;I" ; T;0;@ˋ; F;=i ;>0;5[ ;@ˋ;[ ;@Nj;0;@ˋ; F; o; ; T; ia;!ih;"@7;;I"static VALUE; T;AI"Wstatic VALUE
nucomp_imag(VALUE self)
{
get_dat1(self);
return dat->imag;
}; T;BTo;1;2F;3;4;;;#I"Complex#-@; F;5[ ; [[@eiz;
T;;D;0;[ ;{ ;IC;"CReturns negation of the value.
-Complex(1, 2) #=> (-1-2i)
; T;[o;7
;8I"
overload; F;90;;E;:0;;I" -cmp; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"TReturns negation of the value.
-Complex(1, 2) #=> (-1-2i)
@overload -cmp; T;0;@; F; o; ; T; ir;!iw;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_negate(VALUE self)
{
get_dat1(self);
return f_complex_new2(CLASS_OF(self),
f_negate(dat->real), f_negate(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#+; F;5[[I"
other; T0; [[@ei;
T;;F;0;[ ;{ ;IC;"Performs addition.
Complex(2, 3) + Complex(2, 3) #=> (4+6i)
Complex(900) + Complex(1) #=> (901+0i)
Complex(-2, 9) + Complex(-9, 2) #=> (-11+11i)
Complex(9, 8) + 4 #=> (13+8i)
Complex(20, 9) + 9.8 #=> (29.8+9i)
; T;[o;7
;8I"
overload; F;90;;F;:0;;I"+(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" numeric; T0;@;[ ;I" Performs addition.
Complex(2, 3) + Complex(2, 3) #=> (4+6i)
Complex(900) + Complex(1) #=> (901+0i)
Complex(-2, 9) + Complex(-9, 2) #=> (-11+11i)
Complex(9, 8) + 4 #=> (13+8i)
Complex(20, 9) + 9.8 #=> (29.8+9i)
@overload +(numeric); T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"gstatic VALUE
nucomp_add(VALUE self, VALUE other)
{
return f_addsub(self, other, f_add, '+');
}; T;BTo;1;2F;3;4;;;#I"Complex#-; F;5[[I"
other; T0; [[@ei;
T;;E;0;[ ;{ ;IC;"Performs subtraction.
Complex(2, 3) - Complex(2, 3) #=> (0+0i)
Complex(900) - Complex(1) #=> (899+0i)
Complex(-2, 9) - Complex(-9, 2) #=> (7+7i)
Complex(9, 8) - 4 #=> (5+8i)
Complex(20, 9) - 9.8 #=> (10.2+9i)
; T;[o;7
;8I"
overload; F;90;;E;:0;;I"-(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" numeric; T0;@;[ ;I" Performs subtraction.
Complex(2, 3) - Complex(2, 3) #=> (0+0i)
Complex(900) - Complex(1) #=> (899+0i)
Complex(-2, 9) - Complex(-9, 2) #=> (7+7i)
Complex(9, 8) - 4 #=> (5+8i)
Complex(20, 9) - 9.8 #=> (10.2+9i)
@overload -(numeric); T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"gstatic VALUE
nucomp_sub(VALUE self, VALUE other)
{
return f_addsub(self, other, f_sub, '-');
}; T;BTo;1;2F;3;4;;;#I"Complex#*; F;5[[I"
other; T0; [[@ei;
T;;G;0;[ ;{ ;IC;"Performs multiplication.
Complex(2, 3) * Complex(2, 3) #=> (-5+12i)
Complex(900) * Complex(1) #=> (900+0i)
Complex(-2, 9) * Complex(-9, 2) #=> (0-85i)
Complex(9, 8) * 4 #=> (36+32i)
Complex(20, 9) * 9.8 #=> (196.0+88.2i)
; T;[o;7
;8I"
overload; F;90;;G;:0;;I"*(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@2; F;=i ;>0;5[[I" numeric; T0;@2;[ ;I")Performs multiplication.
Complex(2, 3) * Complex(2, 3) #=> (-5+12i)
Complex(900) * Complex(1) #=> (900+0i)
Complex(-2, 9) * Complex(-9, 2) #=> (0-85i)
Complex(9, 8) * 4 #=> (36+32i)
Complex(20, 9) * 9.8 #=> (196.0+88.2i)
@overload *(numeric); T;0;@2; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"Gstatic VALUE
nucomp_mul(VALUE self, VALUE other)
{
if (k_complex_p(other)) {
VALUE real, imag;
get_dat2(self, other);
real = f_sub(f_mul(adat->real, bdat->real),
f_mul(adat->imag, bdat->imag));
imag = f_add(f_mul(adat->real, bdat->imag),
f_mul(adat->imag, bdat->real));
return f_complex_new2(CLASS_OF(self), real, imag);
}
if (k_numeric_p(other) && f_real_p(other)) {
get_dat1(self);
return f_complex_new2(CLASS_OF(self),
f_mul(dat->real, other),
f_mul(dat->imag, other));
}
return rb_num_coerce_bin(self, other, '*');
}; T;BTo;1;2F;3;4;;;#I"Complex#/; F;5[[I"
other; T0; [[@ei%;
T;;H;0;[ ;{ ;IC;"JPerforms division.
Complex(2, 3) / Complex(2, 3) #=> ((1/1)+(0/1)*i)
Complex(900) / Complex(1) #=> ((900/1)+(0/1)*i)
Complex(-2, 9) / Complex(-9, 2) #=> ((36/85)-(77/85)*i)
Complex(9, 8) / 4 #=> ((9/4)+(2/1)*i)
Complex(20, 9) / 9.8 #=> (2.0408163265306123+0.9183673469387754i)
; T;[o;7
;8I"
overload; F;90;;H;:0;;I"/(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@L; F;=i ;>0;5[[I" numeric; T0;@Lo;7
;8I"
overload; F;90;;I;:0;;I"quo(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@L; F;=i ;>0;5[[I" numeric; T0;@L;[ ;I"xPerforms division.
Complex(2, 3) / Complex(2, 3) #=> ((1/1)+(0/1)*i)
Complex(900) / Complex(1) #=> ((900/1)+(0/1)*i)
Complex(-2, 9) / Complex(-9, 2) #=> ((36/85)-(77/85)*i)
Complex(9, 8) / 4 #=> ((9/4)+(2/1)*i)
Complex(20, 9) / 9.8 #=> (2.0408163265306123+0.9183673469387754i)
@overload /(numeric)
@overload quo(numeric); T;0;@L; F; o; ; T; i;!i";"@7;;I"static VALUE; T;AI"jstatic VALUE
nucomp_div(VALUE self, VALUE other)
{
return f_divide(self, other, f_quo, id_quo);
}; T;BTo;1;2F;3;4;;;#I"Complex#quo; F;5[ ; [ ;
F;;I;;@;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@p;"@7;BTo;1;2F;3;4;;;#I"Complex#fdiv; F;5[[I"
other; T0; [[@ei5;
T;;J;0;[ ;{ ;IC;"Performs division as each part is a float, never returns a float.
Complex(11, 22).fdiv(3) #=> (3.6666666666666665+7.333333333333333i)
; T;[o;7
;8I"
overload; F;90;;J;:0;;I"fdiv(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@y; F;=i ;>0;5[[I" numeric; T0;@y;[ ;I"Performs division as each part is a float, never returns a float.
Complex(11, 22).fdiv(3) #=> (3.6666666666666665+7.333333333333333i)
@overload fdiv(numeric); T;0;@y; F; o; ; T; i-;!i2;"@7;;I"static VALUE; T;AI"mstatic VALUE
nucomp_fdiv(VALUE self, VALUE other)
{
return f_divide(self, other, f_fdiv, id_fdiv);
}; T;BTo;1;2F;3;4;;;#I"Complex#**; F;5[[I"
other; T0; [[@eiJ;
T;;N;0;[ ;{ ;IC;"Performs exponentiation.
Complex('i') ** 2 #=> (-1+0i)
Complex(-8) ** Rational(1, 3) #=> (1.0000000000000002+1.7320508075688772i)
; T;[o;7
;8I"
overload; F;90;;N;:0;;I"**(numeric); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" numeric; T0;@;[ ;I"Performs exponentiation.
Complex('i') ** 2 #=> (-1+0i)
Complex(-8) ** Rational(1, 3) #=> (1.0000000000000002+1.7320508075688772i)
@overload **(numeric); T;0;@; F; o; ; T; iA;!iG;"@7;;I"static VALUE; T;AI"nstatic VALUE
nucomp_expt(VALUE self, VALUE other)
{
if (k_numeric_p(other) && k_exact_zero_p(other))
return f_complex_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other) && f_one_p(f_denominator(other)))
other = f_numerator(other); /* c14n */
if (k_complex_p(other)) {
get_dat1(other);
if (k_exact_zero_p(dat->imag))
other = dat->real; /* c14n */
}
if (k_complex_p(other)) {
VALUE r, theta, nr, ntheta;
get_dat1(other);
r = f_abs(self);
theta = f_arg(self);
nr = m_exp_bang(f_sub(f_mul(dat->real, m_log_bang(r)),
f_mul(dat->imag, theta)));
ntheta = f_add(f_mul(theta, dat->real),
f_mul(dat->imag, m_log_bang(r)));
return f_complex_polar(CLASS_OF(self), nr, ntheta);
}
if (k_fixnum_p(other)) {
if (f_gt_p(other, ZERO)) {
VALUE x, z;
long n;
x = self;
z = x;
n = FIX2LONG(other) - 1;
while (n) {
long q, r;
while (1) {
get_dat1(x);
q = n / 2;
r = n % 2;
if (r)
break;
x = nucomp_s_new_internal(CLASS_OF(self),
f_sub(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag)),
f_mul(f_mul(TWO, dat->real), dat->imag));
n = q;
}
z = f_mul(z, x);
n--;
}
return z;
}
return f_expt(f_reciprocal(self), f_negate(other));
}
if (k_numeric_p(other) && f_real_p(other)) {
VALUE r, theta;
if (k_bignum_p(other))
rb_warn("in a**b, b may be too big");
r = f_abs(self);
theta = f_arg(self);
return f_complex_polar(CLASS_OF(self), f_expt(r, other),
f_mul(theta, other));
}
return rb_num_coerce_bin(self, other, id_expt);
}; T;BTo;1;2F;3;4;;;#I"Complex#==; F;5[[I"
other; T0; [[@ei;
T;;O;0;[ ;{ ;IC;"Returns true if cmp equals object numerically.
Complex(2, 3) == Complex(2, 3) #=> true
Complex(5) == 5 #=> true
Complex(0) == 0.0 #=> true
Complex('1/3') == 0.33 #=> false
Complex('1/2') == '1/2' #=> false
; T;[o;7
;8I"
overload; F;90;;O;:0;;I"==(object); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@;[ ;I"@return [Boolean]; T;0;@; F;=i ;>0;5[[I" object; T0;@;[ ;I"BReturns true if cmp equals object numerically.
Complex(2, 3) == Complex(2, 3) #=> true
Complex(5) == 5 #=> true
Complex(0) == 0.0 #=> true
Complex('1/3') == 0.33 #=> false
Complex('1/2') == '1/2' #=> false
@overload ==(object)
@return [Boolean]; T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_eqeq_p(VALUE self, VALUE other)
{
if (k_complex_p(other)) {
get_dat2(self, other);
return f_boolcast(f_eqeq_p(adat->real, bdat->real) &&
f_eqeq_p(adat->imag, bdat->imag));
}
if (k_numeric_p(other) && f_real_p(other)) {
get_dat1(self);
return f_boolcast(f_eqeq_p(dat->real, other) && f_zero_p(dat->imag));
}
return f_eqeq_p(other, self);
}; T;BTo;1;2F;3;4;;;#I"Complex#coerce; F;5[[I"
other; T0; [[@ei;
T;;C;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@̌; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"{static VALUE
nucomp_coerce(VALUE self, VALUE other)
{
if (k_numeric_p(other) && f_real_p(other))
return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self);
if (RB_TYPE_P(other, T_COMPLEX))
return rb_assoc_new(other, self);
rb_raise(rb_eTypeError, "%s can't be coerced into %s",
rb_obj_classname(other), rb_obj_classname(self));
return Qnil;
}; T;BTo;1;2F;3;4;;;#I"Complex#abs; F;5[ ; [[@ei;
T;;Y;0;[ ;{ ;IC;"vReturns the absolute part of its polar form.
Complex(-1).abs #=> 1
Complex(3.0, -4.0).abs #=> 5.0
; T;[o;7
;8I"
overload; F;90;;Y;:0;;I"abs; T;IC;" ; T;[ ;[ ;I" ; T;0;@܌; F;=i ;>0;5[ ;@܌o;7
;8I"
overload; F;90;;Z;:0;;I"magnitude; T;IC;" ; T;[ ;[ ;I" ; T;0;@܌; F;=i ;>0;5[ ;@܌;[ ;I"Returns the absolute part of its polar form.
Complex(-1).abs #=> 1
Complex(3.0, -4.0).abs #=> 5.0
@overload abs
@overload magnitude; T;0;@܌; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_abs(VALUE self)
{
get_dat1(self);
if (f_zero_p(dat->real)) {
VALUE a = f_abs(dat->imag);
if (k_float_p(dat->real) && !k_float_p(dat->imag))
a = f_to_f(a);
return a;
}
if (f_zero_p(dat->imag)) {
VALUE a = f_abs(dat->real);
if (!k_float_p(dat->real) && k_float_p(dat->imag))
a = f_to_f(a);
return a;
}
return m_hypot(dat->real, dat->imag);
}; T;BTo;1;2F;3;4;;;#I"Complex#magnitude; F;5[ ; [[@ei;
T;;Z;0;[ ;{ ;IC;"vReturns the absolute part of its polar form.
Complex(-1).abs #=> 1
Complex(3.0, -4.0).abs #=> 5.0
; T;[o;7
;8I"
overload; F;90;;Y;:0;;I"abs; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;Z;:0;;I"magnitude; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;@;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_abs(VALUE self)
{
get_dat1(self);
if (f_zero_p(dat->real)) {
VALUE a = f_abs(dat->imag);
if (k_float_p(dat->real) && !k_float_p(dat->imag))
a = f_to_f(a);
return a;
}
if (f_zero_p(dat->imag)) {
VALUE a = f_abs(dat->real);
if (!k_float_p(dat->real) && k_float_p(dat->imag))
a = f_to_f(a);
return a;
}
return m_hypot(dat->real, dat->imag);
}; T;BTo;1;2F;3;4;;;#I"Complex#abs2; F;5[ ; [[@ei;
T;;;0;[ ;{ ;IC;"rReturns square of the absolute value.
Complex(-1).abs2 #=> 1
Complex(3.0, -4.0).abs2 #=> 25.0
; T;[o;7
;8I"
overload; F;90;;;:0;;I" abs2; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"~Returns square of the absolute value.
Complex(-1).abs2 #=> 1
Complex(3.0, -4.0).abs2 #=> 25.0
@overload abs2; T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_abs2(VALUE self)
{
get_dat1(self);
return f_add(f_mul(dat->real, dat->real),
f_mul(dat->imag, dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#arg; F;5[ ; [[@ei;
T;;e;0;[ ;{ ;IC;"kReturns the angle part of its polar form.
Complex.polar(3, Math::PI/2).arg #=> 1.5707963267948966
; T;[o;7
;8I"
overload; F;90;;e;:0;;I"arg; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@-;[ ;I"@return [Float]; T;0;@-; F;=i ;>0;5[ ;@-o;7
;8I"
overload; F;90;;f;:0;;I"
angle; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@-;[ ;I"@return [Float]; T;0;@-; F;=i ;>0;5[ ;@-o;7
;8I"
overload; F;90;;g;:0;;I"
phase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@-;[ ;I"@return [Float]; T;0;@-; F;=i ;>0;5[ ;@-;[ ;I"Returns the angle part of its polar form.
Complex.polar(3, Math::PI/2).arg #=> 1.5707963267948966
@overload arg
@return [Float]
@overload angle
@return [Float]
@overload phase
@return [Float]; T;0;@-; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"ostatic VALUE
nucomp_arg(VALUE self)
{
get_dat1(self);
return m_atan2_bang(dat->imag, dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#angle; F;5[ ; [[@ei;
T;;f;0;[ ;{ ;IC;"kReturns the angle part of its polar form.
Complex.polar(3, Math::PI/2).arg #=> 1.5707963267948966
; T;[o;7
;8I"
overload; F;90;;e;:0;;I"arg; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@b;[ ;I"@return [Float]; T;0;@b; F;=i ;>0;5[ ;@bo;7
;8I"
overload; F;90;;f;:0;;I"
angle; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@b;[ ;I"@return [Float]; T;0;@b; F;=i ;>0;5[ ;@bo;7
;8I"
overload; F;90;;g;:0;;I"
phase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@b;[ ;I"@return [Float]; T;0;@b; F;=i ;>0;5[ ;@b;[ ;@^;0;@b; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"ostatic VALUE
nucomp_arg(VALUE self)
{
get_dat1(self);
return m_atan2_bang(dat->imag, dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#phase; F;5[ ; [[@ei;
T;;g;0;[ ;{ ;IC;"kReturns the angle part of its polar form.
Complex.polar(3, Math::PI/2).arg #=> 1.5707963267948966
; T;[o;7
;8I"
overload; F;90;;e;:0;;I"arg; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@;[ ;I"@return [Float]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;f;:0;;I"
angle; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@;[ ;I"@return [Float]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;g;:0;;I"
phase; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@;[ ;I"@return [Float]; T;0;@; F;=i ;>0;5[ ;@;[ ;@^;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"ostatic VALUE
nucomp_arg(VALUE self)
{
get_dat1(self);
return m_atan2_bang(dat->imag, dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#rectangular; F;5[ ; [[@ei
;
T;;;0;[ ;{ ;IC;"VReturns an array; [cmp.real, cmp.imag].
Complex(1, 2).rectangular #=> [1, 2]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@ʍ;[ ;I"@return [Array]; T;0;@ʍ; F;=i ;>0;5[ ;@ʍo;7
;8I"
overload; F;90;;;:0;;I"rectangular; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@ʍ;[ ;I"@return [Array]; T;0;@ʍ; F;=i ;>0;5[ ;@ʍ;[ ;I"Returns an array; [cmp.real, cmp.imag].
Complex(1, 2).rectangular #=> [1, 2]
@overload rect
@return [Array]
@overload rectangular
@return [Array]; T;0;@ʍ; F; o; ; T; i;!i ;"@7;;I"static VALUE; T;AI"pstatic VALUE
nucomp_rect(VALUE self)
{
get_dat1(self);
return rb_assoc_new(dat->real, dat->imag);
}; T;BTo;1;2F;3;4;;;#I"Complex#rect; F;5[ ; [[@ei
;
T;;;0;[ ;{ ;IC;"VReturns an array; [cmp.real, cmp.imag].
Complex(1, 2).rectangular #=> [1, 2]
; T;[o;7
;8I"
overload; F;90;;;:0;;I" rect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;[ ;I"@return [Array]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;;:0;;I"rectangular; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;[ ;I"@return [Array]; T;0;@; F;=i ;>0;5[ ;@;[ ;@;0;@; F; o; ; T; i;!i ;"@7;;I"static VALUE; T;AI"pstatic VALUE
nucomp_rect(VALUE self)
{
get_dat1(self);
return rb_assoc_new(dat->real, dat->imag);
}; T;BTo;1;2F;3;4;;;#I"Complex#polar; F;5[ ; [[@ei ;
T;;;0;[ ;{ ;IC;"nReturns an array; [cmp.abs, cmp.arg].
Complex(1, 2).polar #=> [2.23606797749979, 1.1071487177940904]
; T;[o;7
;8I"
overload; F;90;;;:0;;I"
polar; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Array; T;@;[ ;I"@return [Array]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns an array; [cmp.abs, cmp.arg].
Complex(1, 2).polar #=> [2.23606797749979, 1.1071487177940904]
@overload polar
@return [Array]; T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"astatic VALUE
nucomp_polar(VALUE self)
{
return rb_assoc_new(f_abs(self), f_arg(self));
}; T;BTo;1;2F;3;4;;;#I"Complex#conjugate; F;5[ ; [[@ei+;
T;;;0;[ ;{ ;IC;"KReturns the complex conjugate.
Complex(1, 2).conjugate #=> (1-2i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I" conj; T;IC;" ; T;[ ;[ ;I" ; T;0;@4; F;=i ;>0;5[ ;@4o;7
;8I"
overload; F;90;;;:0;;I"conjugate; T;IC;" ; T;[ ;[ ;I" ; T;0;@4; F;=i ;>0;5[ ;@4;[ ;I"pReturns the complex conjugate.
Complex(1, 2).conjugate #=> (1-2i)
@overload conj
@overload conjugate; T;0;@4; F; o; ; T; i";!i(;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_conj(VALUE self)
{
get_dat1(self);
return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#conj; F;5[ ; [[@ei+;
T;;;0;[ ;{ ;IC;"KReturns the complex conjugate.
Complex(1, 2).conjugate #=> (1-2i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I" conj; T;IC;" ; T;[ ;[ ;I" ; T;0;@R; F;=i ;>0;5[ ;@Ro;7
;8I"
overload; F;90;;;:0;;I"conjugate; T;IC;" ; T;[ ;[ ;I" ; T;0;@R; F;=i ;>0;5[ ;@R;[ ;@N;0;@R; F; o; ; T; i";!i(;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_conj(VALUE self)
{
get_dat1(self);
return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#~; F;5[ ; [[@ei+;
T;;@;0;[ ;{ ;IC;"KReturns the complex conjugate.
Complex(1, 2).conjugate #=> (1-2i)
; T;[o;7
;8I"
overload; F;90;;;:0;;I" conj; T;IC;" ; T;[ ;[ ;I" ; T;0;@o; F;=i ;>0;5[ ;@oo;7
;8I"
overload; F;90;;;:0;;I"conjugate; T;IC;" ; T;[ ;[ ;I" ; T;0;@o; F;=i ;>0;5[ ;@o;[ ;@N;0;@o; F; o; ; T; i";!i(;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_conj(VALUE self)
{
get_dat1(self);
return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#real?; F;5[ ; [[@eiA;
T;;};0;[ ;{ ;IC;"Returns false.
; T;[o;7
;8I"
overload; F;90;;};:0;;I"
real?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
false; T;@;[ ;I"@return [false]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I"7Returns false.
@overload real?
@return [false]; T;0;@; F; o; ; T; i;;!i?;"@7;;I"static VALUE; T;AI"Astatic VALUE
nucomp_false(VALUE self)
{
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Complex#complex?; F;5[ ; [[@ei4;
T;:
complex?;0;[ ;{ ;IC;" :nodoc:
; T;[o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I" :nodoc:; T;0;@; F; o; ; T; i3;!i3;"@7;;I"static VALUE; T;AI"?static VALUE
nucomp_true(VALUE self)
{
return Qtrue;
}; T;BTo;1;2F;3;4;;;#I"Complex#exact?; F;5[ ; [[@eiI;
T;: exact?;0;[ ;{ ;IC;" :nodoc:
; T;[o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I" :nodoc:; T;0;@; F; o; ; T; iH;!iH;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_exact_p(VALUE self)
{
get_dat1(self);
return f_boolcast(k_exact_p(dat->real) && k_exact_p(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#inexact?; F;5[ ; [[@eiQ;
T;:
inexact?;0;[ ;{ ;IC;" :nodoc:
; T;[o;<
;8I" return; F;9@f;0;:[@h;@̎;[ ;I" :nodoc:; T;0;@̎; F; o; ; T; iP;!iP;"@7;;I"static VALUE; T;AI"`static VALUE
nucomp_inexact_p(VALUE self)
{
return f_boolcast(!nucomp_exact_p(self));
}; T;BTo;1;2F;3;4;;;#I"Complex#numerator; F;5[ ; [[@eiy;
T;;h;0;[ ;{ ;IC;"Returns the numerator.
1 2 3+4i <- numerator
- + -i -> ----
2 3 6 <- denominator
c = Complex('1/2+2/3i') #=> ((1/2)+(2/3)*i)
n = c.numerator #=> (3+4i)
d = c.denominator #=> 6
n / d #=> ((1/2)+(2/3)*i)
Complex(Rational(n.real, d), Rational(n.imag, d))
#=> ((1/2)+(2/3)*i)
See denominator.
; T;[o;7
;8I"
overload; F;90;;h;:0;;I"numerator; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Numeric; T;@ݎ;[ ;I"@return [Numeric]; T;0;@ݎ; F;=i ;>0;5[ ;@ݎ;[ ;I"Returns the numerator.
1 2 3+4i <- numerator
- + -i -> ----
2 3 6 <- denominator
c = Complex('1/2+2/3i') #=> ((1/2)+(2/3)*i)
n = c.numerator #=> (3+4i)
d = c.denominator #=> 6
n / d #=> ((1/2)+(2/3)*i)
Complex(Rational(n.real, d), Rational(n.imag, d))
#=> ((1/2)+(2/3)*i)
See denominator.
@overload numerator
@return [Numeric]; T;0;@ݎ; F; o; ; T; ig;!iw;"@7;;I"static VALUE; T;AI"4static VALUE
nucomp_numerator(VALUE self)
{
VALUE cd;
get_dat1(self);
cd = f_denominator(self);
return f_complex_new2(CLASS_OF(self),
f_mul(f_numerator(dat->real),
f_div(cd, f_denominator(dat->real))),
f_mul(f_numerator(dat->imag),
f_div(cd, f_denominator(dat->imag))));
}; T;BTo;1;2F;3;4;;;#I"Complex#denominator; F;5[ ; [[@ei`;
T;;i;0;[ ;{ ;IC;"WReturns the denominator (lcm of both denominator - real and imag).
See numerator.
; T;[o;7
;8I"
overload; F;90;;i;:0;;I"denominator; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"~Returns the denominator (lcm of both denominator - real and imag).
See numerator.
@overload denominator
@return [Integer]; T;0;@; F; o; ; T; iX;!i^;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_denominator(VALUE self)
{
get_dat1(self);
return rb_lcm(f_denominator(dat->real), f_denominator(dat->imag));
}; T;BTo;1;2F;3;4;;;#I"Complex#hash; F;5[ ; [[@ei;
T;;W;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_hash(VALUE self)
{
st_index_t v, h[2];
VALUE n;
get_dat1(self);
n = rb_hash(dat->real);
h[0] = NUM2LONG(n);
n = rb_hash(dat->imag);
h[1] = NUM2LONG(n);
v = rb_memhash(h, sizeof(h));
return LONG2FIX(v);
}; T;BTo;1;2F;3;4;;;#I"Complex#eql?; F;5[[I"
other; T0; [[@ei;
T;;V;0;[ ;{ ;IC;" :nodoc:
; T;[o;<
;8I" return; F;9@f;0;:[@h;@!;[ ;I" :nodoc:; T;0;@!; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI" static VALUE
nucomp_eql_p(VALUE self, VALUE other)
{
if (k_complex_p(other)) {
get_dat2(self, other);
return f_boolcast((CLASS_OF(adat->real) == CLASS_OF(bdat->real)) &&
(CLASS_OF(adat->imag) == CLASS_OF(bdat->imag)) &&
f_eqeq_p(self, other));
}
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"Complex#to_s; F;5[ ; [[@ei;
T;;6;0;[ ;{ ;IC;"5Returns the value as a string.
Complex(2).to_s #=> "2+0i"
Complex('-8/6').to_s #=> "-4/3+0i"
Complex('1/2i').to_s #=> "0+1/2i"
Complex(0, Float::INFINITY).to_s #=> "0+Infinity*i"
Complex(Float::NAN, Float::NAN).to_s #=> "NaN+NaN*i"
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@4;[ ;I"@return [String]; T;0;@4; F;=i ;>0;5[ ;@4;[ ;I"YReturns the value as a string.
Complex(2).to_s #=> "2+0i"
Complex('-8/6').to_s #=> "-4/3+0i"
Complex('1/2i').to_s #=> "0+1/2i"
Complex(0, Float::INFINITY).to_s #=> "0+Infinity*i"
Complex(Float::NAN, Float::NAN).to_s #=> "NaN+NaN*i"
@overload to_s
@return [String]; T;0;@4; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"Pstatic VALUE
nucomp_to_s(VALUE self)
{
return f_format(self, f_to_s);
}; T;BTo;1;2F;3;4;;;#I"Complex#inspect; F;5[ ; [[@ei;
T;;?;0;[ ;{ ;IC;"bReturns the value as a string for inspection.
Complex(2).inspect #=> "(2+0i)"
Complex('-8/6').inspect #=> "((-4/3)+0i)"
Complex('1/2i').inspect #=> "(0+(1/2)*i)"
Complex(0, Float::INFINITY).inspect #=> "(0+Infinity*i)"
Complex(Float::NAN, Float::NAN).inspect #=> "(NaN+NaN*i)"
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@O;[ ;I"@return [String]; T;0;@O; F;=i ;>0;5[ ;@O;[ ;I"Returns the value as a string for inspection.
Complex(2).inspect #=> "(2+0i)"
Complex('-8/6').inspect #=> "((-4/3)+0i)"
Complex('1/2i').inspect #=> "(0+(1/2)*i)"
Complex(0, Float::INFINITY).inspect #=> "(0+Infinity*i)"
Complex(Float::NAN, Float::NAN).inspect #=> "(NaN+NaN*i)"
@overload inspect
@return [String]; T;0;@O; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_inspect(VALUE self)
{
VALUE s;
s = rb_usascii_str_new2("(");
rb_str_concat(s, f_format(self, f_inspect));
rb_str_cat2(s, ")");
return s;
}; T;BTo;1;2F;3;4;;
;#I"Complex#marshal_dump; F;5[ ; [[@ei
;
T;;C;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@j; F; o; ; T; i ;!i ;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_marshal_dump(VALUE self)
{
VALUE a;
get_dat1(self);
a = rb_assoc_new(dat->real, dat->imag);
rb_copy_generic_ivar(a, self);
return a;
}; T;BTo; ;IC;[o;1;2F;3;4;;
;#I"%Complex::compatible#marshal_load; F;5[[I"a; T0; [[@ei;
T;;D;0;[ ;{ ;IC;" :nodoc:
; T;[ ;[ ;I" :nodoc:; T;0;@z; F; o; ; T; i;!i;"@x;;I"static VALUE; T;AI"Vstatic VALUE
nucomp_marshal_load(VALUE self, VALUE a)
{
Check_Type(a, T_ARRAY);
if (RARRAY_LEN(a) != 2)
rb_raise(rb_eArgError, "marshaled complex must have an array whose length is 2 but %ld", RARRAY_LEN(a));
rb_ivar_set(self, id_i_real, RARRAY_AREF(a, 0));
rb_ivar_set(self, id_i_imag, RARRAY_AREF(a, 1));
return self;
}; T;BT;l@x;mIC;[ ;l@x;nIC;[ ;l@x;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@eiu;
F;:compatible;;@;;;[ ;{ ;IC;" ; T;[ ;[ ;@f;0;@x;=i ;"@7;#I"Complex::compatible; F;v@ o;1;2F;3;4;;;#I"Complex#to_i; F;5[ ; [[@eiN;
T;;\;0;[ ;{ ;IC;"Returns the value as an integer if possible (the imaginary part
should be exactly zero).
Complex(1, 0).to_i #=> 1
Complex(1, 0.0).to_i # RangeError
Complex(1, 2).to_i # RangeError
; T;[o;7
;8I"
overload; F;90;;\;:0;;I" to_i; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Integer; T;@;[ ;I"@return [Integer]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the value as an integer if possible (the imaginary part
should be exactly zero).
Complex(1, 0).to_i #=> 1
Complex(1, 0.0).to_i # RangeError
Complex(1, 2).to_i # RangeError
@overload to_i
@return [Integer]; T;0;@; F; o; ; T; iC;!iL;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_to_i(VALUE self)
{
get_dat1(self);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
VALUE s = f_to_s(self);
rb_raise(rb_eRangeError, "can't convert %s into Integer",
StringValuePtr(s));
}
return f_to_i(dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#to_f; F;5[ ; [[@eif;
T;;X;0;[ ;{ ;IC;"Returns the value as a float if possible (the imaginary part should
be exactly zero).
Complex(1, 0).to_f #=> 1.0
Complex(1, 0.0).to_f # RangeError
Complex(1, 2).to_f # RangeError
; T;[o;7
;8I"
overload; F;90;;X;:0;;I" to_f; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
Float; T;@;[ ;I"@return [Float]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the value as a float if possible (the imaginary part should
be exactly zero).
Complex(1, 0).to_f #=> 1.0
Complex(1, 0.0).to_f # RangeError
Complex(1, 2).to_f # RangeError
@overload to_f
@return [Float]; T;0;@; F; o; ; T; i[;!id;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_to_f(VALUE self)
{
get_dat1(self);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
VALUE s = f_to_s(self);
rb_raise(rb_eRangeError, "can't convert %s into Float",
StringValuePtr(s));
}
return f_to_f(dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#to_r; F;5[ ; [[@ei;
T;;j;0;[ ;{ ;IC;"Returns the value as a rational if possible (the imaginary part
should be exactly zero).
Complex(1, 0).to_r #=> (1/1)
Complex(1, 0.0).to_r # RangeError
Complex(1, 2).to_r # RangeError
See rationalize.
; T;[o;7
;8I"
overload; F;90;;j;:0;;I" to_r; T;IC;" ; T;[ ;[ ;I" ; T;0;@Ϗ; F;=i ;>0;5[ ;@Ϗ;[ ;I"Returns the value as a rational if possible (the imaginary part
should be exactly zero).
Complex(1, 0).to_r #=> (1/1)
Complex(1, 0.0).to_r # RangeError
Complex(1, 2).to_r # RangeError
See rationalize.
@overload to_r; T;0;@Ϗ; F; o; ; T; is;!i};"@7;;I"static VALUE; T;AI" static VALUE
nucomp_to_r(VALUE self)
{
get_dat1(self);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
VALUE s = f_to_s(self);
rb_raise(rb_eRangeError, "can't convert %s into Rational",
StringValuePtr(s));
}
return f_to_r(dat->real);
}; T;BTo;1;2F;3;4;;;#I"Complex#rationalize; F;5[[@0; [[@ei;
T;;k;0;[ ;{ ;IC;"Returns the value as a rational if possible (the imaginary part
should be exactly zero).
Complex(1.0/3, 0).rationalize #=> (1/3)
Complex(1, 0.0).rationalize # RangeError
Complex(1, 2).rationalize # RangeError
See to_r.
; T;[o;7
;8I"
overload; F;90;;k;:0;;I"rationalize([eps]); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I"
[eps]; T0;@;[ ;I"
Returns the value as a rational if possible (the imaginary part
should be exactly zero).
Complex(1.0/3, 0).rationalize #=> (1/3)
Complex(1, 0.0).rationalize # RangeError
Complex(1, 2).rationalize # RangeError
See to_r.
@overload rationalize([eps]); T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI"static VALUE
nucomp_rationalize(int argc, VALUE *argv, VALUE self)
{
get_dat1(self);
rb_scan_args(argc, argv, "01", NULL);
if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {
VALUE s = f_to_s(self);
rb_raise(rb_eRangeError, "can't convert %s into Rational",
StringValuePtr(s));
}
return rb_funcall2(dat->real, rb_intern("rationalize"), argc, argv);
}; T;BTo;1;2F;3;4;;;#I"Complex#to_c; F;5[ ; [[@ei;
T;;|;0;[ ;{ ;IC;"ZReturns self.
Complex(2).to_c #=> (2+0i)
Complex(-8, 6).to_c #=> (-8+6i)
; T;[o;7
;8I"
overload; F;90;;|;:0;;I" to_c; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" self; T;@;[ ;I"@return [self]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"|Returns self.
Complex(2).to_c #=> (2+0i)
Complex(-8, 6).to_c #=> (-8+6i)
@overload to_c
@return [self]; T;0;@; F; o; ; T; i;!i;"@7;;I"static VALUE; T;AI">static VALUE
nucomp_to_c(VALUE self)
{
return self;
}; T;BTo;
; [[@ei;
F;:I;;;;;[ ;{ ;IC;"The imaginary unit.
; T;[ ;[ ;I"The imaginary unit.
; T;0;@; F; o; ; T; i;!i;"@7;#I"Complex::I; F;$I"0f_complex_new_bang2(rb_cComplex, ZERO, ONE); T;l@7;mIC;[ ;l@7;nIC;[ ;l@7;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@ei ;
F;;;;@;;;[ ;{ ;IC;"3A complex number can be represented as a paired real number with
imaginary unit; a+bi. Where a is real part, b is imaginary part
and i is imaginary unit. Real a equals complex a+0i
mathematically.
In ruby, you can create complex object with Complex, Complex::rect,
Complex::polar or to_c method.
Complex(1) #=> (1+0i)
Complex(2, 3) #=> (2+3i)
Complex.polar(2, 3) #=> (-1.9799849932008908+0.2822400161197344i)
3.to_c #=> (3+0i)
You can also create complex object from floating-point numbers or
strings.
Complex(0.3) #=> (0.3+0i)
Complex('0.3-0.5i') #=> (0.3-0.5i)
Complex('2/3+3/4i') #=> ((2/3)+(3/4)*i)
Complex('1@2') #=> (-0.4161468365471424+0.9092974268256817i)
0.3.to_c #=> (0.3+0i)
'0.3-0.5i'.to_c #=> (0.3-0.5i)
'2/3+3/4i'.to_c #=> ((2/3)+(3/4)*i)
'1@2'.to_c #=> (-0.4161468365471424+0.9092974268256817i)
A complex object is either an exact or an inexact number.
Complex(1, 1) / 2 #=> ((1/2)+(1/2)*i)
Complex(1, 1) / 2.0 #=> (0.5+0.5i)
; T;[ ;[ ;I"4A complex number can be represented as a paired real number with
imaginary unit; a+bi. Where a is real part, b is imaginary part
and i is imaginary unit. Real a equals complex a+0i
mathematically.
In ruby, you can create complex object with Complex, Complex::rect,
Complex::polar or to_c method.
Complex(1) #=> (1+0i)
Complex(2, 3) #=> (2+3i)
Complex.polar(2, 3) #=> (-1.9799849932008908+0.2822400161197344i)
3.to_c #=> (3+0i)
You can also create complex object from floating-point numbers or
strings.
Complex(0.3) #=> (0.3+0i)
Complex('0.3-0.5i') #=> (0.3-0.5i)
Complex('2/3+3/4i') #=> ((2/3)+(3/4)*i)
Complex('1@2') #=> (-0.4161468365471424+0.9092974268256817i)
0.3.to_c #=> (0.3+0i)
'0.3-0.5i'.to_c #=> (0.3-0.5i)
'2/3+3/4i'.to_c #=> ((2/3)+(3/4)*i)
'1@2'.to_c #=> (-0.4161468365471424+0.9092974268256817i)
A complex object is either an exact or an inexact number.
Complex(1, 1) / 2 #=> ((1/2)+(1/2)*i)
Complex(1, 1) / 2.0 #=> (0.5+0.5i)
; T;0;@7; F; o; ; T; i;!i;"@;#I" Complex; F;v@o; ;IC;[o;1;2F;3;4;;;#I"NilClass#to_c; F;5[ ; [[@ei;
T;;|;0;[ ;{ ;IC;" Returns zero as a complex.
; T;[o;7
;8I"
overload; F;90;;|;:0;;I" to_c; T;IC;" ; T;[ ;[ ;I" ; T;0;@8; F;=i ;>0;5[ ;@8;[ ;I"0Returns zero as a complex.
@overload to_c; T;0;@8; F; o; ; T; i;!i;"@6;;I"static VALUE; T;AI"Wstatic VALUE
nilclass_to_c(VALUE self)
{
return rb_complex_new1(INT2FIX(0));
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_r; F;5[ ; [[@ is;
T;;j;0;[ ;{ ;IC;" Returns zero as a rational.
; T;[o;7
;8I"
overload; F;90;;j;:0;;I" to_r; T;IC;" ; T;[ ;[ ;I" ; T;0;@N; F;=i ;>0;5[ ;@N;[ ;I"1Returns zero as a rational.
@overload to_r; T;0;@N; F; o; ; T; im;!ip;"@6;;I"static VALUE; T;AI"Xstatic VALUE
nilclass_to_r(VALUE self)
{
return rb_rational_new1(INT2FIX(0));
}; T;BTo;1;2F;3;4;;;#I"NilClass#rationalize; F;5[[@0; [[@ i;
T;;k;0;[ ;{ ;IC;"NReturns zero as a rational. The optional argument eps is always
ignored.
; T;[o;7
;8I"
overload; F;90;;k;:0;;I"rationalize([eps]); T;IC;" ; T;[ ;[ ;I" ; T;0;@d; F;=i ;>0;5[[I"
[eps]; T0;@d;[ ;I"mReturns zero as a rational. The optional argument eps is always
ignored.
@overload rationalize([eps]); T;0;@d; F; o; ; T; iy;!i};"@6;;I"static VALUE; T;AI"static VALUE
nilclass_rationalize(int argc, VALUE *argv, VALUE self)
{
rb_scan_args(argc, argv, "01", NULL);
return nilclass_to_r(self);
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_i; F;5[ ; [[@R
ic;
T;;\;0;[ ;{ ;IC;".Always returns zero.
nil.to_i #=> 0
; T;[o;7
;8I"
overload; F;90;;\;:0;;I" to_i; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0; T;@};[ ;I"@return [0]; T;0;@}; F;=i ;>0;5[ ;@};[ ;I"MAlways returns zero.
nil.to_i #=> 0
@overload to_i
@return [0]; T;0;@}; F; o; ; T; iY;!i_;"@6;;I"static VALUE; T;AI"@static VALUE
nil_to_i(VALUE obj)
{
return INT2FIX(0);
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_f; F;5[ ; [[@R
ir;
T;;X;0;[ ;{ ;IC;"0Always returns zero.
nil.to_f #=> 0.0
; T;[o;7
;8I"
overload; F;90;;X;:0;;I" to_f; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"0.0; T;@;[ ;I"@return [0.0]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"QAlways returns zero.
nil.to_f #=> 0.0
@overload to_f
@return [0.0]; T;0;@; F; o; ; T; ii;!io;"@6;;I"static VALUE; T;AI"Bstatic VALUE
nil_to_f(VALUE obj)
{
return DBL2NUM(0.0);
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_s; F;5[ ; [[@R
i;
T;;6;0;[ ;{ ;IC;"%Always returns the empty string.
; T;[o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"6Always returns the empty string.
@overload to_s; T;0;@; F; o; ; T; ix;!i{;"@6;;I"static VALUE; T;AI"Nstatic VALUE
nil_to_s(VALUE obj)
{
return rb_usascii_str_new(0, 0);
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_a; F;5[ ; [[@R
i;
T;;;0;[ ;{ ;IC;"\call-seq:
nil.to_a -> []
Always returns an empty array.
nil.to_a #=> []
; T;[ ;[ ;I"_
call-seq:
nil.to_a -> []
Always returns an empty array.
nil.to_a #=> []
; T;0;@ɐ; F; o; ; T; i;!i;"@6;;I"static VALUE; T;AI"Dstatic VALUE
nil_to_a(VALUE obj)
{
return rb_ary_new2(0);
}; T;BTo;1;2F;3;4;;;#I"NilClass#to_h; F;5[ ; [[@R
i;
T;;;0;[ ;{ ;IC;"[call-seq:
nil.to_h -> {}
Always returns an empty hash.
nil.to_h #=> {}
; T;[ ;[ ;I"^
call-seq:
nil.to_h -> {}
Always returns an empty hash.
nil.to_h #=> {}
; T;0;@א; F; o; ; T; i;!i;"@6;;I"static VALUE; T;AI"Cstatic VALUE
nil_to_h(VALUE obj)
{
return rb_hash_new();
}; T;BTo;1;2F;3;4;;;#I"NilClass#inspect; F;5[ ; [[@R
i;
T;;?;0;[ ;{ ;IC;"%Always returns the string "nil".
; T;[o;7
;8I"
overload; F;90;;?;:0;;I" inspect; T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[ ;@;[ ;I"9Always returns the string "nil".
@overload inspect; T;0;@; F; o; ; T; i;!i;"@6;;I"static VALUE; T;AI"Sstatic VALUE
nil_inspect(VALUE obj)
{
return rb_usascii_str_new2("nil");
}; T;BTo;1;2F;3;4;;;#I"NilClass#&; F;5[[I" obj2; T0; [[@R
i";
T;;A;0;[ ;{ ;IC;"And---Returns false. obj is always
evaluated as it is the argument to a method call---there is no
short-circuit evaluation in this case.
; T;[o;7
;8I"
overload; F;90;;A;:0;;I" &(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
false; T;@;[ ;I"@return [false]; T;0;@; F;=i ;>0;5[[I"obj; T0;@o;7
;8I"
overload; F;90;;A;:0;;I" &(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I"
false; T;@;[ ;I"@return [false]; T;0;@; F;=i ;>0;5[[I"obj; T0;@;[ ;I"And---Returns false. obj is always
evaluated as it is the argument to a method call---there is no
short-circuit evaluation in this case.
@overload &(obj)
@return [false]
@overload &(obj)
@return [false]; T;0;@; F; o; ; T; i;!i ;"@6;;I"static VALUE; T;AI"Istatic VALUE
false_and(VALUE obj, VALUE obj2)
{
return Qfalse;
}; T;BTo;1;2F;3;4;;;#I"NilClass#|; F;5[[I" obj2; T0; [[@R
i2;
T;;B;0;[ ;{ ;IC;"zOr---Returns false if obj is
nil or false; true otherwise.
; T;[o;7
;8I"
overload; F;90;;B;:0;;I" |(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@);[ ;I"@return [Boolean]; T;0;@); F;=i ;>0;5[[I"obj; T0;@)o;7
;8I"
overload; F;90;;B;:0;;I" |(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@);[ ;I"@return [Boolean]; T;0;@); F;=i ;>0;5[[I"obj; T0;@);[ ;I"Or---Returns false if obj is
nil or false; true otherwise.
@overload |(obj)
@return [Boolean]
@overload |(obj)
@return [Boolean]; T;0;@); F; o; ; T; i);!i0;"@6;;I"static VALUE; T;AI"Zstatic VALUE
false_or(VALUE obj, VALUE obj2)
{
return RTEST(obj2)?Qtrue:Qfalse;
}; T;BTo;1;2F;3;4;;;#I"NilClass#^; F;5[[I" obj2; T0; [[@R
iE;
T;;C;0;[ ;{ ;IC;"Exclusive Or---If obj is nil or
false, returns false; otherwise, returns
true.
; T;[o;7
;8I"
overload; F;90;;C;:0;;I" ^(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@W;[ ;I"@return [Boolean]; T;0;@W; F;=i ;>0;5[[I"obj; T0;@Wo;7
;8I"
overload; F;90;;C;:0;;I" ^(obj); T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" Boolean; T;@W;[ ;I"@return [Boolean]; T;0;@W; F;=i ;>0;5[[I"obj; T0;@W;[ ;I"Exclusive Or---If obj is nil or
false, returns false; otherwise, returns
true.
@overload ^(obj)
@return [Boolean]
@overload ^(obj)
@return [Boolean]; T;0;@W; F; o; ; T; i:;!iC;"@6;;I"static VALUE; T;AI"[static VALUE
false_xor(VALUE obj, VALUE obj2)
{
return RTEST(obj2)?Qtrue:Qfalse;
}; T;BTo;1;2F;3;4;;;#I"NilClass#nil?; F;5[ ; [[@R
iR;
T;;;0;[ ;{ ;IC;"POnly the object nil responds true to nil?.
; T;[o;7
;8I"
overload; F;90;;;:0;;I" nil?; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" true; T;@;[ ;I"@return [true]; T;0;@; F;=i ;>0;5[ ;@o;<
;8I" return; F;9@f;0;:[@h;@;[ ;I"rOnly the object nil responds true to nil?.
@overload nil?
@return [true]; T;0;@; F; o; ; T; iK;!iO;"@6;;I"static VALUE; T;AI":static VALUE
rb_true(VALUE obj)
{
return Qtrue;
}; T;BT;l@6;mIC;[ ;l@6;nIC;[ ;l@6;oIC;p{;qIC;p{ ;rT;4IC;p{ ;rT;rT;s{ ;t[ ; [[@R
iS[@R
i!
;
T;:
NilClass;;@;;;[ ;{ ;IC;"8The class of the singleton object nil.; T;[ ;[ ;I";
The class of the singleton object nil.
; T;0;@6; F; o; ; T; iS;!iU;=i ;"@;#I"
NilClass; F;v@ @)o; ;IC;[ o;1;2F;3;4;;;#I"Encoding#to_s; F;5[ ; [[@>i6;
T;;6;0;[ ;{ ;IC;"OReturns the name of the encoding.
Encoding::UTF_8.name #=> "UTF-8"
; T;[o;7
;8I"
overload; F;90;: name;:0;;I" name; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@o;7
;8I"
overload; F;90;;6;:0;;I" to_s; T;IC;" ; T;[o;<
;8I" return; F;9I" ; T;0;:[I" String; T;@;[ ;I"@return [String]; T;0;@; F;=i ;>0;5[ ;@;[ ;I"Returns the name of the encoding.
Encoding::UTF_8.name #=> "UTF-8"
@overload name
@return [String]
@overload to_s
@return [String]; T;0;@; F; o; ; T; i-;!i5;"@;;I"static VALUE; T;AI"ustatic VALUE
enc_name(VALUE self)
{
return rb_usascii_str_new2(rb_enc_name((rb_encoding*)DATA_PTR(self)));
}; T;BTo;1;2F;3;4;;;#I"Encoding#inspect; F;5[ ; [[@>i;
T;;?;0;[ ;{ ;IC;"Returns a string which represents the encoding for programmers.
Encoding::UTF_8.inspect #=> "#Encoding.find("internal") however returns nil
when no encoding named "internal", in other words, when Ruby has no
default internal encoding.
; T;[o;7
;8I"
overload; F;90;;;:0;;I"find(string); T;IC;" ; T;[ ;[ ;I" ; T;0;@; F;=i ;>0;5[[I" string; T0;@;[ ;I"uSearch the encoding with specified name.
name should be a string.
Encoding.find("US-ASCII") #=> #Encoding.find("internal") however returns nil
when no encoding named "internal", in other words, when Ruby has no
default internal encoding.
@overload find(string); T;0;@; F; o; ; T; iv;!i;"@;;I"static VALUE; T;AI"static VALUE
enc_find(VALUE klass, VALUE enc)
{
int idx;
if (is_obj_encoding(enc))
return enc;
idx = str_to_encindex(enc);
if (idx == UNSPECIFIED_ENCODING) return Qnil;
return rb_enc_from_encoding_index(idx);
}; T;BTo;1;2F;3;q;;;#I"Encoding.compatible?; F;5[[I" str1; T0[I" str2; T0; [[@>i;
T;:compatible?;0;[ ;{ ;IC;"iChecks the compatibility of two objects.
If the objects are both strings they are compatible when they are
concatenatable. The encoding of the concatenated string will be returned
if they are compatible, nil if they are not.
Encoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b")
#=> #