rbs 4.0.0.dev.5 → 4.0.1.dev.1

data/core/process.rbs

@@ -98,8 +98,8 @@
 #     What the word "executable" means here is depending on platforms.
 #
 #     Even if the file considered "executable", its content may not be in proper
-#     executable format.  In that case, Ruby tries to run it by using `/bin/sh`
-#     on a Unix-like system, like system(3) does.
+#     executable format.  In that case, Ruby tries to run it by using
+#     <code>/bin/sh</code> on a Unix-like system, like system(3) does.
 #
 #         File.write('shell_command', 'echo $SHELL', perm: 0o755)
 #         system('./shell_command')        # prints "/bin/sh" or something.
@@ -157,7 +157,7 @@
 #
 # Optional trailing argument `options` is a hash of execution options.
 #
-# #### Working Directory (`:chdir`)
+# #### Working Directory (<code>:chdir</code>)
 #
 # By default, the working directory for the new process is the same as that of
 # the current process:
@@ -169,7 +169,8 @@
 #
 #     /var
 #
-# Use option `:chdir` to set the working directory for the new process:
+# Use option <code>:chdir</code> to set the working directory for the new
+# process:
 #
 #     Process.spawn('ruby -e "puts Dir.pwd"', {chdir: '/tmp'})
 #
@@ -194,42 +195,43 @@
 #
 # There are these shorthand symbols for fds:
 #
-# *   `:in`: Specifies file descriptor 0 (STDIN).
-# *   `:out`: Specifies file descriptor 1 (STDOUT).
-# *   `:err`: Specifies file descriptor 2 (STDERR).
+# *   <code>:in</code>: Specifies file descriptor 0 (STDIN).
+# *   <code>:out</code>: Specifies file descriptor 1 (STDOUT).
+# *   <code>:err</code>: Specifies file descriptor 2 (STDERR).
 #
 # The value given with a source is one of:
 #
 # *   *n*: Redirects to fd *n* in the parent process.
 # *   `filepath`: Redirects from or to the file at `filepath` via
-#     `open(filepath, mode, 0644)`, where `mode` is `'r'` for source `:in`, or
-#     `'w'` for source `:out` or `:err`.
-# *   `[filepath]`: Redirects from the file at `filepath` via `open(filepath,
-#     'r', 0644)`.
-# *   `[filepath, mode]`: Redirects from or to the file at `filepath` via
-#     `open(filepath, mode, 0644)`.
-# *   `[filepath, mode, perm]`: Redirects from or to the file at `filepath` via
-#     `open(filepath, mode, perm)`.
-# *   `[:child, fd]`: Redirects to the redirected `fd`.
-# *   `:close`: Closes the file descriptor in child process.
+#     <code>open(filepath, mode, 0644)</code>, where `mode` is <code>'r'</code>
+#     for source <code>:in</code>, or <code>'w'</code> for source
+#     <code>:out</code> or <code>:err</code>.
+# *   <code>[filepath]</code>: Redirects from the file at `filepath` via
+#     <code>open(filepath, 'r', 0644)</code>.
+# *   <code>[filepath, mode]</code>: Redirects from or to the file at `filepath`
+#     via <code>open(filepath, mode, 0644)</code>.
+# *   <code>[filepath, mode, perm]</code>: Redirects from or to the file at
+#     `filepath` via <code>open(filepath, mode, perm)</code>.
+# *   <code>[:child, fd]</code>: Redirects to the redirected `fd`.
+# *   <code>:close</code>: Closes the file descriptor in child process.
 #
 # See [Access Modes](rdoc-ref:File@Access+Modes) and [File
 # Permissions](rdoc-ref:File@File+Permissions).
 #
-# #### Environment Variables (`:unsetenv_others`)
+# #### Environment Variables (<code>:unsetenv_others</code>)
 #
 # By default, the new process inherits environment variables from the parent
-# process; use execution option key `:unsetenv_others` with value `true` to
-# clear environment variables in the new process.
+# process; use execution option key <code>:unsetenv_others</code> with value
+# `true` to clear environment variables in the new process.
 #
 # Any changes specified by execution option `env` are made after the new process
 # inherits or clears its environment variables; see [Execution
 # Environment](rdoc-ref:Process@Execution+Environment).
 #
-# #### File-Creation Access (`:umask`)
+# #### File-Creation Access (<code>:umask</code>)
 #
-# Use execution option `:umask` to set the file-creation access for the new
-# process; see [Access Modes](rdoc-ref:File@Access+Modes):
+# Use execution option <code>:umask</code> to set the file-creation access for
+# the new process; see [Access Modes](rdoc-ref:File@Access+Modes):
 #
 #     command = 'ruby -e "puts sprintf(\"0%o\", File.umask)"'
 #     options = {:umask => 0644}
@@ -239,28 +241,29 @@
 #
 #     0644
 #
-# #### Process Groups (`:pgroup` and `:new_pgroup`)
+# #### Process Groups (<code>:pgroup</code> and <code>:new_pgroup</code>)
 #
 # By default, the new process belongs to the same [process
 # group](https://en.wikipedia.org/wiki/Process_group) as the parent process.
 #
-# To specify a different process group. use execution option `:pgroup` with one
-# of the following values:
+# To specify a different process group. use execution option
+# <code>:pgroup</code> with one of the following values:
 #
 # *   `true`: Create a new process group for the new process.
 # *   *pgid*: Create the new process in the process group whose id is *pgid*.
 #
-# On Windows only, use execution option `:new_pgroup` with value `true` to
-# create a new process group for the new process.
+# On Windows only, use execution option <code>:new_pgroup</code> with value
+# `true` to create a new process group for the new process.
 #
 # #### Resource Limits
 #
 # Use execution options to set resource limits.
 #
-# The keys for these options are symbols of the form `:rlimit_*resource_name`*,
-# where *resource_name* is the downcased form of one of the string resource
-# names described at method Process.setrlimit. For example, key `:rlimit_cpu`
-# corresponds to resource limit `'CPU'`.
+# The keys for these options are symbols of the form
+# <code>:rlimit_<i>resource_name</i></code>, where *resource_name* is the
+# downcased form of one of the string resource names described at method
+# Process.setrlimit. For example, key <code>:rlimit_cpu</code> corresponds to
+# resource limit <code>'CPU'</code>.
 #
 # The value for such as key is one of:
 #
@@ -271,13 +274,14 @@
 #
 # By default, the new process inherits file descriptors from the parent process.
 #
-# Use execution option `:close_others => true` to modify that inheritance by
-# closing non-standard fds (3 and greater) that are not otherwise redirected.
+# Use execution option <code>:close_others => true</code> to modify that
+# inheritance by closing non-standard fds (3 and greater) that are not otherwise
+# redirected.
 #
 # ### Execution Shell
 #
-# On a Unix-like system, the shell invoked is `/bin/sh`; the entire string
-# `command_line` is passed as an argument to [shell option
+# On a Unix-like system, the shell invoked is <code>/bin/sh</code>; the entire
+# string `command_line` is passed as an argument to [shell option
 # -c](https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/utilities/sh.
 # html).
 #
@@ -295,21 +299,23 @@
 #
 # On Windows, the shell invoked is determined by environment variable
 # `RUBYSHELL`, if defined, or `COMSPEC` otherwise; the entire string
-# `command_line` is passed as an argument to `-c` option for `RUBYSHELL`, as
-# well as `/bin/sh`, and [/c
+# `command_line` is passed as an argument to <code>-c</code> option for
+# `RUBYSHELL`, as well as <code>/bin/sh</code>, and [/c
 # option](https://learn.microsoft.com/en-us/windows-server/administration/window
 # s-commands/cmd) for `COMSPEC`.  The shell is invoked automatically in the
 # following cases:
 #
-# *   The command is a built-in of `cmd.exe`, such as `echo`.
-# *   The executable file is a batch file; its name ends with `.bat` or `.cmd`.
+# *   The command is a built-in of <code>cmd.exe</code>, such as `echo`.
+# *   The executable file is a batch file; its name ends with <code>.bat</code>
+#     or <code>.cmd</code>.
 #
 # Note that the command will still be invoked as `command_line` form even when
-# called in `exe_path` form, because `cmd.exe` does not accept a script name
-# like `/bin/sh` does but only works with `/c` option.
+# called in `exe_path` form, because <code>cmd.exe</code> does not accept a
+# script name like <code>/bin/sh</code> does but only works with <code>/c</code>
+# option.
 #
-# The standard shell `cmd.exe` performs environment variable expansion but does
-# not have globbing functionality:
+# The standard shell <code>cmd.exe</code> performs environment variable
+# expansion but does not have globbing functionality:
 #
 # Example:
 #
@@ -405,7 +411,7 @@ module Process
   #   - Process._fork   -> integer
   # -->
   # An internal API for fork. Do not call this method directly. Currently, this is
-  # called via Kernel#fork, Process.fork, and IO.popen with `"-"`.
+  # called via Kernel#fork, Process.fork, and IO.popen with <code>"-"</code>.
   #
   # This method is not for casual code but for application monitoring libraries.
   # You can add custom code before and after fork events by overriding this
@@ -453,17 +459,17 @@ module Process
   #     Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :second)            # => 0
   #
   # In addition to the values for `unit` supported in Process.clock_gettime, this
-  # method supports `:hertz`, the integer number of clock ticks per second (which
-  # is the reciprocal of `:float_second`):
+  # method supports <code>:hertz</code>, the integer number of clock ticks per
+  # second (which is the reciprocal of <code>:float_second</code>):
   #
   #     Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)        # => 100.0
   #     Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :float_second) # => 0.01
   #
   # **Accuracy**: Note that the returned resolution may be inaccurate on some
   # platforms due to underlying bugs. Inaccurate resolutions have been reported
-  # for various clocks including `:CLOCK_MONOTONIC` and `:CLOCK_MONOTONIC_RAW` on
-  # Linux, macOS, BSD or AIX platforms, when using ARM processors, or when using
-  # virtualization.
+  # for various clocks including <code>:CLOCK_MONOTONIC</code> and
+  # <code>:CLOCK_MONOTONIC_RAW</code> on Linux, macOS, BSD or AIX platforms, when
+  # using ARM processors, or when using virtualization.
   #
   def self.clock_getres: (Symbol | Integer clock_id, ?Symbol unit) -> (Float | Integer)
 
@@ -482,74 +488,77 @@ module Process
   # Optional argument `unit` should be a symbol that specifies the unit to be used
   # in the returned clock time; see below.
   #
-  # **Argument `clock_id`**
+  # <strong>Argument `clock_id`</strong>
   #
   # Argument `clock_id` specifies the clock whose time is to be returned; it may
-  # be a constant such as `Process::CLOCK_REALTIME`, or a symbol shorthand such as
-  # `:CLOCK_REALTIME`.
+  # be a constant such as <code>Process::CLOCK_REALTIME</code>, or a symbol
+  # shorthand such as <code>:CLOCK_REALTIME</code>.
   #
   # The supported clocks depend on the underlying operating system; this method
   # supports the following clocks on the indicated platforms (raises Errno::EINVAL
   # if called with an unsupported clock):
   #
-  # *   `:CLOCK_BOOTTIME`: Linux 2.6.39.
-  # *   `:CLOCK_BOOTTIME_ALARM`: Linux 3.0.
-  # *   `:CLOCK_MONOTONIC`: SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0,
-  #     OpenBSD 3.4, macOS 10.12, Windows-2000.
-  # *   `:CLOCK_MONOTONIC_COARSE`: Linux 2.6.32.
-  # *   `:CLOCK_MONOTONIC_FAST`: FreeBSD 8.1.
-  # *   `:CLOCK_MONOTONIC_PRECISE`: FreeBSD 8.1.
-  # *   `:CLOCK_MONOTONIC_RAW`: Linux 2.6.28, macOS 10.12.
-  # *   `:CLOCK_MONOTONIC_RAW_APPROX`: macOS 10.12.
-  # *   `:CLOCK_PROCESS_CPUTIME_ID`: SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3,
-  #     OpenBSD 5.4, macOS 10.12.
-  # *   `:CLOCK_PROF`: FreeBSD 3.0, OpenBSD 2.1.
-  # *   `:CLOCK_REALTIME`: SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0,
-  #     OpenBSD 2.1, macOS 10.12, Windows-8/Server-2012. Time.now is recommended
-  #     over +:CLOCK_REALTIME:.
-  # *   `:CLOCK_REALTIME_ALARM`: Linux 3.0.
-  # *   `:CLOCK_REALTIME_COARSE`: Linux 2.6.32.
-  # *   `:CLOCK_REALTIME_FAST`: FreeBSD 8.1.
-  # *   `:CLOCK_REALTIME_PRECISE`: FreeBSD 8.1.
-  # *   `:CLOCK_SECOND`: FreeBSD 8.1.
-  # *   `:CLOCK_TAI`: Linux 3.10.
-  # *   `:CLOCK_THREAD_CPUTIME_ID`: SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD
-  #     5.4, macOS 10.12.
-  # *   `:CLOCK_UPTIME`: FreeBSD 7.0, OpenBSD 5.5.
-  # *   `:CLOCK_UPTIME_FAST`: FreeBSD 8.1.
-  # *   `:CLOCK_UPTIME_PRECISE`: FreeBSD 8.1.
-  # *   `:CLOCK_UPTIME_RAW`: macOS 10.12.
-  # *   `:CLOCK_UPTIME_RAW_APPROX`: macOS 10.12.
-  # *   `:CLOCK_VIRTUAL`: FreeBSD 3.0, OpenBSD 2.1.
+  # *   <code>:CLOCK_BOOTTIME</code>: Linux 2.6.39.
+  # *   <code>:CLOCK_BOOTTIME_ALARM</code>: Linux 3.0.
+  # *   <code>:CLOCK_MONOTONIC</code>: SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0,
+  #     NetBSD 2.0, OpenBSD 3.4, macOS 10.12, Windows-2000.
+  # *   <code>:CLOCK_MONOTONIC_COARSE</code>: Linux 2.6.32.
+  # *   <code>:CLOCK_MONOTONIC_FAST</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_MONOTONIC_PRECISE</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_MONOTONIC_RAW</code>: Linux 2.6.28, macOS 10.12.
+  # *   <code>:CLOCK_MONOTONIC_RAW_APPROX</code>: macOS 10.12.
+  # *   <code>:CLOCK_PROCESS_CPUTIME_ID</code>: SUSv3 to 4, Linux 2.5.63, FreeBSD
+  #     9.3, OpenBSD 5.4, macOS 10.12.
+  # *   <code>:CLOCK_PROF</code>: FreeBSD 3.0, OpenBSD 2.1.
+  # *   <code>:CLOCK_REALTIME</code>: SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0,
+  #     NetBSD 2.0, OpenBSD 2.1, macOS 10.12, Windows-8/Server-2012. Time.now is
+  #     recommended over +:CLOCK_REALTIME:.
+  # *   <code>:CLOCK_REALTIME_ALARM</code>: Linux 3.0.
+  # *   <code>:CLOCK_REALTIME_COARSE</code>: Linux 2.6.32.
+  # *   <code>:CLOCK_REALTIME_FAST</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_REALTIME_PRECISE</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_SECOND</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_TAI</code>: Linux 3.10.
+  # *   <code>:CLOCK_THREAD_CPUTIME_ID</code>: SUSv3 to 4, Linux 2.5.63, FreeBSD
+  #     7.1, OpenBSD 5.4, macOS 10.12.
+  # *   <code>:CLOCK_UPTIME</code>: FreeBSD 7.0, OpenBSD 5.5.
+  # *   <code>:CLOCK_UPTIME_FAST</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_UPTIME_PRECISE</code>: FreeBSD 8.1.
+  # *   <code>:CLOCK_UPTIME_RAW</code>: macOS 10.12.
+  # *   <code>:CLOCK_UPTIME_RAW_APPROX</code>: macOS 10.12.
+  # *   <code>:CLOCK_VIRTUAL</code>: FreeBSD 3.0, OpenBSD 2.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` as
-  # mandatory but `:CLOCK_MONOTONIC`, `:CLOCK_PROCESS_CPUTIME_ID`, and
-  # `:CLOCK_THREAD_CPUTIME_ID` are optional.
+  # clock_gettime is defined in the POSIX part. SUS defines
+  # <code>:CLOCK_REALTIME</code> as mandatory but <code>:CLOCK_MONOTONIC</code>,
+  # <code>:CLOCK_PROCESS_CPUTIME_ID</code>, and
+  # <code>:CLOCK_THREAD_CPUTIME_ID</code> are optional.
   #
   # Certain emulations are used when the given `clock_id` is not supported
   # directly:
   #
-  # *   Emulations for `:CLOCK_REALTIME`:
+  # *   Emulations for <code>:CLOCK_REALTIME</code>:
   #
-  #     *   `:GETTIMEOFDAY_BASED_CLOCK_REALTIME`: Use gettimeofday() defined by
-  #         SUS (deprecated in SUSv4). The resolution is 1 microsecond.
-  #     *   `:TIME_BASED_CLOCK_REALTIME`: Use time() defined by ISO C. The
-  #         resolution is 1 second.
+  #     *   <code>:GETTIMEOFDAY_BASED_CLOCK_REALTIME</code>: Use gettimeofday()
+  #         defined by SUS (deprecated in SUSv4). The resolution is 1 microsecond.
+  #     *   <code>:TIME_BASED_CLOCK_REALTIME</code>: Use time() defined by ISO C.
+  #         The resolution is 1 second.
   #
-  # *   Emulations for `:CLOCK_MONOTONIC`:
+  # *   Emulations for <code>:CLOCK_MONOTONIC</code>:
   #
-  #     *   `: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, thus:
+  #     *   <code>:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC</code>: Use
+  #         mach_absolute_time(), available on Darwin. The resolution is CPU
+  #         dependent.
+  #     *   <code>:TIMES_BASED_CLOCK_MONOTONIC</code>: Use the result value of
+  #         times() defined by POSIX, thus:
   # > Upon successful completion, 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_MONOTONIC` instead, though.)
+  #         monotonic. (FreeBSD uses <code>:CLOCK_MONOTONIC</code> 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
@@ -557,40 +566,40 @@ module Process
   #         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` as 1000000;
-  #         other systems may define it differently. If `CLOCKS_PER_SEC` is
-  #         1000000 (as in SUS), the resolution is 1 microsecond. If
-  #         `CLOCKS_PER_SEC` is 1000000 and clock_t is a 32-bit integer type, it
-  #         cannot represent over 72 minutes.
-  #
-  # **Argument `unit`**
-  #
-  # Optional argument `unit` (default `:float_second`) specifies the unit for the
-  # returned value.
-  #
-  # *   `:float_microsecond`: Number of microseconds as a float.
-  # *   `:float_millisecond`: Number of milliseconds as a float.
-  # *   `:float_second`: Number of seconds as a float.
-  # *   `:microsecond`: Number of microseconds as an integer.
-  # *   `:millisecond`: Number of milliseconds as an integer.
-  # *   `:nanosecond`: Number of nanoseconds as an integer.
-  # *   `:second`: Number of seconds as an integer.
+  # *   Emulations for <code>:CLOCK_PROCESS_CPUTIME_ID</code>:
+  #
+  #     *   <code>:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID</code>: 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.
+  #     *   <code>:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID</code>: 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.
+  #     *   <code>:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID</code>: Use clock()
+  #         defined by ISO C. The resolution is <code>1/CLOCKS_PER_SEC</code>.
+  #         `CLOCKS_PER_SEC` is the C-level macro defined by time.h. SUS defines
+  #         `CLOCKS_PER_SEC` as 1000000; other systems may define it differently.
+  #         If `CLOCKS_PER_SEC` is 1000000 (as in SUS), the resolution is 1
+  #         microsecond. If `CLOCKS_PER_SEC` is 1000000 and clock_t is a 32-bit
+  #         integer type, it cannot represent over 72 minutes.
+  #
+  # <strong>Argument `unit`</strong>
+  #
+  # Optional argument `unit` (default <code>:float_second</code>) specifies the
+  # unit for the returned value.
+  #
+  # *   <code>:float_microsecond</code>: Number of microseconds as a float.
+  # *   <code>:float_millisecond</code>: Number of milliseconds as a float.
+  # *   <code>:float_second</code>: Number of seconds as a float.
+  # *   <code>:microsecond</code>: Number of microseconds as an integer.
+  # *   <code>:millisecond</code>: Number of milliseconds as an integer.
+  # *   <code>:nanosecond</code>: Number of nanoseconds as an integer.
+  # *   <code>:second</code>: Number of seconds as an integer.
   #
   # Examples:
   #
@@ -611,15 +620,15 @@ module Process
   #
   # 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
-  # `:nanosecond` as the `unit`.
+  # <code>:CLOCK_REALTIME</code>. If the exact nanoseconds value is required, use
+  # <code>:nanosecond</code> as the `unit`.
   #
   # The origin (time zero) of the returned value is system-dependent, and may be,
   # 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`; some systems count leap seconds and others don't, so the result may vary
-  # across systems.
+  # The origin in <code>:CLOCK_REALTIME</code> is defined as the Epoch:
+  # <code>1970-01-01 00:00:00 UTC</code>; some systems count leap seconds and
+  # others don't, so the result may vary across systems.
   #
   def self.clock_gettime: (Symbol | Integer clock_id) -> Float
                         | (Symbol | Integer clock_id, :float_second | :float_millisecond | :float_microsecond unit) -> Float
@@ -906,29 +915,29 @@ module Process
   #
   # Argument `signal` specifies the signal to be sent; the argument may be:
   #
-  # *   An integer signal number: e.g., `-29`, `0`, `29`.
-  # *   A signal name (string), with or without leading `'SIG'`, and with or
-  #     without a further prefixed minus sign (`'-'`): e.g.:
+  # *   An integer signal number: e.g., <code>-29</code>, `0`, `29`.
+  # *   A signal name (string), with or without leading <code>'SIG'</code>, and
+  #     with or without a further prefixed minus sign (<code>'-'</code>): e.g.:
   #
-  #     *   `'SIGPOLL'`.
-  #     *   `'POLL'`,
-  #     *   `'-SIGPOLL'`.
-  #     *   `'-POLL'`.
+  #     *   <code>'SIGPOLL'</code>.
+  #     *   <code>'POLL'</code>,
+  #     *   <code>'-SIGPOLL'</code>.
+  #     *   <code>'-POLL'</code>.
   #
-  # *   A signal symbol, with or without leading `'SIG'`, and with or without a
-  #     further prefixed minus sign (`'-'`): e.g.:
+  # *   A signal symbol, with or without leading <code>'SIG'</code>, and with or
+  #     without a further prefixed minus sign (<code>'-'</code>): e.g.:
   #
-  #     *   `:SIGPOLL`.
-  #     *   `:POLL`.
-  #     *   `:'-SIGPOLL'`.
-  #     *   `:'-POLL'`.
+  #     *   <code>:SIGPOLL</code>.
+  #     *   <code>:POLL</code>.
+  #     *   <code>:'-SIGPOLL'</code>.
+  #     *   <code>:'-POLL'</code>.
   #
   # If `signal` is:
   #
-  # *   A non-negative integer, or a signal name or symbol without prefixed `'-'`,
-  #     each process with process ID `id` is signalled.
-  # *   A negative integer, or a signal name or symbol with prefixed `'-'`, each
-  #     process group with group ID `id` is signalled.
+  # *   A non-negative integer, or a signal name or symbol without prefixed
+  #     <code>'-'</code>, each process with process ID `id` is signalled.
+  # *   A negative integer, or a signal name or symbol with prefixed
+  #     <code>'-'</code>, each process group with group ID `id` is signalled.
   #
   # Use method Signal.list to see which signals are supported by Ruby on the
   # underlying platform; the method returns a hash of the string names and
@@ -1064,40 +1073,46 @@ module Process
   #
   # Argument `resource` specifies the resource whose limits are to be set; the
   # argument may be given as a symbol, as a string, or as a constant beginning
-  # with `Process::RLIMIT_` (e.g., `:CORE`, `'CORE'`, or `Process::RLIMIT_CORE`.
+  # with <code>Process::RLIMIT_</code> (e.g., <code>:CORE</code>,
+  # <code>'CORE'</code>, or <code>Process::RLIMIT_CORE</code>.
   #
   # The resources available and supported are system-dependent, and may include
   # (here expressed as symbols):
   #
-  # *   `:AS`: Total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD
-  #     except 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).
-  # *   `:NPTS`: Number of pseudo terminals (number) (FreeBSD).
-  # *   `:RSS`: Resident memory size (bytes) (4.2BSD, GNU/Linux).
-  # *   `:RTPRIO`: Ceiling on the process's real-time priority (number)
+  # *   <code>:AS</code>: Total available memory (bytes) (SUSv3, NetBSD, FreeBSD,
+  #     OpenBSD except 4.4BSD-Lite).
+  # *   <code>:CORE</code>: Core size (bytes) (SUSv3).
+  # *   <code>:CPU</code>: CPU time (seconds) (SUSv3).
+  # *   <code>:DATA</code>: Data segment (bytes) (SUSv3).
+  # *   <code>:FSIZE</code>: File size (bytes) (SUSv3).
+  # *   <code>:MEMLOCK</code>: Total size for mlock(2) (bytes) (4.4BSD,
+  #     GNU/Linux).
+  # *   <code>:MSGQUEUE</code>: Allocation for POSIX message queues (bytes)
   #     (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).
+  # *   <code>:NICE</code>: Ceiling on process's nice(2) value (number)
+  #     (GNU/Linux).
+  # *   <code>:NOFILE</code>: File descriptors (number) (SUSv3).
+  # *   <code>:NPROC</code>: Number of processes for the user (number) (4.4BSD,
+  #     GNU/Linux).
+  # *   <code>:NPTS</code>: Number of pseudo terminals (number) (FreeBSD).
+  # *   <code>:RSS</code>: Resident memory size (bytes) (4.2BSD, GNU/Linux).
+  # *   <code>:RTPRIO</code>: Ceiling on the process's real-time priority (number)
+  #     (GNU/Linux).
+  # *   <code>:RTTIME</code>: CPU time for real-time process (us) (GNU/Linux).
+  # *   <code>:SBSIZE</code>: All socket buffers (bytes) (NetBSD, FreeBSD).
+  # *   <code>:SIGPENDING</code>: Number of queued signals allowed (signals)
+  #     (GNU/Linux).
+  # *   <code>:STACK</code>: Stack size (bytes) (SUSv3).
   #
   # Arguments `cur_limit` and `max_limit` may be:
   #
   # *   Integers (`max_limit` should not be smaller than `cur_limit`).
-  # *   Symbol `:SAVED_MAX`, string `'SAVED_MAX'`, or constant
-  #     `Process::RLIM_SAVED_MAX`: saved maximum limit.
-  # *   Symbol `:SAVED_CUR`, string `'SAVED_CUR'`, or constant
-  #     `Process::RLIM_SAVED_CUR`: saved current limit.
-  # *   Symbol `:INFINITY`, string `'INFINITY'`, or constant
-  #     `Process::RLIM_INFINITY`: no limit on resource.
+  # *   Symbol <code>:SAVED_MAX</code>, string <code>'SAVED_MAX'</code>, or
+  #     constant <code>Process::RLIM_SAVED_MAX</code>: saved maximum limit.
+  # *   Symbol <code>:SAVED_CUR</code>, string <code>'SAVED_CUR'</code>, or
+  #     constant <code>Process::RLIM_SAVED_CUR</code>: saved current limit.
+  # *   Symbol <code>:INFINITY</code>, string <code>'INFINITY'</code>, or constant
+  #     <code>Process::RLIM_INFINITY</code>: no limit on resource.
   #
   # This example raises the soft limit of core size to the hard limit to try to
   # make core dump possible:
@@ -1164,8 +1179,8 @@ module Process
   #   - Process.wait(pid = -1, flags = 0) -> integer
   # -->
   # Waits for a suitable child process to exit, returns its process ID, and sets
-  # `$?` to a Process::Status object containing information on that process. Which
-  # child it waits for depends on the value of the given `pid`:
+  # <code>$?</code> to a Process::Status object containing information on that
+  # process. Which child it waits for depends on the value of the given `pid`:
   #
   # *   Positive integer: Waits for the child process whose process ID is `pid`:
   #
@@ -1211,7 +1226,7 @@ module Process
   #         Process.wait(0) returned pid 225788, which is child 0 pid.
   #         Raised Errno::ECHILD, because child 1 process group ID differs from parent process group ID.
   #
-  # *   `-1` (default): Waits for any child process:
+  # *   <code>-1</code> (default): Waits for any child process:
   #
   #         parent_pgpid = Process.getpgid(Process.pid)
   #         puts "Parent process group ID is #{parent_pgpid}."
@@ -1243,7 +1258,8 @@ module Process
   #         true
   #         true
   #
-  # *   Less than `-1`: Waits for any child whose process group ID is `-pid`:
+  # *   Less than <code>-1</code>: Waits for any child whose process group ID is
+  #     <code>-pid</code>:
   #
   #         parent_pgpid = Process.getpgid(Process.pid)
   #         puts "Parent process group ID is #{parent_pgpid}."
@@ -1329,8 +1345,8 @@ module Process
   #   - Process.wait(pid = -1, flags = 0) -> integer
   # -->
   # Waits for a suitable child process to exit, returns its process ID, and sets
-  # `$?` to a Process::Status object containing information on that process. Which
-  # child it waits for depends on the value of the given `pid`:
+  # <code>$?</code> to a Process::Status object containing information on that
+  # process. Which child it waits for depends on the value of the given `pid`:
   #
   # *   Positive integer: Waits for the child process whose process ID is `pid`:
   #
@@ -1376,7 +1392,7 @@ module Process
   #         Process.wait(0) returned pid 225788, which is child 0 pid.
   #         Raised Errno::ECHILD, because child 1 process group ID differs from parent process group ID.
   #
-  # *   `-1` (default): Waits for any child process:
+  # *   <code>-1</code> (default): Waits for any child process:
   #
   #         parent_pgpid = Process.getpgid(Process.pid)
   #         puts "Parent process group ID is #{parent_pgpid}."
@@ -1408,7 +1424,8 @@ module Process
   #         true
   #         true
   #
-  # *   Less than `-1`: Waits for any child whose process group ID is `-pid`:
+  # *   Less than <code>-1</code>: Waits for any child whose process group ID is
+  #     <code>-pid</code>:
   #
   #         parent_pgpid = Process.getpgid(Process.pid)
   #         puts "Parent process group ID is #{parent_pgpid}."
@@ -1483,13 +1500,14 @@ module Process
   # running applications.
   #
   # This method is expected to be called at the end of the application boot. If
-  # the application is deployed using a pre-forking model, `Process.warmup` should
-  # be called in the original process before the first fork.
+  # the application is deployed using a pre-forking model,
+  # <code>Process.warmup</code> should be called in the original process before
+  # the first fork.
   #
   # The actual optimizations performed are entirely implementation specific and
   # may change in the future without notice.
   #
-  # On CRuby, `Process.warmup`:
+  # On CRuby, <code>Process.warmup</code>:
   #
   # *   Performs a major GC.
   # *   Compacts the heap.
@@ -1832,9 +1850,9 @@ end
 # <!-- rdoc-file=process.c -->
 # A Process::Status contains information about a system process.
 #
-# Thread-local variable `$?` is initially `nil`. Some methods assign to it a
-# Process::Status object that represents a system process (either running or
-# terminated):
+# Thread-local variable <code>$?</code> is initially `nil`. Some methods assign
+# to it a Process::Status object that represents a system process (either
+# running or terminated):
 #
 #     `ruby -e "exit 99"`
 #     stat = $?       # => #<Process::Status: pid 1262862 exit 99>
@@ -1912,8 +1930,8 @@ class Process::Status < Object
   #   rdoc-file=process.c
   #   - exited? -> true or false
   # -->
-  # Returns `true` if the process exited normally (for example using an `exit()`
-  # call or finishing the program), `false` if not.
+  # Returns `true` if the process exited normally (for example using an
+  # <code>exit()</code> call or finishing the program), `false` if not.
   #
   def exited?: () -> bool
 
@@ -2108,8 +2126,8 @@ module Process::Sys
   #   - Process::Sys.setregid(rid, eid)   -> nil
   # -->
   # Sets the (group) real and/or effective group IDs of the current process to
-  # *rid* and *eid*, respectively. A value of `-1` for either means to leave that
-  # ID unchanged. Not available on all platforms.
+  # *rid* and *eid*, respectively. A value of <code>-1</code> for either means to
+  # leave that ID unchanged. Not available on all platforms.
   #
   def self.setregid: (Integer rid, Integer eid) -> nil
 
@@ -2118,8 +2136,8 @@ module Process::Sys
   #   - Process::Sys.setresgid(rid, eid, sid)   -> nil
   # -->
   # Sets the (group) real, effective, and saved user IDs of the current process to
-  # *rid*, *eid*, and *sid* respectively. A value of `-1` for any value means to
-  # leave that ID unchanged. Not available on all platforms.
+  # *rid*, *eid*, and *sid* respectively. A value of <code>-1</code> for any value
+  # means to leave that ID unchanged. Not available on all platforms.
   #
   def self.setresgid: (Integer rid, Integer eid, Integer sid) -> nil
 
@@ -2128,8 +2146,8 @@ module Process::Sys
   #   - Process::Sys.setresuid(rid, eid, sid)   -> nil
   # -->
   # Sets the (user) real, effective, and saved user IDs of the current process to
-  # *rid*, *eid*, and *sid* respectively. A value of `-1` for any value means to
-  # leave that ID unchanged. Not available on all platforms.
+  # *rid*, *eid*, and *sid* respectively. A value of <code>-1</code> for any value
+  # means to leave that ID unchanged. Not available on all platforms.
   #
   def self.setresuid: (Integer rid, Integer eid, Integer sid) -> nil
 
@@ -2138,8 +2156,8 @@ module Process::Sys
   #   - Process::Sys.setreuid(rid, eid)   -> nil
   # -->
   # Sets the (user) real and/or effective user IDs of the current process to *rid*
-  # and *eid*, respectively. A value of `-1` for either means to leave that ID
-  # unchanged. Not available on all platforms.
+  # and *eid*, respectively. A value of <code>-1</code> for either means to leave
+  # that ID unchanged. Not available on all platforms.
   #
   def self.setreuid: (Integer rid, Integer eid) -> nil