RC
Section: User Commands (1)
Updated: 2014-09-01
Index
Return to Main Contents
NAME
rc - shell
SYNOPSIS
rc
[
-deiIlnopsvx]
[
-c
command]
[
arguments]
DESCRIPTION
rc
is a command interpreter and programming language similar to
sh(1).
It is based on the AT&T Plan 9 shell of the same name.
The shell offers a C-like syntax (much more so than the C shell),
and a powerful mechanism for manipulating variables.
It is reasonably small and reasonably fast,
especially when compared to contemporary shells.
Its use is intended to be interactive,
but the language lends itself well to scripts.
OPTIONS
-
R-c
-
If
R-c
is present, commands are executed from the immediately following
argument.
Any further arguments to
rc
are placed in
R$*R.
R$*
Thus:
Rrc -c 'echo $*' 1 2 3
-
prints out
R1 2 3
-
R-d
-
This flag causes
rc
not to ignore
RSIGQUIT
or
RSIGTERMR.
RSIGTERM
Thus
rc
can be made to dump core if sent
RSIGQUITR.
RSIGQUIT
This flag is only useful for debugging
rc.
-
R-e
-
If the
R-e
flag is present, then
rc
will exit if the exit status of a command is false (nonzero).
rc
will not exit, however, if a conditional fails, e.g., an
Rif()
command.
-
R-i
-
If the
R-i
flag is present or if the input to
rc
is from a terminal (as determined by
isatty(3))
then
rc
will be in
interactive
mode.
That is, a prompt (from
R$prompt(1)R)
R$prompt(1)
will be printed before an input line is taken, and
rc
will ignore
RSIGINTR.
RSIGINT
-
R-I
-
If the
R-I
flag is present, or if the input to
rc
is not from a terminal, then
rc
will not be in interactive mode.
No prompts will be printed, and
RSIGINT
will cause
rc
to exit.
-
R-l
-
If the
R-l
flag is present, or if
rc's
Rargv[0][0]
is a dash
R(R-R),
R(R-
R(
then
rc
will behave as a login shell.
That is, it will run commands from
R$home/.rcrcR,
R$home/.rcrc
if this file exists, before reading any other input.
-
R-n
-
This flag causes
rc
to read its input and parse it, but not to execute any commands.
This is useful for syntax checking on scripts.
If used in combination with the
R-x
flag,
rc
will print each command as it is parsed in a form similar to the one
used for exporting functions into the environment.
-
R-o
-
This flag prevents the usual practice of trying to open
R/dev/null
on file descriptors 0, 1, and 2, if any of those descriptors
are inherited closed.
-
R-p
-
This flag prevents
rc
from initializing shell functions from the environment.
This allows
rc
to run in a protected mode, whereby it becomes more difficult for
an
rc
script to be subverted by placing false commands in the environment.
(Note that the presence of this flag does
not
mean that it is safe to run setuid
rc
scripts; the usual caveats about the setuid bit still apply.)
-
R-s
-
This flag causes
rc
to read from standard input.
Any arguments are placed in
R$*R.
R$*
-
R-v
-
This flag causes
rc
to echo its input
to standard error as it is read.
-
R-x
-
This flag causes
rc
to print every command on standard error before it is executed.
It can be useful for debugging
rc
scripts.
COMMANDS
A simple command is a sequence of words, separated by white space
(space and tab) characters that ends with a newline, semicolon
R(R;R),
R(R;
R(
or ampersand
R(R&R).
R(R&
R(
The first word of a command is the name of that command.
If the name begins with
R/R,
R/
R./R,
R./
or
R../R,
R../
then the name is used as an absolute path
name referring to an executable file.
Otherwise, the name of the command is looked up in a table
of shell functions, builtin commands,
or as a file in the directories named by
R$pathR.
R$path
Background Tasks
A command ending with
R&
is run in the background; that is,
the shell returns immediately rather than waiting for the command to
complete.
Background commands have
R/dev/null
connected to their standard input unless an explicit redirection for
standard input is used.
Subshells
A command prefixed with an at-sign
R(R@R)
R(R@
R(
is executed in a subshell.
This insulates the parent shell from the effects
of state changing operations such as a
cd
or a variable assignment.
For example:
R@ {cd ..; make}
will run
make(1)
in the parent directory
R(R..R),
R(R..
R(
but leaves the shell running in the current directory.
Line continuation
A long logical line may be continued over several physical lines by
terminating each line (except the last) with a backslash
R(R\R).
R(R\
R(
The backslash-newline sequence is treated as a space.
A backslash is not otherwise special to
rc.
(In addition,
inside quotes a backslash loses its special meaning
even when it is followed by a newline.)
Quoting
rc
interprets several characters specially; special characters
automatically terminate words.
The following characters are special:
R# ; & | ^ $ = ` ' { } ( ) < >
The single quote
R(R'R)
R(R'
R(
prevents special treatment of any character other than itself.
All characters, including control characters, newlines,
and backslashes between two quote characters are treated as an
uninterpreted string.
A quote character itself may be quoted by placing two quotes in a row.
The minimal sequence needed to enter the quote character is
R''''R.
R''''
The empty string is represented by
R''R.
R''
Thus:
Recho 'What''s the plan, Stan?'
prints out
RWhat's the plan, Stan?
The number sign
R(R#R)
R(R#
R(
begins a comment in
rc.
All characters up to but not including the next newline are ignored.
Note that backslash continuation does not work inside a comment,
i.e.,
the backslash is ignored along with everything else.
Grouping
Zero or more commands may be grouped within braces
R("R{R"
R("R{
R("
and
R"R}R"),
R"R}
R"
and are then treated as one command.
Braces do not otherwise define scope;
they are used only for command grouping.
In particular, be wary of the command:
Rfor (i) {
R command
R} | command
Since pipe binds tighter than
RforR,
Rfor
this command does not perform what the user expects it to.
Instead, enclose the whole
Rfor
statement in braces:
R{for (i) command} | command
Fortunately,
rc's
grammar is simple enough that a (confident) user can
understand it by examining the skeletal
yacc(1)
grammar
at the end of this man page (see the section entitled
GRAMMAR).
Input and output
The standard output may be redirected to a file with
Rcommand > file
and the standard input may be taken from a file with
Rcommand < file
Redirections can appear anywhere in the line: the word
following the redirection symbol is the filename and must be
quoted if it contains spaces or other special characters.
These are all equivalent.
Recho 1 2 3 > foo
R> foo echo 1 2 3
Recho 1 2 > foo 3
File descriptors other than 0 and 1 may be specified also.
For example, to redirect standard error to a file, use:
Rcommand >[2] file
In order to duplicate a file descriptor, use
R>[InR=ImR].
R>[InR=Im
R>[InR=
R>[In
R>[
Thus to redirect both standard output and standard error
to the same file, use
Rcommand > file >[2=1]
As in
sh,
redirections are processed from left to right.
Thus this sequence
Rcommand >[2=1] > file
is usually a mistake.
It first duplicates standard error to standard
output; then redirects standard output to a file, leaving standard error
wherever standard output originally was.
To close a file descriptor that may be open, use
R>[InR=].
R>[In
R>[
For example, to
close file descriptor 7:
Rcommand >[7=]
Note that no spaces may appear in these constructs:
Rcommand > [2] file
would send the output of the command to a file named
R[2]R,
R[2]
with the intended filename appearing in the command's argument list.
In order to place the output of a command at the end of an already
existing file, use:
Rcommand >> file
If the file does not exist, then it is created.
"Here documents" are supported as in
sh
with the use of
Rcommand << 'eof-marker'
Subsequent lines form the standard input of
the command, till a line containing just the
marker, in this case
Reof-markerR,
Reof-marker
is encountered.
If the end-of-file marker is enclosed in quotes,
then no variable substitution occurs inside the here document.
Otherwise, every variable is substituted
by its space-separated-list value (see
Flat Lists,
below),
and if a
R^
character follows a variable name, it is deleted.
This allows the unambiguous use of variables adjacent to text, as in
R$variable^follow
To include a literal
R$
in a here document when an unquoted end-of-file marker is being used,
enter it as
R$$R.
R$$
Additionally,
rc
supports "here strings", which are like here documents,
except that input is taken directly from a string on the command line.
Their use is illustrated here:
Rcat <<< 'this is a here string' | wc
(This feature enables
rc
to export functions using here documents into the environment;
the author does not expect users to find this feature useful.)
Pipes
Two or more commands may be combined in a pipeline by placing the
vertical bar
R(R|R)
R(R|
R(
between them.
The standard output (file descriptor 1)
of the command on the left is tied to the standard input (file
descriptor 0) of the command on the right.
The notation
R|[InR=ImR]
R|[InR=Im
R|[InR=
R|[In
R|[
indicates that file descriptor
n
of the left process is connected to
file descriptor
m
of the right process.
R|[InR]
R|[In
R|[
is a shorthand for
R|[InR=0].
R|[In
R|[
As an example, to pipe the standard error of a command to
wc(1),
use:
Rcommand |[2] wc
As with file redirections, no spaces may occur in the construct specifying
numbered file descriptors.
The exit status of a pipeline is considered true if and only if every
command in the pipeline exits true.
Commands as Arguments
Some commands, like
cmp(1)
or
diff(1),
take their arguments on the command
line, and do not read input from standard input.
It is convenient
sometimes to build nonlinear pipelines so that a command like
cmp
can read the output of two other commands at once.
rc
does it like this:
Rcmp <{command} <{command}
compares the output of the two commands in braces.
Note: since this form of
redirection is implemented with some kind of pipe, and since one cannot
lseek(2)
on a pipe, commands that use
lseek(2)
will hang.
For example, some versions of
diff(1)
use
lseek(2)
on their inputs.
Data can be sent down a pipe to several commands using
tee(1)
and the output version of this notation:
Recho hi there | tee >{sed 's/^/p1 /'} >{sed 's/^/p2 /'}
CONTROL STRUCTURES
The following may be used for control flow in
rc:
If-Else Statements
Rif (ItestR) {
Rif (Itest
Rif (
cmd
-
R} else Icmd
R} else
-
The
test
is executed, and if its return status is zero, the first
command is executed, otherwise the second is.
Braces are not mandatory around the commands.
However, an
Relse
statement is valid only if it
follows a close-brace on the same line.
Otherwise, the
Rif
is taken to be a simple-if:
Rif (test)
R command
While and For Loops
-
Rwhile (ItestR)I cmd
Rwhile (ItestR)
Rwhile (Itest
Rwhile (
-
rc
executes the
test
and performs the command as long as the
test
is true.
-
Rfor (IvarR in IlistR)I cmd
Rfor (IvarR in IlistR)
Rfor (IvarR in Ilist
Rfor (IvarR in
Rfor (Ivar
Rfor (
-
rc
sets
var
to each element of
list
(which may contain variables and backquote substitutions) and runs
cmd.
If
R"Rin
R"
list"
is omitted, then
rc
will set
var
to each element of
R$*R.
R$*
For example:
Rfor (i in `{ls -F | grep '\*$' | sed 's/\*$//'}) { commands }
-
will set
R$i
to the name of each file in the current directory that is
executable.
Switch
-
Rswitch (IlistR) { caseI ...R }
Rswitch (IlistR) { caseI ...
Rswitch (IlistR) { case
Rswitch (Ilist
Rswitch (
-
rc
looks inside the braces after a
Rswitch
for statements beginning with the word
RcaseR.
Rcase
If any of the patterns following
Rcase
match the list supplied to
RswitchR,
Rswitch
then the commands up until the next
Rcase
statement are executed.
The metacharacters
R*R,
R*
R[
or
R?
should not be quoted;
matching is performed only against the strings in
list,
not against file names.
(Matching for case statements is the same as for the
R~
command.)
Logical Operators
There are a number of operators in
rc
which depend on the exit status of a command.
Rcommand && command
executes the first command and then executes the second command if and only if
the first command exits with a zero exit status ("true" in Unix).
Rcommand || command
executes the first command and then executes the second command if and only if
the first command exits with a nonzero exit status ("false" in Unix).
R! command
negates the exit status of a command.
PATTERN MATCHING
There are two forms of pattern matching in
rc.
One is traditional shell globbing.
This occurs in matching for file names in argument lists:
Rcommand argument argument ...
When the characters
R*R,
R*
R[
or
R?
occur in an argument or command,
rc
looks at the
argument as a pattern for matching against files.
(Contrary to the behavior other shells exhibit,
rc
will only perform pattern matching if a metacharacter occurs unquoted and
literally in the input.
Thus,
Rfoo='*'
Recho $foo
will always echo just a star.
In order for non-literal metacharacters to be expanded, an
Reval
statement must be used in order to rescan the input.)
Pattern matching occurs according to the following rules: a
R*
matches any number (including zero) of
characters.
A
R?
matches any single character, and a
R[
followed by a
number of characters followed by a
R]
matches a single character in that
class.
The rules for character class matching are the same as those for
ed(1),
with the exception that character class negation is achieved
with the tilde
R(R~R),
R(R~
R(
not the caret
R(R^R),
R(R^
R(
since the caret already means
something else in
rc.
rc
also matches patterns against strings with the
R~
command:
R~ subject pattern pattern ...
R~
sets
R$status
to zero if and only if a supplied pattern matches any
single element of the subject list.
Thus
R~ foo f*
sets status to zero, while
R~ (bar baz) f*
sets status to one.
The null list is matched by the null list, so
R~ $foo ()
checks to see whether
R$foo
is empty or not.
This may also be achieved
by the test
R~ $#foo 0
Note that inside a
R~
command
rc
does not match patterns against file
names, so it is not necessary to quote the characters
R*R,
R*
R[
and
R?R.
R?
However,
rc
does expand the subject against filenames if it contains
metacharacters.
Thus, the command
R~ * ?
returns true if any of the files in the current directory have a
single-character name.
If the
R~
command is given a list as its first
argument, then a successful match against any of the elements of that
list will cause
R~
to return true.
For example:
R~ (foo goo zoo) z*
is true.
LISTS AND VARIABLES
The primary data structure in
rc
is the list, which is a sequence of words.
Parentheses are used to group lists.
The empty list is represented by
R()R.
R()
Lists have no hierarchical structure;
a list inside another list is expanded so the
outer list contains all the elements of the inner list.
Thus, the following are all equivalent
Rone two three
R(one two three)
R((one) () ((two three)))
Note that the null string,
R''R,
R''
and the null list,
R()R,
R()
are two very different things.
Assigning the null string to a variable is a valid operation, but it
does not remove its definition.
Rnull = '' empty = () echo $#null $#empty
produces the output
R1 0
List Concatenation
Two lists may be joined by the concatenation operator
R(R^R).
R(R^
R(
Concatenation works according to the following rules:
if the two lists have the same number of elements,
then concatenation is pairwise:
Recho (a- b- c-)^(1 2 3)
produces the output
Ra-1 b-2 c-3
Otherwise, at least one of the lists must have a single element,
and then the concatenation is distributive:
Rcc -^(O g c) (malloc alloca)^.c
has the effect of performing the command
Rcc -O -g -c malloc.c alloca.c
A single word is a list of length one, so
Recho foo^bar
produces the output
Rfoobar
Free Carets
rc
inserts carets (concatenation operators) for free in certain situations,
in order to save some typing on the user's behalf.
For
example, the above example could also be typed in as:
Ropts=(O g c) files=(malloc alloca) cc -$opts $files.c
rc
takes care to insert a free-caret between the
R"R-R"
R"R-
R"
and
R$optsR,
R$opts
as well
as between
R$files
and
R.cR.
R.c
The rule for free carets is as follows: if
a word or keyword is immediately
followed by another word, keyword, dollar-sign or
backquote, then
rc
inserts a caret between them.
Variables
A list may be assigned to a variable, using the notation:
IvarR = IlistIvarR =
Ivar
The special variable
R*
may also be assigned to using this notation;
rc
has no
set
builtin.
Any non-empty sequence of characters, except a sequence including only
digits, may be used as a variable name.
Any character except
R=
may be used, but special characters must be quoted.
All user-defined variables are exported into the environment.
The value of a variable is referenced with the dollar
R(R$R)
R(R$
R(
operator:
R$IvarR$
Any variable which has not been assigned a value returns the null list,
R()R,
R()
when referenced.
Multiple references are allowed:
Ra = foo
Rb = a
Recho $ $ b
prints
Rfoo
A variable's definition may also be removed by
assigning the null list to a variable:
IvarR=()Ivar
For "free careting" to work correctly,
rc
must make certain assumptions
about what characters may appear in a variable name.
rc
assumes that a variable name consists only of alphanumeric characters,
underscore
R(R_R)
R(R_
R(
and star
R(R*R).
R(R*
R(
To reference a variable with other
characters in its name, quote the variable name.
Thus:
Recho $'we$Ird:Variab!le'
Local Variables
Any number of variable assignments may be made local to a single
command by typing:
Ra=foo b=bar ... command
The command may be a compound command, so for example:
Rpath=. ifs=() {
R R...R
R}
sets
Rpath
to
R.
and removes
Rifs
for the duration of one long compound command.
Variable Subscripts
Variables may be subscripted with the notation
R$var(InR)R$var(In
R$var(
where
n
is a list of integers (origin 1).
The opening parenthesis must immediately follow the variable name.
The list of subscripts need not be in order or even unique.
Thus,
Ra=(one two three)
Recho $a(3 3 3)
prints
Rthree three three
If
n
references a nonexistent element, then
R$var(InR)
R$var(In
R$var(
returns the null list.
The notation
R$In,
R$
where
n
is an integer, is a shorthand for
R$*(InR).
R$*(In
R$*(
Thus,
rc's
arguments may be referred to as
R$1R,
R$1
R$2R,
R$2
and so on.
Note also that the list of subscripts may be given by any of
rc's
list operations:
R$var(`{awk 'BEGIN{for(i=1;i<=10;i++)print i;exit; }'})
returns the first 10 elements of
R$varR.
R$var
To count the number of elements in a variable, use
R$#var
This returns a single-element list, with the number of elements in
R$varR.
R$var
Flat Lists
In order to create a single-element list from a multi-element list,
with the components space-separated, use the dollar-caret
R(R$^R)
R(R$^
R(
operator:
R$^var
This is useful when the normal list concatenation rules need to be
bypassed.
For example, to append a single period at the end of
R$pathR,
R$path
use:
Recho $^path.
Backquote Substitution
A list may be formed from the output of a command by using backquote
substitution:
R`{ command }
returns a list formed from the standard output of the command in braces.
R$ifs
is used to split the output into list elements.
By default,
R$ifs
has the value space-tab-newline.
The braces may be omitted if the command is a single word.
Thus
R`ls
may be used instead of
R`{ls}R.
R`{ls}
This last feature is useful when defining functions that expand
to useful argument lists.
A frequent use is:
Rfn src { echo *.[chy] }
followed by
Rwc `src
(This will print out a word-count of all C source files in the current
directory.)
In order to override the value of
R$ifs
for a single backquote
substitution, use:
R`` (ifs-list) { command }
R$ifs
will be temporarily ignored and the command's output will be split as specified by
the list following the double backquote.
For example:
R`` ($nl :) {cat /etc/passwd}
splits up
R/etc/passwd
into fields, assuming that
R$nl
contains a newline
as its value.
SPECIAL VARIABLES
Several variables are known to
rc
and are treated specially.
In the following list, "default" indicates that
rc
gives the variable a default value on startup; "no-export" indicates
that the variable is never exported; and "read-only" indicates that
an attempt to set the variable will silently have no effect.
Also, "alias" means that the variable is aliased to the same name in
capitals.
For example, an assignment to
R$cdpath
causes an automatic assignment to
R$CDPATHR,
R$CDPATH
and vice-versa.
If
R$CDPATH
is set when
rc
is started, its value is imported into
R$cdpathR.
R$cdpath
R$cdpath
and
R$path
are
rc
lists;
R$CDPATH
and
R$PATH
are colon-separated lists.
Only the names spelt in capitals are exported into the environment.
-
R*R (no-export)
R*
-
The argument list of
rc.
R$1, $2,
etc. are the same as
R$*(1)R,
R$*(1)
R$*(2)R,
R$*(2)
etc.
-
R0R (default no-export)
R0
-
The variable
R$0
holds the value of
Rargv[0]
with which
rc
was invoked.
Additionally,
R$0
is set to the name of a function for the duration of
the execution of that function, and
R$0
is also set to the name of the
file being interpreted for the duration of a
R.
command.
R$0
is not an element of
R$*R,
R$*
and is never treated as one.
-
RapidR (no-export)
Rapid
-
The process ID of the last process started in the background.
-
RapidsR (no-export read-only)
Rapids
-
A list whose elements are the process IDs of all background processes
which are still alive, or which have died and have not been waited for
yet.
-
RbqstatusR (no-export)
Rbqstatus
-
The exit status of the
rc
forked to execute the most recent backquote substitution. Note that, unlike
R$statusR,
R$status
R$bqstatus
is always a single element list (see
EXIT STATUS
below). For example:
Recho foo |grep bar; whatis status
-
prints
Rstatus=(0 1)
-
whereas
Rx=`{echo foo |grep bar}; whatis bqstatus
-
prints
Rbqstatus=1
-
RcdpathR (alias)
Rcdpath
-
A list of directories to search for the target of a
cd
command.
The empty string stands for the current directory.
Note that if the
R$cdpath
variable does not contain the current directory, then the current
directory will not be searched; this allows directory searching to
begin in a directory other than the current directory.
-
Rhistory
-
R$history
contains the name of a file to which commands are appended as
rc
reads them.
This facilitates the use of a stand-alone history program
(such as
history(1))
which parses the contents of the history file and presents them to
rc
for reinterpretation.
If
R$history
is not set, then
rc
does not append commands to any file.
-
RhomeR (alias)
Rhome
-
The default directory for the builtin
cd
command, and the directory in which
rc
looks to find its initialization file,
R.rcrcR,
R.rcrc
if
rc
has been started up as a login shell.
-
RifsR (default)
Rifs
-
The internal field separator, used for splitting up the output of
backquote commands for digestion as a list. On startup,
rc
assigns the list containing the characters space, tab, and newline to
R$ifsR.
R$ifs
-
RpathR (alias)
Rpath
-
This is a list of directories to search in for commands.
The empty string stands for the current directory.
If neither
R$PATH
nor
R$path
is set at startup time,
R$path
assumes a default value suitable for your system.
This is typically
R(/usr/local/bin /usr/bin /usr/ucb /bin .)
-
RpidR (default no-export)
Rpid
-
On startup,
R$pid
is initialized to the numeric process ID of the currently running
rc.
-
RpromptR (default)
Rprompt
-
This variable holds the two prompts (in list form, of course) that
rc
prints.
R$prompt(1)
is printed before each command is read, and
R$prompt(2)
is printed when input is expected to continue on the next
line.
rc
sets
R$prompt
to
R('; ' '')
by default.
The reason for this is that it enables an
rc
user to grab commands from previous lines using a
mouse, and to present them to
rc
for re-interpretation; the semicolon
prompt is simply ignored by
rc.
The null
R$prompt(2)
also has its
justification: an
rc
script, when typed interactively, will not leave
R$prompt(2)R's
R$prompt(2)
on the screen,
and can therefore be grabbed by a mouse and placed
directly into a file for use as a shell script, without further editing
being necessary.
-
RpromptR (function)
Rprompt
-
If this function is defined, then it gets executed every time
rc
is about to print
R$prompt(1)R.
R$prompt(1)
-
RstatusR (no-export read-only)
Rstatus
-
The exit status of the last command.
If the command exited with a numeric value, that number is the status.
If the command died with a signal, the status is the name of that signal;
if a core file was created, the string
R"R+coreR"
R"R+core
R"
is appended.
The value of
R$status
for a pipeline is a list, with one entry, as above, for each process
in the pipeline.
For example, the command
Rls | wc
-
usually sets
R$status
to
R(0 0)R.
R(0 0)
-
RversionR (default)
Rversion
-
On startup, the first element of this list variable is initialized to
a string which identifies this version of
rc.
The second element is initialized to a string which can be found by
ident(1)
and the
what
command of
sccs(1).
FUNCTIONS
rc
functions are identical to
rc
scripts, except that they are stored
in memory and are automatically exported into the environment.
A shell function is declared as:
Rfn name { commands }
rc
scans the definition until the close-brace, so the function can
span more than one line.
The function definition may be removed by typing
Rfn name
(One or more names may be specified.
With an accompanying definition, all names receive the same definition.
This is sometimes useful
for assigning the same signal handler to many signals.
Without a definition, all named functions are deleted.)
When a function is executed,
R$*
is set to the arguments to that
function for the duration of the command.
Thus a reasonable definition for
RlR,
Rl
a shorthand for
ls(1),
could be:
Rfn l { ls -FC $* }
but not
Rfn l { ls -FC } # WRONG
INTERRUPTS AND SIGNALS
rc
recognizes a number of signals, and allows the user to define shell
functions which act as signal handlers.
rc
by default traps
RSIGINT
when it is in interactive mode.
RSIGQUIT
and
RSIGTERM
are ignored, unless
rc
has been invoked with the
R-d
flag.
However, user-defined signal handlers may be written for these and
all other signals.
The way to define a signal handler is to
write a function by the name of the signal in lower case.
Thus:
Rfn sighup { echo hangup; rm /tmp/rc$pid.*; exit }
In addition to Unix signals,
rc
recognizes the artificial signal
RSIGEXIT
which occurs as
rc
is about to exit.
In order to remove a signal handler's definition,
remove it as though it were a regular function.
For example:
Rfn sigint
returns the handler of
RSIGINT
to the default value.
In order to ignore a signal, set the signal handler's value to
R{}R.
R{}
Thus:
Rfn sigint {}
causes
RSIGINT
to be ignored by the shell.
Only signals that are being ignored are passed on to programs run by
rc;
signal functions are not exported.
On System V-based Unix systems,
rc
will not allow you to trap
RSIGCLDR.
RSIGCLD
BUILTIN COMMANDS
Builtin commands execute in the context of the shell, but otherwise
behave exactly like other commands.
Although
!,
~
and
@
are not strictly speaking builtin commands,
they can usually be used as such.
- . [-i] file [arg ...]
-
Reads
file
as input to
rc
and executes its contents.
With a
R-i
flag, input is interactive.
Thus from within a shell script,
R. -i /dev/tty
-
does the "right thing".
- break
-
Breaks from the innermost
Rfor
or
RwhileR,
Rwhile
as in C.
It is an error to invoke
break
outside of a loop.
(Note that there is no
break
keyword between commands in
Rswitch
statements, unlike C.)
- builtin command [arg ...]
-
Executes the command ignoring any function definition of the
same name.
This command is present to allow functions with the
same names as builtins to use the underlying builtin or binary.
For example:
Rfn ls { builtin ls -FC $* }
-
is a reasonable way to pass a default set of arguments to
RlsR(1),
Rls
whereas
Rfn ls { ls -FC $* } # WRONG
-
is a non-terminating recursion, which will cause
Rrc
to exhaust its stack space and (eventually) terminate if it is executed.
- cd [directory]
-
Changes the current directory to
directory.
The variable
R$cdpath
is searched for possible locations of
directory,
analogous to the searching of
R$path
for executable files.
With no argument,
cd
changes the current directory to
R$homeR.
R$home
- echo [-n] [--] [arg ...]
-
Prints its arguments to standard output, terminated by a newline.
Arguments are separated by spaces.
If the first argument is
R-n
no final newline is printed.
If the first argument is
R--R,
R--
then all other arguments are echoed literally.
This is used for echoing a literal
R-nR.
R-n
- eval [list]
-
Concatenates the elements of
list
with spaces and feeds the resulting string to
rc
for re-scanning.
This is the only time input is rescanned in
rc.
- exec [arg ...]
-
Replaces
rc
with the given command.
If the exec contains only redirections,
then these redirections apply to the current shell
and the shell does not exit.
For example,
Rexec >[2] err.out
-
places further output to standard error in the file
err.out.
- exit [status]
-
Cause the current shell to exit with the given exit
status.
If no argument is given, the current value of
R$status
is used.
- limit [-h] [resource [value]]
-
Similar to the
csh(1)
limit
builtin, this command operates upon the
BSD-style resource limits of a process.
The
R-h
flag displays/alters the hard
limits.
The resources which can be shown or altered are
cputime,
filesize,
datasize,
stacksize,
coredumpsize,
memoryuse,
and, where supported,
descriptors,
memoryuse,
memoryrss,
maxproc,
memorylocked,
and
filelocks.
For example:
Rlimit coredumpsize 0
-
disables core dumps.
To set a soft limit equal to the hard limit:
Rlimit `{limit -h datasize}
- newpgrp
-
Puts
rc
into a new process group.
This builtin is useful for making
rc
behave like a job-control shell in a hostile environment.
One example is the NeXT Terminal program, which implicitly assumes
that each shell it forks will put itself into a new process group.
- return [n]
-
Returns from the current function, with status
n,
where
n
is a valid exit status, or a list of them.
Thus it is legal to have
Rreturn (sigpipe 1 2 3)
-
(This is commonly used to allow a function to return with the exit status
of a previously executed pipeline of commands.)
If
n
is omitted, then
R$status
is left unchanged.
It is an error to invoke
return
when not inside a function.
- shift [n]
-
Deletes
n
elements from the beginning of
R$*
and shifts the other
elements down by
n.
n
defaults to 1.
- umask [mask]
-
Sets the current umask (see
umask(2))
to the octal
mask.
If no argument is present, the current mask value is printed.
- wait [pid]
-
Waits for process with the specified
pid,
which must have been started by
rc,
to exit.
If no
pid
is specified,
rc
waits for all its child processes to exit.
- whatis [-b] [-f] [-p] [-s] [-v] [--] [name ...]
-
Prints a definition of the named objects.
For builtins,
Rbuiltin
foo
is printed; for functions, including signal handlers, their definitions
are printed; for executable files, path names are printed; and for
variables, their values are printed.
The flags restrict output to builtins, functions, executable
programs, signal handlers, and variables, respectively.
If no
names
are specified,
rc
lists all objects of that type.
(This is not permitted for
R-pR.)
R-p
Without arguments,
Rwhatis
is equivalent to
Rwhatis -fvR,
Rwhatis -fv
and prints the values of all shell variables and functions.
-
Note that
whatis
output is suitable for input to
rc;
by saving the output of
whatis
in a file, it should be possible to recreate the state of
rc
by sourcing this file with a
R.
command.
Another note:
Rwhatis -s > file
cannot be used to store the state of
rc's
signal handlers in a file, because builtins with redirections
are run in a subshell, and
rc
always restores signal handlers to their default value after a
Rfork()R.
Rfork()
-
Since
whatis
uses
getopt(3)
to parse its arguments, you can use the special argument
R--
to terminate its flags.
This allows you to use names beginning with a dash, such as
the
history(1)
commands.
For example,
Rwhatis -- -p
EXAMPLES
The
shift
builtin only shifts
R$*R.
R$*
This function can shift any variable (except
R$lshiftR).
R$lshift
Rfn lshift { lshift=$*; *=$$1; shift $lshift(2); $lshift(1)=$* }
With this definition in place,
Rwalrus = (shoes ships sealing-wax cabbages kings)
Rlshift walrus 3
Rwhatis walrus
prints
Rwalrus=(cabbages kings)
The
R$^var
operator flattens a list by separating each element with a space.
This function allows the separator to be an arbitrary string.
Rfn lflat {
R lflat=$*; *=$$1
R while () {
R echo -n $1; shift
R ~ $#* 0 && break
R echo -n $lflat(2)
R}
With this definition in place,
Rhops=(uunet mcvax ukc tlg)
Rlflat hops !
prints (with no final newline)
Ruunet!mcvax!ukc!tlg
EXIT STATUS
The exit status of
rc
is normally the same as that of the last command executed.
If the
last command was a pipeline,
rc
exits
R0
if every command in the pipeline did; otherwise it exits
R1R.
R1
rc
can be made to exit with a particular status using the
exit
builtin.
GRAMMAR
Here is
rc's
grammar, edited to remove semantic actions.
R%term ANDAND BACKBACK BANG CASE COUNT DUP ELSE END FLAT FN FOR IF IN
%term OROR PIPE REDIR SUB SUBSHELL SWITCH TWIDDLE WHILE WORD HUH
%left WHILE ')' ELSE
%left ANDAND OROR '\n'
%left BANG SUBSHELL
%left PIPE
%right '$'
%left SUB
%start rc
%%
rc: line end
| error end
end: END /* EOF */ | '\n'
cmdsa: cmd ';' | cmd '&'
line: cmd | cmdsa line
body: cmd | cmdsan body
cmdsan: cmdsa | cmd '\n'
brace: '{' body '}'
paren: '(' body ')'
assign: first '=' word
epilog: /* empty */ | redir epilog
redir: DUP | REDIR word
case: CASE words ';' | CASE words '\n'
cbody: cmd | case cbody | cmdsan cbody
iftail: cmd %prec ELSE
| brace ELSE optnl cmd
cmd : /* empty */ %prec WHILE
| simple
| brace epilog
| IF paren optnl iftail
| FOR '(' word IN words ')' optnl cmd
| FOR '(' word ')' optnl cmd
| WHILE paren optnl cmd
| SWITCH '(' word ')' optnl '{' cbody '}'
| TWIDDLE optcaret word words
| cmd ANDAND optnl cmd
| cmd OROR optnl cmd
| cmd PIPE optnl cmd
| redir cmd %prec BANG
| assign cmd %prec BANG
| BANG optcaret cmd
| SUBSHELL optcaret cmd
| FN words brace
| FN words
optcaret: /* empty */ | '^'
simple: first | simple word | simple redir
first: comword | first '^' sword
sword: comword | keyword
word: sword | word '^' sword
comword: '$' sword
| '$' sword SUB words ')'
| COUNT sword
| FLAT sword
| '`' sword
| '`' brace
| BACKBACK word brace | BACKBACK word sword
| '(' words ')'
| REDIR brace
| WORD
keyword: FOR | IN | WHILE | IF | SWITCH
| FN | ELSE | CASE | TWIDDLE | BANG | SUBSHELL
words: /* empty */ | words word
optnl: /* empty */ | optnl '\n'
FILES
R$HOME/.rcrcR,
R$HOME/.rcrc
R/tmp/rc*R,
R/tmp/rc*
R/dev/null
CREDITS
rc
was written by Byron Rakitzis, with valuable help
from Paul Haahr, Hugh Redelmeier and David Sanderson.
The design of this shell was copied from the
rc
that Tom Duff wrote at Bell Labs.
BUGS
There is a compile-time limit on the number of
R;
separated commands in a line: usually 500.
This is sometimes a problem for automatically generated scripts:
substituting the newline character for
R;
avoids the limit.
On modern systems that support
R/dev/fd
or
R/proc/self/fdR,
R/proc/self/fd
R<{foo}
style redirection is implemented that way.
However, on older systems it is implemented with named pipes.
Allegedly, it is sometimes possible to foil
rc
into removing the FIFO it places in
R/tmp
prematurely, or it is even possible to cause
rc
to hang.
(The current maintainer has never seen this, but then he
doesn't use systems which lack
R/dev/fd
any more.
If anybody can reproduce this problem, please let the maintainer know.)
The
echo
command does not need to be a builtin. It is one for reasons of
performance and portability (of
rc
scripts).
There should be a way to avoid exporting a variable.
Extra parentheses around a
R~
expression or a
R!
expression are a syntax error.
Thus, this code is illegal.
Rwhile ((~ $1 -*) && (! ~ $1 --)) { ...
- The redundant inner parentheses must be omitted.
-
Variable subscripting cannot be used in here documents.
The
Rlimit
builtin silently ignores extra arguments.
Backquote substitution never produces empty strings - multiple
consecutive occurrences of the separator are treated the same as a
single occurrence.
Rifs=! { x = `{echo -n a!!b}; whatis x }
Rx=(a b) # NOT x=(a '' b)
Bug reports should be mailed to
R<toby@paccrat.org>R.R<toby@paccrat.org>
INCOMPATIBILITIES
Here is a list of features which distinguish this incarnation of
rc
from the one described in the Bell Labs manual pages:
The Tenth Edition
rc
does not have the
else
keyword.
Instead,
if
is optionally followed by
an
if not
clause which is executed
if the preceding
if
test does not succeed.
Backquotes are slightly different in Tenth Edition
rc:
a backquote must always be followed by a left-brace.
This restriction is not present for single-word commands in this
rc.
For
R.
file,
the Tenth Edition
rc
searches
R$path
for
file.
This
rc
does not, since it is not considered useful.
The list flattening operator,
R$^fooR,
R$^foo
is spelt
R$"foo
in those versions of the Bell Labs
rc
which have it.
The following are all new with this version of
rc:
The
R-n
flag,
here strings (they facilitate exporting of functions
with here documents into the environment),
the
return
and
break
keywords,
the
echo
builtin,
the
Rbqstatus
and
Rversion
variables,
the support for the GNU
readline(3)
library,
and the support for the
Rprompt
function.
This
rc
also sets
R$0
to the name of a function being executed/file
being sourced.
SEE ALSO
"rc --- A Shell for Plan 9 and UNIX Systems",
Unix Research System,
Tenth Edition,
Volume 2. (Saunders College Publishing)
Rhttp://static.tobold.org/rc/rc-duff.htmlR,
Rhttp://static.tobold.org/rc/rc-duff.html
an updated version of the above paper.
history(1)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- OPTIONS
-
- COMMANDS
-
- Background Tasks
-
- Subshells
-
- Line continuation
-
- Quoting
-
- Grouping
-
- Input and output
-
- Pipes
-
- Commands as Arguments
-
- CONTROL STRUCTURES
-
- If-Else Statements
-
- While and For Loops
-
- Switch
-
- Logical Operators
-
- PATTERN MATCHING
-
- LISTS AND VARIABLES
-
- List Concatenation
-
- Free Carets
-
- Variables
-
- Local Variables
-
- Variable Subscripts
-
- Flat Lists
-
- Backquote Substitution
-
- SPECIAL VARIABLES
-
- FUNCTIONS
-
- INTERRUPTS AND SIGNALS
-
- BUILTIN COMMANDS
-
- EXAMPLES
-
- EXIT STATUS
-
- GRAMMAR
-
- FILES
-
- CREDITS
-
- BUGS
-
- INCOMPATIBILITIES
-
- SEE ALSO
-