SH(I) 4/18/73 SH(I)
NAME
sh - shell (command interpreter)
SYNOPSIS
sh [ 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
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
kill.
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
messages:
Bus error
Trace/BPT trap
Illegal instruction
IOT trap
EMT trap
Bad system call
Quit
Floating exception
Memory violation
Killed
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 of the associated command.
An argument of the form `>arg' causes file `arg' to be used
as the standard output file 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.
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
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
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
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
process.
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.
FILES
/etc/glob, which interprets `*', `?', and `['.
/dev/null as a source of end-of-file.
SEE ALSO
`The UNIX Time-sharing System', which gives the theory of
operation of the Shell.
chdir(I), login(I), wait(I), shift(I)
BUGS
When output is redirected, particularly to make a
multicommand pipeline, diagnostics tend to be sent down the
pipe and are sometimes lost altogether. Not all components
of a pipeline swawned with `&' ignore interrupts.