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 an>
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-~)