bash - GNU Bourne-Again SHell
bash [options] [file]
Bash is Copyright (C) 1989-2001 by the Free Software Foundation, Inc.
Bash is an sh-compatible command language interpreter that executes
commands read from the standard input or from a file. Bash also incorporates
useful features from the Korn and C shells (ksh and csh).
Bash is intended to be a conformant implementation of the IEEE POSIX
Shell and Tools specification (IEEE Working Group 1003.2).
In addition to the single-character shell options documented in the
description of the set builtin command, bash interprets the following
options when it is invoked:
-c string If the -c option is present, then commands are read from
string. If there are arguments after the string, they are
assigned to the positional parameters, starting with $0.
-r If the -r option is present, the shell becomes restricted
(see RESTRICTED SHELL below).
-i If the -i option is present, the shell is interactive.
-s If the -s option is present, or if no arguments remain after
option processing, then commands are read from the standard
input. This option allows the positional parameters to be
set when invoking an interactive shell.
-v Print shell input lines as they are read.
-x Print commands and their arguments as they are executed.
-D A list of all double-quoted strings preceded by $ is printed
on the standard ouput. These are the strings that are subject
to language translation when the current locale is not C
or POSIX. This implies the -n option; no commands will be
executed.
[-+]O [shopt_option]
shopt_option is one of the shell options accepted by the
shopt builtin (see SHELL BUILTIN COMMANDS below). If
shopt_option is present, -O sets the value of that option; +O
unsets it. If shopt_option is not supplied, the names and
values of the shell options accepted by shopt are printed on
the standard output. If the invocation option is +O, the
output is displayed in a format that may be reused as input.
-- A -- signals the end of options and disables further option
processing. Any arguments after the -- are treated as filenames
and arguments. An argument of - is equivalent to --.
Bash also interprets a number of multi-character options. These
options must appear on the command line before the single-character
options in order for them to be recognized.
--dump-po-strings
Equivalent to -D, but the output is in the GNU gettext po (portable
object) file format.
--dump-strings
Equivalent to -D.
--help Display a usage message on standard output and exit successfully.
--init-file file
--rcfile file
Execute commands from file instead of the standard personal initialization
file ~/.bashrc if the shell is interactive (see
INVOCATION below).
--login
Make bash act as if it had been invoked as a login shell (see
INVOCATION below).
--noediting
Do not use the GNU readline library to read command lines when
the shell is interactive.
--noprofile
Do not read either the system-wide startup file /etc/profile or
any of the personal initialization files ~/.bash_profile,
~/.bash_login, or ~/.profile. By default, bash reads these
files when it is invoked as a login shell (see INVOCATION
below).
--norc Do not read and execute the personal initialization file
~/.bashrc if the shell is interactive. This option is on by
default if the shell is invoked as sh.
--posix
Change the behavior of bash where the default operation differs
from the POSIX 1003.2 standard to match the standard (posix
mode).
--restricted
The shell becomes restricted (see RESTRICTED SHELL below).
--verbose
Equivalent to -v.
--version
Show version information for this instance of bash on the standard
output and exit successfully.
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. If 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. An attempt is first made to open the
file in the current directory, and, if no file is found, then the shell
searches the directories in PATH for the script.
A login shell is one whose first character of argument zero is a -, or
one started with the --login option.
An interactive shell is one started without non-option arguments and
without the -c option 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.
The following paragraphs describe 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 below under Tilde Expan-
sion in the EXPANSION section.
When bash is invoked as an interactive login shell, or as a non-interactive
shell with the --login option, 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.
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, or a non-interactive shell with the --login option,
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 other 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.
If the shell is started with the effective user (group) id not equal to
the real user (group) id, and the -p option is not supplied, no startup
files are read, shell functions are not inherited from the environment,
the SHELLOPTS variable, if it appears in the environment, is ignored,
and the effective user id is set to the real user id. If the -p option
is supplied at invocation, the startup behavior is the same, but the
effective user id is not reset.
The following definitions are used throughout the rest of this document.
blank A space or tab.
word A sequence of characters considered as a single unit by the
shell. Also known as a token.
name A word consisting only of alphanumeric characters and underscores,
and beginning with an alphabetic character or an underscore.
Also referred to as an identifier.
metacharacter
A character that, when unquoted, separates words. One of the
following:
| & ; ( ) < > space tab
control operator
A token that performs a control function. It is one of the following
symbols:
|| & && ; ;; ( ) | <newline>
Reserved words are words that have a special meaning to the shell. The
following words are recognized as reserved when unquoted and either the
first word of a simple command (see SHELL GRAMMAR below) or the third
word of a case or for command:
! case do done elif else esac fi for function if in select then until
while { } time [[ ]]
Simple Commands
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,
and is passed as argument zero. 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.
Pipelines [Toc] [Back]
A pipeline is a sequence of one or more commands separated by the character
|. The format for a pipeline is:
[time [-p]] [ ! ] command [ | command2 ... ]
The standard output of command is connected via a pipe 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.
If the time reserved word precedes a pipeline, the elapsed as well as
user and system time consumed by its execution are reported when the
pipeline terminates. 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 the description of TIMEFORMAT under Shell Variables below.
Each command in a pipeline is executed as a separate process (i.e., in
a subshell).
Lists [Toc] [Back]
A list is a sequence of one or more pipelines separated by one of the
operators ;, &, &&, or ||, and optionally 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
command1 && command2
command2 is executed if, and only if, command1 returns an exit status
of zero.
An OR list has the form
command1 || command2
command2 is executed if and only if command1 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.
Compound Commands [Toc] [Back]
A compound command is one of the following:
(list) list is executed in a subshell. Variable assignments and
builtin commands that affect the shell's environment do not
remain in effect after the command completes. The return status
is the exit status of list.
{ list; }
list is simply executed in the current shell environment. list
must be terminated with a newline or semicolon. This is known
as a group command. The return status is the exit status of
list. Note that unlike the metacharacters ( and , { and } are
reserved words and must occur where a reserved word is permitted
to be recognized. Since they do not cause a word break, they
must be separated from list by whitespace.
((expression))
The expression is evaluated according to the rules described
below under ARITHMETIC EVALUATION. 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".
[[ 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 under CONDITIONAL EXPRESSIONS.
Word splitting and pathname 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 under 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 )
Returns the value of expression. This may be used to
override the normal precedence of operators.
! expression
True if expression is false.
expression1 && expression2
True if both expression1 and expression2 are true.
expression1 || expression2
True if either expression1 or expression2 is true.
The && and || operators do not execute expression2 if the value
of expression1 is sufficient to determine the return value of
the entire conditional expression.
for name [ in word ] ; do list ; done
The list of words following in is expanded, generating a list of
items. The variable name is set to each element of this list in
turn, and list is executed each time. If the in word is omitted,
the for command executes list once for each positional
parameter that is set (see PARAMETERS below). The return status
is the exit status of the last command that executes. If the
expansion of the items following in results in an empty list, no
commands are executed, and the return status is 0.
for (( expr1 ; expr2 ; expr3 )) ; do list ; done
First, the arithmetic expression expr1 is evaluated according to
the rules described below under ARITHMETIC EVALUATION. The
arithmetic expression expr2 is then evaluated repeatedly until
it evaluates to zero. Each time expr2 evaluates to a non-zero
value, list is executed and the arithmetic expression expr3 is
evaluated. If any expression is omitted, it behaves as if it
evaluates to 1. The return value is the exit status of the last
command in list that is executed, or false if any of the expressions
is invalid.
select name [ in word ] ; do list ; done
The list of words following in is expanded, generating a list of
items. The set of expanded words is printed on the standard
error, each preceded by a number. If the in word is omitted,
the positional parameters are printed (see PARAMETERS below).
The PS3 prompt is then displayed and a line 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 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 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.
case word in [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac
A case command first expands word, and tries to match it against
each pattern in turn, using the same matching rules as for pathname
expansion (see Pathname Expansion below). When a match is
found, the corresponding list is executed. After the first
match, no subsequent matches are attempted. The exit status is
zero if no pattern matches. Otherwise, it is the exit status of
the last command executed in list.
if list; then list; [ elif list; then list; ] ... [ else list; ] fi
The if list is executed. If its exit status is zero, the then
list is executed. Otherwise, each elif list is executed in
turn, and if its exit status is zero, the corresponding then
list is executed and the command completes. Otherwise, the else
list is executed, if present. The exit status is the exit status
of the last command executed, or zero if no condition tested
true.
while list; do list; done
until list; do list; done
The while command continuously executes the do list as long as
the last command in list returns an exit status of zero. The
until command is identical to the while command, except that the
test is negated; the do list is executed as long as the last
command in list returns a non-zero exit status. The exit status
of the while and until commands is the exit status of the last
do list command executed, or zero if none was executed.
[ function ] name () { list; }
This defines a function named name. The body of the function is
the list of commands between { and }. This list is executed
whenever name is specified as the name of a simple command. The
exit status of a function is the exit status of the last command
executed in the body. (See FUNCTIONS below.)
In a non-interactive shell, or an interactive shell in which the inter-
active_comments option to the shopt builtin is enabled (see SHELL
BUILTIN COMMANDS below), 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.
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 metacharacters listed above under DEFINITIONS has special
meaning to the shell and must be quoted if it is to represent itself.
When the command history expansion facilities are being used, the his-
tory expansion character, usually !, must be quoted to prevent history
expansion.
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
itself 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. 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).
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 alert (bell)
\b backspace
\e an escape character
\f form feed
\n new line
\r carriage return
\t horizontal tab
\v vertical tab
\\ backslash
\' single quote
\nnn the eight-bit character whose value is the octal value
nnn (one to three digits)
\xHH the eight-bit character whose value is the hexadecimal
value HH (one or two hex digits)
The expanded 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.
A parameter is an entity that stores values. It can be a name, a number,
or one of the special characters listed below under Special Param-
eters. For the shell's purposes, a variable is a parameter denoted by
a name. A variable has a value and zero or more attributes.
Attributes are assigned using the declare builtin command (see declare
below in SHELL BUILTIN COMMANDS).
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 (see EXPAN-
SION below). If the variable has its integer attribute set, then value
is subject to arithmetic expansion even if the $((...)) expansion is
not used (see Arithmetic Expansion below). Word splitting is not performed,
with the exception of "$@" as explained below under Special
Parameters. Pathname expansion is not performed. Assignment statements
may also appear as arguments to the declare, typeset, export,
readonly, and local builtin commands.
Positional Parameters [Toc] [Back]
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).
Special Parameters [Toc] [Back]
The shell treats several parameters specially. These parameters may
only be referenced; assignment to them is not allowed.
* Expands to the positional parameters, starting from one. When
the expansion occurs within double quotes, it expands to a single
word with the value of each parameter separated by the first
character of the 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.
@ Expands to the positional parameters, starting from one. When
the expansion occurs within double quotes, each parameter
expands to a separate word. That is, "$@" is equivalent to "$1"
"$2" ... When there are no positional parameters, "$@" and $@
expand to nothing (i.e., they are removed).
# Expands to the number of positional parameters in decimal.
? Expands to the status of the most recently executed foreground
pipeline.
- Expands to the current option flags as specified upon invocation,
by the set builtin command, or those set by the shell
itself (such as the -i option).
$ Expands to the process ID of the shell. In a () subshell, it
expands to the process ID of the current shell, not the subshell.
! Expands to the process ID of the most recently executed background
(asynchronous) command.
0 Expands to the name of the shell or shell script. This is set
at shell initialization. If bash is invoked with a file of commands,
$0 is set to the name of that file. If bash is started
with the -c option, then $0 is set to the first argument after
the string to be executed, if one is present. Otherwise, it is
set to the file name used to invoke bash, as given by argument
zero.
_ At shell startup, set to the absolute file name of the shell or
shell script being executed as passed in the argument list.
Subsequently, expands to the last argument to the previous command,
after expansion. Also set to the full file name of each
command executed and placed in the environment exported to that
command. When checking mail, this parameter holds the name of
the mail file currently being checked.
Shell Variables [Toc] [Back]
The following variables are set by the shell:
BASH Expands to the full file name used to invoke this instance of
bash.
BASH_VERSINFO
A readonly array variable whose members hold version information
for this instance of bash. The values assigned to the array
members are as follows:
BASH_VERSINFO[0] The major version number (the release).
BASH_VERSINFO[1] The minor version number (the version).
BASH_VERSINFO[2] The patch level.
BASH_VERSINFO[3] The build version.
BASH_VERSINFO[4] The release status (e.g., beta1).
BASH_VERSINFO[5] The value of MACHTYPE.
BASH_VERSION [Toc] [Back]
Expands to a string describing the version of this instance of
bash.
COMP_CWORD [Toc] [Back]
An index into ${COMP_WORDS} of the word containing the current
cursor position. This variable is available only in shell functions
invoked by the programmable completion facilities (see
Programmable Completion below).
COMP_LINE [Toc] [Back]
The current command line. This variable is available only in
shell functions and external commands invoked by the programmable
completion facilities (see Programmable Completion
below).
COMP_POINT [Toc] [Back]
The index of the current cursor position relative to the beginning
of the current command. If the current cursor position is
at the end of the current command, the value of this variable is
equal to ${#COMP_LINE}. This variable is available only in
shell functions and external commands invoked by the programmable
completion facilities (see Programmable Completion
below).
COMP_WORDS [Toc] [Back]
An array variable (see Arrays below) consisting of the individual
words in the current command line. This variable is available
only in shell functions invoked by the programmable completion
facilities (see Programmable Completion below).
DIRSTACK [Toc] [Back]
An array variable (see Arrays below) containing the current contents
of the directory stack. Directories appear in the stack
in the order they are displayed by the 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 Expands to the effective user ID of the current user, initialized
at shell startup. This variable is readonly.
FUNCNAME [Toc] [Back]
The name of any currently-executing shell function. This variable
exists only when a shell function is executing. Assignments
to FUNCNAME have no effect and return an error status. If
FUNCNAME is unset, it loses its special properties, even if it
is subsequently reset.
GROUPS An array variable containing the list of groups of which the
current user is a member. Assignments to GROUPS have no effect
and return an error status. If GROUPS is unset, it loses its
special properties, even if it is subsequently reset.
HISTCMD [Toc] [Back]
The history number, or index in the history list, of the current
command. If HISTCMD is unset, it loses its special properties,
even if it is subsequently reset.
HOSTNAME [Toc] [Back]
Automatically set to the name of the current host.
HOSTTYPE [Toc] [Back]
Automatically set to a string that uniquely describes the type
of machine on which bash is executing. The default is systemdependent.
LINENO Each time this parameter is referenced, the shell substitutes a
decimal number representing the current sequential line number
(starting with 1) within a script or function. When not in a
script or function, the value substituted is not guaranteed to
be meaningful. If LINENO is unset, it loses its special properties,
even if it is subsequently reset.
MACHTYPE [Toc] [Back]
Automatically set to a string that fully describes the system
type on which bash is executing, in the standard GNU cpu-com-
pany-system format. The default is system-dependent.
OLDPWD The previous working directory as set by the cd command.
OPTARG The value of the last option argument processed by the getopts
builtin command (see SHELL BUILTIN COMMANDS below).
OPTIND The index of the next argument to be processed by the getopts
builtin command (see SHELL BUILTIN COMMANDS below).
OSTYPE Automatically set to a string that describes the operating system
on which bash is executing. The default is system-dependent.
PIPESTATUS [Toc] [Back]
An array variable (see Arrays below) containing a list of exit
status values from the processes in the most-recently-executed
foreground pipeline (which may contain only a single command).
PPID The process ID of the shell's parent. This variable is readonly.
PWD The current working directory as set by the cd command.
RANDOM Each time this parameter is referenced, a random integer between
0 and 32767 is generated. The sequence of random numbers may be
initialized by assigning a value to RANDOM. If RANDOM is unset,
it loses its special properties, even if it is subsequently
reset.
REPLY Set to the line of input read by the read builtin command when
no arguments are supplied.
SECONDS [Toc] [Back]
Each time this parameter is referenced, the number of seconds
since shell invocation is returned. If a value is assigned to
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.
SHELLOPTS [Toc] [Back]
A colon-separated list of enabled shell options. Each word in
the list is a valid argument for the -o option to the set
builtin command (see SHELL BUILTIN COMMANDS below). 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 read-only.
SHLVL Incremented by one each time an instance of bash is started.
UID Expands to the user ID of the current user, initialized at shell
startup. This variable is readonly.
The following variables are used by the shell. In some cases, bash
assigns a default value to a variable; these cases are noted below.
BASH_ENV [Toc] [Back]
If this parameter is set when bash is executing a shell script,
its value is interpreted as a filename containing commands to
initialize the shell, as in ~/.bashrc. The value of BASH_ENV is
subjected to parameter expansion, command substitution, and
arithmetic expansion before being interpreted as a file name.
PATH is not used to search for the resultant file name.
CDPATH The search path for the cd command. This is a colon-separated
list of directories in which the shell looks for destination
directories specified by the cd command. A sample value is
``.:~:/usr''.
COLUMNS
Used by the select builtin command to determine the terminal
width when printing selection lists. Automatically set upon
receipt of a SIGWINCH.
COMPREPLY
An array variable from which bash reads the possible completions
generated by a shell function invoked by the programmable completion
facility (see Programmable Completion below).
FCEDIT The default editor for the fc builtin command.
FIGNORE
A colon-separated list of suffixes to ignore when performing
filename completion (see 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:~'' (Quoting
is needed when assigning a value to this variable, which contains
tildes).
GLOBIGNORE
A colon-separated list of patterns defining the set of filenames
to be ignored by pathname expansion. If a filename matched by a
pathname expansion pattern also matches one of the patterns in
GLOBIGNORE, it is removed from the list of matches.
HISTCONTROL
If set to a value of ignorespace, lines which begin with a space
character are not entered on the history list. If set to a
value of ignoredups, lines matching the last history line are
not entered. A value of ignoreboth combines the two options.
If unset, or if set to any other value than those above, all
lines read by the parser are saved on the history list, subject
to the value of HISTIGNORE. This variable's function is superseded
by HISTIGNORE. 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 HISTCONTROL.
HISTFILE
The name of the file in which command history is saved (see HIS-
TORY below). The default value is ~/.bash_history. If unset,
the command history is not saved when an interactive shell
exits.
HISTFILESIZE
The maximum number of lines contained in the history file. When
this variable is assigned a value, the history file is truncated,
if necessary, to contain no more than that number of
lines. The default value is 500. The history file is also
truncated to this size after writing it when an interactive
shell exits.
HISTIGNORE
A colon-separated list of patterns used to decide which command
lines should be saved on the history list. Each pattern is
anchored at the beginning of the line and must match the complete
line (no implicit `*' is appended). Each pattern is
tested against the line after the checks specified by HISTCON-
TROL 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.
HISTSIZE
The number of commands to remember in the command history (see
HISTORY below). The default value is 500.
HOME The home directory of the current user; the default argument for
the cd builtin command. The value of this variable is also used
when performing tilde expansion.
HOSTFILE
Contains the name of a file in the same format as /etc/hosts
that should be read when the shell needs to complete a hostname.
The list of possible hostname completions may be changed while
the shell is running; the next time hostname completion is
attempted after the value is changed, bash adds the contents of
the new file to the existing list. If HOSTFILE is set, but has
no value, bash attempts to read /etc/hosts to obtain the list of
possible hostname completions. When HOSTFILE is unset, the
hostname list is cleared.
IFS The Internal Field Separator that is used for word splitting
after expansion and to split lines into words with the read
builtin command. The default value is ``<space><tab><newline>''.
IGNOREEOF
Controls the action of an interactive shell on receipt of an EOF
character as the sole input. If set, the value is the number of
consecutive EOF characters which must be 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.
INPUTRC
The filename for the readline startup file, overriding the
default of ~/.inputrc (see READLINE below).
LANG Used to determine the locale category for any category not
specifically selected with a variable starting with LC_.
LC_ALL This variable overrides the value of LANG and any other LC_
variable specifying a locale category.
LC_COLLATE
This variable determines the collation order used when sorting
the results of pathname expansion, and determines the behavior
of range expressions, equivalence classes, and collating
sequences within pathname expansion and pattern matching.
LC_CTYPE
This variable determines the interpretation of characters and
the behavior of character classes within pathname expansion and
pattern matching.
LC_MESSAGES
This variable determines the locale used to translate doublequoted
strings preceded by a $.
LC_NUMERIC
This variable determines the locale category used for number
formatting.
LINES Used by the select builtin command to determine the column
length for printing selection lists. Automatically set upon
receipt of a SIGWINCH.
MAIL If this parameter is set to a file name and the MAILPATH variable
is not set, bash informs the user of the arrival of mail in
the specified file.
MAILCHECK
Specifies how often (in seconds) bash checks for mail. The
default is 60 seconds. When it is time to check for mail, the
shell does so before displaying the primary prompt. If this
variable is unset, or set to a value that is not a number
greater than or equal to zero, the shell disables mail checking.
MAILPATH
A colon-separated list of file names to be checked for mail.
The message to be printed when mail arrives in a particular file
may be specified by separating the file name from the message
with a `?'. When used in the text of the message, $_ expands to
the name of the current mailfile. Example:
MAILPATH='/var/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., /var/mail/$USER).
OPTERR If set to the value 1, bash displays error messages generated by
the getopts builtin command (see SHELL BUILTIN COMMANDS below).
OPTERR is initialized to 1 each time the shell is invoked or a
shell script is executed.
PATH The search path for commands. It is a colon-separated list of
directories in which the shell looks for commands (see 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:.''.
POSIXLY_CORRECT
If this variable is in the environment when bash starts, the
shell enters posix mode before reading the startup files, as if
the --posix invocation option had been supplied. If it is set
while the shell is running, bash enables posix mode, as if the
command set -o posix had been executed.
PROMPT_COMMAND
If set, the value is executed as a command prior to issuing each
primary prompt.
PS1 The value of this parameter is expanded (see PROMPTING below)
and used as the primary prompt string. The default value is
``\s-\v\$ ''.
PS2 The value of this parameter is expanded as with PS1 and used as
the secondary prompt string. The default is ``> ''.
PS3 The value of this parameter is used as the prompt for the select
command (see SHELL GRAMMAR above).
PS4 The value of this parameter is expanded as with PS1 and the
value is printed before each command bash displays during an
execution trace. The first character of PS4 is replicated multiple
times, as necessary, to indicate multiple levels of indirection.
The default is ``+ ''.
TIMEFORMAT
The value of this parameter is used as a format string specifying
how the timing information for pipelines prefixed with the
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.
%% A literal %.
%[p][l]R The elapsed time in seconds.
%[p][l]U The number of CPU seconds spent in user mode.
%[p][l]S The number of CPU seconds spent in system mode.
%P The CPU percentage, computed as (%U + %S) / %R.
The optional p is a digit specifying the precision, the number
of fractional digits after a decimal point. A value of 0 causes
no decimal point or fraction to be output. At most three places
after the decimal point may be specified; values of p greater
than 3 are changed to 3. If p is not specified, the value 3 is
used.
The optional 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%3lS'. If the value is null, no
timing information is displayed. A trailing newline is added
when the format string is displayed.
TMOUT If set to a value greater than zero, the value is interpreted as
the number of seconds to wait for input after issuing the primary
prompt. Bash terminates after waiting for that number of
seconds if input does not arrive.
auto_resume
This variable controls how the shell interacts with the user and
job control. If this variable is set, single word simple commands
without redirections are treated as candidates for resumption
of an existing stopped job. There is no ambiguity allowed;
if there is more than one job beginning with the string typed,
the job most recently accessed is selected. The name of a
stopped job, in this context, is the command line used to start
it. If set to the value exact, the string su
|
