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

    NAME
         sh  -  shell (command interpreter)

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

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

         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
              Quit
              Floating exception
              Memory violation
              Killed
              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
         name.

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

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

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

         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.

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

    SEE ALSO
         `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)

    BUGS
         There is no way to redirect the diagnostic output.

                                  - 5 -