LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    rc

    
    
    

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

           -c     If  -c  is  present,  commands are executed from the immediately
                  following argument.  Any further arguments to rc are  placed  in
                  $*.  Thus:
    
                       rc -c 'echo $*' 1 2 3
    
                  prints out
    
                       1 2 3
    
           -d     This  flag  causes rc not to ignore SIGQUIT or SIGTERM.  Thus rc
                  can be made to dump core if sent SIGQUIT.   This  flag  is  only
                  useful for debugging rc.
    
           -e     If  the -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 if() command.
    
           -i     If the -i flag is present or if the input to rc is from a termi-
                  nal (as determined by isatty(3)) then rc will be in  interactive
                  mode.   That  is,  a  prompt  (from  $prompt(1)) will be printed
                  before an input line is taken, and rc will ignore SIGINT.
    
           -I     If the -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 SIGINT will cause rc to exit.
    
           -l     If the -l flag is present, or if rc's argv[0][0] is a dash  (-),
                  then rc will behave as a login shell.  That is, it will run com-
                  mands from $home/.rcrc, if this file exists, before reading  any
                  other input.
    
           -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 flag, rc will print
                  each command as it is parsed in a form similar to the  one  used
                  for exporting functions into the environment.
    
           -o     This  flag  prevents  the  usual  practice  of  trying  to  open
           -v     This flag causes rc to echo its input to standard error as it is
                  read.
    
           -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 (;),  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 & 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:
           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
    
           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.
    
                echo 1 2 3 > foo
                > foo echo 1 2 3
                echo 1 2 > foo 3
    
           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]
    
           As  in  sh,  redirections  are processed from left to right.  Thus this
           sequence
    
                command >[2=1] > file
    
           is usually a mistake.  It first duplicates standard error  to  standard
           output;  then  redirects  standard  output  to a file, leaving standard
           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'
    
           Subsequent  lines  form  the standard input of the command, till a line
           containing just the marker, in this case eof-marker, is encountered.
    
           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.  Their 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
    
           As  with file redirections, no spaces may occur in the construct speci-
           fying numbered file descriptors.
    
           The exit status of a pipeline is considered true if and only  if  every
           command in the pipeline exits true.
    
           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 $*.  For exam-
                  ple:
    
                       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
    
    
    

    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  subject  against  filenames  if  it  contains
           metacharacters.  Thus, the command
           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 a variable is a valid
           operation, but it does not remove its definition.
    
                null = '' empty = () echo $#null $#empty
    
           produces the output
    
                1 0
    
       List Concatenation
           Two lists may be joined by the concatenation operator (^).   Concatena-
           tion  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, at least 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
    
           A single word is a list of length one, so
    
                echo foo^bar
    
           produces the output
    
                foobar
    
       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 special variable * 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 = may  be
           used,  but  special  characters must be quoted.  All user-defined vari-
           ables are exported into the environment.
    
           The value of a variable is referenced with the dollar ($) operator:
    
                $var
    
           Any variable which has not been assigned a value returns the null list,
           (), when referenced.  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$Ird:Variab!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
    
           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 the dollar-caret ($^) opera-
           tor:
    
                $^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
    
    
    

    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 $cdpath causes an automatic
           assignment to $CDPATH, and vice-versa.  If $CDPATH is set  when  rc  is
           started,  its value is imported into $cdpath.  $cdpath and $path are rc
           lists; $CDPATH and $PATH are colon-separated  lists.   Only  the  names
           spelt in capitals are exported into the environment.
    
           * (no-export)
                  The  argument  list  of rc.  $1, $2, etc. are the same as $*(1),
                  $*(2), etc.
    
           0 (default no-export)
                  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.  $0 is not an  element  of  $*,  and  is  never
                  treated as one.
    
           apid (no-export)
                  The process ID of the last process started in the background.
    
           apids (no-export read-only)
                  A list whose elements are the process IDs of all background pro-
                  cesses which are still alive, or which have died  and  have  not
                  been waited for yet.
    
           bqstatus (no-export)
                  The  exit  status  of  the  rc forked to execute the most recent
                  backquote substitution.  Note that, unlike $status, $bqstatus is
                  always a single element list (see EXIT STATUS below).  For exam-
                  ple:
    
                       echo foo |grep bar; whatis status
    
                  prints
    
                       status=(0 1)
    
                  whereas
    
                       x='{echo foo |grep bar}; whatis bqstatus
    
                  prints
                  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 (alias)
                  The default directory for the builtin cd command, and the direc-
                  tory  in  which rc looks to find its initialization file, .rcrc,
                  if rc has been started up as a login shell.
    
           ifs (default)
                  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  new-
                  line to $ifs.
    
           path (alias)
                  This  is  a  list of directories to search in for commands.  The
                  empty string stands for the current directory.  If neither $PATH
                  nor  $path is set at startup time, $path assumes a default value
                  suitable for your system.   This  is  typically  (/usr/local/bin
                  /usr/bin /usr/ucb /bin .)
    
           pid (default no-export)
                  On startup, $pid is initialized to the numeric process ID of the
                  currently running rc.
    
           prompt (default)
                  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 defined, then it gets executed every time rc
                  is about to print $prompt(1).
    
           status (no-export read-only)
                  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 ''+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
    
           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 } # 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  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.
           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.
                  For example:
    
                       fn ls { builtin ls -FC $* }
    
                  is a reasonable way to pass a default set of arguments to ls(1),
                  whereas
    
                       fn ls { ls -FC $* } # WRONG
    
                  is  a  non-terminating recursion, which will cause rc to exhaust
                  its stack space and (eventually) terminate if it is executed.
    
           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]]
           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
                  valid exit status, or a list of them.  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.
    
           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, builtin
                  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 per-
                  mitted  for  -p.)   Without  arguments,  whatis is equivalent to
                  whatis -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  recre-
                  ate  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  signal handlers in a file, because builtins with redi-
                  rections 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
    
                walrus = (shoes ships sealing-wax cabbages kings)
                lshift walrus 3
                whatis walrus
    
           prints
    
                walrus=(cabbages kings)
    
           The  $^var  operator  flattens a list by separating each element with a
           space.  This function allows the separator to be an arbitrary string.
    
                fn lflat {
                  lflat=$*; *=$$1
                  while () {
                    echo -n $1; shift
                    ~ $#* 0 && break
                    echo -n $lflat(2)
                }
    
           With this definition in place,
    
                hops=(uunet mcvax ukc tlg)
                lflat hops !
    
           prints (with no final newline)
    
                uunet!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 0 if every com-
           mand in the pipeline did; otherwise it exits 1.
    
           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.
    
                %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
    
                %%
    
    
                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
    
    
    

    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 ; separated commands in
           a line: usually 500.  This is sometimes  a  problem  for  automatically
           generated  scripts: substituting the newline character for ; avoids the
           limit.
    
           On modern systems that support /dev/fd or /proc/self/fd,  <{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 /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 /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 ~ expression or a !  expression are a syntax
           error.  Thus, this code is illegal.
    
                while ((~ $1 -*) && (! ~ $1 --)) { ...
    
           The redundant inner parentheses must be omitted.
    
           Variable subscripting cannot be used in here documents.
    
           The limit builtin silently ignores extra arguments.
    
           Bug reports should be mailed to <tjg@star.le.ac.uk>.
    
    
    

    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 pre-
           ceding 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 .  file, the Tenth Edition rc searches $path  for  file.   This  rc
           does not, since it is not considered useful.
    
           http://www.star.le.ac.uk/~tjg/rc/misc/td, an  updated  version  of  the
           above paper.
    
           history(1)
    
                                      2003-07-17                             RC(1)
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz