rc man page on 4.4BSD

Man page or keyword search:  
man Server   1065 pages
apropos Keyword Search (all sections)
Output format
4.4BSD logo
[printable version]

RC(1)									 RC(1)

       rc - shell

       rc [-eixvldnpo] [-c command] [arguments]

       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

       -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

       -v     This  option  will  echo	input to rc on standard error as it is

       -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

       -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

       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.

       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.)

       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.

       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

       Since  pipe  binds tighter than for, this command does not perform what
       the user expects it to.	Instead, enclose the whole  for	 statement  in

	    {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

       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

       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 /'}

       The following may be used for control flow in rc:

   If-else Statements
       if (test) {
       } 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)

   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 (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

	    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

	    ! command

       negates the exit status of a command.

       There are two forms of pattern matching	in  rc.	  One  is  traditional
       shell  globbing.	  This	occurs	in matching for file names in argument

	    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,

	    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.)

       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


       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.

       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:


       Any variable which has not been assigned a value returns the null list,
       (), when referenced.  In addition, multiple references are allowed:

	    echo $$b



       A  variable's definition may also be removed by assigning the null list
       to a variable:


       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

   Variable Subscripts
       Variables may be subscripted with the notation


       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)


	    echo $a(3 3 3)


	    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

	    $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


       This returns a single-element list, with	 the  number  of  elements  in

   Flat Lists
       In  order  to  create  a single-element list from a multi-element list,
       with the components space-separated, use


       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,

	    echo $^path.

   Backquote Substitution
       A list may be formed from the output of a command  by  using  backquote

	    `{ 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

       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.

       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 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.

       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 }

       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

       On System V-based Unix systems, rc will not allow you to trap SIGCLD.

       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.

	      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

       Here is rc's grammar, edited to remove semantic actions.


	    %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

	    words: /* empty */ | words word

	    optnl: /* empty */ | optnl '\n'

       $HOME/.rcrc, /tmp/rc*, /dev/null

       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.

       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.

       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

       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.

       ``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.)


				 28 April 1991				 RC(1)

List of man pages available for 4.4BSD

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net