bash
Version 2.02.
Copyright (C) 1991, 1993, 1996 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation.
Bash is the shell, or command language interpreter, that will appear in the
GNU operating system. The name is an acronym for the `Bourne-Again
SHell', a pun on Steve Bourne, the author of the direct ancestor of the
current Unix shell /bin/sh
, which appeared in the Seventh Edition
Bell Labs Research version of Unix.
Bash is an sh
-compatible shell that incorporates useful features
from the Korn shell ksh
and the C shell csh
. It is
intended to be a conformant implementation of the IEEE POSIX Shell and Tools
specification (IEEE Working Group 1003.2). It offers functional improvements
over sh
for both interactive and programming use.
While the GNU operating system will include a version of csh
,
Bash will be the default shell. Like other GNU software, Bash is quite portable.
It currently runs on nearly every version of Unix and a few other operating
systems - independently-supported ports exist for MS-DOS, OS/2, Windows 95, and
Windows NT.
At its base, a shell is simply a macro processor that executes commands. A Unix shell is both a command interpreter, which provides the user interface to the rich set of Unix utilities, and a programming language, allowing these utilitites to be combined. Files containing commands can be created, and become commands themselves. These new commands have the same status as system commands in directories like `/bin', allowing users or groups to establish custom environments.
A shell allows execution of Unix commands, both synchronously and
asynchronously. The shell waits for synchronous commands to complete before
accepting more input; asynchronous commands continue to execute in parallel with
the shell while it reads and executes additional commands. The
redirection constructs permit fine-grained control of the input and
output of those commands, and the shell allows control over the contents of
their environment. Unix shells also provide a small set of built-in commands
(builtins) implementing functionality impossible (e.g.,
cd
, break
, continue
, and
exec
), or inconvenient (history
, getopts
,
kill
, or pwd
, for example) to obtain via separate
utilities. Shells may be used interactively or non-interactively: they accept
input typed from the keyboard or from a file. All of the shell builtins are
described in subsequent sections.
While executing commands is essential, most of the power (and complexity) of shells is due to their embedded programming languages. Like any high-level language, the shell provides variables, flow control constructs, quoting, and functions.
Shells have begun offering features geared specifically for interactive use rather than to augment the programming language. These interactive features include job control, command line editing, history and aliases. Each of these features is described in this manual.
These definitions are used throughout the remainder of this manual.
POSIX
blank
builtin
control operator
word
that performs a control function. It
is a newline
or one of the following: `||',
`&&', `&', `;',
`;;', `|', `(', or `)'.
exit status
field
filename
job
job control
metacharacter
blank
or one of the following characters:
`|', `&', `;', `(',
`)', `<', or `>'.
name
word
consisting solely
of letters, numbers, and underscores, and beginning with a letter or
underscore. Name
s are used as shell variable and function names.
Also referred to as an identifier
.
operator
control operator
or a redirection
operator
. See section Redirections,
for a list of redirection operators.
process group
process group ID
process
group
during its lifetime.
reserved word
word
that has a special meaning to the
shell. Most reserved words introduce shell flow control constructs, such as
for
and while
.
return status
exit status
.
signal
special builtin
token
word
or an operator
.
word
token
that is not an
operator
. Bash is an acronym for `Bourne-Again SHell'. The Bourne shell is the traditional Unix shell originally written by Stephen Bourne. All of the Bourne shell builtin commands are available in Bash, and the rules for evaluation and quoting are taken from the POSIX 1003.2 specification for the `standard' Unix shell.
This chapter briefly summarizes the shell's `building blocks': commands, control structures, shell functions, shell parameters, shell expansions, redirections, which are a way to direct input and output from and to named files, and how the shell executes commands.
The following is a brief description of the shell's operation when it reads and executes a command. Basically, the shell does the following:
metacharacters
. Alias expansion is
performed by this step (see section Aliases).
Quoting is used to remove the special meaning of certain characters or words to the shell. Quoting can be used to disable special treatment for special characters, to prevent reserved words from being recognized as such, and to prevent parameter expansion.
Each of the shell metacharacters (see section Definitions) has special meaning to the shell and must be quoted if it is to represent itself. There are three quoting mechanisms: the escape character, single quotes, and double quotes.
A non-quoted backslash `\' is the Bash escape character. It
preserves the literal value of the next character that follows, with the
exception of newline
. If a \newline
pair appears, and
the backslash itself is not quoted, the \newline
is treated as a
line continuation (that is, it is removed from the input stream and effectively
ignored).
Enclosing characters in single quotes preserves the literal value of each character within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash.
Enclosing characters in double quotes preserves the literal value of all
characters within the quotes, with the exception of `$',
``', and `\'. The characters `$' and
``' retain their special meaning within double quotes (see section
Shell
Expansions). The backslash retains its special meaning only when followed by
one of the following characters: `$', ``',
`"', `\', or newline
. Within double
quotes, backslashes that are followed by one of these characters are removed.
Backslashes preceding characters without a special meaning are left unmodified.
A double quote may be quoted within double quotes by preceding it with a
backslash.
The special parameters `*' and `@' have special meaning when in double quotes (see section Shell Parameter Expansion).
Words of the form $'string'
are treated specially.
The word expands to string, with backslash-escaped characters
replaced as specifed by the ANSI C standard. Backslash escape sequences, if
present, are decoded as follows:
\a
\b
\e
\f
\n
\r
\t
\v
\\
\nnn
ASCII
code is the octal value
nnn (one to three digits)
\xnnn
ASCII
code is the hexadecimal value
nnn (one to three digits) The result is single-quoted, as if the dollar sign had not been present.
A double-quoted string preceded by a dollar sign (`$') will
cause the string to be translated according to the current locale. If the
current locale is C
or POSIX
, the dollar sign is
ignored. If the string is translated and replaced, the replacement is
double-quoted.
In a non-interactive shell, or an interactive shell in which the
interactive_comments
option to the shopt
builtin is
enabled (see section Bash Builtin
Commands), a word beginning with `#' causes that word and all
remaining characters on that line to be ignored. An interactive shell without
the interactive_comments
option enabled does not allow comments.
The interactive_comments
option is on by default in interactive
shells. See section Is This Shell
Interactive?, for a description of what makes a shell interactive.
A simple command is the kind of command encountered most often. It's just a
sequence of words separated by blank
s, terminated by one of the
shell's control operators (see section Definitions).
The first word generally specifies a command to be executed.
The return status (see section Exit
Status) of a simple command is its exit status as provided by the POSIX.1
waitpid
function, or 128+n if the command was terminated
by signal n.
A pipeline
is a sequence of simple commands separated by
`|'.
[time
[-p
]] [!
] command1 [|
command2 ...]
The output of each command in the pipeline is connected to the input of the next command. That is, each command reads the previous command's output.
The reserved word time
causes timing statistics to be printed
for the pipeline once it finishes. The statistics currently consist of elapsed
(wall-clock) time and user and system time consumed by the command's execution.
The `-p' option changes the output format to that specified by
POSIX. The TIMEFORMAT
variable may be set to a format string that
specifies how the timing information should be displayed. See section Bash
Variables, for a description of the available formats. The use of
time
as a reserved word permits the timing of shell builtins, shell
functions, and pipelines. An external time
command cannot time
these easily.
If the pipeline is not executed asynchronously (see section Lists of Commands), the shell waits for all commands in the pipeline to complete.
Each command in a pipeline is executed in its own subshell (see section Command Execution Environment). The exit status of a pipeline is the exit status of the last command in the pipeline. If the reserved word `!' precedes the pipeline, the exit status is the logical negation of the exit status of the last command.
A list
is a sequence of one or more pipelines separated by one
of the operators `;', `&',
`&&', or `||', and optionally terminated by
one of `;', `&', or a newline
.
Of these list operators, `&&' and `||' have equal precedence, followed by `;' and `&', which have equal precedence.
If a command is terminated by the control operator `&', the
shell executes the command asynchronously in a subshell. This is known as
executing the command in the background. The shell does not wait for
the command to finish, and the return status is 0 (true). The standard input for
asynchronous commands, in the absence of any explicit redirections, is
redirected from /dev/null
.
Commands separated by a `;' are executed sequentially; the shell waits for each command to terminate in turn. The return status is the exit status of the last command executed.
The control operators `&&' and `||' denote AND lists and OR lists, respectively. An AND list has the form
command && command2
command2 is executed if, and only if, command returns an exit status of zero.
An OR list has the form
command || command2
command2 is executed if, and only if, command returns a non-zero exit status.
The return status of AND and OR lists is the exit status of the last command executed in the list.
Bash supports the following looping constructs.
Note that wherever you see a `;' in the description of a command's syntax, it may be replaced with one or more newlines.
until
until
command is: until test-commands; do consequent-commands; doneExecute consequent-commands as long as test-commands has an exit status which is not zero. The return status is the exit status of the last command executed in consequent-commands, or zero if none was executed.
while
while
command is: while test-commands; do consequent-commands; doneExecute consequent-commands as long as test-commands has an exit status of zero. The return status is the exit status of the last command executed in consequent-commands, or zero if none was executed.
for
for
command is: for name [in words ...]; do commands; doneExpand words, and execute commands once for each member in the resultant list, with name bound to the current member. If `in words' is not present, `in "$@"' is assumed. The return status is the exit status of the last command that executes. If there are no items in the expansion of words, no commands are executed, and the return status is zero.
The break
and continue
builtins (see section Bourne Shell
Builtins) may be used to control loop execution.
if
if
command is: if test-commands; then consequent-commands; [elif more-test-commands; then more-consequents;] [else alternate-consequents;] fiThe test-commands list is executed, and if its return status is zero, the consequent-commands list is executed. If test-commands returns a non-zero status, each
elif
list is executed in turn, and if its exit status is zero, the corresponding
more-consequents is executed and the command completes. If
`else alternate-consequents' is present, and the final
command in the final if
or elif
clause has a
non-zero exit status, then alternate-consequents is executed. The
return status is the exit status of the last command executed, or zero if no
condition tested true.
case
case
command is: case word in [ [(] pattern [| pattern]...) command-list ;;]... esac
case
will selectively execute the command-list
corresponding to the first pattern that matches word.
The `|' is used to separate multiple patterns, and the
`)' operator terminates a pattern list. A list of patterns and an
associated command-list is known as a clause. Each clause must be
terminated with `;;'. The word undergoes tilde
expansion, parameter expansion, command substitution, arithmetic expansion,
and quote removal before matching is attempted. Each pattern
undergoes tilde expansion, parameter expansion, command substitution, and
arithmetic expansion. There may be an arbitrary number of case
clauses, each terminated by a `;;'. The first pattern that
matches determines the command-list that is executed. Here is an example using
case
in a script that could be used to describe one interesting
feature of an animal: echo -n "Enter the name of an animal: " read ANIMAL echo -n "The $ANIMAL has " case $ANIMAL in horse | dog | cat) echo -n "four";; man | kangaroo ) echo -n "two";; *) echo -n "an unknown number of";; esac echo " legs."The return status is zero if no pattern is matched. Otherwise, the return status is the exit status of the command-list executed.
select
select
construct allows the easy
generation of menus. It has almost the same syntax as the for
command: select name [in words ...]; do commands; doneThe list of words following
in
is expanded, generating a
list of items. The set of expanded words is printed on the standard error
output stream, each preceded by a number. If the `in
words' is omitted, the positional parameters are printed, as
if `in "$@"' had been specifed. The PS3
prompt is
then displayed and a line is read from the standard input. If the line
consists of a number corresponding to one of the displayed words, then the
value of name is set to that word. If the line is empty, the words
and prompt are displayed again. If EOF
is read, the
select
command completes. Any other value read causes
name to be set to null. The line read is saved in the variable
REPLY
. The commands are executed after each selection
until a break
or return
command is executed, at
which point the select
command completes. Here is an example that
allows the user to pick a filename from the current directory, and displays
the name and index of the file selected. select fname in *; do echo you picked $fname \($REPLY\) break; done
((...))
(( expression ))The arithmetic expression is evaluated according to the rules described below (see section Shell Arithmetic). If the value of the expression is non-zero, the return status is 0; otherwise the return status is 1. This is exactly equivalent to
let "expression"See section Bash Builtin Commands, for a full description of the
let
builtin.
[[...]]
[[ expression ]]Return a status of 0 or 1 depending on the evaluation of the conditional expression expression. Expressions are composed of the primaries described below in section Bash Conditional Expressions. Word splitting and filename expansion are not performed on the words between the `[[' and `]]'; tilde expansion, parameter and variable expansion, arithmetic expansion, command substitution, process substitution, and quote removal are performed. When the `==' and `!=' operators are used, the string to the right of the operator is considered a pattern and matched according to the rules described below in section Pattern Matching. The return value is 0 if the string matches or does not match the pattern, respectively, and 1 otherwise. Any part of the pattern may be quoted to force it to be matched as a string. Expressions may be combined using the following operators, listed in decreasing order of precedence:
( expression )
! expression
expression1 && expression2
expression1 || expression2
Bash provides two ways to group a list of commands to be executed as a unit. When commands are grouped, redirections may be applied to the entire command list. For example, the output of all the commands in the list may be redirected to a single stream.
()
( list )Placing a list of commands between parentheses causes a subshell to be created, and each of the commands in list to be executed in that subshell. Since the list is executed in a subshell, variable assignments do not remain in effect after the subshell completes.
{}
{ list; }Placing a list of commands between curly braces causes the list to be executed in the current shell context. No subshell is created. The semicolon (or newline) following list is required.
In addition to the creation of a subshell, there is a subtle difference
between these two constructs due to historical reasons. The braces are
reserved words
, so they must be separated from the list
by blank
s. The parentheses are operators
, and are
recognized as separate tokens by the shell even if they are not separated from
the list by whitespace.
The exit status of both of these constructs is the exit status of list.
Shell functions are a way to group commands for later execution using a single name for the group. They are executed just like a "regular" command. Shell functions are executed in the current shell context; no new process is created to interpret them.
Functions are declared using this syntax:
[ function
] name () { command-list; }
This defines a shell function named name. The reserved word
function
is optional. If the function
reserved word is
supplied, the parentheses are optional. The body of the function is
the command-list between { and }. This list is executed whenever
name is specified as the name of a command. The exit status of a
function is the exit status of the last command executed in the body.
When a function is executed, the arguments to the function become the
positional parameters during its execution (see section Positional
Parameters). The special parameter `#' that expands to the
number of positional parameters is updated to reflect the change. Positional
parameter 0
is unchanged.
If the builtin command return
is executed in a function, the
function completes and execution resumes with the next command after the
function call. When a function completes, the values of the positional
parameters and the special parameter `#' are restored to the values
they had prior to the function's execution. If a numeric argument is given to
return
, that is the function's return status; otherwise the
functions's return status is the exit status of the last command executed before
the return
.
Variables local to the function may be declared with the local
builtin. These variables are visible only to the function and the commands it
invokes.
Functions may be recursive. No limit is placed on the number of recursive calls.
A parameter is an entity that stores values. It can be a
name
, a number, or one of the special characters listed below. For
the shell's purposes, a variable is a parameter denoted by a
name
.
A parameter is set if it has been assigned a value. The null string is a
valid value. Once a variable is set, it may be unset only by using the
unset
builtin command.
A variable may be assigned to by a statement of the form
name=[value]
If value is not given, the variable is assigned the null string.
All values undergo tilde expansion, parameter and variable expansion,
command substitution, arithmetic expansion, and quote removal (detailed below).
If the variable has its integer
attribute set (see the description
of the declare
builtin in section Bash Builtin
Commands), then value is subject to arithmetic expansion even if
the $((...))
expansion is not used (see section Arithmetic
Expansion). Word splitting is not performed, with the exception of
"$@"
as explained below. Filename expansion is not performed.
A positional parameter is a parameter denoted by one or more
digits, other than the single digit 0
. Positional parameters are
assigned from the shell's arguments when it is invoked, and may be reassigned
using the set
builtin command. Positional parameter N
may be referenced as ${N}
. Positional parameters may not be
assigned to with assignment statements. The positional parameters are
temporarily replaced when a shell function is executed (see section Shell
Functions).
When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces.
The shell treats several parameters specially. These parameters may only be referenced; assignment to them is not allowed.
*
IFS
special variable. That is, "$*"
is equivalent to
"$1c$2c..."
, where c is the
first character of the value of the IFS
variable. If
IFS
is unset, the parameters are separated by spaces. If
IFS
is null, the parameters are joined without intervening
separators.
@
"$@"
is equivalent to "$1" "$2"
...
. When there are no positional parameters, "$@"
and
$@
expand to nothing (i.e., they are removed).
#
?
-
set
builtin command, or those set by the shell
itself (such as the `-i' option).
$
()
subshell, it expands to the process ID of the invoking shell,
not the subshell.
!
0
$0
is set to the name of that file. If Bash is
started with the `-c' option (see section Invoking
Bash), then $0
is set to the first argument after the string
to be executed, if one is present. Otherwise, it is set to the filename used
to invoke Bash, as given by argument zero.
_
Expansion is performed on the command line after it has been split into
token
s. There are seven kinds of expansion performed:
The order of expansions is: brace expansion, tilde expansion, parameter, variable, and arithmetic expansion and command substitution (done in a left-to-right fashion), word splitting, and filename expansion.
On systems that can support it, there is an additional expansion available: process substitution. This is performed at the same time as parameter, variable, and arithmetic expansion and command substitution.
Only brace expansion, word splitting, and filename expansion can change the
number of words of the expansion; other expansions expand a single word to a
single word. The only exceptions to this are the expansions of "$@"
(see section Special
Parameters) and "${name[@]}"
(see section Arrays).
After all expansions, quote removal
(see section Quote
Removal) is performed.
Brace expansion is a mechanism by which arbitrary strings may be generated. This mechanism is similar to filename expansion (see section Filename Expansion), but the file names generated need not exist. Patterns to be brace expanded take the form of an optional preamble, followed by a series of comma-separated strings between a pair of braces, followed by an optional postscript. The preamble is prepended to each string contained within the braces, and the postscript is then appended to each resulting string, expanding left to right.
Brace expansions may be nested. The results of each expanded string are not sorted; left to right order is preserved. For example,
bash$ echo a{d,c,b}e ade ace abe
Brace expansion is performed before any other expansions, and any characters special to other expansions are preserved in the result. It is strictly textual. Bash does not apply any syntactic interpretation to the context of the expansion or the text between the braces.
A correctly-formed brace expansion must contain unquoted opening and closing braces, and at least one unquoted comma. Any incorrectly formed brace expansion is left unchanged.
This construct is typically used as shorthand when the common prefix of the strings to be generated is longer than in the above example:
mkdir /usr/local/src/bash/{old,new,dist,bugs}
or
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}
If a word begins with an unquoted tilde character (`~'), all of
the characters up to the first unquoted slash (or all characters, if there is no
unquoted slash) are considered a tilde-prefix. If none of the
characters in the tilde-prefix are quoted, the characters in the tilde-prefix
following the tilde are treated as a possible login name. If this
login name is the null string, the tilde is replaced with the value of the
HOME
shell variable. If HOME
is unset, the home
directory of the user executing the shell is substituted instead. Otherwise, the
tilde-prefix is replaced with the home directory associated with the specified
login name.
If the tilde-prefix is `~+', the value of the shell variable
PWD
replaces the tilde-prefix. If the tilde-prefix is
`~-', the value of the shell variable OLDPWD
, if it is
set, is substituted.
If the characters following the tilde in the tilde-prefix consist of a number
N, optionally prefixed by a `+' or a `-',
the tilde-prefix is replaced with the corresponding element from the directory
stack, as it would be displayed by the dirs
builtin invoked with
the characters following tilde in the tilde-prefix as an argument (see section
The
Directory Stack). If the tilde-prefix, sans the tilde, consists of a number
without a leading `+' or `-', `+' is
assumed.
If the login name is invalid, or the tilde expansion fails, the word is left unchanged.
Each variable assignment is checked for unquoted tilde-prefixes immediately
following a `:' or `='. In these cases, tilde
expansion is also performed. Consequently, one may use file names with tildes in
assignments to PATH
, MAILPATH
, and
CDPATH
, and the shell assigns the expanded value.
The following table shows how Bash treats unquoted tilde-prefixes:
~
$HOME
~/foo
~fred/foo
foo
of the home directory of the user
fred
~+/foo
~-/foo
~N
~+N
~-N
The `$' character introduces parameter expansion, command substitution, or arithmetic expansion. The parameter name or symbol to be expanded may be enclosed in braces, which are optional but serve to protect the variable to be expanded from characters immediately following it which could be interpreted as part of the name.
When braces are used, the matching ending brace is the first `}' not escaped by a backslash or within a quoted string, and not within an embedded arithmetic expansion, command substitution, or parameter expansion.
The basic form of parameter expansion is ${parameter}. The value of parameter is substituted. The braces are required when parameter is a positional parameter with more than one digit, or when parameter is followed by a character that is not to be interpreted as part of its name.
If the first character of parameter is an exclamation point, a
level of variable indirection is introduced. Bash uses the value of the variable
formed from the rest of parameter as the name of the variable; this
variable is then expanded and that value is used in the rest of the
substitution, rather than the value of parameter itself. This is
known as indirect expansion
.
In each of the cases below, word is subject to tilde expansion, parameter expansion, command substitution, and arithmetic expansion. When not performing substring expansion, Bash tests for a parameter that is unset or null; omitting the colon results in a test only for a parameter that is unset.
${parameter:-word}
${parameter:=word}
${parameter:?word}
${parameter:+word}
${parameter:offset}
${parameter:offset:length}
${parameter[offset]}
. Substring indexing is
zero-based unless the positional parameters are used, in which case the
indexing starts at 1.
${#parameter}
${parameter#word}
${parameter##word}
${parameter%word}
${parameter%%word}
${parameter/pattern/string}
${parameter//pattern/string}
/
following pattern may be omitted. If
parameter is `@' or `*', the substitution
operation is applied to each positional parameter in turn, and the expansion
is the resultant list. If parameter is an array variable
subscripted with `@' or `*', the substitution
operation is applied to each member of the array in turn, and the expansion is
the resultant list. Command substitution allows the output of a command to replace the command name. There are two forms:
$(command)
or
`command`
Bash performs the expansion by executing command and replacing the
command substitution with the standard output of the command, with any trailing
newlines deleted. Embedded newlines are not deleted, but they may be removed
during word splitting. The command substitution $(cat
file)
can be replaced by the equivalent but faster
$(< file)
.
When the old-style backquote form of substitution is used, backslash retains
its literal meaning except when followed by `$', ``',
or `\'. The first backquote not preceded by a backslash terminates
the command substitution. When using the $(command)
form, all characters between the parentheses make up the command; none are
treated specially.
Command substitutions may be nested. To nest when using the backquoted form, escape the inner backquotes with backslashes.
If the substitution appears within double quotes, word splitting and filename expansion are not performed on the results.
Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is:
$(( expression ))
The expression is treated as if it were within double quotes, but a double quote inside the parentheses is not treated specially. All tokens in the expression undergo parameter expansion, command substitution, and quote removal. Arithmetic substitutions may be nested.
The evaluation is performed according to the rules listed below (see section Shell Arithmetic). If the expression is invalid, Bash prints a message indicating failure to the standard error and no substitution occurs.
Process substitution is supported on systems that support named pipes (FIFOs) or the `/dev/fd' method of naming open files. It takes the form of
<(list)
or
>(list)
The process list is run with its input or output connected to a
FIFO or some file in `/dev/fd'. The name of this file is passed as an
argument to the current command as the result of the expansion. If the
>(list)
form is used, writing to the file will
provide input for list. If the <(list)
form is used, the file passed as an argument should be read to obtain the output
of list.
When available, process substitution is performed simultaneously with parameter and variable expansion, command substitution, and arithmetic expansion.
The shell scans the results of parameter expansion, command substitution, and arithmetic expansion that did not occur within double quotes for word splitting.
The shell treats each character of $IFS
as a delimiter, and
splits the results of the other expansions into words on these characters. If
IFS
is unset, or its value is exactly
<space><tab><newline>
, the default, then any
sequence of IFS
characters serves to delimit words. If
IFS
has a value other than the default, then sequences of the
whitespace characters space
and tab
are ignored at the
beginning and end of the word, as long as the whitespace character is in the
value of IFS
(an IFS
whitespace character). Any
character in IFS
that is not IFS
whitespace, along
with any adjacent IFS
whitespace characters, delimits a field. A
sequence of IFS
whitespace characters is also treated as a
delimiter. If the value of IFS
is null, no word splitting occurs.
Explicit null arguments (""
or "
) are retained.
Unquoted implicit null arguments, resulting from the expansion of
parameters that have no values, are removed. If a parameter with no
value is expanded within double quotes, a null argument results and is retained.
Note that if no expansion occurs, no splitting is performed.
After word splitting, unless the `-f' option has been set (see
section The Set
Builtin), Bash scans each word for the characters `*',
`?', `(', and `['. If one of these
characters appears, then the word is regarded as a pattern, and
replaced with an alphabetically sorted list of file names matching the pattern.
If no matching file names are found, and the shell option nullglob
is disabled, the word is left unchanged. If the nullglob
option is
set, and no matches are found, the word is removed. If the shell option
nocaseglob
is enabled, the match is performed without regard to the
case of alphabetic characters.
When a pattern is used for filename generation, the character
`.' at the start of a filename or immediately following a slash
must be matched explicitly, unless the shell option dotglob
is set.
When matching a file name, the slash character must always be matched
explicitly. In other cases, the `.' character is not treated
specially.
See the description of shopt
in section Bash Builtin
Commands, for a description of the nocaseglob
,
nullglob
, and dotglob
options.
The GLOBIGNORE
shell variable may be used to restrict the set of
filenames matching a pattern. If GLOBIGNORE
is set, each matching
filename that also matches one of the patterns in GLOBIGNORE
is
removed from the list of matches. The filenames `.' and `..'
are always ignored, even when GLOBIGNORE
is set. However, setting
GLOBIGNORE
has the effect of enabling the dotglob
shell option, so all other filenames beginning with a `.' will
match. To get the old behavior of ignoring filenames beginning with a
`.', make `.*' one of the patterns in
GLOBIGNORE
. The dotglob
option is disabled when
GLOBIGNORE
is unset.
Any character that appears in a pattern, other than the special pattern characters described below, matches itself. The NUL character may not occur in a pattern. The special pattern characters must be quoted if they are to be matched literally.
The special pattern characters have the following meanings:
*
?
[...]
[:
class:]
,
where class is one of the following classes defined in the POSIX.2
standard: alnum alpha ascii blank cntrl digit graph lower print punct space upper xdigitA character class matches any character belonging to that class. Within `[' and `]', an equivalence class can be specified using the syntax
[=
c=]
, which
matches all characters with the same collation weight (as defined by the
current locale) as the character c. Within `[' and
`]', the syntax [.
symbol.]
matches the collating symbol symbol. If the extglob
shell option is enabled using the
shopt
builtin, several extended pattern matching operators are
recognized. In the following description, a pattern-list is a list of
one or more patterns separated by a `|'. Composite patterns may be
formed using one or more of the following sub-patterns:
?(pattern-list)
*(pattern-list)
+(pattern-list)
@(pattern-list)
!(pattern-list)
After the preceding expansions, all unquoted occurrences of the characters `\', `'', and `"' that did not result from one of the above expansions are removed.
Before a command is executed, its input and output may be redirected using a special notation interpreted by the shell. Redirection may also be used to open and close files for the current shell execution environment. The following redirection operators may precede or appear anywhere within a simple command or may follow a command. Redirections are processed in the order they appear, from left to right.
In the following descriptions, if the file descriptor number is omitted, and the first character of the redirection operator is `<', the redirection refers to the standard input (file descriptor 0). If the first character of the redirection operator is `>', the redirection refers to the standard output (file descriptor 1).
The word following the redirection operator in the following descriptions, unless otherwise noted, is subjected to brace expansion, tilde expansion, parameter expansion, command substitution, arithmetic expansion, quote removal, and filename expansion. If it expands to more than one word, Bash reports an error.
Note that the order of redirections is significant. For example, the command
ls > dirlist 2>&1
directs both standard output and standard error to the file dirlist, while the command
ls 2>&1 > dirlist
directs only the standard output to file dirlist, because the standard error was duplicated as standard output before the standard output was redirected to dirlist.
A failure to open or create a file causes the redirection to fail.
Redirection of input causes the file whose name results from the expansion of
word to be opened for reading on file descriptor n
, or
the standard input (file descriptor 0) if n
is not specified.
The general format for redirecting input is:
[n]<word
Redirection of output causes the file whose name results from the expansion
of word to be opened for writing on file descriptor n
,
or the standard output (file descriptor 1) if n
is not specified.
If the file does not exist it is created; if it does exist it is truncated to
zero size.
The general format for redirecting output is:
[n]>[|]word
If the redirection operator is `>', and the
noclobber
option to the set
builtin has been enabled,
the redirection will fail if the filename whose name results from the expansion
of word exists and is a regular file. If the redirection operator is
`>|', or the redirection operator is `>' and the
noclobber
option is not enabled, the redirection is attempted even
if the file named by word exists.
Redirection of output in this fashion causes the file whose name results from
the expansion of word to be opened for appending on file descriptor
n
, or the standard output (file descriptor 1) if n
is
not specified. If the file does not exist it is created.
The general format for appending output is:
[n]>>word
Bash allows both the standard output (file descriptor 1) and the standard error output (file descriptor 2) to be redirected to the file whose name is the expansion of word with this construct.
There are two formats for redirecting standard output and standard error:
&>word
and
>&word
Of the two forms, the first is preferred. This is semantically equivalent to
>word 2>&1
This type of redirection instructs the shell to read input from the current source until a line containing only word (with no trailing blanks) is seen. All of the lines read up to that point are then used as the standard input for a command.
The format of here-documents is as follows:
<<[-]word here-document delimiter
No parameter expansion, command substitution, filename expansion, or
arithmetic expansion is performed on word. If any characters in
word are quoted, the delimiter is the result of quote
removal on word, and the lines in the here-document are not expanded.
If word is unquoted, all lines of the here-document are subjected to
parameter expansion, command substitution, and arithmetic expansion. In the
latter case, the pair \newline
is ignored, and `\'
must be used to quote the characters `\', `$', and
``'.
If the redirection operator is `<<-', then all leading tab characters are stripped from input lines and the line containing delimiter. This allows here-documents within shell scripts to be indented in a natural fashion.
The redirection operator
[n]<&word
is used to duplicate input file descriptors. If word expands to
one or more digits, the file descriptor denoted by n
is made to be
a copy of that file descriptor. If the digits in word do not specify
a file descriptor open for input, a redirection error occurs. If word
evaluates to `-', file descriptor n
is closed. If
n
is not specified, the standard input (file descriptor 0) is used.
The operator
[n]>&word
is used similarly to duplicate output file descriptors. If n
is
not specified, the standard output (file descriptor 1) is used. If the digits in
word do not specify a file descriptor open for output, a redirection
error occurs. As a special case, if n
is omitted, and
word does not expand to one or more digits, the standard output and
standard error are redirected as described previously.
The redirection operator
[n]<>word
causes the file whose name is the expansion of word to be opened
for both reading and writing on file descriptor n
, or on file
descriptor 0 if n
is not specified. If the file does not exist, it
is created.
When a simple command is executed, the shell performs the following expansions, assignments, and redirections, from left to right.
If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment. If any of the assignments attempts to assign a value to a readonly variable, an error occurs, and the command exits with a non-zero status.
If no command name results, redirections are performed, but do not affect the current shell environment. A redirection error causes the command to exit with a non-zero status.
If there is a command name left after expansion, execution proceeds as described below. Otherwise, the command exits. If one of the expansions contained a command substitution, the exit status of the command is the exit status of the last command substitution performed. If there were no command substitutions, the command exits with a status of zero.
After a command has been split into words, if it results in a simple command and an optional list of arguments, the following actions are taken.
$PATH
for a directory
containing an executable file by that name. Bash uses a hash table to remember
the full pathnames of executable files to avoid multiple PATH
searches (see the description of hash
in section Bourne
Shell Builtins). A full search of the directories in $PATH
is
performed only if the command is not found in the hash table. If the search is
unsuccessful, the shell prints an error message and returns an exit status of
127.
The shell has an execution environment, which consists of the following:
exec
builtin
cd
,
pushd
, or popd
, or inherited by the shell at
invocation
umask
or inherited from
the shell's parent
trap
set
or inherited from the shell's parent in the environment
set
shopt
alias
(see section Aliases)
$$
, and the value of
$PPID
When a simple command other than a builtin or shell function is to be executed, it is invoked in a separate execution environment that consists of the following. Unless otherwise noted, the values are inherited from the shell.
A command invoked in this separate environment cannot affect the shell's execution environment.
Command substitution and asynchronous commands are invoked in a subshell environment that is a duplicate of the shell environment, except that traps caught by the shell are reset to the values that the shell inherited from its parent at invocation. Builtin commands that are invoked as part of a pipeline are also executed in a subshell environment. Changes made to the subshell environment cannot affect the shell's execution environment.
When a program is invoked it is given an array of strings called the
environment. This is a list of name-value pairs, of the form
name=value
.
Bash allows you to manipulate the environment in several ways. On invocation,
the shell scans its own environment and creates a parameter for each name found,
automatically marking it for export to child processes. Executed
commands inherit the environment. The export
and `declare
-x' commands allow parameters and functions to be added to and deleted
from the environment. If the value of a parameter in the environment is
modified, the new value becomes part of the environment, replacing the old. The
environment inherited by any executed command consists of the shell's initial
environment, whose values may be modified in the shell, less any pairs removed
by the unset
and `export -n' commands, plus any
additions via the export
and `declare -x' commands.
The environment for any simple command or function may be augmented temporarily by prefixing it with parameter assignments, as described in section Shell Parameters. These assignment statements affect only the environment seen by that command.
If the `-k' option is set (see section The Set Builtin), then all parameter assignments are placed in the environment for a command, not just those that precede the command name.
When Bash invokes an external command, the variable `$_' is set to the full path name of the command and passed to that command in its environment.
For the shell's purposes, a command which exits with a zero exit status has succeeded. A non-zero exit status indicates failure. This seemingly counter-intuitive scheme is used so there is one well-defined way to indicate success and a variety of ways to indicate various failure modes. When a command terminates on a fatal signal whose number is n, Bash uses the value 128+n as the exit status.
If a command is not found, the child process created to execute it returns a status of 127. If a command is found but is not executable, the return status is 126.
If a command fails because of an error during expansion or redirection, the exit status is greater than zero.
The exit status is used by the Bash conditional commands (see section Conditional Constructs) and some of the list constructs (see section Lists of Commands).
All of the Bash builtins return an exit status of zero if they succeed and a non-zero status on failure, so they may be used by the conditional and list constructs. All builtins return an exit status of 2 to indicate incorrect usage.
When Bash is interactive, in the absence of any traps, it ignores
SIGTERM
(so that `kill 0' does not kill an interactive
shell), and SIGINT
is caught and handled (so that the
wait
builtin is interruptible). When Bash receives a
SIGINT
, it breaks out of any executing loops. In all cases, Bash
ignores SIGQUIT
. If job control is in effect (see section Job
Control), Bash ignores SIGTTIN
, SIGTTOU
, and
SIGTSTP
.
Commands started by Bash have signal handlers set to the values inherited by
the shell from its parent. When job control is not in effect, asynchronous
commands ignore SIGINT
and SIGQUIT
as well. Commands
run as a result of command substitution ignore the keyboard-generated job
control signals SIGTTIN
, SIGTTOU
, and
SIGTSTP
.
The shell exits by default upon receipt of a SIGHUP
. Before
exiting, it resends the SIGHUP
to all jobs, running or stopped.
Stopped jobs are sent SIGCONT
to ensure that they receive the
SIGHUP
. To prevent the shell from sending the SIGHUP
signal to a particular job, it should be removed from the jobs table with the
disown
builtin (see section Job Control
Builtins) or marked to not receive SIGHUP
using disown
-h
.
If the huponexit
shell option has been set with
shopt
(see section Bash Builtin
Commands), Bash sends a SIGHUP
to all jobs when an interactive
login shell exits.
When Bash receives a signal for which a trap has been set while waiting for a
command to complete, the trap will not be executed until the command completes.
When Bash is waiting for an asynchronous command via the wait
builtin, the reception of a signal for which a trap has been set will cause the
wait
builtin to return immediately with an exit status greater than
128, immediately after which the trap is executed.
A shell script is a text file containing shell commands. When such a file is
used as the first non-option argument when invoking Bash, and neither the
`-c' nor `-s' option is supplied (see section Invoking
Bash), Bash reads and executes commands from the file, then exits. This mode
of operation creates a non-interactive shell. When Bash runs a shell script, it
sets the special parameter 0
to the name of the file, rather than
the name of the shell, and the positional parameters are set to the remaining
arguments, if any are given. If no additional arguments are supplied, the
positional parameters are unset.
A shell script may be made executable by using the chmod
command
to turn on the execute bit. When Bash finds such a file while searching the
$PATH
for a command, it spawns a subshell to execute it. In other
words, executing
filename arguments
is equivalent to executing
bash filename arguments
if filename
is an executable shell script. This subshell
reinitializes itself, so that the effect is as if a new shell had been invoked
to interpret the script, with the exception that the locations of commands
remembered by the parent (see the description of hash
in section Bourne Shell
Builtins) are retained by the child.
Most versions of Unix make this a part of the kernel's command execution mechanism. If the first line of a script begins with the two characters `#!', the remainder of the line specifies an interpreter for the program. The arguments to the interpreter consist of a single optional argument following the interpreter name on the first line of the script file, followed by the name of the script file, followed by the rest of the arguments. Bash will perform this action on operating systems that do not handle it themselves. Note that some older versions of Unix limit the interpreter name and argument to a maximum of 32 characters.
This section briefly summarizes things which Bash inherits from the Bourne Shell: builtins, variables, and other features. It also lists the significant differences between Bash and the Bourne Shell. Many of the builtins have been extended by POSIX or Bash.
The following shell builtin commands are inherited from the Bourne Shell. These commands are implemented as specified by the POSIX 1003.2 standard.
:
: [arguments]Do nothing beyond expanding arguments and performing redirections. The return status is zero.
.
. filenameRead and execute commands from the filename argument in the current shell context. If filename does not contain a slash, the
$PATH
variable is used to find filename. The current
directory is searched if filename is not found in
$PATH
. The return status is the exit status of the last command
executed, or zero if no commands are executed. If filename is not
found, or cannot be read, the return status is non-zero.
break
break [n]Exit from a
for
, while
, until
, or
select
loop. If n is supplied, the nth
enclosing loop is exited. n must be greater than or equal to 1. The
return status is zero unless n is not greater than or equal to 1.
cd
cd [-LP] [directory]Change the current working directory to directory. If directory is not given, the value of the
HOME
shell
variable is used. If the shell variable CDPATH
exists, it is used
as a search path. If directory begins with a slash,
CDPATH
is not used. The `-P' option means to not
follow symbolic links; symbolic links are followed by default or with the
`-L' option. If directory is `-', it is
equivalent to $OLDPWD
. The return status is zero if the directory
is successfully changed, non-zero otherwise.
continue
continue [n]Resume the next iteration of an enclosing
for
,
while
, until
, or select
loop. If
n is supplied, the execution of the nth enclosing loop
is resumed. n must be greater than or equal to 1. The return status
is zero unless n is not greater than or equal to 1.
eval
eval [arguments]The arguments are concatenated together into a single command, which is then read and executed, and its exit status returned as the exit status of
eval
. If there are no arguments or only empty arguments, the
return status is zero.
exec
exec [-cl] [-a name] [command [arguments]]If command is supplied, it replaces the shell without creating a new process. If the `-l' option is supplied, the shell places a dash in the zeroth arg passed to command. This is what the
login
program does. The `-c' option causes
command to be executed with an empty environment. If
`-a' is supplied, the shell passes name as the zeroth
argument to command. If no command is specified,
redirections may be used to affect the current shell environment. If there are
no redirection errors, the return status is zero; otherwise the return status
is non-zero.
exit
exit [n]Exit the shell, returning a status of n to the shell's parent. Any trap on
EXIT
is executed before the shell terminates.
export
export [-fn] [-p] [name[=value]]Mark each name to be passed to child processes in the environment. If the `-f' option is supplied, the names refer to shell functions; otherwise the names refer to shell variables. The `-n' option means to no longer mark each name for export. If no names are supplied, or if the `-p' option is given, a list of exported names is displayed. The `-p' option displays output in a form that may be reused as input. The return status is zero unless an invalid option is supplied, one of the names is not a valid shell variable name, or `-f' is supplied with a name that is not a shell function.
getopts
getopts optstring name [args]
getopts
is used by shell scripts to parse positional
parameters. optstring contains the option letters to be recognized;
if a letter is followed by a colon, the option is expected to have an
argument, which should be separated from it by white space. Each time it is
invoked, getopts
places the next option in the shell variable
name, initializing name if it does not exist, and the
index of the next argument to be processed into the variable
OPTIND
. OPTIND
is initialized to 1 each time the
shell or a shell script is invoked. When an option requires an argument,
getopts
places that argument into the variable
OPTARG
. The shell does not reset OPTIND
automatically; it must be manually reset between multiple calls to
getopts
within the same shell invocation if a new set of
parameters is to be used. When the end of options is encountered,
getopts
exits with a return value greater than zero.
OPTIND
is set to the index of the first non-option argument, and
name
is set to `?'. getopts
normally
parses the positional parameters, but if more arguments are given in
args, getopts
parses those instead.
getopts
can report errors in two ways. If the first character of
optstring is a colon, silent error reporting is used. In
normal operation diagnostic messages are printed when invalid options or
missing option arguments are encountered. If the variable OPTERR
is set to 0, no error messages will be displayed, even if the first character
of optstring
is not a colon. If an invalid option is seen,
getopts
places `?' into name and, if not
silent, prints an error message and unsets OPTARG
. If
getopts
is silent, the option character found is placed in
OPTARG
and no diagnostic message is printed. If a required
argument is not found, and getopts
is not silent, a question mark
(`?') is placed in name, OPTARG
is unset,
and a diagnostic message is printed. If getopts
is silent, then a
colon (`:') is placed in name and OPTARG
is set to the option character found.
hash
hash [-r] [-p filename] [name]Remember the full pathnames of commands specified as name arguments, so they need not be searched for on subsequent invocations. The commands are found by searching through the directories listed in
$PATH
. The `-p' option inhibits the path search, and
filename is used as the location of name. The
`-r' option causes the shell to forget all remembered locations.
If no arguments are given, information about remembered commands is printed.
The return status is zero unless a name is not found or an invalid
option is supplied.
pwd
pwd [-LP]Print the current working directory. If the `-P' option is supplied, the path printed will not contain symbolic links. If the `-L' option is supplied, the path printed may contain symbolic links. The return status is zero unless an error is encountered while determining the name of the current directory or an invalid option is supplied.
readonly
readonly [-apf] [name] ...Mark each name as readonly. The values of these names may not be changed by subsequent assignment. If the `-f' option is supplied, each name refers to a shell function. The `-a' option means each name refers to an array variable. If no name arguments are given, or if the `-p' option is supplied, a list of all readonly names is printed. The `-p' option causes output to be displayed in a format that may be reused as input. The return status is zero unless an invalid option is supplied, one of the name arguments is not a valid shell variable or function name, or the `-f' option is supplied with a name that is not a shell function.
return
return [n]Cause a shell function to exit with the return value n. This may also be used to terminate execution of a script being executed with the
.
builtin, returning either n or the exit status of
the last command executed within the script as the exit status of the script.
The return status is false if return
is used outside a function
and not during the execution of a script by `.'.
shift
shift [n]Shift the positional parameters to the left by n. The positional parameters from n+1 ...
$#
are renamed to
$1
... $#
-n+1. Parameters represented by
the numbers $#
to n+1 are unset. n must be
a non-negative number less than or equal to $#
. If n
is zero or greater than $#
, the positional parameters are not
changed. The return status is zero unless n is greater than
$#
or less than zero, non-zero otherwise.
test
[
! expr
( expr )
expr1 -a expr2
expr1 -o expr2
test
and [
builtins evaluate conditional expressions
using a set of rules based on the number of arguments.
times
timesPrint out the user and system times used by the shell and its children. The return status is zero.
trap
trap [-lp] [arg] [sigspec ...]The commands in arg are to be read and executed when the shell receives signal sigspec. If arg is absent or equal to `-', all specified signals are reset to the values they had when the shell was started. If arg is the null string, then the signal specified by each sigspec is ignored by the shell and commands it invokes. If arg is `-p', the shell displays the trap commands associated with each sigspec. If no arguments are supplied, or only `-p' is given,
trap
prints the list of commands associated with each signal number in a form that
may be reused as shell input. Each sigspec is either a signal name
such as SIGINT
(with or without the SIG
prefix) or a
signal number. If a sigspec is 0
or EXIT
,
arg is executed when the shell exits. If a sigspec is
DEBUG
, the command arg is executed after every simple
command. The `-l' option causes the shell to print a list of
signal names and their corresponding numbers. Signals ignored upon entry to
the shell cannot be trapped or reset. Trapped signals are reset to their
original values in a child process when it is created. The return status is
zero unless a sigspec does not specify a valid signal.
umask
umask [-p] [-S] [mode]Set the shell process's file creation mask to mode. If mode begins with a digit, it is interpreted as an octal number; if not, it is interpreted as a symbolic mode mask similar to that accepted by the
chmod
command. If mode is omitted, the current value
of the mask is printed. If the `-S' option is supplied without a
mode argument, the mask is printed in a symbolic format. If the
`-p' option is supplied, and mode is omitted, the
output is in a form that may be reused as input. The return status is zero if
the mode is successfully changed or if no mode argument is
supplied, and non-zero otherwise.
unset
unset [-fv] [name]Each variable or function name is removed. If no options are supplied, or the `-v' option is given, each name refers to a shell variable. If the `-f' option is given, the names refer to shell functions, and the function definition is removed. Readonly variables and functions may not be unset. The return status is zero unless a name does not exist or is readonly.
Bash uses certain shell variables in the same way as the Bourne shell. In some cases, Bash assigns a default value to the variable.
CDPATH
cd
builtin command.
HOME
cd
builtin command. The value of this variable is also used by
tilde expansion (see section Tilde
Expansion).
IFS
MAIL
MAILPATH
variable is not set, Bash informs the user of the
arrival of mail in the specified file.
MAILPATH
$_
expands to the name of the current mail file.
OPTARG
getopts
builtin.
OPTIND
getopts
builtin.
PATH
PS1
PS2
Bash implements essentially the same grammar, parameter and variable expansion, redirection, and quoting as the Bourne Shell. Bash uses the POSIX 1003.2 standard as the specification of how these features are to be implemented. There are some differences between the traditional Bourne shell and Bash; this section quickly details the differences of significance. A number of these differences are explained in greater depth in subsequent sections.
sh
behavior.
bind
builtin.
history
and fc
builtins to manipulate it.
csh
-like history expansion (see section History
Expansion).
$'...'
quoting syntax, which expands ANSI-C
backslash-escaped characters in the text between the single quotes, is
supported (see section ANSI-C
Quoting).
$"..."
quoting syntax to do locale-specific
translation of the characters between the double quotes. The
`-D', `--dump-strings', and
`--dump-po-strings' invocation options list the translatable
strings found in a script (see section Locale-Specific
Translation).
!
keyword to negate the return value of a
pipeline (see section Pipelines).
Very useful when an if
statement needs to act only if a test
fails.
time
reserved word and command timing (see
section Pipelines).
The display of the timing statistics may be controlled with the
TIMEFORMAT
variable.
select
compound command, which allows the
generation of simple menus (see section Conditional
Constructs).
[[
compound command, which makes
conditional testing part of the shell grammar (see section Conditional
Constructs).
alias
and
unalias
builtins (see section Aliases).
((
compound command (see
section Conditional
Constructs), and arithmetic expansion (see section Shell
Arithmetic).
export
command.
${#xx}
, which returns the length of
${xx}
, is supported (see section Shell
Parameter Expansion).
${var:
offset[:
length]}
,
which expands to the substring of var
's value of length
length, beginning at offset, is present (see section Shell
Parameter Expansion).
${var/[/]
pattern[/
replacement]}
,
which matches pattern and replaces it with replacement
in the value of var
, is available (see section Shell
Parameter Expansion).
${!word}
(see section Shell
Parameter Expansion).
$9
using
${num}
.
$()
form of command substitution is implemented
(see section Command
Substitution), and preferred to the Bourne shell's "
(which
is also implemented for backwards compatibility).
UID
, EUID
, and GROUPS
),
the current host (HOSTTYPE
, OSTYPE
,
MACHTYPE
, and HOSTNAME
), and the instance of Bash
that is running (BASH
, BASH_VERSION
, and
BASH_VERSINFO
). See section Bash
Variables, for details.
IFS
variable is used to split only the results of
expansion, not all words (see section Word
Splitting). This closes a longstanding shell security hole.
extglob
shell option is enabled (see section Pattern
Matching).
sh
does not separate the two name spaces.
local
builtin, and thus useful recursive functions may be
written.
sh
, all variable assignments preceding commands are global
unless the command is executed from the file system.
noclobber
option is available to avoid overwriting
existing files with output redirection (see section The Set
Builtin). The `>|' redirection operator may be used to
override noclobber
.
cd
and pwd
builtins (see section Bourne
Shell Builtins) each take `-L' and `-P' builtins
to switch between logical and physical modes.
builtin
and command
builtins (see section Bash
Builtin Commands).
command
builtin allows selective disabling of functions
when command lookup is performed (see section Bash
Builtin Commands).
enable
builtin (see section Bash
Builtin Commands).
exec
builtin takes additional options that allow
users to control the contents of the environment passed to the executed
command, and what the zeroth argument to the command is to be (see section Bourne
Shell Builtins).
export -f
(see section Shell
Functions).
export
, readonly
, and
declare
builtins can take a `-f' option to act on
shell functions, a `-p' option to display variables with various
attributes set in a format that can be used as shell input, a
`-n' option to remove various variable attributes, and
`name=value' arguments to set variable attributes and values
simultaneously.
hash
builtin allows a name to be associated with an
arbitrary filename, even when that filename cannot be found by searching the
$PATH
, using `hash -p' (see section Bourne
Shell Builtins).
help
builtin for quick reference to shell
facilities (see section Bash
Builtin Commands).
printf
builtin is available to display formatted output
(see section Bash
Builtin Commands).
read
builtin (see section Bash
Builtin Commands) will read a line ending in `\' with the
`-r' option, and will use the REPLY
variable as a
default if no arguments are supplied. The Bash read
builtin also
accepts a prompt string with the `-p' option and will use
Readline to obtain the line when given the `-e' option.
return
builtin may be used to abort execution of scripts
executed with the .
or source
builtins (see section
Bourne
Shell Builtins).
shopt
builtin, for finer control of shell
optional capabilities (see section Bash
Builtin Commands).
set
builtin (see section The Set
Builtin).
test
builtin (see section Bourne
Shell Builtins) is slightly different, as it implements the POSIX
algorithm, which specifies the behavior based on the number of arguments.
trap
builtin (see section Bourne
Shell Builtins) allows a DEBUG
pseudo-signal specification,
similar to EXIT
. Commands specified with a DEBUG
trap are executed after every simple command. The DEBUG
trap is
not inherited by shell functions.
type
builtin is more extensive and gives more
information about the names it finds (see section Bash
Builtin Commands).
umask
builtin permits a `-p' option to
cause the output to be displayed in the form of a umask
command
that may be reused as input (see section Bourne
Shell Builtins).
csh
-like directory stack, and provides the
pushd
, popd
, and dirs
builtins to
manipulate it (see section The
Directory Stack). Bash also makes the directory stack visible as the value
of the DIRSTACK
shell variable.
disown
builtin can remove a job from the internal shell
job table (see section Job Control
Builtins) or suppress the sending of SIGHUP
to a job when the
shell exits as the result of a SIGHUP
.
mldmode
and priv
) not present in Bash.
stop
or newgrp
builtins.
SHACCT
variable or perform shell
accounting.
sh
uses a TIMEOUT
variable like Bash
uses TMOUT
. More features unique to Bash may be found in section Bash Features.
Since Bash is a completely new implementation, it does not suffer from many of the limitations of the SVR4.2 shell. For instance:
if
or while
statement.
EOF
under certain circumstances.
This can be the cause of some hard-to-find errors.
SIGSEGV
. If the shell is started from a process with
SIGSEGV
blocked (e.g., by using the system()
C
library function call), it misbehaves badly.
SIGSEGV
,
SIGALRM
, or SIGCHLD
.
IFS
,
MAILCHECK
, PATH
, PS1
, or
PS2
variables to be unset.
-x
-v
); the SVR4.2 shell allows only one option argument
(-xv
). In fact, some versions of the shell dump core if the
second argument begins with a `-'.
jsh
(it
turns on job control). This section describes features unique to Bash.
bash [long-opt] [-ir] [-abefhkmnptuvxdBCDHP] [-o option] [argument ...] bash [long-opt] [-abefhkmnptuvxdBCDHP] [-o option] -c string [argument ...] bash [long-opt] -s [-abefhkmnptuvxdBCDHP] [-o option] [argument ...]
In addition to the single-character shell command-line options (see section The Set Builtin), there are several multi-character options that you can use. These options must appear on the command line before the single-character options in order for them to be recognized.
--dump-po-strings
gettext
PO (portable object) file format.
--dump-strings
--help
--login
csh
. `exec bash --login' will replace
the current shell with a Bash login shell.
--noediting
--noprofile
--norc
sh
.
--posix
--rcfile filename
--restricted
--verbose
--version
There are several single-character options that may be supplied at invocation
which are not available with the set
builtin.
-c string
$0
.
-i
-r
-s
-D
C
or
POSIX
(see section Locale-Specific
Translation). This implies the `-n' option; no commands will
be executed.
--
--
signals the end of options and disables further option
processing. Any arguments after the --
are treated as filenames
and arguments. An interactive shell is one whose input and
output are both connected to terminals (as determined by
isatty(3)
), or one started with the `-i' option.
If arguments remain after option processing, and neither the
`-c' nor the `-s' option has been supplied, the first
argument is assumed to be the name of a file containing shell commands (see
section Shell
Scripts). When Bash is invoked in this fashion, $0
is set to
the name of the file, and the positional parameters are set to the remaining
arguments. Bash reads and executes commands from this file, then exits. Bash's
exit status is the exit status of the last command executed in the script. If no
commands are executed, the exit status is 0.
This section describs how Bash executes its startup files. If any of the files exist but cannot be read, Bash reports an error. Tildes are expanded in file names as described above under Tilde Expansion (see section Tilde Expansion).
When Bash is invoked as an interactive login shell, it first reads and executes commands from the file `/etc/profile', if that file exists. After reading that file, it looks for `~/.bash_profile', `~/.bash_login', and `~/.profile', in that order, and reads and executes commands from the first one that exists and is readable. The `--noprofile' option may be used when the shell is started to inhibit this behavior.
When a login shell exits, Bash reads and executes commands from the file `~/.bash_logout', if it exists.
When an interactive shell that is not a login shell is started, Bash reads and executes commands from `~/.bashrc', if that file exists. This may be inhibited by using the `--norc' option. The `--rcfile file' option will force Bash to read and execute commands from file instead of `~/.bashrc'.
So, typically, your `~/.bash_profile' contains the line
if [ -f `~/.bashrc' ]; then . `~/.bashrc'; fi
after (or before) any login-specific initializations.
When Bash is started non-interactively, to run a shell script, for example,
it looks for the variable BASH_ENV
in the environment, expands its
value if it appears there, and uses the expanded value as the name of a file to
read and execute. Bash behaves as if the following command were executed:
if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
but the value of the PATH
variable is not used to search for the
file name.
If Bash is invoked with the name sh
, it tries to mimic the
startup behavior of historical versions of sh
as closely as
possible, while conforming to the POSIX standard as well.
When invoked as an interactive login shell, it first attempts to read and
execute commands from `/etc/profile' and `~/.profile', in that
order. The `--noprofile' option may be used to inhibit this
behavior. When invoked as an interactive shell with the name sh
,
Bash looks for the variable ENV
, expands its value if it is
defined, and uses the expanded value as the name of a file to read and execute.
Since a shell invoked as sh
does not attempt to read and execute
commands from any other startup files, the `--rcfile' option has no
effect. A non-interactive shell invoked with the name sh
does not
attempt to read any startup files.
When invoked as sh
, Bash enters POSIX mode after the startup
files are read.
When Bash is started in POSIX mode, as with the `--posix'
command line option, it follows the POSIX standard for startup files. In this
mode, interactive shells expand the ENV
variable and commands are
read and executed from the file whose name is the expanded value. No other
startup files are read.
Bash attempts to determine when it is being run by the remote shell daemon,
usually rshd
. If Bash determines it is being run by rshd, it reads
and executes commands from `~/.bashrc', if that file exists and is
readable. It will not do this if invoked as sh
. The
`--norc' option may be used to inhibit this behavior, and the
`--rcfile' option may be used to force another file to be read, but
rshd
does not generally invoke the shell with those options or
allow them to be specified.
As defined in section Invoking
Bash, an interactive shell is one whose input and output are both connected
to terminals (as determined by isatty(3)
), or one started with the
`-i' option.
To determine within a startup script whether Bash is running interactively or
not, examine the variable $PS1
; it is unset in non-interactive
shells, and set in interactive shells. Thus:
if [ -z "$PS1" ]; then echo This shell is not interactive else echo This shell is interactive fi
Alternatively, startup scripts may test the value of the `-'
special parameter. It contains i
when the shell is interactive. For
example:
case "$-" in *i*) echo This shell is interactive ;; *) echo This shell is not interactive ;; esac
This section describes builtin commands which are unique to or have been extended in Bash.
bind
bind [-m keymap] [-lpsvPSV] bind [-m keymap] [-q function] [-u function] [-r keyseq] bind [-m keymap] -f filename bind [-m keymap] keyseq:function-nameDisplay current Readline (see section Command Line Editing) key and function bindings, or bind a key sequence to a Readline function or macro. The binding syntax accepted is identical to that of `.inputrc' (@xref{Readline Init File}), but each binding must be passed as a separate argument: e.g., `"\C-x\C-r":re-read-init-file'. Options, if supplied, have the following meanings:
-m keymap
emacs
,
emacs-standard
, emacs-meta
,
emacs-ctlx
, vi
, vi-command
, and
vi-insert
. vi
is equivalent to
vi-command
; emacs
is equivalent to
emacs-standard
.
-l
-p
-P
-v
-V
-s
-S
-f filename
-q function
-u function
-r keyseq
builtin
builtin [shell-builtin [args]]Run a shell builtin, passing it args, and return its exit status. This is useful when defining a shell function with the same name as a shell builtin, retaining the functionality of the builtin within the function. The return status is non-zero if shell-builtin is not a shell builtin command.
command
command [-pVv] command [arguments ...]Runs command with arguments ignoring any shell function named command. Only shell builtin commands or commands found by searching the
PATH
are executed. If there is a shell
function named ls
, running `command ls' within the
function will execute the external command ls
instead of calling
the function recursively. The `-p' option means to use a default
value for $PATH
that is guaranteed to find all of the standard
utilities. The return status in this case is 127 if command cannot
be found or an error occurred, and the exit status of command
otherwise. If either the `-V' or `-v' option is
supplied, a description of command is printed. The
`-v' option causes a single word indicating the command or file
name used to invoke command to be displayed; the `-V'
option produces a more verbose description. In this case, the return status is
zero if command is found, and non-zero if not.
declare
declare [-afFrxi] [-p] [name[=value]]Declare variables and give them attributes. If no names are given, then display the values of variables instead. The `-p' option will display the attributes and values of each name. When `-p' is used, additional options are ignored. The `-F' option inhibits the display of function definitions; only the function name and attributes are printed. `-F' implies `-f'. The following options can be used to restrict output to variables with the specified attributes or to give variables attributes:
-a
-f
-i
-r
-x
declare
makes each name local, as with the local
command. The
return status is zero unless an invalid option is encountered, an attempt is
made to define a function using -f foo=bar
, an attempt is made to
assign a value to a readonly variable, an attempt is made to assign a value to
an array variable without using the compound assignment syntax (see section Arrays),
one of the names is not a valid shell variable name, an attempt is
made to turn off readonly status for a readonly variable, an attempt is made
to turn off array status for an array variable, or an attempt is made to
display a non-existent function with `-f'.
echo
echo [-neE] [arg ...]Output the args, separated by spaces, terminated with a newline. The return status is always 0. If `-n' is specified, the trailing newline is suppressed. If the `-e' option is given, interpretation of the following backslash-escaped characters is enabled. The `-E' option disables the interpretation of these escape characters, even on systems where they are interpreted by default.
echo
interprets the following escape sequences:
\a
\b
\c
\e
\f
\n
\r
\t
\v
\\
\nnn
ASCII
code is the octal value
nnn (one to three digits)
\xnnn
ASCII
code is the hexadecimal value
nnn (one to three digits) enable
enable [-n] [-p] [-f filename] [-ads] [name ...]Enable and disable builtin shell commands. Disabling a builtin allows a disk command which has the same name as a shell builtin to be executed with specifying a full pathname, even though the shell normally searches for builtins before disk commands. If `-n' is used, the names become disabled. Otherwise names are enabled. For example, to use the
test
binary found via $PATH
instead of the shell builtin version, type `enable -n test'. If
the `-p' option is supplied, or no name arguments
appear, a list of shell builtins is printed. With no other arguments, the list
consists of all enabled shell builtins. The `-a' option means to
list each builtin with an indication of whether or not it is enabled. The
`-f' option means to load the new builtin command name
from shared object filename, on systems that support dynamic
loading. The `-d' option will delete a builtin loaded with
`-f'. If there are no options, a list of the shell builtins is
displayed. The `-s' option restricts enable
to the
POSIX special builtins. If `-s' is used with `-f',
the new builtin becomes a special builtin. The return status is zero unless a
name is not a shell builtin or there is an error loading a new
builtin from a shared object.
help
help [pattern]Display helpful information about builtin commands. If pattern is specified,
help
gives detailed help on all
commands matching pattern, otherwise a list of the builtins is
printed. The return status is zero unless no command matches
pattern.
let
let expression [expression]The
let
builtin allows arithmetic to be performed on shell
variables. Each expression is evaluated according to the rules
given below in section Shell
Arithmetic. If the last expression evaluates to 0,
let
returns 1; otherwise 0 is returned.
local
local name[=value]For each argument, a local variable named name is created, and assigned value.
local
can only be used within a
function; it makes the variable name have a visible scope
restricted to that function and its children. The return status is zero unless
local
is used outside a function or an invalid name is
supplied.
logout
logout [n]Exit a login shell, returning a status of n to the shell's parent.
printf
printf
format [arguments]
Write the formatted arguments to the standard output under
the control of the format. The format is a character
string which contains three types of objects: plain characters, which are
simply copied to standard output, character escape sequences, which are
converted and copied to the standard output, and format specifications, each
of which causes printing of the next successive argument. In
addition to the standard printf(1)
formats, `%b'
causes printf
to expand backslash escape sequences in the
corresponding argument, and `%q' causes
printf
to output the corresponding argument in a
format that can be reused as shell input. The format is reused as
necessary to consume all of the arguments. If the format
requires more arguments than are supplied, the extra format
specifications behave as if a zero value or null string, as appropriate, had
been supplied.
read
read [-a aname] [-p prompt] [-er] [name ...]One line is read from the standard input, and the first word is assigned to the first name, the second word to the second name, and so on, with leftover words and their intervening separators assigned to the last name. If there are fewer words read from the standard input than names, the remaining names are assigned empty values. The characters in the value of the
IFS
variable are used to split the
line into words. If no names are supplied, the line read is assigned to the
variable REPLY
. The return code is zero, unless end-of-file is
encountered. Options, if supplied, have the following meanings:
-r
-p prompt
-a aname
-e
shopt
shopt [-pqsu] [-o] [optname ...]Toggle the values of variables controlling optional shell behavior. With no options, or with the `-p' option, a list of all settable options is displayed, with an indication of whether or not each is set. The `-p' option causes output to be displayed in a form that may be reused as input. Other options have the following meanings:
-s
-u
-q
-o
set
builtin (see section The Set
Builtin). shopt
options are disabled (off) by default. The return status
when listing options is zero if all optnames are enabled, non-zero
otherwise. When setting or unsetting options, the return status is zero unless
an optname is not a valid shell option. The list of
shopt
options is:
cdable_vars
cd
builtin command that
is not a directory is assumed to be the name of a variable whose value is
the directory to change to.
cdspell
cd
command will be corrected. The errors checked for are
transposed characters, a missing character, and a character too many. If a
correction is found, the corrected path is printed, and the command
proceeds. This option is only used by interactive shells.
checkhash
checkwinsize
LINES
and
COLUMNS
.
cmdhist
dotglob
execfail
exec
builtin
command. An interactive shell does not exit if exec
fails.
expand_aliases
extglob
histappend
HISTFILE
variable when the shell exits, rather than
overwriting the file.
histreedit
histverify
hostcomplete
huponexit
SIGHUP
to all jobs when an
interactive login shell exits (see section Signals).
interactive_comments
lithist
cmdhist
option is enabled, multi-line
commands are saved to the history with embedded newlines rather than using
semicolon separators where possible.
mailwarn
"The mail in
mailfile has been read"
is displayed.
nocaseglob
nullglob
promptvars
shift_verbose
shift
builtin prints an error message
when the shift count exceeds the number of positional parameters.
sourcepath
source
builtin uses the value of
PATH
to find the directory containing the file supplied as an
argument. This option is enabled by default. source
source filenameA synonym for
.
(see section Bourne
Shell Builtins).
type
type [-atp] [name ...]For each name, indicate how it would be interpreted if used as a command name. If the `-t' option is used,
type
prints a single word which is one of `alias',
`function', `builtin', `file' or
`keyword', if name is an alias, shell function, shell
builtin, disk file, or shell reserved word, respectively. If the
name is not found, then nothing is printed, and type
returns a failure status. If the `-p' option is used,
type
either returns the name of the disk file that would be
executed, or nothing if `-t' would not return
`file'. If the `-a' option is used,
type
returns all of the places that contain an executable named
file. This includes aliases and functions, if and only if the
`-p' option is not also used. The return status is zero if any of
the names are found, non-zero if none are found.
typeset
typeset [-afFrxi] [-p] [name[=value]]The
typeset
command is supplied for compatibility with the
Korn shell; however, it has been deprecated in favor of the
declare
builtin command.
ulimit
ulimit [-acdflmnpstuvSH] [limit]
ulimit
provides control over the resources available to
processes started by the shell, on systems that allow such control. If an
option is given, it is interpreted as follows:
-S
-H
-a
-c
-d
-f
-l
-m
-n
-p
-s
-t
-u
-v
unlimited
is supplied
as a limit, or an error occurs while setting a new limit. This builtin is so complicated that it deserves its own section.
set
set [--abefhkmnptuvxBCHP] [-o option] [argument ...]If no options or arguments are supplied,
set
displays the
names and values of all shell variables and functions, sorted according to the
current locale, in a format that may be reused as input. When options are
supplied, they set or unset shell attributes. Options, if specified, have the
following meanings:
-a
-b
-e
until
or while
loop, part of an
if
statement, part of a &&
or
||
list, or if the command's return status is being inverted
using !
.
-f
-h
-k
-m
-n
-o option-name
allexport
-a
.
braceexpand
-B
.
emacs
emacs
-style line editing interface (see section Command
Line Editing).
errexit
-e
.
hashall
-h
.
histexpand
-H
.
history
ignoreeof
keyword
-k
.
monitor
-m
.
noclobber
-C
.
noexec
-n
.
noglob
-f
.
notify
-b
.
nounset
-u
.
onecmd
-t
.
physical
-P
.
posix
privileged
-p
.
verbose
-v
.
vi
vi
-style line editing interface.
xtrace
-x
. -p
$BASH_ENV
and
$ENV
files are not processed, shell functions are not inherited
from the environment, and the SHELLOPTS
variable, if it appears
in the environment, is ignored. This is enabled automatically on startup if
the effective user (group) id is not equal to the real user (group) id.
Turning this option off causes the effective user and group ids to be set to
the real user and group ids.
-t
-u
-v
-x
-B
-C
-H
-P
cd
which change the current directory. The physical directory
is used instead. By default, Bash follows the logical chain of directories
when performing commands which change the current directory. For example, if
`/usr/sys' is a symbolic link to `/usr/local/sys' then: $ cd /usr/sys; echo $PWD /usr/sys $ cd ..; pwd /usrIf
set -P
is on, then: $ cd /usr/sys; echo $PWD /usr/local/sys $ cd ..; pwd /usr/local
--
-
$-
. The remaining N arguments
are positional parameters and are assigned, in order, to $1
,
$2
, ... $N
. The special parameter #
is
set to N. The return status is always zero unless an invalid option is
supplied. Conditional expressions are used by the [[
compound command and
the test
and [
builtin commands.
Expressions may be unary or binary. Unary expressions are often used to examine the status of a file. There are string operators and numeric comparison operators as well. If any file argument to one of the primaries is of the form `/dev/fd/N', then file descriptor N is checked.
-a file
-b file
-c file
-d file
-e file
-f file
-g file
-k file
-p file
-r file
-s file
-t fd
-u file
-w file
-x file
-O file
-G file
-L file
-S file
-N file
file1 -nt file2
file1 -ot file2
file1 -ef file2
-o optname
set
builtin (see section The Set
Builtin).
-z string
-n string
string
string1 == string2
string1 != string2
string1 < string2
string1 > string2
arg1 OP arg2
OP
is one of `-eq', `-ne',
`-lt', `-le', `-gt', or
`-ge'. These arithmetic binary operators return true if
arg1 is equal to, not equal to, less than, less than or equal to,
greater than, or greater than or equal to arg2, respectively.
Arg1 and arg2 may be positive or negative integers.
These variables are set or used by Bash, but other shells do not normally treat them specially.
BASH
BASH_ENV
BASH_VERSION
BASH_VERSINFO
BASH_VERSINFO[0]
BASH_VERSINFO[1]
BASH_VERSINFO[2]
BASH_VERSINFO[3]
BASH_VERSINFO[4]
BASH_VERSINFO[5]
MACHTYPE
. DIRSTACK
dirs
builtin.
Assigning to members of this array variable may be used to modify directories
already in the stack, but the pushd
and popd
builtins must be used to add and remove directories. Assignment to this
variable will not change the current directory. If DIRSTACK
is
unset, it loses its special properties, even if it is subsequently reset.
EUID
FCEDIT
fc
builtin command.
FIGNORE
FIGNORE
is excluded from the list of matched file
names. A sample value is `.o:~'
GLOBIGNORE
GLOBIGNORE
, it is removed from the list of matches.
GROUPS
histchars
HISTCMD
HISTCMD
is unset, it loses its special
properties, even if it is subsequently reset.
HISTCONTROL
HISTCONTROL
.
HISTIGNORE
HISTCONTROL
are applied. In addition to
the normal shell pattern matching characters, `&' matches the
previous history line. `&' may be escaped using a backslash.
The backslash is removed before attempting a match. The second and subsequent
lines of a multi-line compound command are not tested, and are added to the
history regardless of the value of HISTIGNORE
.
HISTIGNORE
subsumes the function of HISTCONTROL
. A
pattern of `&' is identical to ignoredups
, and a
pattern of `[ ]*' is identical to ignorespace
.
Combining these two patterns, separating them with a colon, provides the
functionality of ignoreboth
.
HISTFILE
HISTSIZE
HISTFILESIZE
HOSTFILE
HOSTNAME
HOSTTYPE
IGNOREEOF
EOF
character as the sole input. If set, the value denotes the
number of consecutive EOF
characters that can be read as the
first character on an input line before the shell will exit. If the variable
exists but does not have a numeric value (or has no value) then the default is
10. If the variable does not exist, then EOF
signifies the end of
input to the shell. This is only in effect for interactive shells.
INPUTRC
LANG
LC_
.
LC_ALL
LANG
and any other LC_
variable specifying a locale category.
LC_COLLATE
LC_CTYPE
LC_MESSAGES
LINENO
MACHTYPE
MAILCHECK
MAILPATH
or MAIL
variables.
OLDPWD
cd
builtin.
OPTERR
getopts
builtin command.
OSTYPE
PIPESTATUS
PPID
PROMPT_COMMAND
$PS1
).
PS3
select
command. If this variable is not set, the
select
command prompts with `#? '
PS4
PS4
is replicated multiple
times, as necessary, to indicate multiple levels of indirection. The default
is `+ '.
PWD
cd
builtin.
RANDOM
REPLY
read
builtin.
SECONDS
SHELLOPTS
set
builtin command (see section The Set
Builtin). The options appearing in SHELLOPTS
are those
reported as `on' by `set -o'. If this variable is in
the environment when Bash starts up, each shell option in the list will be
enabled before reading any startup files. This variable is readonly.
SHLVL
TIMEFORMAT
time
reserved word should be displayed. The `%'
character introduces an escape sequence that is expanded to a time value or
other information. The escape sequences and their meanings are as follows; the
braces denote optional portions.
%%
%[p][l]R
%[p][l]U
%[p][l]S
%P
l
specifies a longer
format, including minutes, of the form
MMmSS.FFs. The value of p
determines whether or not the fraction is included. If this variable is not
set, Bash acts as if it had the value $'\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS'
If the value is null, no timing information is displayed. A trailing
newline is added when the format string is displayed.
TMOUT
UID
The shell allows arithmetic expressions to be evaluated, as one of the shell
expansions or by the let
builtin.
Evaluation is done in long integers with no check for overflow, though division by 0 is trapped and flagged as an error. The following list of operators is grouped into levels of equal-precedence operators. The levels are listed in order of decreasing precedence.
- +
! ~
**
* / %
+ -
<< >>
<= >= < >
== !=
&
^
|
&&
||
expr ? expr : expr
= *= /= %= += -= <<= >>= &= ^= |=
Shell variables are allowed as operands; parameter expansion is performed before the expression is evaluated. The value of a parameter is coerced to a long integer within an expression. A shell variable need not have its integer attribute turned on to be used in an expression.
Constants with a leading 0 are interpreted as octal numbers. A leading
`0x' or `0X' denotes hexadecimal. Otherwise, numbers
take the form [base#
]n, where base
is a decimal number between 2 and 64 representing the arithmetic base, and
n is a number in that base. If base is omitted, then base
10 is used. The digits greater than 9 are represented by the lowercase letters,
the uppercase letters, `_', and `@', in that order. If
base is less than or equal to 36, lowercase and uppercase letters may
be used interchangably to represent numbers between 10 and 35.
Operators are evaluated in order of precedence. Sub-expressions in parentheses are evaluated first and may override the precedence rules above.
Aliases allow a string to be substituted for a word when it is used as the
first word of a simple command. The shell maintains a list of aliases
that may be set and unset with the alias
and unalias
builtin commands.
The first word of each simple command, if unquoted, is checked to see if it
has an alias. If so, that word is replaced by the text of the alias. The alias
name and the replacement text may contain any valid shell input, including shell
metacharacters, with the exception that the alias name may not contain
`='. The first word of the replacement text is tested for aliases,
but a word that is identical to an alias being expanded is not expanded a second
time. This means that one may alias ls
to "ls -F"
, for
instance, and Bash does not try to recursively expand the replacement text. If
the last character of the alias value is a space or tab character, then the next
command word following the alias is also checked for alias expansion.
Aliases are created and listed with the alias
command, and
removed with the unalias
command.
There is no mechanism for using arguments in the replacement text, as in
csh
. If arguments are needed, a shell function should be used (see
section Shell
Functions).
Aliases are not expanded when the shell is not interactive, unless the
expand_aliases
shell option is set using shopt
(see
section Bash Builtin
Commands).
The rules concerning the definition and use of aliases are somewhat
confusing. Bash always reads at least one complete line of input before
executing any of the commands on that line. Aliases are expanded when a command
is read, not when it is executed. Therefore, an alias definition appearing on
the same line as another command does not take effect until the next line of
input is read. The commands following the alias definition on that line are not
affected by the new alias. This behavior is also an issue when functions are
executed. Aliases are expanded when a function definition is read, not when the
function is executed, because a function definition is itself a compound
command. As a consequence, aliases defined in a function are not available until
after that function is executed. To be safe, always put alias definitions on a
separate line, and do not use alias
in compound commands.
For almost every purpose, aliases are superseded by shell functions.
alias
alias [-p
] [name[=value] ...]
Without arguments or with the `-p' option,
alias
prints the list of aliases on the standard output in a form
that allows them to be reused as input. If arguments are supplied, an alias is
defined for each name whose value is given. If no
value is given, the name and value of the alias is printed.
unalias
unalias [-a] [name ... ]Remove each name from the list of aliases. If `-a' is supplied, all aliases are removed.
Bash provides one-dimensional array variables. Any variable may be used as an
array; the declare
builtin will explicitly declare an array. There
is no maximum limit on the size of an array, nor any requirement that members be
indexed or assigned contiguously. Arrays are zero-based.
An array is created automatically if any variable is assigned to using the syntax
name[subscript]=value
The subscript is treated as an arithmetic expression that must evaluate to a number greater than or equal to zero. To explicitly declare an array, use
declare -a name
The syntax
declare -a name[subscript]
is also accepted; the subscript is ignored. Attributes may be
specified for an array variable using the declare
and
readonly
builtins. Each attribute applies to all members of an
array.
Arrays are assigned to using compound assignments of the form
name=(value1 ... valuen)
where each value is of the form
[[subscript]=]
string. If the optional
subscript is supplied, that index is assigned to; otherwise the index of the
element assigned is the last index assigned to by the statement plus one.
Indexing starts at zero. This syntax is also accepted by the
declare
builtin. Individual array elements may be assigned to using
the name[
subscript]=
value syntax
introduced above.
Any element of an array may be referenced using
${name[
subscript]}
. The braces are required
to avoid conflicts with the shell's filename expansion operators. If the
subscript is `@' or `*', the word expands
to all members of the array name. These subscripts differ only when
the word appears within double quotes. If the word is double-quoted,
${name[*]}
expands to a single word with the value of each array
member separated by the first character of the IFS
variable, and
${name[@]}
expands each element of name to a separate
word. When there are no array members, ${name[@]}
expands to
nothing. This is analogous to the expansion of the special parameters
`@' and `*'.
${#name[
subscript]}
expands to the length
of ${name[
subscript]}
. If
subscript is `@' or `*', the expansion is
the number of elements in the array. Referencing an array variable without a
subscript is equivalent to referencing element zero.
The unset
builtin is used to destroy arrays. unset
name[subscript]
destroys the array element at index
subscript. unset
name, where name
is an array, removes the entire array. A subscript of `*' or
`@' also removes the entire array.
The declare
, local
, and readonly
builtins each accept a `-a' option to specify an array. The
read
builtin accepts a `-a' option to assign a list of
words read from the standard input to an array, and can read values from the
standard input into individual array elements. The set
and
declare
builtins display array values in a way that allows them to
be reused as input.
The directory stack is a list of recently-visited directories. The
pushd
builtin adds directories to the stack as it changes the
current directory, and the popd
builtin removes specified
directories from the stack and changes the current directory to the directory
removed. The dirs
builtin displays the contents of the directory
stack.
The contents of the directory stack are also visible as the value of the
DIRSTACK
shell variable.
dirs
dirs [+N | -N] [-clvp]Display the list of currently remembered directories. Directories are added to the list with the
pushd
command; the popd
command removes directories from the list.
+N
dirs
when invoked without options), starting
with zero.
-N
dirs
when invoked without options), starting
with zero.
-c
-l
-p
dirs
to print the directory stack with one entry per
line.
-v
dirs
to print the directory stack with one entry per
line, prefixing each entry with its index in the stack. popd
popd [+N | -N] [-n]Remove the top entry from the directory stack, and
cd
to
the new top directory. When no arguments are given, popd
removes
the top directory from the stack and performs a cd
to the new top
directory. The elements are numbered from 0 starting at the first directory
listed with dirs
; i.e., popd
is equivalent to
popd +0
.
+N
dirs
), starting with zero.
-N
dirs
), starting with zero.
-n
pushd
pushd [dir | +N | -N] [-n]Save the current directory on the top of the directory stack and then
cd
to dir. With no arguments, pushd
exchanges the top two directories.
+N
dirs
, starting with zero) to the top of the list by
rotating the stack.
-N
dirs
, starting with zero) to the top of the list by
rotating the stack.
-n
dir
cd
dir'.
cd
s to dir. The value of the variable PROMPT_COMMAND
is examined just before
Bash prints each primary prompt. If it is set and non-null, then the value is
executed just as if it had been typed on the command line.
In addition, the following table describes the special characters which can appear in the prompt variables:
\a
\d
\e
\h
\H
\n
\r
\s
$0
(the portion
following the final slash).
\t
\T
\@
\u
\v
\V
\w
\W
$PWD
.
\!
\#
\$
#
, otherwise $
.
\nnn
\\
\[
\]
If Bash is started with the name rbash
, or the
`--restricted' option is supplied at invocation, the shell becomes
restricted. A restricted shell is used to set up an environment more controlled
than the standard shell. A restricted shell behaves identically to
bash
with the exception that the following are disallowed:
cd
builtin.
SHELL
or
PATH
variables.
.
builtin command.
SHELLOPTS
from the shell environment at
startup.
exec
builtin to replace the shell with another
command.
enable
builtin.
command
builtin.
Starting Bash with the `--posix' command-line option or executing `set -o posix' while Bash is running will cause Bash to conform more closely to the POSIX.2 standard by changing the behavior to match that specified by POSIX.2 in areas where the Bash default differs.
The following list is what's changed when `POSIX mode' is in effect:
$PATH
to find the new location. This is also available with
`shopt -s checkhash'.
PS1
and PS2
expansions of
`!' to the history number and `!!' to
`!' are enabled, and parameter expansion is performed on the
values of PS1
and PS2
regardless of the setting of
the promptvars
option.
$ENV
) rather than the
normal Bash files.
$HISTFILE
).
.
filename is not found.
name
s. That is, they may
not contain characters other than letters, digits, and underscores, and may
not start with a digit. Declaring a function with an invalid name causes a
fatal syntax error in non-interactive shells.
cd
builtin finds a directory to change to using
$CDPATH
, the value it assigns to the PWD
variable
does not contain any symbolic links, as if `cd -P' had been
executed.
$CDPATH
is set, the cd
builtin will not
implicitly append the current directory to it. This means that cd
will fail if no valid directory name can be constructed from any of the
entries in $CDPATH
, even if the a directory with the same name as
the name given as an argument to cd
exists in the current
directory.
for
statement or the selection variable in a
select
statement is a readonly variable.
export
and readonly
builtin commands display
their output in the format required by POSIX.2. There is other POSIX.2 behavior that Bash does not implement. Specifically:
This chapter discusses what job control is, how it works, and how Bash allows you to access its facilities.
Job control refers to the ability to selectively stop (suspend) the execution of processes and continue (resume) their execution at a later point. A user typically employs this facility via an interactive interface supplied jointly by the system's terminal driver and Bash.
The shell associates a job with each pipeline. It keeps a table of
currently executing jobs, which may be listed with the jobs
command. When Bash starts a job asynchronously, it prints a line that looks
like:
[1] 25647
indicating that this job is job number 1 and that the process ID of the last process in the pipeline associated with this job is 25647. All of the processes in a single pipeline are members of the same job. Bash uses the job abstraction as the basis for job control.
To facilitate the implementation of the user interface to job control, the
system maintains the notion of a current terminal process group ID. Members of
this process group (processes whose process group ID is equal to the current
terminal process group ID) receive keyboard-generated signals such as
SIGINT
. These processes are said to be in the foreground.
Background processes are those whose process group ID differs from the
terminal's; such processes are immune to keyboard-generated signals. Only
foreground processes are allowed to read from or write to the terminal.
Background processes which attempt to read from (write to) the terminal are sent
a SIGTTIN
(SIGTTOU
) signal by the terminal driver,
which, unless caught, suspends the process.
If the operating system on which Bash is running supports job control, Bash
contains facilities to use it. Typing the suspend character
(typically `^Z', Control-Z) while a process is running causes that
process to be stopped and returns control to Bash. Typing the delayed
suspend character (typically `^Y', Control-Y) causes the
process to be stopped when it attempts to read input from the terminal, and
control to be returned to Bash. The user then manipulates the state of this job,
using the bg
command to continue it in the background, the
fg
command to continue it in the foreground, or the
kill
command to kill it. A `^Z' takes effect
immediately, and has the additional side effect of causing pending output and
typeahead to be discarded.
There are a number of ways to refer to a job in the shell. The character
`%' introduces a job name. Job number n
may be
referred to as `%n'. A job may also be referred to using a prefix
of the name used to start it, or using a substring that appears in its command
line. For example, `%ce' refers to a stopped ce
job.
Using `%?ce', on the other hand, refers to any job containing the
string `ce' in its command line. If the prefix or substring matches
more than one job, Bash reports an error. The symbols `%%' and
`%+' refer to the shell's notion of the current job, which is the
last job stopped while it was in the foreground or started in the background.
The previous job may be referenced using `%-'. In output pertaining
to jobs (e.g., the output of the jobs
command), the current job is
always flagged with a `+', and the previous job with a
`-'.
Simply naming a job can be used to bring it into the foreground: `%1' is a synonym for `fg %1', bringing job 1 from the background into the foreground. Similarly, `%1 &' resumes job 1 in the background, equivalent to `bg %1'
The shell learns immediately whenever a job changes state. Normally, Bash
waits until it is about to print a prompt before reporting changes in a job's
status so as to not interrupt any other output. If the the `-b'
option to the set
builtin is enabled, Bash reports such changes
immediately (see section The Set
Builtin).
If an attempt to exit Bash is while jobs are stopped, the shell prints a
message warning that there are stopped jobs. The jobs
command may
then be used to inspect their status. If a second attempt to exit is made
without an intervening command, Bash does not print another warning, and the
stopped jobs are terminated.
bg
bg [jobspec]Resume the suspended job jobspec in the background, as if it had been started with `&'. If jobspec is not supplied, the current job is used. The return status is zero unless it is run when job control is not enabled, or, when run with job control enabled, if jobspec was not found or jobspec specifies a job that was started without job control.
fg
fg [jobspec]Resume the job jobspec in the foreground and make it the current job. If jobspec is not supplied, the current job is used. The return status is that of the command placed into the foreground, or non-zero if run when job control is disabled or, when run with job control enabled, jobspec does not specify a valid job or jobspec specifies a job that was started without job control.
jobs
jobs [-lpnrs] [jobspec] jobs -x command [arguments]The first form lists the active jobs. The options have the following meanings:
-l
-n
-p
-r
-s
jobs
replaces any jobspec found in
command or arguments with the corresponding process
group ID, and executes command, passing it arguments,
returning its exit status.
kill
kill [-s sigspec] [-n signum] [-sigspec] jobspec or pid kill -l [exit_status]Send a signal specified by sigspec or signum to the process named by job specification jobspec or process ID pid. sigspec is either a signal name such as
SIGINT
(with or without the SIG
prefix) or a signal
number; signum is a signal number. If sigspec and
signum are not present, SIGTERM
is used. The
`-l' option lists the signal names. If any arguments are supplied
when `-l' is given, the names of the signals corresponding to the
arguments are listed, and the return status is zero. exit_status is
a number specifying a signal number or the exit status of a process terminated
by a signal. The return status is zero if at least one signal was successfully
sent, or non-zero if an error occurs or an invalid option is encountered.
wait
wait [jobspec|pid]Wait until the child process specified by process ID pid or job specification jobspec exits and return the exit status of the last command waited for. If a job spec is given, all processes in the job are waited for. If no arguments are given, all currently active child processes are waited for, and the return status is zero. If neither jobspec nor pid specifies an active child process of the shell, the return status is 127.
disown
disown [-ar] [-h] [jobspec ...]Without options, each jobspec is removed from the table of active jobs. If the `-h' option is given, the job is not removed from the table, but is marked so that
SIGHUP
is not sent to the
job if the shell receives a SIGHUP
. If jobspec is not
present, and neither the `-a' nor `-r' option is
supplied, the current job is used. If no jobspec is supplied, the
`-a' option means to remove or mark all jobs; the
`-r' option without a jobspec argument restricts
operation to running jobs.
suspend
suspend [-f]Suspend the execution of this shell until it receives a
SIGCONT
signal. The `-f' option means to suspend
even if the shell is a login shell. When job control is not active, the kill
and wait
builtins do not accept jobspec arguments. They must be supplied
process IDs.
auto_resume
This chapter describes how to use the GNU History Library interactively, from a user's standpoint. It should be considered a user's guide. For information on using the GNU History Library in other programs, see the GNU Readline Library Manual.
When the `-o history' option to the set
builtin is
enabled (see section The Set
Builtin), the shell provides access to the command history, the
list of commands previously typed. The text of the last HISTSIZE
commands (default 500) is saved in a history list. The shell stores each command
in the history list prior to parameter and variable expansion but after history
expansion is performed, subject to the values of the shell variables
HISTIGNORE
and HISTCONTROL
. When the shell starts up,
the history is initialized from the file named by the HISTFILE
variable (default `~/.bash_history'). HISTFILE
is
truncated, if necessary, to contain no more than the number of lines specified
by the value of the HISTFILESIZE
variable. When an interactive
shell exits, the last HISTSIZE
lines are copied from the history
list to HISTFILE
. If the histappend
shell option is
set (see section Bash Builtin
Commands), the lines are appended to the history file, otherwise the history
file is overwritten. If HISTFILE
is unset, or if the history file
is unwritable, the history is not saved. After saving the history, the history
file is truncated to contain no more than $HISTFILESIZE
lines. If
HISTFILESIZE
is not set, no truncation is performed.
The builtin command fc
may be used to list or edit and
re-execute a portion of the history list. The history
builtin can
be used to display or modify the history list and manipulate the history file.
When using the command-line editing, search commands are available in each
editing mode that provide access to the history list.
The shell allows control over which commands are saved on the history list.
The HISTCONTROL
and HISTIGNORE
variables may be set to
cause the shell to save only a subset of the commands entered. The
cmdhist
shell option, if enabled, causes the shell to attempt to
save each line of a multi-line command in the same history entry, adding
semicolons where necessary to preserve syntactic correctness. The
lithist
shell option causes the shell to save the command with
embedded newlines instead of semicolons. See section Bash Builtin
Commands, for a description of shopt
.
Bash provides two builtin commands that allow you to manipulate the history list and history file.
fc
Fix Command. In the first form, a range of commands from first to last is selected from the history list. Both first and last may be specified as a string (to locate the most recent command beginning with that string) or as a number (an index into the history list, where a negative number is used as an offset from the current command number). If last is not specified it is set to first. If first is not specified it is set to the previous command for editing and -16 for listing. If the `-l' flag is given, the commands are listed on standard output. The `-n' flag suppresses the command numbers when listing. The `-r' flag reverses the order of the listing. Otherwise, the editor given by ename is invoked on a file containing those commands. If ename is not given, the value of the following variable expansion is used:fc [-e ename] [-nlr] [first] [last]
fc -s [pat=rep] [command]
${FCEDIT:-${EDITOR:-vi}}
. This says
to use the value of the FCEDIT
variable if set, or the value of
the EDITOR
variable if that is set, or vi
if neither
is set. When editing is complete, the edited commands are echoed and executed.
In the second form, command is re-executed after each instance of
pat in the selected command is replaced by rep. A useful
alias to use with the fc
command is r='fc -s'
, so
that typing `r cc' runs the last command beginning with
cc
and typing `r' re-executes the last command (see
section Aliases).
history
history [-c] [n] history [-anrw] [filename] history -ps argDisplay the history list with line numbers. Lines prefixed with with a `*' have been modified. An argument of n says to list only the last n lines. Options, if supplied, have the following meanings:
-w
-r
-a
-n
-c
-s
-p
HISTFILE
variable is used. The History library provides a history expansion feature that is similar to
the history expansion provided by csh
. This section describes the
syntax used to manipulate the history information.
History expansions introduce words from the history list into the input stream, making it easy to repeat commands, insert the arguments to a previous command into the current input line, or fix errors in previous commands quickly.
History expansion takes place in two parts. The first is to determine which line from the history list should be used during substitution. The second is to select portions of that line for inclusion into the current one. The line selected from the history is called the event, and the portions of that line that are acted upon are called words. Various modifiers are available to manipulate the selected words. The line is broken into words in the same fashion that Bash does, so that several words surrounded by quotes are considered one word. History expansions are introduced by the appearance of the history expansion character, which is `!' by default. Only `\' and `'' may be used to escape the history expansion character.
Several shell options settable with the shopt
builtin (see
section Bash Builtin
Commands) may be used to tailor the behavior of history expansion. If the
histverify
shell option is enabled, and Readline is being used,
history substitutions are not immediately passed to the shell parser. Instead,
the expanded line is reloaded into the Readline editing buffer for further
modification. If Readline is being used, and the histreedit
shell
option is enabled, a failed history expansion will be reloaded into the Readline
editing buffer for correction. The `-p' option to the
history
builtin command may be used to see what a history expansion
will do before using it. The `-s' option to the
history
builtin may be used to add commands to the end of the
history list without actually executing them, so that they are available for
subsequent recall. This is most useful in conjunction with Readline.
The shell allows control of the various characters used by the history
expansion mechanism with the histchars
variable.
An event designator is a reference to a command line entry in the history list.
!
!n
!-n
!!
!string
!?string[?]
^string1^string2^
!!:s/string1/string2/
.
!#
Word designators are used to select desired words from the event. A `:' separates the event specification from the word designator. It may be omitted if the word designator begins with a `^', `$', `*', `-', or `%'. Words are numbered from the beginning of the line, with the first word being denoted by 0 (zero). Words are inserted into the current line separated by single spaces.
0 (zero)
0
th word. For many applications, this is the command
word.
n
^
$
%
x-y
*
0
th. This is a synonym for
`1-$'. It is not an error to use `*' if there is
just one word in the event; the empty string is returned in that case.
x*
x-
If a word designator is supplied without an event specification, the previous command is used as the event.
After the optional word designator, you can add a sequence of one or more of the following modifiers, each preceded by a `:'.
h
t
r
e
p
q
x
s/old/new/
&
g
gs/old/new/
, or with `&'.
This chapter describes the basic features of the GNU command line editing interface.
The following paragraphs describe the notation used to represent keystrokes.
The text C-k is read as `Control-K' and describes the character produced when the k key is pressed while the Control key is depressed.
The text M-k is read as `Meta-K' and describes the character produced when the meta key (if you have one) is depressed, and the k key is pressed. If you do not have a meta key, the identical keystroke can be generated by typing ESC first, and then typing k. Either process is known as metafying the k key.
The text M-C-k is read as `Meta-Control-k' and describes the character produced by metafying C-k.
In addition, several keys have their own names. Specifically, DEL, ESC, LFD, SPC, RET, and TAB all stand for themselves when seen in this text, or in an init file (@xref{Readline Init File}).
Often during an interactive session you type in a long line of text, only to notice that the first word on the line is misspelled. The Readline library gives you a set of commands for manipulating the text as you type it in, allowing you to just fix your typo, and not forcing you to retype the majority of the line. Using these editing commands, you move the cursor to the place that needs correction, and delete or insert the text of the corrections. Then, when you are satisfied with the line, you simply press RETURN. You do not have to be at the end of the line to press RETURN; the entire line is accepted regardless of the location of the cursor within the line.
There are only a few basic constructs allowed in the Readline init file. Blank lines are ignored. Lines beginning with a `#' are comments. Lines beginning with a `$' indicate conditional constructs (see section Conditional Init Constructs). Other lines denote variable settings and key bindings.
set
command within the init file.
Here is how to change from the default Emacs-like key binding to use
vi
line editing commands: set editing-mode viA great deal of run-time behavior is changeable with the following variables.
bell-style
comment-begin
insert-comment
command is executed. The default value
is "#"
.
completion-ignore-case
completion-query-items
100
.
convert-meta
disable-completion
self-insert
. The default is
`off'.
editing-mode
editing-mode
variable controls which
default set of key bindings is used. By default, Readline starts up in Emacs
editing mode, where the keystrokes are most similar to Emacs. This variable
can be set to either `emacs' or `vi'.
enable-keypad
expand-tilde
horizontal-scroll-mode
keymap
keymap
names are
emacs
, emacs-standard
, emacs-meta
,
emacs-ctlx
, vi
, vi-command
, and
vi-insert
. vi
is equivalent to
vi-command
; emacs
is equivalent to
emacs-standard
. The default value is emacs
. The
value of the editing-mode
variable also affects the default
keymap.
mark-directories
mark-modified-lines
input-meta
meta-flag
is a synonym for this variable.
output-meta
print-completions-horizontally
show-all-if-ambiguous
visible-stats
Control-u: universal-argument Meta-Rubout: backward-kill-word Control-o: "> output"In the above example, C-u is bound to the function
universal-argument
, and C-o is bound to run the
macro expressed on the right hand side (that is, to insert the text
`> output' into the line).
"\C-u": universal-argument "\C-x\C-r": re-read-init-file "\e[11~": "Function Key 1"In the above example, C-u is bound to the function
universal-argument
(just as it was in the first example),
`C-x C-r' is bound to the function
re-read-init-file
, and `ESC [
1 1 ~' is bound to insert the text
`Function Key 1'. \C-
\M-
\e
\\
\"
\'
\a
\b
\d
\f
\n
\r
\t
\v
\nnn
\xnnn
"\C-x\\": "\\"
Readline implements a facility similar in spirit to the conditional compilation features of the C preprocessor which allows key bindings and variable settings to be performed as the result of tests. There are four parser directives used.
$if
$if
construct allows bindings to be made based on the
editing mode, the terminal being used, or the application using Readline. The
text of the test extends to the end of the line; no characters are required to
isolate it.
mode
mode=
form of the $if
directive is used to
test whether Readline is in emacs
or vi
mode. This
may be used in conjunction with the `set keymap' command, for
instance, to set bindings in the emacs-standard
and
emacs-ctlx
keymaps only if Readline is starting out in
emacs
mode.
term
term=
form may be used to include terminal-specific key
bindings, perhaps to bind the key sequences output by the terminal's
function keys. The word on the right side of the `=' is tested
against both the full name of the terminal and the portion of the terminal
name before the first `-'. This allows sun
to
match both sun
and sun-cmd
, for instance.
application
$if Bash # Quote the current or previous word "\C-xq": "\eb\"\ef\"" $endif
$endif
$if
command.
$else
$if
directive are executed if
the test fails.
$include
$include /etc/inputrc
Here is an example of an inputrc file. This illustrates key binding, variable assignment, and conditional syntax.
# This file controls the behaviour of line input editing for # programs that use the Gnu Readline library. Existing programs # include FTP, Bash, and Gdb. # # You can re-read the inputrc file with C-x C-r. # Lines beginning with '#' are comments. # # First, include any systemwide bindings and variable assignments from # /etc/Inputrc $include /etc/Inputrc # # Set various bindings for emacs mode. set editing-mode emacs $if mode=emacs Meta-Control-h: backward-kill-word Text after the function name is ignored # # Arrow keys in keypad mode # #"\M-OD": backward-char #"\M-OC": forward-char #"\M-OA": previous-history #"\M-OB": next-history # # Arrow keys in ANSI mode # "\M-[D": backward-char "\M-[C": forward-char "\M-[A": previous-history "\M-[B": next-history # # Arrow keys in 8 bit keypad mode # #"\M-\C-OD": backward-char #"\M-\C-OC": forward-char #"\M-\C-OA": previous-history #"\M-\C-OB": next-history # # Arrow keys in 8 bit ANSI mode # #"\M-\C-[D": backward-char #"\M-\C-[C": forward-char #"\M-\C-[A": previous-history #"\M-\C-[B": next-history C-q: quoted-insert $endif # An old-style binding. This happens to be the default. TAB: complete # Macros that are convenient for shell interaction $if Bash # edit the path "\C-xp": "PATH=${PATH}\e\C-e\C-a\ef\C-f" # prepare to type a quoted word -- insert open and close double quotes # and move to just after the open quote "\C-x\"": "\"\"\C-b" # insert a backslash (testing backslash escapes in sequences and macros) "\C-x\\": "\\" # Quote the current or previous word "\C-xq": "\eb\"\ef\"" # Add a binding to refresh the line, which is unbound "\C-xr": redraw-current-line # Edit variable on current line. "\M-\C-v": "\C-a\C-k$\C-y\M-\C-e\C-a\C-y=" $endif # use a visible bell if one is available set bell-style visible # don't strip characters to 7 bits when reading set input-meta on # allow iso-latin1 characters to be inserted rather than converted to # prefix-meta sequences set convert-meta off # display characters with the eighth bit set directly rather than # as meta-prefixed characters set output-meta on # if there are more than 150 possible completions for a word, ask the # user if he wants to see all of them set completion-query-items 150 # For FTP $if Ftp "\C-xg": "get \M-?" "\C-xt": "put \M-?" "\M-.": yank-last-arg $endif
This section describes Readline commands that may be bound to key sequences.
beginning-of-line (C-a)
end-of-line (C-e)
forward-char (C-f)
backward-char (C-b)
forward-word (M-f)
backward-word (M-b)
clear-screen (C-l)
redraw-current-line ()
accept-line (Newline, Return)
HISTCONTROL
and HISTIGNORE
variables. If this
line was a history line, then restore the history line to its original state.
previous-history (C-p)
next-history (C-n)
beginning-of-history (M-<)
end-of-history (M->)
reverse-search-history (C-r)
forward-search-history (C-s)
non-incremental-reverse-search-history (M-p)
non-incremental-forward-search-history (M-n)
history-search-forward ()
history-search-backward ()
yank-nth-arg (M-C-y)
yank-last-arg (M-., M-_)
yank-nth-arg
. Successive calls to yank-last-arg
move
back through the history list, inserting the last argument of each line in
turn. delete-char (C-d)
delete-char
, then return
EOF
.
backward-delete-char (Rubout)
quoted-insert (C-q, C-v)
self-insert (a, b, A, 1, !, ...)
transpose-chars (C-t)
transpose-words (M-t)
upcase-word (M-u)
downcase-word (M-l)
capitalize-word (M-c)
kill-line (C-k)
backward-kill-line (C-x Rubout)
unix-line-discard (C-u)
kill-whole-line ()
kill-word (M-d)
forward-word
.
backward-kill-word (M-DEL)
backward-word
.
unix-word-rubout (C-w)
delete-horizontal-space ()
kill-region ()
copy-region-as-kill ()
copy-backward-word ()
backward-word
. By default, this
command is unbound.
copy-forward-word ()
forward-word
. By default, this
command is unbound.
yank (C-y)
yank-pop (M-y)
digit-argument (M-0, M-1, ... M--)
universal-argument ()
universal-argument
again ends the numeric argument, but
is otherwise ignored. As a special case, if this command is immediately
followed by a character that is neither a digit or minus sign, the argument
count for the next command is multiplied by four. The argument count is
initially one, so executing this function the first time makes the argument
count four, a second time makes the argument count sixteen, and so on. By
default, this is not bound to a key. complete (TAB)
possible-completions (M-?)
insert-completions (M-*)
possible-completions
.
menu-complete ()
complete
, but replaces the word
to be completed with a single match from the list of possible completions.
Repeated execution of menu-complete
steps through the list of
possible completions, inserting each match in turn. At the end of the list of
completions, the bell is rung and the original text is restored. An argument
of n moves n positions forward in the list of matches; a
negative argument may be used to move backward through the list. This command
is intended to be bound to TAB
, but is unbound by default.
complete-filename (M-/)
possible-filename-completions (C-x /)
complete-username (M-~)
possible-username-completions (C-x ~)
complete-variable (M-$)
possible-variable-completions (C-x $)
complete-hostname (M-@)
possible-hostname-completions (C-x @)
complete-command (M-!)
possible-command-completions (C-x !)
dynamic-complete-history (M-TAB)
complete-into-braces (M-{)
start-kbd-macro (C-x ()
end-kbd-macro (C-x ))
call-last-kbd-macro (C-x e)
re-read-init-file (C-x C-r)
abort (C-g)
bell-style
).
do-uppercase-version (M-a, M-b, M-x, ...)
prefix-meta (ESC)
undo (C-_, C-x C-u)
revert-line (M-r)
undo
command enough times to get back to the
beginning.
tilde-expand (M-~)
set-mark (C-@)
exchange-point-and-mark (C-x C-x)
character-search (C-])
character-search-backward (M-C-])
insert-comment (M-#)
comment-begin
variable is
inserted at the beginning of the current line, and the line is accepted as if
a newline had been typed. This makes the current line a shell comment.
dump-functions ()
dump-variables ()
dump-macros ()
glob-expand-word (C-x *)
glob-list-expansions (C-x g)
glob-expand-word
is displayed, and the line is redrawn.
display-shell-version (C-x C-v)
shell-expand-line (M-C-e)
history-expand-line (M-^)
magic-space ()
alias-expand-line ()
history-and-alias-expand-line ()
insert-last-argument (M-., M-_)
yank-last-arg
.
operate-and-get-next (C-o)
emacs-editing-mode (C-e)
vi
editing mode, this causes a
switch back to emacs
editing mode, as if the command `set
-o emacs' had been executed. While the Readline library does not have a full set of vi
editing functions, it does contain enough to allow simple editing of the line.
The Readline vi
mode behaves as specified in the POSIX 1003.2
standard.
In order to switch interactively between emacs
and
vi
editing modes, use the `set -o emacs' and
`set -o vi' commands (see section The Set
Builtin). The Readline default is emacs
mode.
When you enter a line in vi
mode, you are already placed in
`insertion' mode, as if you had typed an `i'. Pressing
ESC switches you into `command' mode, where you can edit the text of
the line with the standard vi
movement keys, move to previous
history lines with `k' and subsequent lines with `j',
and so forth.
This chapter provides basic instructions for installing Bash on the various supported platforms. The distribution supports nearly every version of Unix (and, someday, GNU). Other independent ports exist for MS-DOS, OS/2, Windows 95, and Windows NT.
These are installation instructions for Bash.
The configure
shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses those values
to create a `Makefile' in each directory of the package (the top
directory, the `builtins' and `doc' directories, and the each
directory under `lib'). It also creates a `config.h' file
containing system-dependent definitions. Finally, it creates a shell script
named config.status
that you can run in the future to recreate the
current configuration, a file `config.cache' that saves the results of
its tests to speed up reconfiguring, and a file `config.log' containing
compiler output (useful mainly for debugging configure
). If at some
point `config.cache' contains results you don't want to keep, you may
remove or edit it.
If you need to do unusual things to compile Bash, please try to figure out
how configure
could check whether or not to do them, and mail diffs
or instructions to bash-maintainers@gnu.org so they can
be considered for the next release.
The file `configure.in' is used to create configure
by
a program called Autoconf. You only need `configure.in' if you want to
change it or regenerate configure
using a newer version of
Autoconf. If you do this, make sure you are using Autoconf version 2.10 or
newer.
If you need to change `configure.in' or regenerate
configure
, you will need to create two files:
`_distribution' and `_patchlevel'. `_distribution'
should contain the major and minor version numbers of the Bash distribution, for
example `2.01'. `_patchlevel' should contain the patch
level of the Bash distribution, `0' for example. The script
`support/mkconffiles' has been provided to automate the creation of
these files.
The simplest way to compile Bash is:
cd
to the directory containing the source code and type
`./configure' to configure Bash for your system. If you're using
csh
on an old version of System V, you might need to type
`sh ./configure' instead to prevent csh
from trying
to execute configure
itself. Running configure
takes
awhile. While running, it prints some messages telling which features it is
checking for.
bashbug
bug reporting script.
bash
and
bashbug
. This will also install the manual pages and Info file.
You can remove the program binaries and object files from the source code
directory by typing `make clean'. To also remove the files that
configure
created (so you can compile Bash for a different kind of
computer), type `make distclean'.
Some systems require unusual options for compilation or linking that the
configure
script does not know about. You can give
configure
initial values for variables by setting them in the
environment. Using a Bourne-compatible shell, you can do that on the command
line like this:
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
On systems that have the env
program, you can do it like this:
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
The configuration process uses GCC to build Bash if it is available.
You can compile Bash for more than one kind of computer at the same time, by
placing the object files for each architecture in their own directory. To do
this, you must use a version of make
that supports the
VPATH
variable, such as GNU make
. cd
to
the directory where you want the object files and executables to go and run the
configure
script from the source directory. You may need to supply
the `--srcdir=PATH' argument to tell configure
where
the source files are. configure
automatically checks for the source
code in the directory that configure
is in and in `..'.
If you have to use a make
that does not supports the
VPATH
variable, you can compile Bash for one architecture at a time
in the source code directory. After you have installed Bash for one
architecture, use `make distclean' before reconfiguring for another
architecture.
Alternatively, if your system supports symbolic links, you can use the `support/mkclone' script to create a build tree which has symbolic links back to each file in the source directory. Here's an example that creates a build directory in the current directory from a source directory `/usr/gnu/src/bash-2.0':
bash /usr/gnu/src/bash-2.0/support/mkclone -s /usr/gnu/src/bash-2.0 .
The mkclone
script requires Bash, so you must have already built
Bash for at least one architecture before you can create build directories for
other architectures.
By default, `make install' will install into
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving
configure
the option `--prefix=PATH'.
You can specify separate installation prefixes for architecture-specific
files and architecture-independent files. If you give configure
the
option `--exec-prefix=PATH', `make install' will use
`PATH' as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
There may be some features configure
can not figure out
automatically, but needs to determine by the type of host Bash will run on.
Usually configure
can figure that out, but if it prints a message
saying it can not guess the host type, give it the `--host=TYPE'
option. `TYPE' can either be a short name for the system type, such
as `sun4', or a canonical name with three fields:
`CPU-COMPANY-SYSTEM' (e.g., `sparc-sun-sunos4.1.2').
See the file `support/config.sub' for the possible values of each field.
If you want to set default values for configure
scripts to
share, you can create a site shell script called config.site
that
gives default values for variables like CC
,
cache_file
, and prefix
. configure
looks
for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
CONFIG_SITE
environment variable to the location of the site
script. A warning: the Bash configure
looks for a site script, but
not all configure
scripts do.
configure
recognizes the following options to control how it
operates.
--cache-file=FILE
configure
.
--help
configure
, and exit.
--quiet
--silent
-q
--srcdir=DIR
configure
can determine that directory automatically.
--version
configure
script, and exit. configure
also accepts some other, not widely used, boilerplate
options.
The Bash configure
has a number of
`--enable-FEATURE' options, where FEATURE
indicates an optional part of Bash. There are also several
`--with-PACKAGE' options, where PACKAGE is
something like `gnu-malloc' or `purify'. To turn off
the default use of a package, use `--without-PACKAGE'.
To configure Bash without a feature that is enabled by default, use
`--disable-FEATURE'.
Here is a complete list of the `--enable-' and
`--with-' options that the Bash configure
recognizes.
--with-afs
--with-curses
--with-glibc-malloc
malloc
in
`lib/malloc/gmalloc.c'. This is not the version of
malloc
that appears in glibc version 2, but a modified version of
the malloc
from glibc version 1. This is somewhat slower than the
default malloc
, but wastes less space on a per-allocation basis,
and will return memory to the operating system under some circumstances.
--with-gnu-malloc
malloc
in
`lib/malloc/malloc.c'. This is not the same malloc
that
appears in GNU libc, but an older version derived from the 4.2 BSD
malloc
. This malloc
is very fast, but wastes some
space on each allocation. This option is enabled by default. The
`NOTES' file contains a list of systems for which this should be
turned off, and configure
disables this option automatically for
a number of systems.
--with-purify
--enable-minimal-config
There are several `--enable-' options that alter how Bash is compiled and linked, rather than changing run-time features.
--enable-profiling
gprof
each time it is executed.
--enable-static-link
gcc
is being
used. This could be used to build a version to use as root's shell. The `minimal-config' option can be used to disable all of the following options, but it is processed first, so individual options may be enabled using `enable-FEATURE'.
All of the following options except for `disabled-builtins' and `usg-echo-default' are enabled by default, unless the operating system does not provide the necessary support.
--enable-alias
alias
and
unalias
builtins (see section Aliases).
--enable-array-variables
--enable-bang-history
csh
-like history substitution (see
section History
Expansion).
--enable-brace-expansion
csh
-like brace expansion ( b{a,b}c
==> bac bbc
). See section Brace
Expansion, for a complete description.
--enable-command-timing
time
as a reserved word and
for displaying timing statistics for the pipeline following time
.
This allows pipelines as well as shell builtins and functions to be timed.
--enable-cond-command
[[
conditional command (see section
Conditional
Constructs).
--enable-directory-stack
csh
-like directory stack and the
pushd
, popd
, and dirs
builtins (see
section The
Directory Stack).
--enable-disabled-builtins
xxx
has been disabled using `enable -n xxx'.
See section Bash
Builtin Commands, for details of the builtin
and
enable
builtin commands.
--enable-dparen-arithmetic
((...))
command (see section Conditional
Constructs).
--enable-extended-glob
--enable-help-builtin
help
builtin, which displays help on shell
builtins and variables.
--enable-history
fc
and history
builtin commands.
--enable-job-control
--enable-process-substitution
--enable-prompt-string-decoding
$PS1
, $PS2
, $PS3
, and
$PS4
prompt strings. See section Controlling
the Prompt, for a complete list of prompt string escape sequences.
--enable-readline
--enable-restricted
rbash
, enters a restricted mode. See section The
Restricted Shell, for a description of restricted mode.
--enable-select
select
builtin, which allows the generation of
simple menus (see section Conditional
Constructs).
--enable-usg-echo-default
echo
builtin expand backslash-escaped characters by
default, without requiring the `-e' option. This makes the Bash
echo
behave more like the System V version. The file `config.h.top' contains C Preprocessor
`#define' statements for options which are not settable from
configure
. Some of these are not meant to be changed; beware of the
consequences if you do. Read the comments associated with each definition for
more information about its effect.
Please report all bugs you find in Bash. But first, you should make sure that it really is a bug, and that it appears in the latest version of Bash that you have.
Once you have determined that a bug actually exists, use the
bashbug
command to submit a bug report. If you have a fix, you are
encouraged to mail that as well! Suggestions and `philosophical' bug reports may
be mailed to bug-bash@gnu.org or posted to
the Usenet newsgroup gnu.bash.bug
.
All bug reports should include:
bashbug
inserts the first three items automatically into the
template it provides for filing a bug report.
Please send all reports concerning this manual to chet@po.CWRU.Edu.
Jump to: . - : - [ - a - b - c - d - e - f - g - h - j - k - l - p - r - s - t - u - w
Jump to: ! - [ - ] - c - d - e - f - i - s - t - u - w - { - }
Jump to: ! - # - $ - * - - - 0 - ? - @ - _ - a - b - c - d - e - f - g - h - i - k - l - m - o - p - r - s - t - u - v
Jump to: a - b - c - d - e - f - g - h - i - k - m - n - o - p - q - r - s - t - u - y
Jump to: a - b - c - d - e - f - h - i - j - l - m - n - o - p - q - r - s - t - v - w
This document was generated on 7 November 1998 using the texi2html translator version 1.52.