Bash is ultimately intended to be a conformant implementation of the IEEE Posix Shell and Tools specification (IEEE Working Group 1003.2).
Bash also interprets a number of multi-character options. These options must appear on the command line before the single-character options to be recognized.
/etc/profile
or any of the personal initialization files
~/.bash_profile,
~/.bash_login,
or
~/.profile.
By default,
bash
normally reads these files when it is invoked as a login shell (see
INVOCATION
below).
INVOCATION
below).
SHELL GRAMMAR
below) or the third word of a
case
or
for
command:
A simple command is a sequence of optional variable assignments followed by blank-separated words and redirections, and terminated by a control operator. The first word specifies the command to be executed. The remaining words are passed as arguments to the invoked command.
The return value of a simple command is its exit status, or 128+n if the command is terminated by signal n.
A pipeline is a sequence of one or more commands separated by the character |. The format for a pipeline is:
[ ! ] command [ | command2 ... ]
The standard output of
command
is connected to the standard input of
command2.
This connection is performed before any redirections specified by the
command (see
REDIRECTION
below).
If the reserved word ! precedes a pipeline, the exit status of that pipeline is the logical NOT of the exit status of the last command. Otherwise, the status of the pipeline is the exit status of the last command. The shell waits for all commands in the pipeline to terminate before returning a value.
Each command in a pipeline is executed as a separate process (i.e., in a subshell).
A list is a sequence of one or more pipelines separated by one of the operators ;, &, &&, or ||, and terminated by one of ;, &, or <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 in the background in a subshell. The shell does not wait for the command to finish, and the return status is 0. 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.
A compound command is one of the following:
PARAMETERS
below).
PARAMETERS
below). The
PS3
prompt is then displayed and a line read from the standard input.
If the line consists of the 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 command completes. Any
other value read causes
name
to be set to null. The line read is saved in the variable
REPLY.
The
list
is executed after each selection until a
break
or
return
command is executed.
The exit status of
select
is the exit status of the last command executed in
list,
or zero if no commands were executed.
FUNCTIONS
below.)
Each of the metacharacters listed above under
DEFINITIONS
has special meaning to the shell and must be quoted if they are to
represent themselves. There are three quoting mechanisms: the
escape character,
single quotes, and double quotes.
A non-quoted backslash (\) is the 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 is not quoted, the \<newline> is treated as a line continuation (that is, it is 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. The backslash retains its special meaning only when followed by one of the following characters: $, `, ", \, or <newline>. 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
PARAMETERS
below).
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 (see
SHELL BUILTIN COMMANDS
below).
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. If
the variable has its
-i
attribute set (see
declare
below in
SHELL BUILTIN COMMANDS)
then
value
is subject to arithmetic expansion even if the $[...] syntax does
not appear. Word splitting is not performed, with the exception
of "$@" as explained below under
Special Parameters.
Pathname 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 parameters may not be assigned to
with assignment statements. The positional parameters are
temporarily replaced when a shell function is executed (see
FUNCTIONS
below).
When a positional parameter consisting of more than a single
digit is expanded, it must be enclosed in braces (see
EXPANSION
below).
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 null or unset, the parameters are separated by spaces.
The following variables are set by the shell:
RANDOM.
If
RANDOM
is unset, it loses its special properties, even if it is
subsequently reset.
SECONDS,
the value returned upon subsequent
references is
the number of seconds since the assignment plus the value assigned.
If
SECONDS
is unset, it loses its special properties, even if it is
subsequently reset.
LINENO
is unset, it loses its special properties, even if it is
subsequently reset.
HISTCMD
is unset, it loses its special properties, even if it is
subsequently reset.
SHELL BUILTIN COMMANDS
below).
SHELL BUILTIN COMMANDS
below).
The following variables are used by the shell. In some cases, bash assigns a default value to a variable; these cases are noted below.
COMMAND EXECUTION
below). The default path is system-dependent,
and is set by the administrator who installs
bash.
A common value is ``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:.''.
ENV
is subjected to parameter expansion, command substitution, and arithmetic
expansion before being interpreted as a pathname.
PATH
is not used to search for the resultant pathname.
MAILPATH
variable is not set,
bash
informs the user of the arrival of mail in the specified file.
MAILPATH='/usr/spool/mail/bfox?"You have mail":~/shell-mail?"$_ has mail!"'
Bash supplies a default value for this variable, but the location of the user mail files that it uses is system dependent (e.g., /usr/spool/mail/$USER).
PROMPTING
below) and used as the primary prompt string. The default value is
``bash\$ ''.
SHELL GRAMMAR
above).
PS4
is replicated multiple times, as necessary, to indicate multiple
levels of indirection. The default is ``+ ''.
HISTORY
below). The default value is 500.
HISTORY
below.) The default value is ~/.bash_history. If unset, the
command history is not saved when an interactive shell exits.
SHELL BUILTIN COMMANDS
below).
OPTERR
is initialized to 1 each time the shell is invoked or a shell
script is executed.
EOF
character as the sole input. If set, the value is the number of
consecutive
EOF
characters typed as the first characters on an input line before
bash
exits. If the variable exists but does not have a numeric value, or
has no value, the default value is 10. If it does not exist,
EOF
signifies the end of input to the shell. This is only in effect for
interactive shells.
READLINE
below). A filename whose suffix matches one of the entries in
FIGNORE
is excluded from the list of matched filenames. A sample
value is ``.o:~''.
~/.inputrc
(see
READLINE
below).
HISTORY EXPANSION
below). The first character is the
history expansion character,
that is, the character which signals the start of a history
expansion, normally `!'.
The second character is the
quick substitution
character, which is used as shorthand for re-running the previous
command entered, substituting one string for another in the command.
The default is `^'.
The optional third character is the character
which signifies that the remainder of the line is a comment, when found
as the first character of a word, normally `#'. The history
comment character causes history substitution to be skipped for the
remaining words on the line. It does not necessarily cause the shell
parser to treat the rest of the line as a comment.
SHELL BUILTIN COMMANDS
below).
/etc/hosts
that should be read when the shell needs to complete a
hostname. The file may be changed interactively; the next
time hostname completion is attempted
bash
adds the contents of the new file to the already existing database.
JOB CONTROL
below). If set to any other value, the supplied string must
be a prefix of a stopped job's name; this provides functionality
analogous to the
%
job id.
The order of expansions is: brace expansion, tilde expansion, parameter, variable, command, and arithmetic substitution (done in a left-to-right fashion), word splitting, and pathname expansion.
On systems that can support it, there is an additional expansion available: process substitution.
Only brace expansion, word splitting, and pathname expansion
can change the number of words of the expansion; other expansions
expand a single word to a single word.
The single exception to this is the expansion of
``$@'' as explained above (see
PARAMETERS).
Brace expansion is a mechanism by which arbitrary strings may be generated. This mechanism is similar to pathname expansion, but the filenames 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 postamble. The preamble is prepended to each string contained within the braces, and the postamble 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, a{d,c,b}e expands into `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}
Brace expansion introduces a slight incompatibility with
traditional versions of
sh,
the Bourne shell.
sh
does not treat opening or closing braces specially when they
appear as part of a word, and preserves them in the output.
Bash
removes braces from words as a consequence of brace
expansion. For example, a word entered to
sh
as file{1,2}
appears identically in the output. The same word is
output as
file1 file2
after expansion by
bash.
If strict compatibility with
sh
is desired, start
bash
with the
-nobraceexpansion
flag (see
OPTIONS
above)
or disable brace expansion with the
+o braceexpand
option to the
set
command (see
SHELL BUILTIN COMMANDS
below).
If a word begins with a tilde character (`~'), all of the characters
preceding the first slash (or all characters, if there is no slash)
are treated as a possible login name. If this login name
is the null string, the tilde is replaced with the value of the
parameter
HOME.
If
HOME
is unset, the home directory of
the user executing the shell is substituted instead.
If a `+' follows the tilde, the value of
PWD
replaces the tilde and `+'. If
a `-' follows, the value of
OLDPWD
is substituted.
If the value following the tilde is a valid login name,
the tilde and login name are replaced with the home directory
associated with that name. If the name is invalid, or the tilde
expansion fails, the word is unchanged.
Each variable assignment is checked for unquoted
instances of tildes following a
:
or
=.
In these cases, tilde substitution is also performed. Consequently, one
may use pathnames with tildes in assignments to
PATH,
MAILPATH,
and
CDPATH,
and the shell assigns the expanded value.
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.
In each of the cases below, word is subject to tilde expansion, parameter expansion, command substitution, and arithmetic 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.
Command substitution allows the output of a command to replace the command name. There are two forms:
$(command)
performs the expansion by executing command and replacing the command substitution with the standard output of the command, with any trailing newlines deleted.
When the old-style backquote form of substitution is used, backslash retains its literal meaning except when followed by $, `, or \. 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 old form, escape the inner backquotes with backslashes.
If the substitution appears within double quotes, word splitting and pathname expansion are not performed on the results.
Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. There are two formats for arithmetic expansion:
$[expression]
$((expression))
The expression is treated as if it were within double quotes, but a double quote inside the braces or 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 under
ARITHMETIC EVALUATION.
If
expression
is invalid,
bash
prints a message indicating failure 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.
On systems that support it, 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 the
value of
IFS
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.
IFS
cannot be unset.
Explicit null arguments ("" or '') are retained. Implicit null arguments, resulting from the expansion of parameters that have no values, are removed.
Note that if no expansion occurs, no splitting is performed.
After word splitting, unless the -f option has been set, 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 pathnames matching the pattern. If no matching pathnames are found, and the shell variable allow_null_glob_expansion is unset, the word is left unchanged. If the variable is set, and no matches are found, the word is removed. When a pattern is used for pathname generation, the character ``.'' at the start of a name or immediately following a slash must be matched explicitly, unless the shell variable glob_dot_filenames is set. The slash character must always be matched explicitly. In other cases, the ``.'' character is not treated specially.
The special pattern characters have the following meanings:
After the preceding expansions, all unquoted occurrences of the characters \, `, and " are removed.
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 that follows the redirection operator in the following descriptions is subjected to brace expansion, tilde expansion, parameter expansion, command substitution, arithmetic expansion, quote removal, and pathname 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.
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 >|, then the value of the -C option to the set builtin command is not tested, and file creation is attempted. (See also the description of noclobber under Shell Variables above.)
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
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, pathname 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. Otherwise, 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 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. 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 as the standard input and standard output if n is not specified. If the file does not exist, it is created.
SHELL GRAMMAR,
stores a series of commands for later execution.
Functions are executed in the context of the
current shell; no new process is created to interpret
them (contrast this with the execution of a shell script).
When a function is executed, the arguments to the
function become the positional parameters
during its execution. The special parameter
#
is updated to reflect the change. Positional parameter 0
is unchanged.
Variables local to the function may be declared with the local builtin command. Ordinarily, variables and their values are shared between the function and its caller.
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 function execution.
Function names and definitions may be listed with the -f option to the declare or typeset builtin commands. Functions may be exported so that subshells automatically have them defined with the -f option to the export builtin.
Functions may be recursive. No limit is imposed on the number of recursive calls.
SHELL BUILTIN COMMANDS
below).
The first word of each 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 the
metacharacters
listed above, 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
blank,
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.
Aliases are not expanded when the shell is not interactive.
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. This means that 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 the 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.
Note that for almost every purpose, aliases are superseded by shell functions.
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 (in the background), 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 allows you to use it. Typing the suspend character (typically ^Z, Control-Z) while a process is running causes that process to be stopped and returns you 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. You may then manipulate 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. If a prefix matches more than one job, bash reports an error. Using %?ce, on the other hand, refers to any job containing the string ce in its command line. If the 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. 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 -b option to the set builtin command is set, bash reports such changes immediately. (See also the description of notify variable under Shell Variables above.)
If you attempt to exit bash while jobs are stopped, the shell prints a message warning you. You may then use the jobs command to inspect their status. If you do this, or try to exit again immediately, you are not warned again, and the stopped jobs are terminated.
SIGTERM
(so that kill 0 does not kill an interactive shell),
and
SIGINT
is caught and handled (so that the wait builtin is interruptible).
In all cases, bash ignores
SIGQUIT.
If job control is in effect,
bash
ignores
SIGTTIN,
SIGTTOU,
and
SIGTSTP.
Synchronous jobs started by bash have signals set to the
values inherited by the shell from its parent. When job control
is not in effect, background jobs (jobs started with
&)
ignore
SIGINT
and
SIGQUIT.
Commands run as a result of command substitution ignore the
keyboard-generated job control signals
SIGTTIN,
SIGTTOU,
and
SIGTSTP.
If the command name contains no slashes, the shell attempts to
locate it. If there exists a shell function by that name, that
function is invoked as described above in
FUNCTIONS.
If the name does not match a function, the shell searches for
it in the list of shell builtins. If a match is found, that
builtin is invoked.
If the name is neither a shell function nor a builtin,
and contains no slashes,
bash
searches each element of the
PATH
for a directory containing an executable file by that name.
If the search is unsuccessful, the shell prints an error
message and returns a nonzero exit status.
If the search is successful, or if the command name contains one or more slashes, the shell executes the named program. Argument 0 is set to the name given, and the remaining arguments to the command are set to the arguments given, if any.
If this execution fails because the file is not in executable
format, and the file is not a directory, it is assumed to be
a shell script, a file
containing shell commands. A subshell is spawned to execute
it. This subshell reinitializes itself, so
that the effect is as if a new shell had been invoked
to handle the script, with the exception that the locations of
commands remembered by the parent (see
hash
below under
SHELL BUILTIN COMMANDS)
are retained by the child.
If the program is a file beginning with #!, the remainder of the first line specifies an interpreter for the program. The shell executes the specified interpreter on operating systems that do not handle this executable format themselves. The arguments to the interpreter consist of a single optional argument following the interpreter name on the first line of the program, followed by the name of the program, followed by the command arguments, if any.
The shell 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 command, 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 above in
PARAMETERS.
These assignment statements affect only the environment seen
by that command.
If the -k flag is set (see the set builtin command below), 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.
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.
Bash itself returns the exit status of the last command executed, unless a syntax error occurs, in which case it exits with a non-zero value. See also the exit builtin command below.
PS1
when it is ready to read a command, and the secondary prompt
PS2
when it needs more input to complete a command.
Bash
allows these prompt strings to be customized by inserting a number of
backslash-escaped special characters that are decoded as follows:
The command number and the history number are usually different:
the history number of a command is its position in the history
list, which may include commands restored from the history file
(see
HISTORY
below), while the command number is the position in the sequence
of commands executed during the current shell session.
After the string is decoded, it is expanded via
parameter expansion,
command substitution, arithmetic expansion, and word splitting.
In this section, the emacs-style notation is used to denote keystrokes. Control keys are denoted by C-key, e.g., C-n means Control-N. Similarly, meta keys are denoted by M-key, so M-x means Meta-X. (On keyboards without a meta key, M-x means ESC x, i.e., press the Escape key then the x key. This makes ESC the meta prefix. The combination M-C-x means ESC-Control-x, or press the Escape key then hold the Control key while pressing the x key.)
The default key-bindings may be changed with an
~/.inputrc
file. The value of the shell variable
INPUTRC,
if set, is used instead of
~/.inputrc.
Other programs that use this library may add their own commands
and bindings.
For example, placing
M-Control-u: universal-argument
~/.inputrc
would make M-C-u execute the readline command
universal-argument.
The following symbolic character names are recognized: RUBOUT, DEL, ESC, LFD, NEWLINE, RET, RETURN, SPC, SPACE, and TAB. In addition to command names, readline allows keys to be bound to a string that is inserted when the key is pressed (a macro).
Readline is customized by putting commands in an initialization
file. The name of this file is taken from the value of the
INPUTRC
variable. If that variable is unset, the default is
~/.inputrc.
When a program which uses the readline library starts up, the
init file is read, and the key bindings and variables are set.
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. Other lines
denote key bindings and variable settings.
The syntax for controlling key bindings in the ~/.inputrc file is simple. All that is required is the name of the command or the text of a macro and a key sequence to which it should be bound. The name may be specified in one of two ways: as a symbolic key name, possibly with Meta- or Control- prefixes, or as a key sequence. When using the form keyname:function-name or macro, keyname is the name of a key spelled out in English. For example:
In the above example, C-u is bound to the function universal-argument, M-DEL is bound to the function backward-kill-word, 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).
In the second form, "keyseq":function-name or macro, keyseq differs from keyname above in that strings denoting an entire key sequence may be specified by placing the sequence within double quotes. Some GNU Emacs style key escapes can be used, as in the following example.
In this example, C-u is again bound to the function universal-argument. 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. The full set of escape sequences is
When entering the text of a macro, single or double quotes should be used to indicate a macro definition. Unquoted text is assumed to be a function name. Backslash will quote any character in the macro text, including " and '.
Bash
allows the current readline key bindings to be displayed or modified
with the
bind
builtin command. The editing mode may be switched during interactive
use by using the
-o
option to the
set
builtin command (see
SHELL BUILTIN COMMANDS
below).
Readline has variables that can be used to further customize its behavior. A variable may be set in the inputrc file with a statement of the form
set variable-name value
Except where noted, readline variables can take the values On or Off. The variables and their default values are:
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 three parser directives used.
$if Bash
# Quote the current or previous word
"\C-xq": "\eb\"\ef\""
$endif
Readline commands may be given numeric arguments, which normally act as a repeat count. Sometimes, however, it is the sign of the argument that is significant. Passing a negative argument to a command that acts in the forward direction (e.g., kill-line) causes that command to act in a backward direction. Commands whose behavior with arguments deviates from this are noted.
When a command is described as killing text, the text deleted is saved for possible future retrieval (yanking). The killed text is saved in a kill-ring. Consecutive kills cause the text to be accumulated into one unit, which can be yanked all at once. Commands which do not kill text separate the chunks of text on the kill-ring.
The following is a list of the names of the commands and the default key sequences to which they are bound.
HISTCONTROL
variable. If the line is a modified history
line, then restore the history line to its original state.
HISTORY EXPANSION
below for a description of history expansion.
HISTORY EXPANSION
below for a description of history expansion.
EOF.
ESC
f
is equivalent to
Meta-f.
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 (see
EXPANSION
above) but after history expansion is performed, subject to the
values of the shell variables
command_oriented_history
and
HISTCONTROL.
On startup, the history is initialized from the file named by
the variable
HISTFILE
(default ~/.bash_history).
HISTFILE
is truncated, if necessary, to contain no more than
HISTFILESIZE
lines.
The builtin command
fc
(see
SHELL BUILTIN COMMANDS
below) may be used to list or edit and re-execute a portion of
the history list.
The
history
builtin can be used to display 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. When an interactive shell exits, the last
HISTSIZE
lines are copied from the history list to
HISTFILE.
If
HISTFILE
is unset, or if the history file is unwritable, the history is
not saved.
The shell supports a history expansion feature that
is similar to the history expansion in
csh.
This section describes what syntax features are available. This
feature is enabled by default for interactive shells, and can be
disabled using the
+H
option to the
set
builtin command (see
SHELL BUILTIN COMMANDS
below). Non-interactive shells do not perform history expansion.
History expansion is performed immediately after a complete line is read, before the shell breaks it into words. It takes place in two parts. The first is to determine which line from the previous history to use during substitution. The second is to select portions of that line for inclusion into the current one. The line selected from the previous history is the event, and the portions of that line that are acted upon are words. The line is broken into words in the same fashion as when reading input, so that several metacharacter-separated words surrounded by quotes are considered as one word. Only backslash (\) and single quotes can quote the history escape character, which is ! by default.
The shell allows control of the various characters used by the history expansion mechanism (see the description of histchars above under Shell Variables).
An event designator is a reference to a command line entry in the history list.
A : separates the event specification from the word designator. It can 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 a 0 (zero).
After the optional word designator, you can add a sequence of one or more of the following modifiers, each preceded by a `:'.
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 36 representing the arithmetic base, and n is a number in that base. If base is omitted, then base 10 is used.
Operators are evaluated in order of precedence. Sub-expressions in parentheses are evaluated first and may override the precedence rules above.
PATH
are used to find the directory containing
filename.
The file searched for in
PATH
need not be executable. The current directory is
searched if no file is found in
PATH.
If any arguments are supplied, they become the positional
parameters when file is executed. Otherwise the positional
parameters are unchanged.
The return status is the status of the last command exited within
the script (0 if no commands are executed), and false if
filename
is not found.
The return value is 0 unless an unrecognized option is given or an error occurred.
HOME
is the
default
dir.
The variable
CDPATH
defines the search path for
the directory containing
dir.
Alternative directory names are
separated by a colon (:). A null directory name in
CDPATH
is the same as
the current directory, i.e., ``.''. If
dir
begins with a slash (/),
then
CDPATH
is not used. An argument of
-
is equivalent to
$OLDPWD.
The return value is true if the directory was successfully changed;
false otherwise.
PATH
are executed. If the
-p
option is given, the search for
command
is performed using a default value for
PATH
that is guaranteed to find all of the standard utilities.
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 pathname
used to invoke
command
to be printed; the
-V
option produces a more verbose description.
An argument of
--
disables option checking for the rest of the arguments.
If the
-V
or
-v
option is supplied, the exit status is 0 if
command
was found, and 1 if not. If neither option is supplied and
an error occurred or
command
cannot be found, the exit status is 127. Otherwise, the exit status of the
command
builtin is the exit status of
command.
ARITHMETIC EVALUATION )
is performed when the variable is assigned a value.
Using `+' instead of `-' turns off the attribute instead. When used in a function, makes names local, as with the local command. The return value is 0 unless an illegal option is encountered, an attempt is made to define a function using "-f foo=bar", one of the names is not a legal shell variable name, an attempt is made to turn off readonly status for a readonly variable, or an attempt is made to display a non-existant function with -f.
The return value is 0 unless an illegal option is supplied or n indexes beyond the end of the directory stack.
PATH
instead of the shell builtin version, type
``enable -n test''. If no arguments are given,
a list of all enabled shell builtins is printed.
If only -n is supplied, a list of all disabled
builtins is printed. If only -all is supplied,
the list printed includes all builtins, with an
indication of whether or not each is enabled.
enable
accepts
-a
as a synonym for
-all.
The return value is 0 unless a
name
is not a shell builtin.
EXIT
is executed before the shell terminates.
The
-n
flag suppresses
the command numbers when listing. The
-r
flag reverses the order of
the commands. If the
-l
flag is given,
the commands are listed on
standard output. Otherwise, the editor given by
ename
is invoked
on a file containing those commands. If
ename
is not given, the
value of the
FCEDIT
variable is used, and
the value of
EDITOR
if
FCEDIT
is not set. If neither variable is set,
vi
is used. When editing is complete, the edited commands are
echoed and executed.
In the second form, command is re-executed after each instance of pat is replaced by rep. A useful alias to use with this is ``r=fc -s'', so that typing ``r cc'' runs the last command beginning with ``cc'' and typing ``r'' re-executes the last command.
If the first form is used, the return value is 0 unless an illegal option is encountered or first or last specify history lines out of range. If the -e option is supplied, the return value is the value of the last command executed or failure if an error occurs with the temporary file of commands. If the second form is used, the return status is that of the command re-executed, unless cmd does not specify a valid history line, in which case fc returns failure.
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.
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 illegal options or missing option arguments are
encountered.
If the variable
OPTERR
is set to 0, no error message will be displayed, even if the first
character of
optstring
is not a colon.
If an illegal 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.
getopts normally parses the positional parameters, but if more arguments are given in args, getopts parses those instead. getopts returns true if an option, specified or unspecified, is found. It returns false if the end of options is encountered or an error occurs.
HISTFILE
is used. Options, if supplied, have the following meanings:
The return value is 0 unless an illegal option is encountered or an error occurs while reading or writing the history file.
If the -x option is supplied, jobs replaces any jobspec found in command or args with the corresponding process group ID, and executes command passing it args, returning its exit status.
SIGKILL
or a signal number. If
sigspec
is a signal name, the name is case insensitive and may be
given with or without the
SIG
prefix.
If
sigspec
is not present, then
SIGTERM
is assumed. An argument of
-l
lists the signal names. If any arguments are supplied when
-l
is given, the names of the specified signals are listed, and
the return status is 0.
An argument of
--
disables option checking for the rest of the arguments.
kill
returns true if at least one signal was successfully sent, or false
if an error occurs or an illegal option is encountered.
ARITHMETIC EVALUATION).
If the last
arg
evaluates to 0,
let
returns 1; 0 is returned otherwise.
If the popd command is successful, a dirs is performed as well, and the return status is 0. popd returns false if an illegal option is encountered, the directory stack is empty, a non-existent directory stack entry is specified, or the directory change fails.
If the pushd command is successful, a dirs is performed as well. If the first form is used, pushd returns 0 unless the cd to dir fails. With the second form, pushd returns 0 unless the directory stack is empty, a non-existant directory stack element is specified, or the directory change to the specified new current directory fails.
IFS
are recognized as word delimiters. 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. If the
-r
option
is given, a backslash-newline pair is not ignored, and
the backslash is considered to be part of the line.
SHELL GRAMMAR
above) exits with a non-zero status. The shell does not exit if the
command that fails is part of an
until
or
while
loop,
part of an
if
statement, part of a
&&
or
||
list, or if the command's return value is
being inverted via
!.
JOB CONTROL
above). Background processes run in a separate process
group and a line containing their exit status is printed
upon their completion.
COMMENTS
above).
If no option-name is supplied, the values of the current options are printed.
PS4,
followed by the command and its expanded arguments.
SHELL GRAMMAR
above).
The flags are off by default unless otherwise noted. Using + rather than - causes these flags to be turned off. The flags can also be specified as options to an invocation of the shell. The current set of flags may be found in $-. After the option arguments are processed, the remaining n args are treated as values for the positional parameters and are assigned, in order, to $1, $2, ... $n. If no options or args are supplied, all shell variables are printed. The return status is always true unless an illegal option is encountered.
SIGCONT
signal. The
-f
option says not to complain if this is
a login shell; just suspend anyway. The return status is 0 unless
the shell is a login shell and
-f
is not supplied, or if job control is not enabled.
- OP
EXIT
(0) the command
arg
is executed on exit from
the shell. With no arguments,
trap
prints the list of commands associated with each signal number.
The
-l
option causes the shell to
print a list of signal names and their corresponding
numbers. An argument of
--
disables option checking for the rest of the arguments.
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 false if either
the trap name or number is invalid; otherwise
trap
returns true.
PATH.
If the
-all
flag is used,
type
prints all of the places that contain
an executable named
name.
This includes aliases and functions,
if and only if the
-path
flag is not also used.
The table of hashed commands is not consulted
when using
-all.
type
accepts
-a,
-t,
and
-p
in place of
-all,
-type,
and
-path,
respectively.
An argument of
--
disables option checking for the rest of the arguments.
type
returns true if any of the arguments are found, false if
none are found.
An argument of -- disables option checking for the rest of the arguments. If limit is given, it is the new value of the specified resource (the -a option is display only). If no option is given, then -f is assumed. Values are in 1024-byte increments, except for -t, which is in seconds, -p, which is in units of 512-byte blocks, and -n and -u, which are unscaled values. The return status is 0 unless an illegal option is encountered, a non-numeric argument other than unlimited is supplied as limit, or an error occurs while setting a new limit.
PATH,
IFS,
PPID,
PS1,
PS2,
UID,
and
EUID
cannot be unset. If any of
RANDOM,
SECONDS,
LINENO,
or
HISTCMD
are unset, they lose their special properties, even if they are
subsequently reset. The exit status is true unless a
name
does not exist or is non-unsettable.
An interactive shell is one whose standard input and output are
both connected to terminals (as determined by
isatty(3)),
or one started with the
-i
option.
PS1
is set and
$-
includes
i
if
bash
is interactive,
allowing a shell script or a startup file to test this state.
Login shells:
On login (subject to the -noprofile option):
if /etc/profile exists, source it.
if ~/.bash_profile exists, source it,
else if ~/.bash_login exists, source it,
else if ~/.profile exists, source it.
On exit:
if ~/.bash_logout exists, source it.
Non-login interactive shells:
On startup (subject to the -norc and -rcfile options):
if ~/.bashrc exists, source it.
Non-interactive shells:
On startup:
if the environment variable ENV is non-null, expand
it and source the file it names, as if the command
if [ "$ENV" ]; then . $ENV; fi
had been executed, but do not use PATH to search
for the pathname. When not started in Posix mode, bash
looks for BASH_ENV before ENV.
If Bash is invoked as sh, it tries to mimic the behavior of sh as closely as possible. For a login shell, it attempts to source only /etc/profile and ~/.profile, in that order. The -noprofile option may still be used to disable this behavior. A shell invoked as sh does not attempt to source any other startup files.
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, the ENV variable is expanded and that file sourced; no other startup files are read.
/bin/bash
/etc/profile
~/.bash_profile
~/.bashrc
~/.inputrc
Chet Ramey, Case Western Reserve University
chet@ins.CWRU.Edu
Once you have determined that a bug actually exists, use the bashbug command to submit a bug report. If you have a fix, you are welcome to mail that as well! Suggestions and `philosophical' bug reports may be mailed to bug-bash@prep.ai.MIT.Edu or posted to the Usenet newsgroup gnu.bash.bug.
ALL bug reports should include:
Comments and bug reports concerning this manual page should be directed to chet@ins.CWRU.Edu.
It's too big and too slow.
There are some subtle differences between
bash
and traditional versions of
sh,
mostly because of the
POSIX
specification.
Aliases are confusing in some uses.