This is bashref.info, produced by makeinfo version 4.0f from
bashref.texi.

INFO-DIR-SECTION Utilities
START-INFO-DIR-ENTRY
* Bash: (bash).                     The GNU Bourne-Again SHell.
END-INFO-DIR-ENTRY

This text is a brief description of the features that are present in
the Bash shell.

This is Edition 2.5a, last updated 13 November 2001,
of `The GNU Bash Reference Manual',
for `Bash', Version 2.05a.

Copyright (C) 1991-2001 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation approved
by the Free Software Foundation.


File: bashref.info,  Node: Specifying the System Type,  Next: Sharing Defaults,  Prev: Installation Names,  Up: Installing Bash

Specifying the System Type
==========================

   There may be some features `configure' can not figure out
automatically, but need to determine by the type of host Bash will run
on.  Usually `configure' can figure that out, but if it prints a
message saying it can not guess the host type, give it the
`--host=TYPE' option.  `TYPE' can either be a short name for the system
type, such as `sun4', or a canonical name with three fields:
`CPU-COMPANY-SYSTEM' (e.g., `i386-unknown-freebsd4.2').

   See the file `support/config.sub' for the possible values of each
field.


File: bashref.info,  Node: Sharing Defaults,  Next: Operation Controls,  Prev: Specifying the System Type,  Up: Installing Bash

Sharing Defaults
================

   If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists.  Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: the Bash `configure' looks for a site script, but not all
`configure' scripts do.


File: bashref.info,  Node: Operation Controls,  Next: Optional Features,  Prev: Sharing Defaults,  Up: Installing Bash

Operation Controls
==================

   `configure' recognizes the following options to control how it
operates.

`--cache-file=FILE'
     Use and save the results of the tests in FILE instead of
     `./config.cache'.  Set FILE to `/dev/null' to disable caching, for
     debugging `configure'.

`--help'
     Print a summary of the options to `configure', and exit.

`--quiet'
`--silent'
`-q'
     Do not print messages saying which checks are being made.

`--srcdir=DIR'
     Look for the Bash source code in directory DIR.  Usually
     `configure' can determine that directory automatically.

`--version'
     Print the version of Autoconf used to generate the `configure'
     script, and exit.

   `configure' also accepts some other, not widely used, boilerplate
options.  `configure --help' prints the complete list.


File: bashref.info,  Node: Optional Features,  Prev: Operation Controls,  Up: Installing Bash

Optional Features
=================

   The Bash `configure' has a number of `--enable-FEATURE' options,
where FEATURE indicates an optional part of Bash.  There are also
several `--with-PACKAGE' options, where PACKAGE is something like
`bash-malloc' or `purify'.  To turn off the default use of a package,
use `--without-PACKAGE'.  To configure Bash without a feature that is
enabled by default, use `--disable-FEATURE'.

   Here is a complete list of the `--enable-' and `--with-' options
that the Bash `configure' recognizes.

`--with-afs'
     Define if you are using the Andrew File System from Transarc.

`--with-bash-malloc'
     Use the Bash version of `malloc' in `lib/malloc/malloc.c'.  This
     is not the same `malloc' that appears in GNU libc, but an older
     version derived from the 4.2 BSD `malloc'.  This `malloc' is very
     fast, but wastes some space on each allocation.  This option is
     enabled by default.  The `NOTES' file contains a list of systems
     for which this should be turned off, and `configure' disables this
     option automatically for a number of systems.

`--with-curses'
     Use the curses library instead of the termcap library.  This should
     be supplied if your system has an inadequate or incomplete termcap
     database.

`--with-gnu-malloc'
     A synonym for `--with-bash-malloc'.

`--with-installed-readline[=PREFIX]'
     Define this to make Bash link with a locally-installed version of
     Readline rather than the version in `lib/readline'.  This works
     only with Readline 4.2 and later versions.  If PREFIX is `yes' or
     not supplied, `configure' uses the values of the make variables
     `includedir' and `libdir', which are subdirectories of `prefix' by
     default, to find the installed version of Readline if it is not in
     the standard system include and library directories.  If PREFIX is
     `no', Bash links with the version in `lib/readline'.  If PREFIX is
     set to any other value, `configure' treats it as a directory
     pathname and looks for the installed version of Readline in
     subdirectories of that directory (include files in
     PREFIX/`include' and the library in PREFIX/`lib').

`--with-purify'
     Define this to use the Purify memory allocation checker from
     Rational Software.

`--enable-minimal-config'
     This produces a shell with minimal features, close to the
     historical Bourne shell.

   There are several `--enable-' options that alter how Bash is
compiled and linked, rather than changing run-time features.

`--enable-largefile'
     Enable support for large files
     (http://www.sas.com/standards/large_file/x_open.20Mar96.html) if
     the operating system requires special compiler options to build
     programs which can access large files.

`--enable-profiling'
     This builds a Bash binary that produces profiling information to be
     processed by `gprof' each time it is executed.

`--enable-static-link'
     This causes Bash to be linked statically, if `gcc' is being used.
     This could be used to build a version to use as root's shell.

   The `minimal-config' option can be used to disable all of the
following options, but it is processed first, so individual options may
be enabled using `enable-FEATURE'.

   All of the following options except for `disabled-builtins' and
`xpg-echo-default' are enabled by default, unless the operating system
does not provide the necessary support.

`--enable-alias'
     Allow alias expansion and include the `alias' and `unalias'
     builtins (*note Aliases::).

`--enable-arith-for-command'
     Include support for the alternate form of the `for' command that
     behaves like the C language `for' statement (*note Looping
     Constructs::).

`--enable-array-variables'
     Include support for one-dimensional array shell variables (*note
     Arrays::).

`--enable-bang-history'
     Include support for `csh'-like history substitution (*note History
     Interaction::).

`--enable-brace-expansion'
     Include `csh'-like brace expansion ( `b{a,b}c' ==> `bac bbc' ).
     See *Note Brace Expansion::, for a complete description.

`--enable-command-timing'
     Include support for recognizing `time' as a reserved word and for
     displaying timing statistics for the pipeline following `time'
     (*note Pipelines::).  This allows pipelines as well as shell
     builtins and functions to be timed.

`--enable-cond-command'
     Include support for the `[[' conditional command (*note
     Conditional Constructs::).

`--enable-directory-stack'
     Include support for a `csh'-like directory stack and the `pushd',
     `popd', and `dirs' builtins (*note The Directory Stack::).

`--enable-disabled-builtins'
     Allow builtin commands to be invoked via `builtin xxx' even after
     `xxx' has been disabled using `enable -n xxx'.  See *Note Bash
     Builtins::, for details of the `builtin' and `enable' builtin
     commands.

`--enable-dparen-arithmetic'
     Include support for the `((...))' command (*note Conditional
     Constructs::).

`--enable-extended-glob'
     Include support for the extended pattern matching features
     described above under *Note Pattern Matching::.

`--enable-help-builtin'
     Include the `help' builtin, which displays help on shell builtins
     and variables (*note Bash Builtins::).

`--enable-history'
     Include command history and the `fc' and `history' builtin
     commands (*note Bash History Facilities::).

`--enable-job-control'
     This enables the job control features (*note Job Control::), if
     the operating system supports them.

`--enable-net-redirections'
     This enables the special handling of filenames of the form
     `/dev/tcp/HOST/PORT' and `/dev/udp/HOST/PORT' when used in
     redirections (*note Redirections::).

`--enable-process-substitution'
     This enables process substitution (*note Process Substitution::) if
     the operating system provides the necessary support.

`--enable-prompt-string-decoding'
     Turn on the interpretation of a number of backslash-escaped
     characters in the `$PS1', `$PS2', `$PS3', and `$PS4' prompt
     strings.  See *Note Printing a Prompt::, for a complete list of
     prompt string escape sequences.

`--enable-progcomp'
     Enable the programmable completion facilities (*note Programmable
     Completion::).  If Readline is not enabled, this option has no
     effect.

`--enable-readline'
     Include support for command-line editing and history with the Bash
     version of the Readline library (*note Command Line Editing::).

`--enable-restricted'
     Include support for a "restricted shell".  If this is enabled,
     Bash, when called as `rbash', enters a restricted mode.  See *Note
     The Restricted Shell::, for a description of restricted mode.

`--enable-select'
     Include the `select' builtin, which allows the generation of simple
     menus (*note Conditional Constructs::).

`--enable-usg-echo-default'
     A synonym for `--enable-xpg-echo-default'.

`--enable-xpg-echo-default'
     Make the `echo' builtin expand backslash-escaped characters by
     default, without requiring the `-e' option.  This sets the default
     value of the `xpg_echo' shell option to `on', which makes the Bash
     `echo' behave more like the version specified in the Single Unix
     Specification, version 2.  *Note Bash Builtins::, for a
     description of the escape sequences that `echo' recognizes.

   The file `config-top.h' contains C Preprocessor `#define' statements
for options which are not settable from `configure'.  Some of these are
not meant to be changed; beware of the consequences if you do.  Read
the comments associated with each definition for more information about
its effect.


File: bashref.info,  Node: Reporting Bugs,  Next: Major Differences From The Bourne Shell,  Prev: Installing Bash,  Up: Top

Reporting Bugs
**************

   Please report all bugs you find in Bash.  But first, you should make
sure that it really is a bug, and that it appears in the latest version
of Bash that you have.

   Once you have determined that a bug actually exists, use the
`bashbug' command to submit a bug report.  If you have a fix, you are
encouraged to mail that as well!  Suggestions and `philosophical' bug
reports may be mailed to <bug-bash@gnu.org> or posted to the Usenet
newsgroup `gnu.bash.bug'.

   All bug reports should include:
   * The version number of Bash.

   * The hardware and operating system.

   * The compiler used to compile Bash.

   * A description of the bug behaviour.

   * A short script or `recipe' which exercises the bug and may be used
     to reproduce it.

`bashbug' inserts the first three items automatically into the template
it provides for filing a bug report.

   Please send all reports concerning this manual to <chet@po.CWRU.Edu>.


File: bashref.info,  Node: Major Differences From The Bourne Shell,  Next: Builtin Index,  Prev: Reporting Bugs,  Up: Top

Major Differences From The Bourne Shell
***************************************

   Bash implements essentially the same grammar, parameter and variable
expansion, redirection, and quoting as the Bourne Shell.  Bash uses the
POSIX 1003.2 standard as the specification of how these features are to
be implemented.  There are some differences between the traditional
Bourne shell and Bash; this section quickly details the differences of
significance.  A number of these differences are explained in greater
depth in previous sections.  This section uses the version of `sh'
included in SVR4.2 as the baseline reference.

   * Bash is POSIX-conformant, even where the POSIX specification
     differs from traditional `sh' behavior (*note Bash POSIX Mode::).

   * Bash has multi-character invocation options (*note Invoking
     Bash::).

   * Bash has command-line editing (*note Command Line Editing::) and
     the `bind' builtin.

   * Bash provides a programmable word completion mechanism (*note
     Programmable Completion::), and two builtin commands, `complete'
     and `compgen', to manipulate it.

   * Bash has command history (*note Bash History Facilities::) and the
     `history' and `fc' builtins to manipulate it.

   * Bash implements `csh'-like history expansion (*note History
     Interaction::).

   * Bash has one-dimensional array variables (*note Arrays::), and the
     appropriate variable expansions and assignment syntax to use them.
     Several of the Bash builtins take options to act on arrays.  Bash
     provides a number of built-in array variables.

   * The `$'...'' quoting syntax, which expands ANSI-C
     backslash-escaped characters in the text between the single quotes,
     is supported (*note ANSI-C Quoting::).

   * Bash supports the `$"..."' quoting syntax to do locale-specific
     translation of the characters between the double quotes.  The
     `-D', `--dump-strings', and `--dump-po-strings' invocation options
     list the translatable strings found in a script (*note Locale
     Translation::).

   * Bash implements the `!' keyword to negate the return value of a
     pipeline (*note Pipelines::).  Very useful when an `if' statement
     needs to act only if a test fails.

   * Bash has the `time' reserved word and command timing (*note
     Pipelines::).  The display of the timing statistics may be
     controlled with the `TIMEFORMAT' variable.

   * Bash implements the `for (( EXPR1 ; EXPR2 ; EXPR3 ))' arithmetic
     for command, similar to the C language (*note Looping
     Constructs::).

   * Bash includes the `select' compound command, which allows the
     generation of simple menus (*note Conditional Constructs::).

   * Bash includes the `[[' compound command, which makes conditional
     testing part of the shell grammar (*note Conditional Constructs::).

   * Bash includes brace expansion (*note Brace Expansion::) and tilde
     expansion (*note Tilde Expansion::).

   * Bash implements command aliases and the `alias' and `unalias'
     builtins (*note Aliases::).

   * Bash provides shell arithmetic, the `((' compound command (*note
     Conditional Constructs::), and arithmetic expansion (*note Shell
     Arithmetic::).

   * Variables present in the shell's initial environment are
     automatically exported to child processes.  The Bourne shell does
     not normally do this unless the variables are explicitly marked
     using the `export' command.

   * Bash includes the POSIX pattern removal `%', `#', `%%' and `##'
     expansions to remove leading or trailing substrings from variable
     values (*note Shell Parameter Expansion::).

   * The expansion `${#xx}', which returns the length of `${xx}', is
     supported (*note Shell Parameter Expansion::).

   * The expansion `${var:'OFFSET`[:'LENGTH`]}', which expands to the
     substring of `var''s value of length LENGTH, beginning at OFFSET,
     is present (*note Shell Parameter Expansion::).

   * The expansion `${var/[/]'PATTERN`[/'REPLACEMENT`]}', which matches
     PATTERN and replaces it with REPLACEMENT in the value of `var', is
     available (*note Shell Parameter Expansion::).

   * The expansion `${!PREFIX}*' expansion, which expands to the names
     of all shell variables whose names begin with PREFIX, is available
     (*note Shell Parameter Expansion::).

   * Bash has INDIRECT variable expansion using `${!word}' (*note Shell
     Parameter Expansion::).

   * Bash can expand positional parameters beyond `$9' using `${NUM}'.

   * The POSIX `$()' form of command substitution is implemented (*note
     Command Substitution::), and preferred to the Bourne shell's ```'
     (which is also implemented for backwards compatibility).

   * Bash has process substitution (*note Process Substitution::).

   * Bash automatically assigns variables that provide information
     about the current user (`UID', `EUID', and `GROUPS'), the current
     host (`HOSTTYPE', `OSTYPE', `MACHTYPE', and `HOSTNAME'), and the
     instance of Bash that is running (`BASH', `BASH_VERSION', and
     `BASH_VERSINFO').  *Note Bash Variables::, for details.

   * The `IFS' variable is used to split only the results of expansion,
     not all words (*note Word Splitting::).  This closes a
     longstanding shell security hole.

   * Bash implements the full set of POSIX 1003.2 filename expansion
     operators, including CHARACTER CLASSES, EQUIVALENCE CLASSES, and
     COLLATING SYMBOLS (*note Filename Expansion::).

   * Bash implements extended pattern matching features when the
     `extglob' shell option is enabled (*note Pattern Matching::).

   * It is possible to have a variable and a function with the same
     name; `sh' does not separate the two name spaces.

   * Bash functions are permitted to have local variables using the
     `local' builtin, and thus useful recursive functions may be written
     (*note Bash Builtins::).

   * Variable assignments preceding commands affect only that command,
     even builtins and functions (*note Environment::).  In `sh', all
     variable assignments preceding commands are global unless the
     command is executed from the file system.

   * Bash performs filename expansion on filenames specified as operands
     to input and output redirection operators (*note Redirections::).

   * Bash contains the `<>' redirection operator, allowing a file to be
     opened for both reading and writing, and the `&>' redirection
     operator, for directing standard output and standard error to the
     same file (*note Redirections::).

   * Bash treats a number of filenames specially when they are used in
     redirection operators (*note Redirections::).

   * Bash can open network connections to arbitrary machines and
     services with the redirection operators (*note Redirections::).

   * The `noclobber' option is available to avoid overwriting existing
     files with output redirection (*note The Set Builtin::).  The `>|'
     redirection operator may be used to override `noclobber'.

   * The Bash `cd' and `pwd' builtins (*note Bourne Shell Builtins::)
     each take `-L' and `-P' options to switch between logical and
     physical modes.

   * Bash allows a function to override a builtin with the same name,
     and provides access to that builtin's functionality within the
     function via the `builtin' and `command' builtins (*note Bash
     Builtins::).

   * The `command' builtin allows selective disabling of functions when
     command lookup is performed (*note Bash Builtins::).

   * Individual builtins may be enabled or disabled using the `enable'
     builtin (*note Bash Builtins::).

   * The Bash `exec' builtin takes additional options that allow users
     to control the contents of the environment passed to the executed
     command, and what the zeroth argument to the command is to be
     (*note Bourne Shell Builtins::).

   * Shell functions may be exported to children via the environment
     using `export -f' (*note Shell Functions::).

   * The Bash `export', `readonly', and `declare' builtins can take a
     `-f' option to act on shell functions, a `-p' option to display
     variables with various attributes set in a format that can be used
     as shell input, a `-n' option to remove various variable
     attributes, and `name=value' arguments to set variable attributes
     and values simultaneously.

   * The Bash `hash' builtin allows a name to be associated with an
     arbitrary filename, even when that filename cannot be found by
     searching the `$PATH', using `hash -p' (*note Bourne Shell
     Builtins::).

   * Bash includes a `help' builtin for quick reference to shell
     facilities (*note Bash Builtins::).

   * The `printf' builtin is available to display formatted output
     (*note Bash Builtins::).

   * The Bash `read' builtin (*note Bash Builtins::) will read a line
     ending in `\' with the `-r' option, and will use the `REPLY'
     variable as a default if no non-option arguments are supplied.
     The Bash `read' builtin also accepts a prompt string with the `-p'
     option and will use Readline to obtain the line when given the
     `-e' option.  The `read' builtin also has additional options to
     control input: the `-s' option will turn off echoing of input
     characters as they are read, the `-t' option will allow `read' to
     time out if input does not arrive within a specified number of
     seconds, the `-n' option will allow reading only a specified
     number of characters rather than a full line, and the `-d' option
     will read until a particular character rather than newline.

   * The `return' builtin may be used to abort execution of scripts
     executed with the `.' or `source' builtins (*note Bourne Shell
     Builtins::).

   * Bash includes the `shopt' builtin, for finer control of shell
     optional capabilities (*note Bash Builtins::), and allows these
     options to be set and unset at shell invocation (*note Invoking
     Bash::).

   * Bash has much more optional behavior controllable with the `set'
     builtin (*note The Set Builtin::).

   * The `test' builtin (*note Bourne Shell Builtins::) is slightly
     different, as it implements the POSIX algorithm, which specifies
     the behavior based on the number of arguments.

   * The `trap' builtin (*note Bourne Shell Builtins::) allows a
     `DEBUG' pseudo-signal specification, similar to `EXIT'.  Commands
     specified with a `DEBUG' trap are executed after every simple
     command.  The `DEBUG' trap is not inherited by shell functions.

     The `trap' builtin (*note Bourne Shell Builtins::) allows an `ERR'
     pseudo-signal specification, similar to `EXIT' and `DEBUG'.
     Commands specified with an `ERR' trap are executed after a simple
     command fails, with a few exceptions.  The `ERR' trap is not
     inherited by shell functions.

   * The Bash `type' builtin is more extensive and gives more
     information about the names it finds (*note Bash Builtins::).

   * The Bash `umask' builtin permits a `-p' option to cause the output
     to be displayed in the form of a `umask' command that may be
     reused as input (*note Bourne Shell Builtins::).

   * Bash implements a `csh'-like directory stack, and provides the
     `pushd', `popd', and `dirs' builtins to manipulate it (*note The
     Directory Stack::).  Bash also makes the directory stack visible
     as the value of the `DIRSTACK' shell variable.

   * Bash interprets special backslash-escaped characters in the prompt
     strings when interactive (*note Printing a Prompt::).

   * The Bash restricted mode is more useful (*note The Restricted
     Shell::); the SVR4.2 shell restricted mode is too limited.

   * The `disown' builtin can remove a job from the internal shell job
     table (*note Job Control Builtins::) or suppress the sending of
     `SIGHUP' to a job when the shell exits as the result of a `SIGHUP'.

   * The SVR4.2 shell has two privilege-related builtins (`mldmode' and
     `priv') not present in Bash.

   * Bash does not have the `stop' or `newgrp' builtins.

   * Bash does not use the `SHACCT' variable or perform shell
     accounting.

   * The SVR4.2 `sh' uses a `TIMEOUT' variable like Bash uses `TMOUT'.


More features unique to Bash may be found in *Note Bash Features::.

Implementation Differences From The SVR4.2 Shell
================================================

   Since Bash is a completely new implementation, it does not suffer
from many of the limitations of the SVR4.2 shell.  For instance:

   * Bash does not fork a subshell when redirecting into or out of a
     shell control structure such as  an `if' or `while' statement.

   * Bash does not allow unbalanced quotes.  The SVR4.2 shell will
     silently insert a needed closing quote at `EOF' under certain
     circumstances.  This can be the cause of some hard-to-find errors.

   * The SVR4.2 shell uses a baroque memory management scheme based on
     trapping `SIGSEGV'.  If the shell is started from a process with
     `SIGSEGV' blocked (e.g., by using the `system()' C library
     function call), it misbehaves badly.

   * In a questionable attempt at security, the SVR4.2 shell, when
     invoked without the `-p' option, will alter its real and effective
     UID and GID if they are less than some magic threshold value,
     commonly 100.  This can lead to unexpected results.

   * The SVR4.2 shell does not allow users to trap `SIGSEGV',
     `SIGALRM', or `SIGCHLD'.

   * The SVR4.2 shell does not allow the `IFS', `MAILCHECK', `PATH',
     `PS1', or `PS2' variables to be unset.

   * The SVR4.2 shell treats `^' as the undocumented equivalent of `|'.

   * Bash allows multiple option arguments when it is invoked (`-x -v');
     the SVR4.2 shell allows only one option argument (`-xv').  In
     fact, some versions of the shell dump core if the second argument
     begins with a `-'.

   * The SVR4.2 shell exits a script if any builtin fails; Bash exits a
     script only if one of the POSIX 1003.2 special builtins fails, and
     only for certain failures, as enumerated in the POSIX 1003.2
     standard.

   * The SVR4.2 shell behaves differently when invoked as `jsh' (it
     turns on job control).


File: bashref.info,  Node: Builtin Index,  Next: Reserved Word Index,  Prev: Major Differences From The Bourne Shell,  Up: Top

Index of Shell Builtin Commands
*******************************

* Menu:

* .:                                     Bourne Shell Builtins.
* ::                                     Bourne Shell Builtins.
* [:                                     Bourne Shell Builtins.
* alias:                                 Bash Builtins.
* bg:                                    Job Control Builtins.
* bind:                                  Bash Builtins.
* break:                                 Bourne Shell Builtins.
* builtin:                               Bash Builtins.
* cd:                                    Bourne Shell Builtins.
* command:                               Bash Builtins.
* compgen:                               Programmable Completion Builtins.
* complete:                              Programmable Completion Builtins.
* continue:                              Bourne Shell Builtins.
* declare:                               Bash Builtins.
* dirs:                                  Directory Stack Builtins.
* disown:                                Job Control Builtins.
* echo:                                  Bash Builtins.
* enable:                                Bash Builtins.
* eval:                                  Bourne Shell Builtins.
* exec:                                  Bourne Shell Builtins.
* exit:                                  Bourne Shell Builtins.
* export:                                Bourne Shell Builtins.
* fc:                                    Bash History Builtins.
* fg:                                    Job Control Builtins.
* getopts:                               Bourne Shell Builtins.
* hash:                                  Bourne Shell Builtins.
* help:                                  Bash Builtins.
* history:                               Bash History Builtins.
* jobs:                                  Job Control Builtins.
* kill:                                  Job Control Builtins.
* let:                                   Bash Builtins.
* local:                                 Bash Builtins.
* logout:                                Bash Builtins.
* popd:                                  Directory Stack Builtins.
* printf:                                Bash Builtins.
* pushd:                                 Directory Stack Builtins.
* pwd:                                   Bourne Shell Builtins.
* read:                                  Bash Builtins.
* readonly:                              Bourne Shell Builtins.
* return:                                Bourne Shell Builtins.
* set:                                   The Set Builtin.
* shift:                                 Bourne Shell Builtins.
* shopt:                                 Bash Builtins.
* source:                                Bash Builtins.
* suspend:                               Job Control Builtins.
* test:                                  Bourne Shell Builtins.
* times:                                 Bourne Shell Builtins.
* trap:                                  Bourne Shell Builtins.
* type:                                  Bash Builtins.
* typeset:                               Bash Builtins.
* ulimit:                                Bash Builtins.
* umask:                                 Bourne Shell Builtins.
* unalias:                               Bash Builtins.
* unset:                                 Bourne Shell Builtins.
* wait:                                  Job Control Builtins.


File: bashref.info,  Node: Reserved Word Index,  Next: Variable Index,  Prev: Builtin Index,  Up: Top

Index of Shell Reserved Words
*****************************

* Menu:

* !:                                     Pipelines.
* [[:                                    Conditional Constructs.
* ]]:                                    Conditional Constructs.
* case:                                  Conditional Constructs.
* do:                                    Looping Constructs.
* done:                                  Looping Constructs.
* elif:                                  Conditional Constructs.
* else:                                  Conditional Constructs.
* esac:                                  Conditional Constructs.
* fi:                                    Conditional Constructs.
* for:                                   Looping Constructs.
* function:                              Shell Functions.
* if:                                    Conditional Constructs.
* in:                                    Conditional Constructs.
* select:                                Conditional Constructs.
* then:                                  Conditional Constructs.
* time:                                  Pipelines.
* until:                                 Looping Constructs.
* while:                                 Looping Constructs.
* {:                                     Command Grouping.
* }:                                     Command Grouping.


File: bashref.info,  Node: Variable Index,  Next: Function Index,  Prev: Reserved Word Index,  Up: Top

Parameter and Variable Index
****************************

* Menu:

* !:                                     Special Parameters.
* #:                                     Special Parameters.
* $:                                     Special Parameters.
* *:                                     Special Parameters.
* -:                                     Special Parameters.
* 0:                                     Special Parameters.
* ?:                                     Special Parameters.
* @:                                     Special Parameters.
* _:                                     Special Parameters.
* auto_resume:                           Job Control Variables.
* BASH:                                  Bash Variables.
* BASH_ENV:                              Bash Variables.
* BASH_VERSINFO:                         Bash Variables.
* BASH_VERSION:                          Bash Variables.
* bell-style:                            Readline Init File Syntax.
* CDPATH:                                Bourne Shell Variables.
* COLUMNS:                               Bash Variables.
* comment-begin:                         Readline Init File Syntax.
* COMP_CWORD:                            Bash Variables.
* COMP_LINE:                             Bash Variables.
* COMP_POINT:                            Bash Variables.
* COMP_WORDS:                            Bash Variables.
* completion-query-items:                Readline Init File Syntax.
* COMPREPLY:                             Bash Variables.
* convert-meta:                          Readline Init File Syntax.
* DIRSTACK:                              Bash Variables.
* disable-completion:                    Readline Init File Syntax.
* editing-mode:                          Readline Init File Syntax.
* enable-keypad:                         Readline Init File Syntax.
* EUID:                                  Bash Variables.
* expand-tilde:                          Readline Init File Syntax.
* FCEDIT:                                Bash Variables.
* FIGNORE:                               Bash Variables.
* FUNCNAME:                              Bash Variables.
* GLOBIGNORE:                            Bash Variables.
* GROUPS:                                Bash Variables.
* histchars:                             Bash Variables.
* HISTCMD:                               Bash Variables.
* HISTCONTROL:                           Bash Variables.
* HISTFILE:                              Bash Variables.
* HISTFILESIZE:                          Bash Variables.
* HISTIGNORE:                            Bash Variables.
* history-preserve-point:                Readline Init File Syntax.
* HISTSIZE:                              Bash Variables.
* HOME:                                  Bourne Shell Variables.
* horizontal-scroll-mode:                Readline Init File Syntax.
* HOSTFILE:                              Bash Variables.
* HOSTNAME:                              Bash Variables.
* HOSTTYPE:                              Bash Variables.
* IFS:                                   Bourne Shell Variables.
* IGNOREEOF:                             Bash Variables.
* input-meta:                            Readline Init File Syntax.
* INPUTRC:                               Bash Variables.
* isearch-terminators:                   Readline Init File Syntax.
* keymap:                                Readline Init File Syntax.
* LANG:                                  Bash Variables.
* LC_ALL:                                Bash Variables.
* LC_COLLATE:                            Bash Variables.
* LC_CTYPE:                              Bash Variables.
* LC_MESSAGES <1>:                       Bash Variables.
* LC_MESSAGES:                           Locale Translation.
* LC_NUMERIC:                            Bash Variables.
* LINENO:                                Bash Variables.
* LINES:                                 Bash Variables.
* MACHTYPE:                              Bash Variables.
* MAIL:                                  Bourne Shell Variables.
* MAILCHECK:                             Bash Variables.
* MAILPATH:                              Bourne Shell Variables.
* mark-modified-lines:                   Readline Init File Syntax.
* match-hidden-files:                    Readline Init File Syntax.
* meta-flag:                             Readline Init File Syntax.
* OLDPWD:                                Bash Variables.
* OPTARG:                                Bourne Shell Variables.
* OPTERR:                                Bash Variables.
* OPTIND:                                Bourne Shell Variables.
* OSTYPE:                                Bash Variables.
* output-meta:                           Readline Init File Syntax.
* PATH:                                  Bourne Shell Variables.
* PIPESTATUS:                            Bash Variables.
* POSIXLY_CORRECT:                       Bash Variables.
* PPID:                                  Bash Variables.
* PROMPT_COMMAND:                        Bash Variables.
* PS1:                                   Bourne Shell Variables.
* PS2:                                   Bourne Shell Variables.
* PS3:                                   Bash Variables.
* PS4:                                   Bash Variables.
* PWD:                                   Bash Variables.
* RANDOM:                                Bash Variables.
* REPLY:                                 Bash Variables.
* SECONDS:                               Bash Variables.
* SHELLOPTS:                             Bash Variables.
* SHLVL:                                 Bash Variables.
* show-all-if-ambiguous:                 Readline Init File Syntax.
* TEXTDOMAIN:                            Locale Translation.
* TEXTDOMAINDIR:                         Locale Translation.
* TIMEFORMAT:                            Bash Variables.
* TMOUT:                                 Bash Variables.
* UID:                                   Bash Variables.
* visible-stats:                         Readline Init File Syntax.


File: bashref.info,  Node: Function Index,  Next: Concept Index,  Prev: Variable Index,  Up: Top

Function Index
**************

* Menu:

* abort (C-g):                           Miscellaneous Commands.
* accept-line (Newline or Return):       Commands For History.
* backward-char (C-b):                   Commands For Moving.
* backward-delete-char (Rubout):         Commands For Text.
* backward-kill-line (C-x Rubout):       Commands For Killing.
* backward-kill-word (M-<DEL>):          Commands For Killing.
* backward-word (M-b):                   Commands For Moving.
* beginning-of-history (M-<):            Commands For History.
* beginning-of-line (C-a):               Commands For Moving.
* call-last-kbd-macro (C-x e):           Keyboard Macros.
* capitalize-word (M-c):                 Commands For Text.
* character-search (C-]):                Miscellaneous Commands.
* character-search-backward (M-C-]):     Miscellaneous Commands.
* clear-screen (C-l):                    Commands For Moving.
* complete (<TAB>):                      Commands For Completion.
* copy-backward-word ():                 Commands For Killing.
* copy-forward-word ():                  Commands For Killing.
* copy-region-as-kill ():                Commands For Killing.
* delete-char (C-d):                     Commands For Text.
* delete-char-or-list ():                Commands For Completion.
* delete-horizontal-space ():            Commands For Killing.
* digit-argument (M-0, M-1, ... M--):    Numeric Arguments.
* do-uppercase-version (M-a, M-b, M-X, ...): Miscellaneous Commands.
* downcase-word (M-l):                   Commands For Text.
* dump-functions ():                     Miscellaneous Commands.
* dump-macros ():                        Miscellaneous Commands.
* dump-variables ():                     Miscellaneous Commands.
* end-kbd-macro (C-x )):                 Keyboard Macros.
* end-of-history (M->):                  Commands For History.
* end-of-line (C-e):                     Commands For Moving.
* exchange-point-and-mark (C-x C-x):     Miscellaneous Commands.
* forward-backward-delete-char ():       Commands For Text.
* forward-char (C-f):                    Commands For Moving.
* forward-search-history (C-s):          Commands For History.
* forward-word (M-f):                    Commands For Moving.
* history-search-backward ():            Commands For History.
* history-search-forward ():             Commands For History.
* insert-comment (M-#):                  Miscellaneous Commands.
* insert-completions (M-*):              Commands For Completion.
* kill-line (C-k):                       Commands For Killing.
* kill-region ():                        Commands For Killing.
* kill-whole-line ():                    Commands For Killing.
* kill-word (M-d):                       Commands For Killing.
* menu-complete ():                      Commands For Completion.
* next-history (C-n):                    Commands For History.
* non-incremental-forward-search-history (M-n): Commands For History.
* non-incremental-reverse-search-history (M-p): Commands For History.
* possible-completions (M-?):            Commands For Completion.
* prefix-meta (<ESC>):                   Miscellaneous Commands.
* previous-history (C-p):                Commands For History.
* quoted-insert (C-q or C-v):            Commands For Text.
* re-read-init-file (C-x C-r):           Miscellaneous Commands.
* redraw-current-line ():                Commands For Moving.
* reverse-search-history (C-r):          Commands For History.
* revert-line (M-r):                     Miscellaneous Commands.
* self-insert (a, b, A, 1, !, ...):      Commands For Text.
* set-mark (C-@):                        Miscellaneous Commands.
* start-kbd-macro (C-x ():               Keyboard Macros.
* transpose-chars (C-t):                 Commands For Text.
* transpose-words (M-t):                 Commands For Text.
* undo (C-_ or C-x C-u):                 Miscellaneous Commands.
* universal-argument ():                 Numeric Arguments.
* unix-line-discard (C-u):               Commands For Killing.
* unix-word-rubout (C-w):                Commands For Killing.
* upcase-word (M-u):                     Commands For Text.
* yank (C-y):                            Commands For Killing.
* yank-last-arg (M-. or M-_):            Commands For History.
* yank-nth-arg (M-C-y):                  Commands For History.
* yank-pop (M-y):                        Commands For Killing.


File: bashref.info,  Node: Concept Index,  Prev: Function Index,  Up: Top

Concept Index
*************

* Menu:

* alias expansion:                       Aliases.
* arithmetic evaluation:                 Shell Arithmetic.
* arithmetic expansion:                  Arithmetic Expansion.
* arithmetic, shell:                     Shell Arithmetic.
* arrays:                                Arrays.
* background:                            Job Control Basics.
* Bash configuration:                    Basic Installation.
* Bash installation:                     Basic Installation.
* Bourne shell:                          Basic Shell Features.
* brace expansion:                       Brace Expansion.
* builtin:                               Definitions.
* command editing:                       Readline Bare Essentials.
* command execution:                     Command Search and Execution.
* command expansion:                     Simple Command Expansion.
* command history:                       Bash History Facilities.
* command search:                        Command Search and Execution.
* command substitution:                  Command Substitution.
* command timing:                        Pipelines.
* commands, conditional:                 Conditional Constructs.
* commands, grouping:                    Command Grouping.
* commands, lists:                       Lists.
* commands, looping:                     Looping Constructs.
* commands, pipelines:                   Pipelines.
* commands, shell:                       Shell Commands.
* commands, simple:                      Simple Commands.
* comments, shell:                       Comments.
* completion builtins:                   Programmable Completion Builtins.
* configuration:                         Basic Installation.
* control operator:                      Definitions.
* directory stack:                       The Directory Stack.
* editing command lines:                 Readline Bare Essentials.
* environment:                           Environment.
* evaluation, arithmetic:                Shell Arithmetic.
* event designators:                     Event Designators.
* execution environment:                 Command Execution Environment.
* exit status <1>:                       Exit Status.
* exit status:                           Definitions.
* expansion:                             Shell Expansions.
* expansion, arithmetic:                 Arithmetic Expansion.
* expansion, brace:                      Brace Expansion.
* expansion, filename:                   Filename Expansion.
* expansion, parameter:                  Shell Parameter Expansion.
* expansion, pathname:                   Filename Expansion.
* expansion, tilde:                      Tilde Expansion.
* expressions, arithmetic:               Shell Arithmetic.
* expressions, conditional:              Bash Conditional Expressions.
* field:                                 Definitions.
* filename:                              Definitions.
* filename expansion:                    Filename Expansion.
* foreground:                            Job Control Basics.
* functions, shell:                      Shell Functions.
* history builtins:                      Bash History Builtins.
* history events:                        Event Designators.
* history expansion:                     History Interaction.
* history list:                          Bash History Facilities.
* History, how to use:                   Programmable Completion Builtins.
* identifier:                            Definitions.
* initialization file, readline:         Readline Init File.
* installation:                          Basic Installation.
* interaction, readline:                 Readline Interaction.
* interactive shell <1>:                 Interactive Shells.
* interactive shell:                     Invoking Bash.
* internationalization:                  Locale Translation.
* job:                                   Definitions.
* job control <1>:                       Job Control Basics.
* job control:                           Definitions.
* kill ring:                             Readline Killing Commands.
* killing text:                          Readline Killing Commands.
* localization:                          Locale Translation.
* login shell:                           Invoking Bash.
* matching, pattern:                     Pattern Matching.
* metacharacter:                         Definitions.
* name:                                  Definitions.
* native languages:                      Locale Translation.
* notation, readline:                    Readline Bare Essentials.
* operator, shell:                       Definitions.
* parameter expansion:                   Shell Parameter Expansion.
* parameters:                            Shell Parameters.
* parameters, positional:                Positional Parameters.
* parameters, special:                   Special Parameters.
* pathname expansion:                    Filename Expansion.
* pattern matching:                      Pattern Matching.
* pipeline:                              Pipelines.
* POSIX:                                 Definitions.
* POSIX Mode:                            Bash POSIX Mode.
* process group:                         Definitions.
* process group ID:                      Definitions.
* process substitution:                  Process Substitution.
* programmable completion:               Programmable Completion.
* prompting:                             Printing a Prompt.
* quoting:                               Quoting.
* quoting, ANSI:                         ANSI-C Quoting.
* Readline, how to use:                  Job Control Variables.
* redirection:                           Redirections.
* reserved word:                         Definitions.
* restricted shell:                      The Restricted Shell.
* return status:                         Definitions.
* shell arithmetic:                      Shell Arithmetic.
* shell function:                        Shell Functions.
* shell script:                          Shell Scripts.
* shell variable:                        Shell Parameters.
* shell, interactive:                    Interactive Shells.
* signal:                                Definitions.
* signal handling:                       Signals.
* special builtin <1>:                   Special Builtins.
* special builtin:                       Definitions.
* startup files:                         Bash Startup Files.
* suspending jobs:                       Job Control Basics.
* tilde expansion:                       Tilde Expansion.
* token:                                 Definitions.
* translation, native languages:         Locale Translation.
* variable, shell:                       Shell Parameters.
* variables, readline:                   Readline Init File Syntax.
* word:                                  Definitions.
* word splitting:                        Word Splitting.
* yanking text:                          Readline Killing Commands.


