/sys/doc/ Documentation archive

SH(I)                        5/15/74                        SH(I)

     sh  -  shell (command interpreter)

     sh [ -t ] [ -c ] [ name [ arg1 ... [ arg9 ] ] ]

     Sh  is  the standard command interpreter.  It is the program
     which reads and arranges the execution of the command  lines
     typed  by  most users.  It may itself be called as a command
     to interpret files of commands.  Before discussing the argu-
     ments  to the Shell used as a command, the structure of com-
     mand lines themselves will be given.

     Commands.  Each command is a sequence of  non-blank  command
     arguments separated by blanks.  The first argument specifies
     the name of a command to be executed.   Except  for  certain
     types  of  special  arguments discussed below, the arguments
     other than the command name are passed  without  interpreta-
     tion to the invoked command.

     If  the first argument is the name of an executable file, it
     is invoked; otherwise the string `/bin/' is prepended to the
     argument.  (In this way most standard commands, which reside
     in `/bin', are found.)  If no such  command  is  found,  the
     string  `/usr'  is further prepended (to give `/usr/bin/com-
     mand') and another attempt is made to execute the  resulting
     file.  (Certain lesser-used commands live in `/usr/bin'.)

     If  a  non-directory  file  has executable mode, but not the
     form of an executable program (does not begin with the prop-
     er  magic  number) then it is assumed to be an ASCII file of
     commands and a new Shell is  created  to  execute  it.   See
     ``Argument passing'' below.

     If the file cannot be found, a diagnostic is printed.

     Command lines.  One or more commands separated by `|' or `^'
     constitute a chain of filters.  The standard output of  each
     command  but  the last is taken as the standard input of the
     next command.  Each command is run as  a  separate  process,
     connected  by pipes (see pipe(II)) to its neighbors.  A com-
     mand line contained in parentheses `( )' may appear in place
     of a simple command as a filter.

     A  command line consists of one or more pipelines separated,
     and perhaps terminated by `;' or `&'.  The semicolon  desig-
     nates  sequential  execution.  The ampersand causes the pre-
     ceding pipeline to be executed without  waiting  for  it  to
     finish.   The  process id of such a pipeline is reported, so
     that it may be used if necessary for a  subsequent  wait  or

     Termination Reporting.   If a command (not followed by `&')
     terminates abnormally, a message is printed.  (All  termina-

                              - 1 -

SH(I)                        5/15/74                        SH(I)

     tions  other  than  exit and interrupt are considered abnor-
     mal.)  Termination reports for commands followed by `&'  are
     given  upon  receipt  of the first command subsequent to the
     termination of the command, or when a wait is executed.  The
     following is a list of the abnormal termination messages:

          Bus error
          Trace/BPT trap
          Illegal instruction
          IOT trap
          EMT trap
          Bad system call
          Floating exception
          Memory violation
          Broken Pipe

     If  a core image is produced, `- Core dumped' is appended to
     the appropriate message.

     Redirection of I/O.  There  are  three  character  sequences
     that cause the immediately following string to be interpret-
     ed as a special argument to the Shell itself.  Such an argu-
     ment  may  appear  anywhere  among the arguments of a simple
     command, or before or after a  parenthesized  command  list,
     and is associated with that command or command list.

     An  argument  of the form `<arg' causes the file `arg' to be
     used as the standard input (file descriptor 0) of the  asso-
     ciated command.

     An  argument of the form `>arg' causes file `arg' to be used
     as the standard output (file descriptor 1) for the associat-
     ed  command.   `Arg'  is created if it did not exist, and in
     any case is truncated at the outset.

     An argument of the form `>>arg' causes file `arg' to be used
     as the standard output for the associated command.  If `arg'
     did not exist, it is created; if it did exist,  the  command
     output is appended to the file.

     For example, either of the command lines

          ls >junk; cat tail >>junk
          ( ls; cat tail ) >junk

     creates, on file `junk', a listing of the working directory,
     followed immediately by the contents of file `tail'.

     Either of the constructs `>arg' or `>>arg'  associated  with
     any but the last command of a pipeline is ineffectual, as is
     `<arg' in any but the first.

     In commands called by the Shell, file descriptor 2 refers to
     the  standard  output  of  the Shell before any redirection.

                              - 2 -

SH(I)                        5/15/74                        SH(I)

     Thus filters may write diagnostics to a location where  they
     have a chance to be seen.

     Generation of argument lists.  If any argument contains any
     of the characters `?', `*' or `[', it is  treated  specially
     as  follows.   The  current  directory is searched for files
     which match the given argument.

     The character `*' in an argument matches any string of char-
     acters in a file name (including the null string).

     The  character  `?'  matches  any single character in a file

     Square brackets `[...]' specify a class of characters  which
     matches any single file-name character in the class.  Within
     the brackets, each ordinary character is taken to be a  mem-
     ber  of  the  class.   A pair of characters separated by `-'
     places in the class each character lexically greater than or
     equal to the first and less than or equal to the second mem-
     ber of the pair.

     Other characters match only the same character in  the  file

     For  example,  `*'  matches  all file names; `?' matches all
     one-character file names; `[ab]*.s' matches all  file  names
     beginning  with  `a'  or `b' and ending with `.s'; `?[zi-m]'
     matches all two-character file names ending with `z' or  the
     letters `i' through `m'.

     If  the  argument  with  `*'  or  `?' also contains a `/', a
     slightly different procedure is used:  instead of  the  cur-
     rent  directory,  the  directory used is the one obtained by
     taking the argument up to the last `/' before a `*' or  `?'.
     The  matching  process matches the remainder of the argument
     after this `/' against the files in the  derived  directory.
     For  example: `/usr/dmr/a*.s' matches all files in directory
     `/usr/dmr' which begin with `a' and end with `.s'.

     In any event, a list of names is obtained  which  match  the
     argument.   This list is sorted into alphabetical order, and
     the resulting sequence of arguments replaces the single  ar-
     gument containing the `*', `[', or `?'.  The same process is
     carried out for each argument (the resulting lists  are  not
     merged) and finally the command is called with the resulting
     list of arguments.

     Quoting.  The character `\' causes the immediately following
     character  to  lose  any  special meaning it may have to the
     Shell;  in this way `<', `>', and other characters  meaning-
     ful to the Shell may be passed as part of arguments.  A spe-
     cial case of this feature allows the  continuation  of  com-
     mands  onto  more than one line:  a new-line preceded by `\'
     is translated into a blank.

                              - 3 -

SH(I)                        5/15/74                        SH(I)

     Sequences of characters enclosed in double (") or single (')
     quotes are also taken literally.  For example:

          ls  |  pr -h "My directory"

     causes  a directory listing to be produced by ls, and passed
     on to pr to be printed  with  the  heading  `My  directory'.
     Quotes  permit the inclusion of blanks in the heading, which
     is a single argument to pr.

     Argument passing.  When the Shell is invoked as  a  command,
     it  has  additional  string processing capabilities.  Recall
     that the form in which the Shell is invoked is

          sh [ name [ arg1 ... [ arg9 ] ] ]

     The name is the name of a file which is read and  interpret-
     ed.   If  not given, this subinstance of the Shell continues
     to read the standard input file.

     In command lines in the file (not in command input), charac-
     ter  sequences of the form `$n', where n is a digit, are re-
     placed by the nth argument to the invocation  of  the  Shell
     (argn).  `$0' is replaced by name.

     The  argument  `-t,' used alone, causes sh to read the stan-
     dard input for a single line, execute it as a  command,  and
     then  exit.   This facility replaces the older `mini-shell.'
     It is useful for interactive programs which allow  users  to
     execute system commands.

     The  argument `-c' (used with one following argument) causes
     the next argument to be taken as a command line and  execut-
     ed.   No  new-line  need be present, but new-line characters
     are treated appropriately.  This facility is  useful  as  an
     alternative  to  `-t' where the caller has already read some
     of the characters of the command to be executed.

     End of file.  An end-of-file in the Shell's input causes  it
     to  exit.   A side effect of this fact means that the way to
     log out from UNIX is to type an EOT.

     Special commands.  The following commands are  treated  spe-
     cially by the Shell.

     chdir  is  done  without spawning a new process by executing
     sys chdir (II).

     login is done by executing /bin/login without creating a new

     wait is done without spawning a new process by executing sys

     shift is done by manipulating the arguments to the Shell.

                              - 4 -

SH(I)                        5/15/74                        SH(I)

     `:' is simply ignored.

     Command file errors; interrupts.  Any Shell-detected  error,
     or  an  interrupt  signal, during the execution of a command
     file causes the Shell to cease execution of that file.

     Processes that are created with `&' ignore interrupts.  Also
     if  such  a process has not redirected its input with a `<',
     its input is automatically redirected  to  the  zero  length
     file /dev/null.

     /etc/glob, which interprets `*', `?', and `['.
     /dev/null as a source of end-of-file.

     `The  UNIX  Time-Sharing  System',  CACM,  July, 1974, which
     gives the theory of operation of the Shell.
     chdir(I), login(I), wait(I), shift(I)

     There is no way to redirect the diagnostic output.

                              - 5 -