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


     sh  -  shell (command interpreter)


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

     arguments to the Shell used as a command, the  structure  of

     command 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

     interpretation 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/command')  and  another attempt is made to execute

     the resulting file.  (Certain lesser-used commands  live  in

     `/usr/bin'.)   If  the  `/usr/bin'  file  exists, but is not

     executable, it is used by the Shell as a command file.  That

     is  to  say  it is executed as though it were typed from the

     console.  If all attempts fail, a diagnostic is printed.

     Command lines.  One or more commands separated by `|' or `^'

     constitute  a pipeline.  The standard output of each command

     but the last in a pipeline 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  command line contained in parentheses `( )' may appear in

     place of a simple command as an element of a pipeline.

     A command line consists of one or more pipelines  separated,

     and  perhaps  terminated  by  `;'  or  `&'.   The  semicolon

     designates sequential execution.  The ampersand  causes  the

     preceding  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

     terminations other than exit and  interrupt  are  considered

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


             Bus error

             Trace/BPT trap

             Illegal instruction

             IOT trap

             EMT trap

             Bad system call


             Floating exception

             Memory violation


     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

     interpreted as a special argument to the Shell itself.  Such

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

     associated command.

     An argument of the form `>arg' causes file `arg' to be  used

     as   the   standard  output  (file  descriptor  1)  for  the

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

     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

     characters 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

     member  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

     member 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

     current 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

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

     For example: directory /usr/dmr  contains  the  files  a1.s,

     a2.s, ..., a9.s.  From any directory, the command

             as /usr/dmr/a?.s

     calls as with arguments  /usr/dmr/a1.s,  /usr/dmr/a2.s,  ...

     /usr/dmr/a9.s in that order.

     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

     meaningful  to the Shell may be passed as part of arguments.

     A special case of this feature allows  the  continuation  of

     commands  onto  more  than one line:  a new-line preceded by

     `\' is translated into a blank.

     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  will  be  read  and

     interpreted.   If  not  given, this subinstance of the Shell

     will continue to read the standard input file.

     In command  lines  in  the  file  (not  in  command  input),

     character  sequences  of  the form `$n', where n is a digit,

     are replaced by the nth argument to the  invocation  of  the

     Shell (argn).  `$0' is replaced by name.

     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

     specially 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

     wait (II).

     shift is done by manipulating the arguments to the Shell.

     `:' 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.

     Process that are created with a `&' 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', 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.