Read commands from standard input (set automatically
if no file arguments are present). This option has
no effect when set after the shell has already started
running (i.e. with set(1)).
.TP
-V vi
Enable the builtin vi(1) command line editor (disables
-E if it has been set).
.TP
-E emacs
Enable the builtin emacs(1) command line editor (disables
-V if it has been set).
.TP
-b notify
Enable asynchronous notification of background job
completion.
(UNIMPLEMENTED for 4.4alpha)
.LP
.sp2
.BLexicalStructure
.sp
.LP
The shell reads input in terms of lines from a file and breaks
it up into words at whitespace (blanks and tabs), and at
certain sequences of
characters that are special to the shell called ``operators''.
There are two types of operators: control operators and
redirection operators (their meaning is discussed later).
Following is a list of operators:
.nf
.sp
Control operators: & && ( ) ; ;; | || <newline>
.sp
Redirection operator: < > >| << >> <& >& <<- <>
.sp
.fi
.sp2
.BQuoting
.sp
.LP
Quoting is used to remove the special meaning of certain characters
or words to the shell, such as operators, whitespace, or
keywords. There are three types of quoting: matched single quotes,
matched double quotes, and backslash.
.sp2
.BBackslash
.sp
.LP
A backslash preserves the literal meaning of the following
character, with the exception of <newline>. A backslash preceding
a <newline> is treated as a line continuation.
.sp2
.BSingleQuotes
.sp
.LP
Enclosing characters in single quotes preserves the literal
meaning of all the characters.
.sp2
.BDoubleQuotes
.sp
.LP
Enclosing characters within double quotes preserves the literal
meaning of all characters except dollarsign ($), backquote (`),
and backslash (\\). The backslash inside double quotes is
historically weird, and serves to quote only the following
characters: $ ` " \\ <newline>.
Otherwise it remains literal.
.sp2
.BReservedWords
.sp
.LP
Reserved words are words that have special meaning to the
shell and are recognized at the beginning of a line and
after a control operator. The following are reserved words:
.nf
! elif fi while case
else for then { }
do done until if esac
.fi
Their meaning is discussed later.
.sp2
.BAliases
.sp
.LP
An alias is a name and corresponding value set using the alias(1)
builtin command. Whenever a reserved word may occur (see above),
and after checking for reserved words, the shell
checks the word to see if it matches an alias. If it does,
it replaces it in the input stream with its value. For example,
if there is an alias called ``lf'' with the value ``ls -F'',
then the input
.nf
lf foobar <return>
would become
ls -F foobar <return>
.fi
.LP
Aliases provide a convenient way for naive users to
create shorthands for commands without having to learn how
to create functions with arguments. They can also be
used to create lexically obscure code. This use is discouraged.
.sp2
.BCommands
.sp
.LP
The shell interprets the words it reads according to a
language, the specification of which is outside the scope
of this man page (refer to the BNF in the POSIX 1003.2
document). Essentially though, a line is read and if
the first word of the line (or after a control operator)
is not a reserved word, then the shell has recognized a
simple command. Otherwise, a complex command or some
other special construct may have been recognized.
.sp2
.BSimpleCommands
.sp
.LP
If a simple command has been recognized, the shell performs
the following actions:
.sp
1) Leading words of the form ``name=value'' are
stripped off and assigned to the environment of
the simple command. Redirection operators and
their arguments (as described below) are stripped
off and saved for processing.
.sp
2) The remaining words are expanded as described in
the section called ``Expansions'', and the
first remaining word is considered the command
name and the command is located. The remaining
words are considered the arguments of the command.
If no command name resulted, then the ``name=value''
variable assignments recognized in 1) affect the
current shell.
.sp
3) Redirections are performed as described in
the next section.
.sp2
.BRedirections
.sp
.LP
Redirections are used to change where a command reads its input
or sends its output. In general, redirections open, close, or
duplicate an existing reference to a file. The overall format
used for redirection is:
.nf
[n] redir-op file
.fi
where redir-op is one of the redirection operators mentioned
previously. Following is a list of the possible redirections.
The [n] is an optional number, as in '3' (not '[3]'), that
refers to a file descriptor.
.TP
[n]> file
Redirect standard output (or n) to file.
.TP
[n]>| file
Same, but override the -C option.
.TP
[n]>> file
Append standard output (or n) to file.
.TP
[n]< file
Redirect standard input (or n) from file.
.TP
[n1]<&n2
Duplicate standard input (or n1) from
file descriptor n2.
.TP
[n]<&-
Close standard input (or n).
.TP
[n1]>&n2
Duplicate standard output (or n) from
n2.
.TP
[n]>&-
Close standard output (or n).
.TP
[n]<> file
Open file for reading and writing on
standard input (or n).
.LP
The following redirection is often called a ``here-document''.
.nf
[n]<< delimiter
here-doc-text...
delimiter
.fi
All the text on successive lines up to the delimiter is
saved away and made available to the command on standard
input, or file descriptor n if it is specified. If the delimiter
as specified on the initial line is quoted, then the here-doc-text
is treated literally, otherwise the text is subjected to
parameter expansion, command substitution, and arithmetic
expansion (as described in the section on ``Expansions''). If
the operator is ``<<-'' instead of ``<<'', then leading tabs
in the here-doc-text are stripped.
.sp2
.BSearchandExecution
.sp
.LP
There are three types of commands: shell functions, builtin commands, and normal programs -- and the
command is searched for (by name) in that order. They
each are executed in a different way.
.LP
When a shell function is executed, all of the shell positional parameters (except $0, which remains unchanged) are
set to the arguments of the shell function.
The variables which are explicitly placed in the environment of
the command (by placing assignments to them before the
function name) are made local to the function and are set
to the values given. Then the command given in the function
definition is executed. The positional parameters are
restored to their original values when the command completes.
.LP
Shell builtins are executed internally to the shell, without spawning a new process.
.LP
Otherwise, if the command name doesn't match a function
or builtin, the command is searched for as a normal
program in the filesystem (as described in the next section).
When a normal program is executed, the shell runs the program,
passing the arguments and the environment to the
program. If the program is a shell procedure, the shell
will interpret the program in a subshell. The shell will
reinitialize itself in this case, so that the effect will
be as if a new shell had been invoked to handle the shell
procedure, except that the location of commands located in
the parent shell will be remembered by the child.
.sp2
.BPathSearch
.sp
.LP
When locating a command, the shell first looks to see if
it has a shell function by that name. Then it looks for a
builtin command by that name.
Finally, it searches each
entry in PATH in turn for the command.
.LP
The value of the PATH variable should be a series of
entries separated by colons. Each entry consists of a
directory name.
The current directory
may be indicated by an empty directory name.
.LP
Command names containing a slash are simply executed without performing any of the above searches.
.sp2
.BCommandExitStatus
.sp
.LP
Each command has an exit status that can influence the behavior
of other shell commands. The paradigm is that a command exits
with zero for normal or success, and non-zero for failure,
error, or a false indication. The man page for each command
should indicate the various exit codes and what they mean.
Additionally, the builtin commands return exit codes, as does
an executed function.
.sp2
.BComplexCommands
.sp
.LP
Complex commands are combinations of simple commands
with control operators or reserved words, together creating a larger complex
command. More generally, a command is one of the following:
.nf
- simple command
- pipeline
- list or compound-list
- compound command
- function definition
.fi
.LP
Unless otherwise stated, the exit status of a command is
that of the last simple command executed by the command.
.sp2
.BPipeline
.sp
.LP
A pipeline is a sequence of one or more commands separated
by the control operator |. The standard output of all but
the last command is connected to the standard input
of the next command.
.LP
The format for a pipeline is:
.nf
[!] command1 [ | command2 ...]
.fi
.LP
The standard output of command1 is connected to the standard
input of command2. The standard input, standard output, or
both of a command is considered to be assigned by the
pipeline before any redirection specified by redirection
operators that are part of the command.
.LP
If the pipeline is not in the background (discussed later),
the shell waits for all commands to complete.
.LP
If the reserved word ! does not precede the pipeline, the
exit status is the exit status of the last command specified
in the pipeline. Otherwise, the exit status is the logical
NOT of the exit status of the last command. That is, if
the last command returns zero, the exit status is 1; if
the last command returns greater than zero, the exit status
is zero.
.LP
Because pipeline assignment of standard input or standard
output or both takes place before redirection, it can be
modified by redirection. For example:
.nf
$ command1 2>&1 | command2
.fi
sends both the standard output and standard error of command1
to the standard input of command2.
.LP
A ; or <newline> terminator causes the preceding
AND-OR-list (described next) to be executed sequentially; a & causes
asynchronous execution of the preceding AND-OR-list.
.sp2
.BBackgroundCommands--&
.sp
.LP
If a command is terminated by the control operator ampersand
(&), the shell executes the command asynchronously -- that is,
the shell does not wait for
the command to finish before executing the next command.
.LP
The format for running a command in background is:
.nf
command1 & [command2 & ...]
.fi
If the shell is not interactive, the standard input of an
asynchronous command is set to /dev/null.
.sp2
.BLists--GenerallySpeaking
.sp
.LP
A list is a sequence of zero or more commands separated by
newlines, semicolons, or ampersands,
and optionally terminated by one of these three characters.
The commands in a
list are executed in the order they are written.
If command is followed by an ampersand, the shell starts the
command and immediately proceed onto the next command;
otherwise it waits for the command to terminate before
proceeding to the next one.
.LP
``&&'' and ``||'' are AND-OR list operators. ``&&'' executes
the first command, and then executes the second command
iff the exit status of the first command is zero. ``||''
is similar, but executes the second command iff the exit
status of the first command is nonzero. ``&&'' and ``||''
both have the same priority.
.LP
The syntax of the if command is
.nf
if list
then list
[ elif list
then list ] ...
[ else list ]
fi
.fi
The syntax of the while command is
.nf
while list
do list
done
.fi
The two lists are executed repeatedly while the exit status of the first list is zero. The until command is similar, but has the word until in place of while
repeat until the exit status of the first list is zero.
.LP
The syntax of the for command is
.nf
for variable in word...
do list
done
.fi
The words are expanded, and then the list is executed
repeatedly with the variable set to each word in turn. do
and done may be replaced with ``{'' and ``}''.
.LP
The syntax of the break and continue command is
.nf
break [ num ]
continue [ num ]
.fi
Break terminates the num innermost for or while loops.
Continue continues with the next iteration of the innermost loop. These are implemented as builtin commands.
.LP
The syntax of the case command is
.nf
case word in
pattern) list ;;
...
esac
.fi
.LP
The pattern can actually be one or more patterns (see Shell
Patterns described later), separated by ``|'' characters.
.LP
Commands may be grouped by writing either
.nf
(list)
.fi
or
.nf
{ list; }
.fi
The first of these executes the commands in a subshell.
.sp2
.BFunctions
.sp
.LP
The syntax of a function definition is
.nf
name ( ) command
.fi
.LP
A function definition is an executable statement; when
executed it installs a function named name and returns an
exit status of zero. The command is normally a list
enclosed between ``{'' and ``}''.
.LP
Variables may be declared to be local to a function by
using a local command. This should appear as the first
statement of a function, and the syntax is
.nf
local [ variable | - ] ...
.fi
Local is implemented as a builtin command.
.LP
When a variable is made local, it inherits the initial
value and exported and readonly flags from the variable
with the same name in the surrounding scope, if there is
one. Otherwise, the variable is initially unset. The shell
uses dynamic scoping, so that if you make the variable x
