RC(1)RC(1)NAME
rc - shell
SYNOPSIS
rc [-eixvldnpo] [-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 rea‐
sonably fast, especially when compared to contemporary shells. Its use
is intended to be interactive, but the language lends itself well to
scripts.
OPTIONS-e If the -e option is present, then rc will exit if the exit sta‐
tus of a command is false (nonzero). rc will not exit, however,
if a conditional fails, e.g., an if() command.
-i If the -i option is present or if the input to rc is from a ter‐
minal (as determined by isatty(3)) then rc will be in interac‐
tive mode. That is, a prompt (from $prompt(1)) will be printed
before an input line is taken, and rc will ignore the signals
SIGINT and SIGQUIT.
-x This option will make rc print every command on standard error
before it is executed. It can be useful for debugging rc
scripts.
-v This option will echo input to rc on standard error as it is
read.
-l If the -l option is present, or if rc's argv[0][0] is a dash
(-), then rc will behave as a login shell. That is, it will try
to run commands present in $home/.rcrc, if this file exists,
before reading any other input.
-d This flag causes rc not to ignore SIGQUIT or SIGTERM. Thus rc
can be made to dump core if sent SIGQUIT. This option is only
useful for debugging rc.
-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 -x option, rc will
print each command as it is parsed in a form similar to the one
used for exporting functions into the environment.
-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 this
presence of this option does NOT mean that it is safe to run
setuid rc scripts; the usual caveats about the setuid bit still
apply.)
-o This flag prevents the usual practice of trying to open
/dev/null on file descriptors 0, 1, and 2, if any of those
descriptors are inherited closed.
-c If -c is present, commands are executed from the immediately
following argument. Any further arguments to rc are placed in
$*.
COMMANDS
A simple command is a sequence of words, separated by white space
(space and tab) characters that ends with a newline, semicolon (;), or
ampersand (&). The first word of a command is the name of that com‐
mand. If the name begins with /, ./, or ../, 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 $path.
Background Tasks
A command ending with a & is run in the background; that is, the shell
returns immediately rather than waiting for the command to complete.
Background commands have /dev/null connected to their standard input
unless an explicit redirection for standard input is used.
Subshells
A command prefixed with an at-sign (@) is executed in a subshell. This
insulates the parent shell from the effects of state changing opera‐
tions such as a cd or a variable assignment. For example:
@ {cd ..; make}
will run make(1) in the parent directory (..), 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 (\). 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 automat‐
ically terminate words. The following characters are special:
# ; & | ^ $ = ` ' { } ( ) < >
The single quote (') 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 uninter‐
preted string. A quote character itself may be quoted by placing two
quotes in a row. The minimal sequence needed to enter the quote char‐
acter is ''''. The empty string is represented by ''. Thus:
echo 'What''s the plan, Stan?'
prints out
What's the plan, Stan?
The number sign (#) begins a comment in rc. All characters up to but
not including the next newline are ignored. Note that backslash con‐
tinuation 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 (``{'' and ``}''),
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:
for (i) {
command
} | command
Since pipe binds tighter than for, this command does not perform what
the user expects it to. Instead, enclose the whole for statement in
braces:
{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
command > file
and the standard input may be taken from a file with
command < file
File descriptors other than 0 and 1 may be specified also. For exam‐
ple, to redirect standard error to a file, use:
command >[2] file
In order to duplicate a file descriptor, use >[n=m]. Thus to redirect
both standard output and standard error to the same file, use
command > file >[2=1]
To close a file descriptor that may be open, use >[n=]. For example,
to close file descriptor 7:
command >[7=]
In order to place the output of a command at the end of an already
existing file, use:
command >> file
If the file does not exist, then it is created.
``Here documents'' are supported as in sh with the use of
command << 'eof-marker'
If the end-of-file marker is enclosed in quotes, then no variable sub‐
stitution occurs inside the here document. Otherwise, every variable
is substituted by its space-separated-list value (see Flat Lists,
below), and if a ^ character follows a variable name, it is deleted.
This allows the unambiguous use of variables adjacent to text, as in
$variable^follow
To include a literal $ in a here document when an unquoted end-of-file
marker is being used, enter it as $$.
Additionally, rc supports ``here strings'', which are like here docu‐
ments, except that input is taken directly from a string on the command
line. Its use is illustrated here:
cat <<< '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 ver‐
tical bar (|) 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 |[n=m] indicates that
file descriptor n of the left process is connected to file descriptor m
of the right process. |[n] is a shorthand for |[n=0]. As an example,
to pipe the standard error of a command to wc(1), use:
command |[2] wc
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 com‐
mand 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:
cmp <{command} <{command}
compares the output of the two commands in braces. A 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, most 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:
echo hi there | tee >{sed 's/^/p1 /'} >{sed 's/^/p2 /'}
CONTROL STRUCTURES
The following may be used for control flow in rc:
If-else Statements
if (test) {
cmd
} else cmd
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 else statement
is valid only if it follows a close-brace on the same line.
Otherwise, the if is taken to be a simple-if:
if (test)
command
While and For Loops
while (test) cmd
rc executes the test and performs the command as long as the
test is true.
for (var in list) cmd
rc sets var to each element of list (which may contain variables
and backquote substitutions) and runs cmd. If ``in list'' is
omitted, then rc will set var to each element of $* (excluding
$0). For example:
for (i in `{ls -F | grep '\*$' | sed 's/\*$//'}) { commands }
will set $i to the name of each file in the current directory
that is executable.
Switch
switch (list) { case ... }
rc looks inside the braces after a switch for statements begin‐
ning with the word case. If any of the patterns following case
match the list supplied to switch, then the commands up until
the next case statement are executed. The metacharacters *, [
or ? 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 ~ command.)
Logical Operators
There are a number of operators in rc which depend on the exit status
of a command.
command && 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).
command || command
executes the first command executing the second command if and only if
the second command exits with a nonzero exit status (``false'' in
Unix).
! 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:
command argument argument ...
When the characters *, [ or ? occur in an argument or command, rc
looks at the argument as a pattern for matching against files. (Con‐
trary to the behavior other shells exhibit, rc will only perform pat‐
tern matching if a metacharacter occurs unquoted and literally in the
input. Thus,
foo='*'
echo $foo
will always echo just a star. In order for non-literal metacharacters
to be expanded, an eval statement must be used in order to rescan the
input.) Pattern matching occurs according to the following rules: a *
matches any number (including zero) of characters. A ? matches any
single character, and a [ followed by a number of characters followed
by a ] matches a single character in that class. The rules for charac‐
ter class matching are the same as those for ed(1), with the exception
that character class negation is achieved with the tilde (~), not the
caret (^), since the caret already means something else in rc.
rc also matches patterns against strings with the ~ command:
~ subject pattern pattern ...
~ sets $status to zero if and only if a supplied pattern matches any
single element of the subject list. Thus
~ foo f*
sets status to zero, while
~ (bar baz) f*
sets status to one. The null list is matched by the null list, so
~ $foo ()
checks to see whether $foo is empty or not. This may also be achieved
by the test
~ $#foo 0
Note that inside a ~ command rc does not match patterns against file
names, so it is not necessary to quote the characters *, [ and ?. How‐
ever, rc does expand the glob the subject against filenames if it con‐
tains metacharacters. Thus, the command
~ * ?
returns true if any of the files in the current directory have a sin‐
gle-character name. (Note that if the ~ command is given a list as its
first argument, then a successful match against any of the elements of
that list will cause ~ to return true. For example:
~ (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 repre‐
sented by (). 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
one two three
(one two three)
((one) () ((two three)))
Note that the null string, '', and the null list, (), are two very dif‐
ferent things. Assigning the null string to variable is a valid opera‐
tion, but it does not remove its definition. For example, if $a is set
to '', then $#a, returns a 1.
List Concatenation
Two lists may be joined by the concatenation operator (^). A single
word is treated as a list of length one, so
echo foo^bar
produces the output
foobar
For lists of more than one element, concatenation works according to
the following rules: if the two lists have the same number of elements,
then concatenation is pairwise:
echo (a- b- c-)^(1 2 3)
produces the output
a-1 b-2 c-3
Otherwise, one of the lists must have a single element, and then the
concatenation is distributive:
cc -^(O g c) (malloc alloca)^.c
has the effect of performing the command
cc -O -g -c malloc.c alloca.c
Free Carets
rc inserts carets (concatenation operators) for free in certain situa‐
tions, in order to save some typing on the user's behalf. For example,
the above example could also be typed in as:
opts=(O g c) files=(malloc alloca) cc -$opts $files.c
rc takes care to insert a free-caret between the ``-'' and $opts, as
well as between $files and .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:
var = list
Any sequence of non-special characters, except a sequence including
only digits, may be used as a variable name. All user-defined vari‐
ables are exported into the environment.
The value of a variable is referenced with the notation:
$var
Any variable which has not been assigned a value returns the null list,
(), when referenced. In addition, multiple references are allowed:
a=foo
b=a
echo $$b
prints
foo
A variable's definition may also be removed by assigning the null list
to a variable:
var=()
For ``free careting'' to work correctly, rc must make certain assump‐
tions about what characters may appear in a variable name. rc assumes
that a variable name consists only of alphanumeric characters, under‐
score (_) and star (*). To reference a variable with other characters
in its name, quote the variable name. Thus:
echo $'we$Irdriab!le'
Local Variables
Any number of variable assignments may be made local to a single com‐
mand by typing:
a=foo b=bar ... command
The command may be a compound command, so for example:
path=. ifs=() {
...
}
sets path to . and removes ifs for the duration of one long compound
command.
Variable Subscripts
Variables may be subscripted with the notation
$var(n)
where n is a list of integers (origin 1). The list of subscripts need
not be in order or even unique. Thus, if
a=(one two three)
then
echo $a(3 3 3)
prints
three three three
If n references a nonexistent element, then $var(n) returns the null
list. The notation $n, where n is an integer, is a shorthand for
$*(n). Thus, rc's arguments may be referred to as $1, $2, and so on.
Note also that the list of subscripts may be given by any of rc's list
operations:
$var(`{awk 'BEGIN{for(i=1;i<=10;i++)print i;exit; }'})
returns the first 10 elements of $var.
To count the number of elements in a variable, use
$#var
This returns a single-element list, with the number of elements in
$var.
Flat Lists
In order to create a single-element list from a multi-element list,
with the components space-separated, use
$^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 $path,
use:
echo $^path.
Backquote Substitution
A list may be formed from the output of a command by using backquote
substitution:
`{ command }
returns a list formed from the standard output of the command in
braces. $ifs is used to split the output into list elements. By
default, $ifs has the value space-tab-newline. The braces may be omit‐
ted if the command is a single word. Thus `ls may be used instead of
`{ls}. This last feature is useful when defining functions that expand
to useful argument lists. A frequent use is:
fn src { echo *.[chy] }
followed by
wc `src
(This will print out a word-count of all C source files in the current
directory.)
In order to override the value of $ifs for a single backquote substitu‐
tion, use:
`` (ifs-list) { command }
$ifs will be temporarily ignored and the command's output will be split
as specified by the list following the double backquote. For example:
`` ($nl :) {cat /etc/passwd}
splits up /etc/passwd into fields, assuming that $nl contains a newline
as its value.
SPECIAL VARIABLES
Several variables are known to rc and are treated specially.
* The argument list of rc. $1, $2, etc. are the same as $*(1),
$*(2), etc. The variable $0 holds the value of argv[0] with
which rc was invoked. Additionally, $0 is set to the name of a
function for the duration of the execution of that function, and
$0 is also set to the name of the file being interpreted for the
duration of a . command.
apid The process ID of the last process started in the background.
apids The process IDs of any background processes which are outstand‐
ing or which have died and have not been waited for yet.
cdpath 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 $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 cur‐
rent directory. Note also that an assignment to $cdpath causes
an automatic assignment to $CDPATH, and vice-versa.
history
$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 con‐
tents of the history file and presents them to rc for reinter‐
pretation. If $history is not set, then rc does not append com‐
mands to any file.
home The default directory for the builtin cd command and is the
directory in which rc looks to find its initialization file,
.rcrc, if rc has been started up as a login shell. Like $cdpath
and $CDPATH, $home and $HOME are aliased to each other.
ifs The internal field separator, used for splitting up the output
of backquote commands for digestion as a list.
path This is a list of directories to search in for commands. The
empty string stands for the current directory. Note that like
$cdpath and $CDPATH, $path and $PATH are aliased to each other.
If $path or $PATH is not set at startup time, $path assumes a
default value suitable for your system. This is typically
(/usr/ucb /usr/bin /bin .)
pid The process ID of the currently running rc.
prompt This variable holds the two prompts (in list form, of course)
that rc prints. $prompt(1) is printed before each command is
read, and $prompt(2) is printed when input is expected to con‐
tinue on the next line. rc sets $prompt to ('; ' '') 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 $prompt(2) also has its justification:
an rc script, when typed interactively, will not leave
$prompt(2)'s 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.
prompt (function)
If this function is set, then it gets executed every time rc is
about to print $prompt(1).
status The exit status of the last command. If the command exited with
a numeric value, that number is the status. If the died with a
signal, the status is the name of that signal; if a core file
was created, the string ``+core'' is appended. The value of
$status for a pipeline is a list, with one entry, as above, for
each process in the pipeline. For example, the command
ls | wc
usually sets $status to (0 0).
The values of $path, $cdpath, and $home are derived from the environ‐
ment values of $PATH, $CDPATH, and $HOME. Otherwise, they are derived
from the environment values of $path, $cdpath and $home. This is for
compatibility with other Unix programs, like sh(1). $PATH and $CDPATH
are assumed to be colon-separated lists.
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:
fn 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
fn 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 defini‐
tion, all named functions are deleted.) When a function is executed,
$* is set to the arguments to that function for the duration of the
command. Thus a reasonable definition for l, a shorthand for ls(1),
could be:
fn l { ls -FC $* }
but not
fn l { ls -FC }
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 SIGINT
when it is in interactive mode. SIGQUIT and SIGTERM are ignored,
unless rc has been invoked with the -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:
fn sighup { echo hangup; rm /tmp/rc$pid.*; exit }
In addition to Unix signals, rc recognizes the artificial signal
SIGEXIT 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:
fn sigint
returns the handler of SIGINT to the default value. In order to ignore
a signal, set the signal handler's value to {}. Thus:
fn sigint {}
causes SIGINT 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 SIGCLD.
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 -i
flag, input is interactive. Thus from within a shell script,
. -i /dev/tty
does the ``right'' thing.
break Breaks from the innermost for or while, as in C. It is an error
to invoke break outside of a loop. (Note that there is no break
keyword between commands in switch 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.
cd [directory]
Changes the current directory to directory. The variable
$cdpath is searched for possible locations of directory, analo‐
gous to the searching of $path for executable files. With no
argument, cd changes the current directory to $home.
echo [-n] [--] [arg ...]
Prints its arguments to standard output, terminated by a new‐
line. Arguments are separated by spaces. If the first argument
is -n no final newline is printed. If the first argument is --,
then all other arguments are echoed literally. This is used for
echoing a literal -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,
exec >[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 $status is used.
limit [-h] [resource [value]]
Similar to the csh(1) limit builtin, this command operates upon
the BSD-style limits of a process. The -h flag displays/alters
the hard limits. The resources which can be shown or altered
are cputime, filesize, datasize, stacksize, coredumpsize and
memoryuse. For example:
limit coredumpsize 0
disables core dumps.
newpgrp
Puts rc into a new process group. This builtin is useful for
making rc behave like a job-control shell in a hostile environ‐
ment. One example is the NeXT Terminal program, which implic‐
itly 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
single value or a list of possible exit statuses. Thus it is
legal to have
return (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 $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 $* and shifts the other
elements down by n. n defaults to 1. (Note that $0 is not
affected by shift.)
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 the specified pid, which must have been started by rc.
If no pid is specified, rc waits for any child process to exit.
whatis [-s] [--] [name ...]
Prints a definition of the named objects. For variables, their
values are printed; for functions, their definitions are; and
for executable files, path names are printed. Without argu‐
ments, whatis prints the values of all shell variables and func‐
tions. With a -s argument, whatis also prints out a list of
available signals and their handlers (if any). 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 . command. Another note:
whatis -s > file cannot be used to store the state of rc's sig‐
nal 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 fork().
Since whatis uses getopt(3) to parse its arguments, you can use
the special argument -- to terminate its options. This allows
you to use names beginning with a dash, such as the history(1)
commands. For example,
whatis -- -p
GRAMMAR
Here is rc's grammar, edited to remove semantic actions.
%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
$HOME/.rcrc, /tmp/rc*, /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 has been
copied from the rc that Tom Duff wrote at Bell Labs.
BUGS
On systems that support /dev/fd, <{foo} style redirection is imple‐
mented that way. However, on other systems it is implemented with
named pipes, and it is sometimes possible to foil rc into removing the
FIFO it places in /tmp prematurely, or it is even possible to cause rc
to hang.
The functionality of shift should be available for variables other than
$*.
echo is built in only for performance reasons, which is a bad idea.
There should be a way to avoid exporting a variable.
The $^var notation for flattening should allow for using an arbitrary
separating character, not just space.
Bug reports should be mailed to byron@archone.tamu.edu.
INCOMPATIBILITIES
Here is a list of features which distinguish this incarnation of rc
from the one described in the Bell Labs manual pages:
The treatment of if-else is different in the v10 rc: that version uses
an if not clause which gets executed if the preceding if test does not
succeed.
Backquotes are slightly different in v10 rc: a backquote must always be
followed by a left-brace. This restriction is not present for single-
word commands in this rc.
The following are all new with this version of rc: The -n option, the
list flattening operator, here strings (they facilitate exporting of
functions with here documents into the environment), the return and
break keywords, the echo builtin, the support for the GNU readline(3)
library and the support for the prompt function. This rc also sets $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,
10th Edition, vol. 2. (Saunders College Publishing) (This paper is also
distributed with this rc in PostScript form.)
history(1)
28 April 1991 RC(1)