## SYNOPSIS

           bash [options] [file]

## COPYRIGHT

           Bash is Copyright (C) 1989-2002 by the Free Software Foun
           dation, Inc.

## DESCRIPTION

           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).

## OPTIONS

           In  addition  to  the single-character shell options docu
           mented 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.
           -i        If the -i option is present, the shell is inter
                     active.
           -l        Make  bash  act  as  if it had been invoked as a
                     login shell (see INVOCATION below).
           -r        If the -r option is present, the  shell  becomes
                     restricted (see RESTRICTED SHELL below).
           -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  trans
                     lation  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 val

                  Equivalent to -D, but the output is in the GNU get
                  text 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
                  Equivalent to -l.

           --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 ~/.pro
                  file.  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 oper
                  ation 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.

## ARGUMENTS

           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
           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 Expansion 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 behav
           ior.

           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

           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 func
           tions are not inherited from the  environment,  the  SHEL
           LOPTS  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.

## DEFINITIONS

           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

           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  com
           mand (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 [[ ]]

## SHELL GRAMMAR

       Simple Commands
                  [time [-p]] [ ! ] command [ | command2 ... ]

           The standard output of command is connected via a pipe  to
           the  standard  input of command2.  This connection is per
           formed before any redirections specified  by  the  command
           (see REDIRECTION below).

           If the reserved word !  precedes a pipeline, the exit sta
           tus 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 pro
           cess (i.e., in a subshell).

       Lists
           A list is a sequence of one or more pipelines separated by
           one  of the operators ;, &, &&, or ||, and optionally ter
           minated by one of ;, &, or <newline>.

           Of these list operators, && and || have equal  precedence,
           followed by ; and &, which have equal precedence.

           A  sequence  of  one or more newlines may appear in a list
           instead of a semicolon to delimit commands.

           If a command is terminated by the control operator &,  the
           shell  executes  the  command  in the background in a sub
           shell.  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.
           (list) list  is  executed in a subshell.  Variable assign
                  ments and builtin commands that affect the  shell's
                  environment  do not remain in effect after the com
                  mand completes.  The return status is the exit sta
                  tus of list.

           { list; }
                  list  is simply executed in the current shell envi
                  ronment.  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 evalua
                  tion  of  the  conditional  expression  expression.
                  Expressions are composed of the primaries described
                  below under CONDITIONAL EXPRESSIONS.   Word  split
                  ting  and  pathname  expansion are not performed on
                  the words between the [[ and ]];  tilde  expansion,
                  parameter and variable expansion, arithmetic expan
                  sion, 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  pat
                  tern  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 pat
                  tern, 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 prece
                  dence:

                  ( expression )
                         Returns the value of expression.   This  may
                         be used to override the normal precedence of
                         operators.

           for name [ in word ] ; do list ; done
                  The  list of words following in is expanded, gener
                  ating a list of items.  The variable name is set to
                  each element of this list in turn, and list is exe
                  cuted 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 com
                  mand 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 ARITH
                  METIC 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 expres
                  sion 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,  gener
                  ating  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 posi
                  tional  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  com
                  mands 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
                  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  speci
                  fied  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.)

## COMMENTS

           In a non-interactive shell, or  an  interactive  shell  in
           which the interactive_comments option to the shopt builtin
           is enabled (see SHELL  BUILTIN  COMMANDS  below),  a  word
           beginning  with # causes that word and all remaining char
           acters 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

           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 pre
           vent 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 history 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
           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 preced
           ing 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)
                  \cx    a control-x character

           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.

## PARAMETERS

           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 Parameters.  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).

           may  also  appear  as  arguments  to the declare, typeset,
           export, readonly, and local builtin commands.

       Positional Parameters
           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 sin
           gle digit is expanded, it must be enclosed in braces  (see
           EXPANSION below).

       Special Parameters
           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 cur
                  rent shell, not the subshell.
           !      Expands to the process ID of the most recently exe
                  cuted background (asynchronous) command.
           0      Expands  to  the name of the shell or shell script.
                  This is set at shell initialization.   If  bash  is
                  being checked.

       Shell Variables
           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 ver
                  sion information for this instance  of  bash.   The
                  values  assigned  to  the array members are as fol
                  lows:
                  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
                  Expands  to a string describing the version of this
                  instance of bash.

           COMP_CWORD
                  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  Pro
                  grammable Completion below).

           COMP_LINE
                  The current command line.  This variable is  avail
                  able  only in shell functions and external commands
                  invoked by the programmable  completion  facilities
                  (see Programmable Completion below).

           COMP_POINT
                  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 cur
                  rent 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 Pro
                  grammable Completion below).

           COMP_WORDS
                  An array variable (see Arrays below) consisting  of
                  the  individual  words in the current command line.
                  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
                  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 sub
                  sequently 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  proper
                  ties, even if it is subsequently reset.

           HISTCMD
                  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 subse
                  quently reset.

           HOSTNAME
                  Automatically set to the name of the current  host.

           HOSTTYPE
                  Automatically   set   to  a  string  that  uniquely
                  describes the type of machine on which bash is exe
                  cuting.  The default is system-dependent.

           LINENO Each  time  this parameter is referenced, the shell
                  substitutes a decimal number representing the  cur
                  rent  sequential  line  number  (starting  with  1)
                  within a script or function.  When not in a  script
                  or  function,  the value substituted is not guaran
                  teed to be meaningful.   If  LINENO  is  unset,  it
                  loses  its special properties, even if it is subse
                  quently reset.

           MACHTYPE
                  Automatically set to a string that fully  describes
                  the  system type on which bash is executing, in the
                  standard  GNU   cpu-company-system   format.    The
                  default is system-dependent.

           OLDPWD The  previous  working  directory  as set by the cd
                  command.
                  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 vari
                  able is readonly.

           PWD    The current working directory as set by the cd com
                  mand.

           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 sub
                  sequently reset.

           REPLY  Set to the line of input read by the  read  builtin
                  command when no arguments are supplied.

           SECONDS
                  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
                  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,  ini
                  tialized  at shell startup.  This variable is read
                  only.

           The following variables are used by the  shell.   In  some
           cases,  bash  assigns a default value to a variable; these
           cases are noted below.

                  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  possi
                  ble  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:~".
           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 pat
                  tern also matches one of the  patterns  in  GLOBIG
                  NORE, 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  his
                  tory  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  HISTIG
                  NORE.   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 HISTORY 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  his
                  tory 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
                  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 host
                  name  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 charac
                  ters  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, over
                  riding the  default  of  ~/.inputrc  (see  READLINE
                  below).
           LANG   Used to determine the locale category for any cate
                  gory 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  trans
                  playing  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.  Exam
                  ple:
                  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-sepa
                  rated 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  indirec
                  tion.  The default is ``+ ''.
                            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 spec
                  ified, 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  dis
                  played.   A trailing newline is added when the for
                  mat string is displayed.

           TMOUT  If set to a  value  greater  than  zero,  TMOUT  is
                  treated   as  the  default  timeout  for  the  read
                  builtin.  The select command  terminates  if  input
                  does  not  arrive after TMOUT seconds when input is
                  coming from a terminal.  In an  interactive  shell,
                  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 supplied
                  must match the name of a stopped  job  exactly;  if
                  set  to  substring,  the  string  supplied needs to
                  match a substring of the name  of  a  stopped  job.
                  The  substring  value provides functionality analo
                  gous to the %?  job  identifier  (see  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
                  identifier.
                  normally `#'.  The history comment character causes
                  history  substitution to be skipped for the remain
                  ing words on the line.   It  does  not  necessarily
                  cause  the  shell  parser  to treat the rest of the
                  line as a comment.

       Arrays
           Bash provides one-dimensional array variables.  Any  vari
           able  may  be  used  as an array; the declare builtin will
           explicitly declare an array.  There is no maximum limit on
           the  size of an array, nor any requirement that members be
           indexed or  assigned  contiguously.   Arrays  are  indexed
           using integers and are zero-based.

           An  array  is  created  automatically  if  any variable is
           assigned to using the syntax  name[subscript]=value.   The
           subscript is treated as an arithmetic expression that must
           evaluate to a number greater than or equal  to  zero.   To
           explicitly  declare  an  array,  use  declare -a name (see
           SHELL BUILTIN COMMANDS below).  declare -a name[subscript]
           is  also  accepted;  the subscript is ignored.  Attributes
           may be specified for an array variable using  the  declare
           and readonly builtins.  Each attribute applies to all mem
           bers of an array.

           Arrays are assigned to using compound assignments  of  the
           form  name=(value1 ... valuen), where each value is of the
           form [subscript]=string.  Only string is required.  If the
           optional  brackets  and subscript are supplied, that index
           is  assigned  to;  otherwise  the  index  of  the  element
           assigned  is  the  last index assigned to by the statement
           plus one.  Indexing starts at zero.  This syntax  is  also
           accepted  by  the  declare builtin.  Individual array ele
           ments may be assigned to using  the  name[subscript]=value
           syntax introduced above.

           Any   element   of   an  array  may  be  referenced  using
           ${name[subscript]}.  The braces are required to avoid con
           flicts  with  pathname expansion.  If subscript is @ or *,
           the word expands to all members of name.  These subscripts
           differ  only  when  the word appears within double quotes.
           If the word is double-quoted, ${name[*]} expands to a sin
           gle  word with the value of each array member separated by
           the first character  of  the  IFS  special  variable,  and
           ${name[@]}  expands  each  element  of  name to a separate
           word.  When there are no array members, ${name[@]} expands
           to  nothing.   This  is  analogous to the expansion of the
           special parameters * and @ (see Special Parameters above).
           ${#name[subscript]}  expands  to the length of ${name[sub
           script]}.  If subscript is * or @, the  expansion  is  the
           number  of  elements  in  the array.  Referencing an array
           variable without a subscript is equivalent to  referencing

## EXPANSION

           Expansion is performed on the command line  after  it  has
           been split into words.  There are seven kinds of expansion
           performed: brace expansion, tilde expansion, parameter and
           variable   expansion,   command  substitution,  arithmetic
           expansion, word splitting, and pathname expansion.

           The order of expansions is: brace expansion, tilde  expan
           sion,  parameter,  variable  and  arithmetic expansion and
           command 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  expan
           sion  can  change  the  number  of words of the expansion;
           other expansions expand a single word to  a  single  word.
           The only exceptions to this are the expansions of "$@" and
           "${name[@]}" as explained above (see PARAMETERS).

       Brace Expansion
           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
           postscript.  The preamble is prefixed to each string  con
           tained  within  the  braces,  and  the  postscript is then
           appended to  each  resulting  string,  expanding  left  to
           right.

           Brace  expansions  may  be  nested.   The  results of each
           expanded string are not sorted; left  to  right  order  is
           preserved.   For  example, 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 pre
           served 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.   A  {  or  , may be quoted with a backslash to
           prevent its being considered part of a  brace  expression.
           To avoid conflicts with parameter expansion, the string ${
           is not considered eligible for 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  compati
           bility  with  sh is desired, start bash with the +B option
           or disable brace expansion with the +B option to  the  set
           command (see SHELL BUILTIN COMMANDS below).

       Tilde Expansion
           If  a  word begins with an unquoted tilde character (`~'),
           all of the characters preceding the first  unquoted  slash
           (or  all  characters,  if  there is no unquoted slash) are
           considered a tilde-prefix.  If none of the  characters  in
           the  tilde-prefix are quoted, the characters in the tilde-
           prefix following the tilde are treated as a possible login
           name.  If this login name is the null string, the tilde is
           replaced with the value of the shell parameter  HOME.   If
           HOME  is  unset,  the home directory of the user executing
           the shell is substituted instead.  Otherwise,  the  tilde-
           prefix is replaced with the home directory associated with
           the specified login name.

           If the tilde-prefix is a `~+',  the  value  of  the  shell
           variable PWD replaces the tilde-prefix.  If the tilde-pre
           fix is a `~-', the value of the shell variable OLDPWD,  if
           it  is  set,  is substituted.  If the characters following
           the tilde in the  tilde-prefix  consist  of  a  number  N,
           optionally prefixed by a `+' or a `-', the tilde-prefix is
           replaced with the corresponding element from the directory
           stack,  as  it  would  be  displayed  by  the dirs builtin
           invoked with the tilde-prefix  as  an  argument.   If  the
           characters following the tilde in the tilde-prefix consist
           of a number without a leading `+' or `-', `+' is  assumed.

           If  the  login  name  is  invalid,  or the tilde expansion
           fails, the word is unchanged.

           Each variable assignment is checked  for  unquoted  tilde-
           prefixes  immediately following a : or =.  In these cases,
           tilde expansion is also performed.  Consequently, one  may
           use  file  names with tildes in assignments to PATH, MAIL
           PATH, and CDPATH,  and  the  shell  assigns  the  expanded
           value.

       Parameter Expansion
           The  `$' character introduces parameter expansion, command
           substitution, or arithmetic expansion.  The parameter name
           or  symbol to be expanded may be enclosed in braces, which
           are optional but serve  to  protect  the  variable  to  be
           expanded  from  characters  immediately following it which
           could be interpreted as part of the name.

           When braces are used, the matching  ending  brace  is  the
           of parameter as the name of the variable; this variable is
           then  expanded  and  that value is used in the rest of the
           substitution, rather than the value of  parameter  itself.
           This  is  known  as  indirect expansion.  The exception to
           this is the expansion of ${!prefix*} described below.

           In each of the cases  below,  word  is  subject  to  tilde
           expansion,  parameter expansion, command substitution, and
           arithmetic  expansion.   When  not  performing   substring
           expansion,  bash  tests  for  a parameter that is unset or
           null; omitting the colon results in  a  test  only  for  a
           parameter that is unset.

           ${parameter:-word}
                  Use Default Values.  If parameter is unset or null,
                  the expansion of word is  substituted.   Otherwise,
                  the value of parameter is substituted.
           ${parameter:=word}
                  Assign  Default  Values.   If parameter is unset or
                  null, the expansion of word is assigned to  parame
                  ter.   The  value of parameter is then substituted.
                  Positional parameters and  special  parameters  may
                  not be assigned to in this way.
           ${parameter:?word}
                  Display  Error  if  Null or Unset.  If parameter is
                  null or unset, the expansion of word (or a  message
                  to  that  effect if word is not present) is written
                  to the standard error and the shell, if it  is  not
                  interactive, exits.  Otherwise, the value of param
                  eter is substituted.
           ${parameter:+word}
                  Use Alternate  Value.   If  parameter  is  null  or
                  unset, nothing is substituted, otherwise the expan
                  sion of word is substituted.
           ${parameter:offset}
           ${parameter:offset:length}
                  Substring Expansion.  Expands to up to length char
                  acters of parameter starting at the character spec
                  ified by offset.  If length is omitted, expands  to
                  the  substring of parameter starting at the charac
                  ter specified by offset.   length  and  offset  are
                  arithmetic  expressions  (see ARITHMETIC EVALUATION
                  below).  length must evaluate to a  number  greater
                  than  or  equal  to zero.  If offset evaluates to a
                  number less than zero, the value is used as an off
                  set  from  the  end  of the value of parameter.  If
                  parameter is @, the  result  is  length  positional
                  parameters beginning at offset.  If parameter is an
                  array name indexed by @ or *,  the  result  is  the
                  length members of the array beginning with ${param
                  eter[offset]}.  Substring  indexing  is  zero-based
                  unless the positional parameters are used, in which

           ${parameter#word}
           ${parameter##word}
                  The  word  is expanded to produce a pattern just as
                  in pathname expansion.  If the pattern matches  the
                  beginning  of  the  value  of  parameter,  then the
                  result of the expansion is the  expanded  value  of
                  parameter  with  the shortest matching pattern (the
                  ``#'' case) or the longest  matching  pattern  (the
                  ``##''  case) deleted.  If parameter is @ or *, the
                  pattern removal operation is applied to each  posi
                  tional  parameter in turn, and the expansion is the
                  resultant list.  If parameter is an array  variable
                  subscripted with @ or *, the pattern removal opera
                  tion is applied to each  member  of  the  array  in
                  turn, and the expansion is the resultant list.

           ${parameter%word}
           ${parameter%%word}
                  The  word  is expanded to produce a pattern just as
                  in pathname expansion.  If the  pattern  matches  a
                  trailing  portion  of the expanded value of parame
                  ter, then  the  result  of  the  expansion  is  the
                  expanded  value  of  parameter  with  the  shortest
                  matching pattern (the ``%'' case)  or  the  longest
                  matching  pattern  (the  ``%%''  case) deleted.  If
                  parameter is @ or *, the pattern removal  operation
                  is  applied  to  each positional parameter in turn,
                  and the expansion is the resultant list.  If param
                  eter  is an array variable subscripted with @ or *,
                  the pattern removal operation is  applied  to  each
                  member  of  the array in turn, and the expansion is
                  the resultant list.

           ${parameter/pattern/string}
           ${parameter//pattern/string}
                  The pattern is expanded to produce a  pattern  just
                  as  in  pathname  expansion.  Parameter is expanded
                  and the longest match of pattern against its  value
                  is  replaced  with string.  In the first form, only
                  the first  match  is  replaced.   The  second  form
                  causes  all  matches of pattern to be replaced with
                  string.  If pattern begins with #, it must match at
                  the  beginning  of the expanded value of parameter.
                  If pattern begins with %, it must match at the  end
                  of  the  expanded value of parameter.  If string is
                  null, matches of pattern are deleted and the / fol
                  lowing  pattern  may be omitted.  If parameter is @
                  or *, the substitution operation is applied to each
                  positional  parameter in turn, and the expansion is
                  the resultant list.  If parameter is an array vari
                  able  subscripted  with  @  or  *, the substitution

           put of the command, with any  trailing  newlines  deleted.
           Embedded newlines are not deleted, but they may be removed
           during word splitting.   The  command  substitution  $(cat
           file)  can  be  replaced  by the equivalent but faster $(<
           file).

           When the old-style backquote form of substitution is used,
           backslash retains its literal meaning except when followed
           by $, `, or \.  The first  backquote  not  preceded  by  a
           backslash terminates the command substitution.  When using
           the $(command) form, all characters between the  parenthe
           ses make up the command; none are treated specially.

           Command  substitutions  may be nested.  To nest when using
           the backquoted form,  escape  the  inner  backquotes  with
           backslashes.

           If  the  substitution  appears  within double quotes, word
           splitting and pathname expansion are not performed on  the
           results.

       Arithmetic Expansion
           Arithmetic  expansion  allows  the evaluation of an arith
           metic expression and the substitution of the result.   The
           format for arithmetic expansion is:

                  $((expression))

           The  expression  is  treated  as  if it were within double
           quotes, but a double quote inside the parentheses  is  not
           treated  specially.   All tokens in the expression undergo
           parameter expansion, string expansion,  command  substitu
           tion,  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
           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 pro
           cess 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.

           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  char
           acter).   Any character in IFS that is not IFS whitespace,
           along with any adjacent IFS whitespace characters,  delim
           its  a  field.  A sequence of IFS whitespace characters is
           also treated as a delimiter.  If the value of IFS is null,
           no word splitting occurs.

           Explicit null arguments ("" or '') are retained.  Unquoted
           implicit null arguments, resulting from the  expansion  of
           parameters that have no values, are removed.  If a parame
           ter with no value is expanded within double quotes, a null
           argument results and is retained.

           Note  that  if  no  expansion occurs, no splitting is per
           formed.

       Pathname Expansion
           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 file names matching the pattern.  If  no  matching
           file  names  are  found,  and the shell option nullglob is
           disabled, the word is left  unchanged.   If  the  nullglob
           option  is  set,  and  no  matches  are found, the word is
           removed.  If the shell option nocaseglob is  enabled,  the
           match  is  performed  without regard to the case of alpha
           betic characters.  When a pattern  is  used  for  pathname
           expansion,  the character ``.''  at the start of a name or
           immediately following a slash must be matched  explicitly,
           unless  the  shell option dotglob is set.  When matching a
           pathname, the  slash  character  must  always  be  matched
           explicitly.   In  other cases, the ``.''  character is not
           treated specially.  See the  description  of  shopt  below
           under  SHELL  BUILTIN  COMMANDS  for  a description of the
           nocaseglob, nullglob, and dotglob shell options.

           The GLOBIGNORE shell variable may be used to restrict  the
           set  of  file  names matching a pattern.  If GLOBIGNORE is
           set, each matching file name that also matches one of  the
           patterns  in  GLOBIGNORE  is  removed  from  the  list  of
           matches.  The file names ``.''   and  ``..''   are  always
           ignored,  even  when  GLOBIGNORE is set.  However, setting
           GLOBIGNORE has the effect of enabling  the  dotglob  shell
           option,  so  all  other  file names beginning with a ``.''
           will match.  To get the  old  behavior  of  ignoring  file
           names beginning with a ``.'', make ``.*''  one of the pat
           terns in GLOBIGNORE.  The dotglob option is disabled  when
           GLOBIGNORE is unset.
           [...]  Matches any one of the enclosed characters.  A pair
                  of characters separated by a hyphen denotes a range
                  expression; any character that sorts between  those
                  two   characters,   inclusive,  using  the  current
                  locale's collating sequence and character  set,  is
                  matched.  If the first character following the [ is
                  a !  or a ^ then  any  character  not  enclosed  is
                  matched.   The sorting order of characters in range
                  expressions is determined by the current locale and
                  the value of the LC_COLLATE shell variable, if set.
                  A - may be matched by including it as the first  or
                  last  character  in the set.  A ] may be matched by
                  including it as the first character in the set.

                  Within [ and ], character classes can be  specified
                  using  the  syntax [:class:], where class is one of
                  the following classes defined in the POSIX.2  stan
                  dard:
                  alnum  alpha  ascii  blank  cntrl digit graph lower
                  print punct space upper word xdigit
                  A character class matches any  character  belonging
                  to  that  class.   The word character class matches
                  letters, digits, and the character _.

                  Within [ and ], an equivalence class can be  speci
                  fied  using  the  syntax  [=c=],  which matches all
                  characters  with  the  same  collation  weight  (as
                  defined  by the current locale) as the character c.

                  Within [ and ], the syntax [.symbol.]  matches  the
                  collating symbol symbol.

           If  the  extglob  shell  option is enabled using the shopt
           builtin, several extended pattern matching  operators  are
           recognized.   In the following description, a pattern-list
           is a list of one or more patterns separated by a |.   Com
           posite  patterns  may  be  formed using one or more of the
           following sub-patterns:

                  ?(pattern-list)
                         Matches zero or one occurrence of the  given
                         patterns
                  *(pattern-list)
                         Matches  zero  or  more  occurrences  of the
                         given patterns
                  +(pattern-list)
                         Matches one or more occurrences of the given
                         patterns
                  @(pattern-list)
                         Matches exactly one of the given patterns
                  !(pattern-list)
                         Matches  anything  except  one  of the given

           Redirections are processed in the order they appear,  from
           left to right.

           In the following descriptions, if the file descriptor num
           ber is omitted, and the first character of the redirection
           operator  is  <,  the  redirection  refers to the standard
           input (file descriptor 0).  If the first character of  the
           redirection  operator  is >, the redirection refers to the
           standard output (file descriptor 1).

           The word following the redirection operator in the follow
           ing  descriptions, unless otherwise noted, is subjected to
           brace expansion,  tilde  expansion,  parameter  expansion,
           command substitution, arithmetic expansion, quote removal,
           pathname expansion, and word splitting.  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.

           Bash  handles  several  filenames  specially when they are
           used in redirections, as described in the following table:

                  /dev/fd/fd
                         If fd is a valid integer, file descriptor fd
                         is duplicated.
                  /dev/stdin
                         File descriptor 0 is duplicated.
                  /dev/stdout
                         File descriptor 1 is duplicated.
                  /dev/stderr
                         File descriptor 2 is duplicated.
                  /dev/tcp/host/port
                         If host is  a  valid  hostname  or  Internet
                         address,  and port is an integer port number
                         or service name, bash attempts to open a TCP
                         connection to the corresponding socket.
                  /dev/udp/host/port
                         If  host  is  a  valid  hostname or Internet
                         address, and port is an integer port  number
                         or service name, bash attempts to open a UDP

       Redirecting Output
           Redirection of output causes the file whose  name  results
           from  the  expansion  of  word to be opened for writing on
           file descriptor n, or the standard output (file descriptor
           1)  if  n is not specified.  If the file does not exist it
           is created; if it does exist it is truncated to zero size.

           The general format for redirecting output is:

                  [n]>word

           If the redirection operator is >, and the noclobber option
           to the set builtin has been enabled, the redirection  will
           fail  if the file whose name results from the expansion of
           word exists and is a regular  file.   If  the  redirection
           operator  is  >|, or the redirection operator is > and the
           noclobber  option  to  the  set  builtin  command  is  not
           enabled,  the  redirection  is  attempted even if the file
           named by word exists.

       Appending Redirected Output
           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

       Redirecting Standard Output and Standard Error
           Bash allows both the standard output (file  descriptor  1)
           and  the  standard  error output (file descriptor 2) to be
           redirected to the file whose name is the expansion of word
           with this construct.

           There  are two formats for redirecting standard output and
           standard error:

                  &>word
           and
                  >&word

           Of the two forms, the first is preferred.  This is  seman
           tically equivalent to

                  >word 2>&1

       Here Documents
           any  characters  in  word are quoted, the delimiter is the
           result of quote removal on word,  and  the  lines  in  the
           here-document  are not expanded.  If word is unquoted, all
           lines of the  here-document  are  subjected  to  parameter
           expansion, command substitution, and arithmetic expansion.
           In the latter case, the character sequence  \<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 con
           taining  delimiter.   This  allows  here-documents  within
           shell scripts to be indented in a natural fashion.

       Here Strings
           A variant of here documents, the format is:

                  <<<word

           The  word  is  expanded and supplied to the command on its
           standard input.

       Duplicating File Descriptors
           The redirection operator

                  [n]<&word

           is used to duplicate  input  file  descriptors.   If  word
           expands to one or more digits, the file descriptor denoted
           by n is made to be a copy of that file descriptor.  If the
           digits  in  word do not specify a file descriptor open for
           input, a redirection error occurs.  If word  evaluates  to
           -,  file  descriptor  n is closed.  If n is not specified,
           the standard input (file descriptor 0) is used.

           The operator

                  [n]>&word

           is used similarly to duplicate  output  file  descriptors.
           If  n is not specified, the standard output (file descrip
           tor 1) is used.  If the digits in word do  not  specify  a
           file  descriptor  open  for  output,  a  redirection error
           occurs.  As a special case, if n is omitted, and word does
           not  expand to one or more digits, the standard output and
           standard error are redirected as described previously.

       Moving File Descriptors
           The redirection operator

                  [n]<&digit-

                  [n]<>word

           causes the file whose name is the expansion of word to  be
           opened  for both reading and writing on file descriptor n,
           or on file descriptor 0 if n is  not  specified.   If  the
           file does not exist, it is created.

## ALIASES

           Aliases  allow  a string to be substituted for a word when
           it is used as the first word of  a  simple  command.   The
           shell  maintains  a  list  of  aliases that may be set and
           unset with the alias and  unalias  builtin  commands  (see
           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  con
           tain  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 replace
           ment text.  If arguments  are  needed,  a  shell  function
           should be used (see FUNCTIONS below).

           Aliases  are  not  expanded when the shell is not interac
           tive, unless the expand_aliases shell option is set  using
           shopt  (see  the  description of shopt under SHELL BUILTIN
           COMMANDS below).

           The rules concerning the definition and use of aliases are
           somewhat  confusing.   Bash always reads at least one com
           plete 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  defi
           nition  appearing on the same line as another command does
           not take effect until the next line of input is read.  The
           commands  following  the alias definition on that line are
           not affected by the new alias.  This behavior is  also  an
           issue  when  functions are executed.  Aliases are expanded
           when a function definition is read, not when the  function
           is  executed,  because  a  function definition is itself a
           text 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.
           The FUNCNAME variable is set to the name of  the  function
           while the function is executing.  All other aspects of the
           shell execution environment are identical between a  func
           tion and its caller with the exception that the DEBUG trap
           (see the description  of  the  trap  builtin  under  SHELL
           BUILTIN  COMMANDS below) is not inherited unless the func
           tion has been given the trace attribute (see the  descrip
           tion of the declare builtin below).

           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 com
           pletes, the values of the positional  parameters  and  the
           special  parameter  #  are restored to the values they had
           prior to the function's execution.

           Function names and definitions may be listed with  the  -f
           option to the declare or typeset builtin commands.  The -F
           option to declare or typeset will list the function  names
           only.   Functions  may be exported so that subshells auto
           matically 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.

## ARITHMETIC EVALUATION

           The shell allows arithmetic expressions to  be  evaluated,
           under  certain  circumstances (see the let builtin command
           and Arithmetic Expansion).  Evaluation is done  in  fixed-
           width integers with no check for overflow, though division
           by 0 is trapped and flagged as an  error.   The  operators
           and  their precedence and associativity are the same as in
           the C  language.   The  following  list  of  operators  is
           grouped  into  levels  of equal-precedence operators.  The
           levels are listed in order of decreasing precedence.

           id++ id--
                  variable post-increment and post-decrement
           ++id --id
                  variable pre-increment and pre-decrement
           - +    unary minus and plus
                  conditional evaluation
           = *= /= %= += -= <<= >>= &= ^= |=
                  assignment
           expr1 , expr2
                  comma

           Shell variables are allowed as operands; parameter  expan
           sion  is  performed  before  the  expression is evaluated.
           Within an expression, shell variables may also  be  refer
           enced  by  name without using the parameter expansion syn
           tax.  The value of a variable is evaluated  as  an  arith
           metic  expression when it is referenced.  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 num
           bers.  A leading 0x or 0X denotes hexadecimal.  Otherwise,
           numbers  take  the  form [base#]n, where base is a decimal
           number between 2 and 64 representing the arithmetic  base,
           and n is a number in that base.  If base# is omitted, then
           base 10 is used.  The digits greater  than  9  are  repre
           sented by the lowercase letters, the uppercase letters, @,
           and _, in that order.  If base is less than  or  equal  to
           36,  lowercase  and  uppercase  letters may be used inter
           changably to represent numbers between 10 and 35.

           Operators are evaluated  in  order  of  precedence.   Sub-
           expressions  in  parentheses  are  evaluated first and may
           override the precedence rules above.

## CONDITIONAL EXPRESSIONS

           Conditional expressions are used by the [[  compound  com
           mand  and  the  test  and  [ builtin commands to test file
           attributes and perform string and arithmetic  comparisons.
           Expressions  are formed from the following unary or binary
           primaries.  If any file argument to one of  the  primaries
           is  of  the  form  /dev/fd/n,  then  file  descriptor n is
           checked.  If the file argument to one of the primaries  is
           one  of  /dev/stdin,  /dev/stdout,  or  /dev/stderr,  file
           descriptor 0, 1, or 2, respectively, is checked.

           -a file
                  True if file exists.
           -b file
                  True if file exists and is a block special file.
           -c file
                  True if file exists  and  is  a  character  special
                  file.
           -d file
                  True if file exists and is a directory.
           -e file
                  True if file exists.
                  zero.
           -t fd  True  if file descriptor fd is open and refers to a
                  terminal.
           -u file
                  True if file exists and its set-user-id bit is set.
           -w file
                  True if file exists and is writable.
           -x file
                  True if file exists and is executable.
           -O file
                  True  if  file exists and is owned by the effective
                  user id.
           -G file
                  True if file exists and is owned by  the  effective
                  group id.
           -L file
                  True if file exists and is a symbolic link.
           -S file
                  True if file exists and is a socket.
           -N file
                  True  if file exists and has been modified since it
                  was last read.
           file1 -nt file2
                  True if file1 is newer (according  to  modification
                  date) than file2, or if file1 exists and file2 does
                  not.
           file1 -ot file2
                  True if file1 is older  than  file2,  or  if  file2
                  exists and file1 does not.
           file1 -ef file2
                  True  if  file1  and file2 refer to the same device
                  and inode numbers.
           -o optname
                  True if shell option optname is enabled.   See  the
                  list  of  options  under  the description of the -o
                  option to the set builtin below.
           -z string
                  True if the length of string is zero.
           -n string
           string True if the length of string is non-zero.
           string1 == string2
                  True if the strings are equal.  = may  be  used  in
                  place of == for strict POSIX compliance.
           string1 != string2
                  True if the strings are not equal.
           string1 < string2
                  True  if string1 sorts before string2 lexicographi
                  cally in the current locale.
           string1 > string2
                  True if string1 sorts after  string2  lexicographi
                  cally in the current locale.
           arg1 OP arg2
                  redirections are saved for later processing.

           2.     The words that  are  not  variable  assignments  or
                  redirections  are  expanded.   If  any words remain
                  after expansion, the first word is taken to be  the
                  name of the command and the remaining words are the
                  arguments.

           3.     Redirections are performed as described above under
                  REDIRECTION.

           4.     The  text  after  the = in each variable assignment
                  undergoes  tilde  expansion,  parameter  expansion,
                  command  substitution,  arithmetic  expansion,  and
                  quote removal before being assigned  to  the  vari
                  able.

           If  no  command  name  results,  the  variable assignments
           affect the  current  shell  environment.   Otherwise,  the
           variables  are  added  to  the environment of the executed
           command and do not affect the current  shell  environment.
           If  any of the assignments attempts to assign a value to a
           readonly variable, an error occurs, and the command  exits
           with a non-zero status.

           If  no  command  name results, redirections are performed,
           but do not affect the current shell environment.  A  redi
           rection  error  causes the command to exit with a non-zero
           status.

           If there is a command name left after expansion, execution
           proceeds  as  described  below.   Otherwise,  the  command
           exits.  If one of the expansions contained a command  sub
           stitution, the exit status of the command is the exit sta
           tus of the last command substitution performed.  If  there
           were  no  command  substitutions, the command exits with a
           status of zero.

## COMMAND EXECUTION

           After a command has been split into words, if  it  results
           in a simple command and an optional list of arguments, the
           following actions are taken.

           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
           If  this  execution  fails because the file is not in exe
           cutable format, and the file is not  a  directory,  it  is
           assumed to be a shell script, a file containing shell com
           mands.  A subshell is spawned to execute  it.   This  sub
           shell  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  pro
           gram.   The  shell  executes  the specified interpreter on
           operating systems that do not handle this executable  for
           mat  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.

## COMMAND EXECUTION ENVIRONMENT

           The  shell has an execution environment, which consists of
           the following:

           ·      open files inherited by the shell at invocation, as
                  modified  by  redirections  supplied  to  the  exec
                  builtin

           ·      the current working directory as set by cd,  pushd,
                  or popd, or inherited by the shell at invocation

           ·      the  file  creation  mode  mask  as set by umask or
                  inherited from the shell's parent

           ·      current traps set by trap

           ·      shell parameters that are set by  variable  assign
                  ment or with set or inherited from the shell's par
                  ent in the environment

           ·      shell functions defined during execution or  inher
                  ited from the shell's parent in the environment

           ·      options enabled at invocation (either by default or
                  with command-line arguments) or by set

           ·      options enabled by shopt

           ·      shell aliases defined with alias

           ·      various process IDs, including those of  background

           ·      shell variables marked for export, along with vari
                  ables exported for the command, passed in the envi
                  ronment

           ·      traps caught by the shell are reset to  the  values
                  the  inherited  from  the shell's parent, and traps
                  ignored by the shell are ignored

           A command invoked  in  this  separate  environment  cannot
           affect the shell's execution environment.

           Command substitution and asynchronous commands are invoked
           in a subshell environment that is a duplicate of the shell
           environment,  except  that  traps  caught by the shell are
           reset to the values that the shell inherited from its par
           ent  at  invocation.  Builtin commands that are invoked as
           part of a pipeline are also executed in a  subshell  envi
           ronment.   Changes made to the subshell environment cannot
           affect the shell's execution environment.

           If a command is followed by a & and  job  control  is  not
           active,  the default standard input for the command is the
           empty file  /dev/null.   Otherwise,  the  invoked  command
           inherits the file descriptors of the calling shell as mod
           ified by redirections.

## ENVIRONMENT

           When a program is invoked it is given an array of  strings
           called  the  environment.   This  is  a list of name-value
           pairs, of the form name=value.

           The shell provides several ways to manipulate the environ
           ment.   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 com
           mands 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.

           uses the value of 128+N as the exit status.

           If  a  command  is not found, the child process created to
           execute it returns a status of 127.  If a command is found
           but is not executable, the return status is 126.

           If a command fails because of an error during expansion or
           redirection, the exit status is greater than zero.

           Shell builtin commands return a status of 0 (true) if suc
           cessful,  and  non-zero  (false)  if an error occurs while
           they execute.  All builtins return an exit status of 2  to
           indicate incorrect usage.

           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.

## SIGNALS

           When bash is interactive, in the absence of any traps,  it
           ignores  SIGTERM (so that kill 0 does not kill an interac
           tive 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 signal handlers set
           to the values inherited by  the  shell  from  its  parent.
           When  job  control is not in effect, asynchronous commands
           ignore SIGINT and SIGQUIT as  well.   Commands  run  as  a
           result  of command substitution ignore the keyboard-gener
           ated job control signals SIGTTIN, SIGTTOU, and SIGTSTP.

           The shell exits by  default  upon  receipt  of  a  SIGHUP.
           Before exiting, an interactive shell resends the SIGHUP to
           all jobs, running or stopped.  Stopped jobs are sent  SIG
           CONT  to  ensure that they receive the SIGHUP.  To prevent
           the shell from sending the signal to a particular job,  it
           should  be  removed  from  the  jobs table with the disown
           builtin (see SHELL BUILTIN COMMANDS below)  or  marked  to
           not receive SIGHUP using disown -h.

           If  the  huponexit  shell  option has been set with shopt,
           bash sends a SIGHUP to all jobs when an interactive  login
           shell exits.

           When  bash receives a signal for which a trap has been set
           while waiting for a command to complete, the trap will not
           be  executed  until  the  command completes.  When bash is
           waiting for an asynchronous command via the wait  builtin,
           the  reception  of  a signal for which a trap has been set
           chronously  (in  the  background),  it  prints a line that
           looks like:

                  [1] 25647

           indicating that this job is job number 1 and that the pro
           cess  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 operating system maintains the notion of
           a current terminal process group ID.  Members of this pro
           cess  group  (processes whose process group ID is equal to
           the current terminal process group ID)  receive  keyboard-
           generated  signals  such  as  SIGINT.  These processes are
           said to be in the foreground.   Background  processes  are
           those  whose process group ID differs from the terminal's;
           such processes are immune to  keyboard-generated  signals.
           Only  foreground  processes  are  allowed  to read from or
           write to the terminal.  Background processes which attempt
           to  read  from  (write to) the terminal are sent a SIGTTIN
           (SIGTTOU) signal by the  terminal  driver,  which,  unless
           caught, suspends the process.

           If  the operating system on which bash is running supports
           job control, bash contains facilities to use  it.   Typing
           the  suspend  character  (typically ^Z, Control-Z) while a
           process is running causes that process to be  stopped  and
           returns control to bash.  Typing the delayed suspend char
           acter (typically ^Y, Control-Y) causes the process  to  be
           stopped  when it attempts to read input from the terminal,
           and control to be returned to bash.   The  user  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 dis
           carded.

           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 sub
           string 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
           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  enabled,  bash  reports such changes
           immediately.  Any trap on SIGCHLD  is  executed  for  each
           child that exits.

           If an attempt to exit bash is made while jobs are stopped,
           the shell prints a warning message.  The jobs command  may
           then be used to inspect their status.  If a second attempt
           to exit is made without an intervening command, the  shell
           does  not  print another warning, and the stopped jobs are
           terminated.

## PROMPTING

           When executing interactively, bash  displays  the  primary
           prompt  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 cus
           tomized by inserting a number of backslash-escaped special
           characters that are decoded as follows:
                  \a     an ASCII bell character (07)
                  \d     the  date  in  "Weekday  Month  Date" format
                         (e.g., "Tue May 26")
                  \D{format}
                         the format is passed to strftime(3) and  the
                         result  is  inserted into the prompt string;
                         an empty format results in a locale-specific
                         time   representation.    The   braces   are
                         required
                  \e     an ASCII escape character (033)
                  \h     the hostname up to the first `.'
                  \H     the hostname
                  \j     the number of jobs currently managed by  the
                         shell
                  \l     the  basename of the shell's terminal device
                         name
                  \n     newline
                  \r     carriage return
                  \s     the name of the shell, the  basename  of  $0
                         (the portion following the final slash)
                  \t     the current time in 24-hour HH:MM:SS format
                  \T     the current time in 12-hour HH:MM:SS format
                  \@     the current time in 12-hour am/pm format
                  \A     the current time in 24-hour HH:MM format
                  \u     the username of the current user
                  \v     the version of bash (e.g., 2.00)
                  \V     the  release  of  bash, version + patchelvel
                         (e.g., 2.00.0)
                  \w     the current working directory
                  \W     the basename of the current  working  direc
                         tory
                  \!     the history number of this command

           the history file (see HISTORY below),  while  the  command
           number  is  the  position in the sequence of commands exe
           cuted during the current shell session.  After the  string
           is  decoded,  it is expanded via parameter expansion, com
           mand  substitution,  arithmetic   expansion,   and   quote
           removal,  subject  to  the  value  of the promptvars shell
           option (see the description of  the  shopt  command  under
           SHELL BUILTIN COMMANDS below).

## READLINE

           This  is the library that handles reading input when using
           an interactive shell, unless  the  --noediting  option  is
           given  at  shell invocation.  By default, the line editing
           commands are similar to those of emacs.  A  vi-style  line
           editing  interface  is  also  available.  To turn off line
           editing after the shell is running, use the +o emacs or +o
           vi  options to the set builtin (see SHELL BUILTIN COMMANDS
           below).

       Readline Notation
           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 pre
           fix.  The combination M-C-x means ESC-Control-x, or  press
           the  Escape  key  then hold the Control key while pressing
           the x key.)

           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 argu
           ments deviates from this are noted below.

           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.

       Readline Initialization
           Readline  is customized by putting commands in an initial
           ization file (the inputrc file).  The name of this file is
           taken  from the value of the INPUTRC environment variable.
           If  that  variable  is  unset,  readline  will  read  both
           /etc/inputrc  and  ~/.inputrc.   When a program which uses
           the readline library starts up, the initialization file is
           or
                  C-Meta-u: universal-argument
           into the 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 Key Bindings
           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,  key
           name  is  the  name  of a key spelled out in English.  For
           example:

                  Control-u: universal-argument
                  Meta-Rubout: backward-kill-word
                  Control-o: "> output"

           In the above example, C-u is bound to the function univer
           sal-argument,   M-DEL  is  bound  to  the  function  back
           ward-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,  key
           seq 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, but  the
           symbolic character names are not recognized.

                  "\C-u": universal-argument
                  "\C-x\C-r": re-read-init-file
                  "\e[11~": "Function Key 1"

           In  this  example, C-u is again bound to the function uni
           versal-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 GNU Emacs style escape sequences is
                  \r     carriage return
                  \t     horizontal tab
                  \v     vertical tab
                  \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)

           When entering the text of a macro, single or double quotes
           must  be  used  to  indicate a macro definition.  Unquoted
           text is assumed to be a function name.  In the macro body,
           the backslash escapes described above are expanded.  Back
           slash will quote any other character in  the  macro  text,
           including " and '.

           Bash  allows  the current readline key bindings to be dis
           played 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 Variables
           Readline  has  variables  that can be used to further cus
           tomize 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:

           bell-style (audible)
                  Controls what happens when readline wants  to  ring
                  the  terminal bell.  If set to none, readline never
                  rings the bell.  If set to visible, readline uses a
                  visible  bell if one is available.  If set to audi
                  ble, readline attempts to ring the terminal's bell.
           comment-begin (``#'')
                  The  string  that  is  inserted  when  the readline
                  insert-comment command is executed.   This  command
                  is  bound  to M-# in emacs mode and to # in vi com
                  mand mode.
           completion-ignore-case (Off)
                  If set to On, readline performs  filename  matching
                  and completion in a case-insensitive fashion.
           completion-query-items (100)
                  This  determines  when  the  user  is queried about
                  viewing the number of possible  completions  gener
                  ated  by  the possible-completions command.  It may
                  be set to any integer value greater than  or  equal
                  to  zero.  If the number of possible completions is
                  greater than or equal to the value  of  this  vari
                  Controls whether readline begins with a set of  key
                  bindings  similar to emacs or vi.  editing-mode can
                  be set to either emacs or vi.
           enable-keypad (Off)
                  When set to On, readline will  try  to  enable  the
                  application keypad when it is called.  Some systems
                  need this to enable the arrow keys.
           expand-tilde (Off)
                  If set to on, tilde  expansion  is  performed  when
                  readline attempts word completion.
           history-preserve-point
                  If  set  to  on, the history code attempts to place
                  point at the same location  on  each  history  line
                  retrived with previous-history or next-history.
           horizontal-scroll-mode (Off)
                  When  set  to  On, makes readline use a single line
                  for display, scrolling the input horizontally on  a
                  single  screen line when it becomes longer than the
                  screen width rather than wrapping to a new line.
           input-meta (Off)
                  If set to On, readline will enable eight-bit  input
                  (that  is,  it will not strip the high bit from the
                  characters it reads), regardless of what the termi
                  nal claims it can support.  The name meta-flag is a
                  synonym for this variable.
           isearch-terminators (``C-[C-J'')
                  The string of characters that should  terminate  an
                  incremental  search  without subsequently executing
                  the character as a command.  If this  variable  has
                  not  been given a value, the characters ESC and C-J
                  will terminate an incremental search.
           keymap (emacs)
                  Set the current readline keymap.  The set of  valid
                  keymap  names is emacs, emacs-standard, emacs-meta,
                  emacs-ctlx, vi, vi-command, and vi-insert.   vi  is
                  equivalent  to  vi-command;  emacs is equivalent to
                  emacs-standard.  The default value  is  emacs;  the
                  value  of  editing-mode  also  affects  the default
                  keymap.
           mark-directories (On)
                  If set to On,  completed  directory  names  have  a
                  slash appended.
           mark-modified-lines (Off)
                  If set to On, history lines that have been modified
                  are displayed with a preceding asterisk (*).
           mark-symlinked-directories (Off)
                  If set to On, completed names  which  are  symbolic
                  links to directories have a slash appended (subject
                  to the value of mark-directories).
           match-hidden-files (On)
                  This variable, when set to On, causes  readline  to
                  match  files  whose  names begin with a `.' (hidden
                  order, rather than down the screen.
           show-all-if-ambiguous (Off)
                  This alters the default behavior of the  completion
                  functions.   If  set  to  on, words which have more
                  than one possible completion cause the  matches  to
                  be  listed immediately instead of ringing the bell.
           visible-stats (Off)
                  If set to On, a character denoting a file's type as
                  reported  by  stat(2)  is  appended to the filename
                  when listing possible completions.

       Readline Conditional Constructs
           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 per
           formed  as  the  result  of  tests.  There are four parser
           directives used.

           $if    The $if construct allows bindings to be made  based
                  on  the  editing  mode, the terminal being used, or
                  the application using readline.  The  text  of  the
                  test  extends to the end of the line; no characters
                  are required to isolate it.

                  mode   The mode= form of the $if directive is  used
                         to  test  whether readline is in emacs or vi
                         mode.  This may be used in conjunction  with
                         the set keymap command, for instance, to set
                         bindings   in   the    emacs-standard    and
                         emacs-ctlx   keymaps  only  if  readline  is
                         starting out in emacs mode.

                  term   The term= form may be used to include termi
                         nal-specific  key  bindings, perhaps to bind
                         the key sequences output by  the  terminal's
                         function  keys.   The word on the right side
                         of the = is tested  against  the  both  full
                         name  of the terminal and the portion of the
                         terminal name  before  the  first  -.   This
                         allows  sun  to  match both sun and sun-cmd,
                         for instance.

                  application
                         The application construct is used to include
                         application-specific settings.  Each program
                         using the readline library sets the applica
                         tion  name,  and  an initialization file can
                         test for a particular value.  This could  be
                         used to bind key sequences to functions use
                         ful for a specific program.   For  instance,
                         the  following  command  adds a key sequence
                         that quotes the current or previous word  in

                  This  directive takes a single filename as an argu
                  ment and reads  commands  and  bindings  from  that
                  file.   For  example, the following directive would
                  read /etc/inputrc:

                  $include  /etc/inputrc

       Searching
           Readline provides commands for searching through the  com
           mand  history  (see  HISTORY below) for lines containing a
           specified string.  There are two search modes: incremental
           and non-incremental.

           Incremental  searches  begin  before the user has finished
           typing the search string.  As each character of the search
           string is typed, readline displays the next entry from the
           history matching the string typed so far.  An  incremental
           search  requires only as many characters as needed to find
           the desired history entry.  The characters present in  the
           value of the isearch-terminators variable are used to ter
           minate an incremental search.  If that  variable  has  not
           been  assigned a value the Escape and Control-J characters
           will terminate  an  incremental  search.   Control-G  will
           abort an incremental search and restore the original line.
           When the search is terminated, the history entry  contain
           ing the search string becomes the current line.

           To  find  other matching entries in the history list, type
           Control-S or Control-R as appropriate.  This  will  search
           backward  or  forward  in  the  history for the next entry
           matching the search string typed so far.   Any  other  key
           sequence  bound  to  a readline command will terminate the
           search and execute that command.  For instance, a  newline
           will  terminate  the  search  and accept the line, thereby
           executing the command from the history list.

           Readline remembers the last incremental search string.  If
           two  Control-Rs  are typed without any intervening charac
           ters defining a new search string, any  remembered  search
           string is used.

           Non-incremental  searches  read  the  entire search string
           before starting to search for matching history lines.  The
           search  string  may be typed by the user or be part of the
           contents of the current line.

       Readline Command Names
           The following is a list of the names of the  commands  and
           the  default  key sequences to which they are bound.  Com
           mand  names  without  an  accompanying  key  sequence  are
           unbound  by default.  In the following descriptions, point
           refers to the current cursor position, and mark refers  to
                  are  composed  of  alphanumeric characters (letters
                  and digits).
           backward-word (M-b)
                  Move back to the start of the current  or  previous
                  word.   Words  are composed of alphanumeric charac
                  ters (letters and digits).
           clear-screen (C-l)
                  Clear the screen leaving the current  line  at  the
                  top  of  the screen.  With an argument, refresh the
                  current line without clearing the screen.
           redraw-current-line
                  Refresh the current line.

       Commands for Manipulating the History
           accept-line (Newline, Return)
                  Accept the line regardless of where the cursor  is.
                  If  this  line  is non-empty, add it to the history
                  list according to  the  state  of  the  HISTCONTROL
                  variable.   If the line is a modified history line,
                  then restore  the  history  line  to  its  original
                  state.
           previous-history (C-p)
                  Fetch  the  previous command from the history list,
                  moving back in the list.
           next-history (C-n)
                  Fetch the next command from the history list,  mov
                  ing forward in the list.
           beginning-of-history (M-<)
                  Move to the first line in the history.
           end-of-history (M->)
                  Move  to  the  end  of the input history, i.e., the
                  line currently being entered.
           reverse-search-history (C-r)
                  Search backward starting at the  current  line  and
                  moving `up' through the history as necessary.  This
                  is an incremental search.
           forward-search-history (C-s)
                  Search forward starting at  the  current  line  and
                  moving  `down'  through  the  history as necessary.
                  This is an incremental search.
           non-incremental-reverse-search-history (M-p)
                  Search backward through the history starting at the
                  current  line  using a non-incremental search for a
                  string supplied by the user.
           non-incremental-forward-search-history (M-n)
                  Search forward through the  history  using  a  non-
                  incremental  search  for  a  string supplied by the
                  user.
           history-search-forward
                  Search forward through the history for  the  string
                  of characters between the start of the current line
                  and the point.  This is a non-incremental search.
                  (the  last  word  of  the  previous history entry).
                  With an argument, behave exactly like yank-nth-arg.
                  Successive calls to yank-last-arg move back through
                  the history list, inserting the  last  argument  of
                  each line in turn.
           shell-expand-line (M-C-e)
                  Expand  the  line as the shell does.  This performs
                  alias and history expansion as well as all  of  the
                  shell word expansions.  See HISTORY EXPANSION below
                  for a description of history expansion.
           history-expand-line (M-^)
                  Perform history expansion on the current line.  See
                  HISTORY  EXPANSION  below for a description of his
                  tory expansion.
           magic-space
                  Perform history expansion on the current  line  and
                  insert  a space.  See HISTORY EXPANSION below for a
                  description of history expansion.
           alias-expand-line
                  Perform alias expansion on the current  line.   See
                  ALIASES above for a description of alias expansion.
           history-and-alias-expand-line
                  Perform history and alias expansion on the  current
                  line.
           insert-last-argument (M-., M-_)
                  A synonym for yank-last-arg.
           operate-and-get-next (C-o)
                  Accept the current line for execution and fetch the
                  next line relative to the  current  line  from  the
                  history for editing.  Any argument is ignored.
           edit-and-execute-command (C-xC-e)
                  Invoke  an  editor on the current command line, and
                  execute  the  result  as  shell   commands.    Bash
                  attempts  to  invoke $FCEDIT, $EDITOR, and emacs as
                  the editor, in that order.

       Commands for Changing Text
           delete-char (C-d)
                  Delete the character at point.  If point is at  the
                  beginning  of  the line, there are no characters in
                  the line, and the  last  character  typed  was  not
                  bound to delete-char, then return EOF.
           backward-delete-char (Rubout)
                  Delete the character behind the cursor.  When given
                  a numeric argument, save the deleted  text  on  the
                  kill ring.
           forward-backward-delete-char
                  Delete  the  character under the cursor, unless the
                  cursor is at the end of the line, in which case the
                  character behind the cursor is deleted.
           quoted-insert (C-q, C-v)
                  Add  the next character typed to the line verbatim.
                  point, moving point over that  word  as  well.   If
                  point  is  at  the end of the line, this transposes
                  the last two words on the line.
           upcase-word (M-u)
                  Uppercase the current (or following) word.  With  a
                  negative argument, uppercase the previous word, but
                  do not move point.
           downcase-word (M-l)
                  Lowercase the current (or following) word.  With  a
                  negative argument, lowercase the previous word, but
                  do not move point.
           capitalize-word (M-c)
                  Capitalize the current (or following) word.  With a
                  negative  argument,  capitalize  the previous word,
                  but do not move point.
           overwrite-mode
                  Toggle overwrite mode.  With an  explicit  positive
                  numeric argument, switches to overwrite mode.  With
                  an explicit non-positive numeric argument, switches
                  to  insert  mode.   This command affects only emacs
                  mode; vi mode  does  overwrite  differently.   Each
                  call to readline() starts in insert mode.  In over
                  write mode, characters bound to self-insert replace
                  the  text  at point rather than pushing the text to
                  the   right.     Characters    bound    to    back
                  ward-delete-char replace the character before point
                  with a space.  By default, this command is unbound.

       Killing and Yanking
           kill-line (C-k)
                  Kill the text from point to the end of the line.
           backward-kill-line (C-x Rubout)
                  Kill backward to the beginning of the line.
           unix-line-discard (C-u)
                  Kill  backward  from  point to the beginning of the
                  line.  The killed text is saved on the kill-ring.
           kill-whole-line
                  Kill all characters on the current line, no  matter
                  where point is.
           kill-word (M-d)
                  Kill  from point to the end of the current word, or
                  if between words, to the  end  of  the  next  word.
                  Word  boundaries are the same as those used by for
                  ward-word.
           backward-kill-word (M-Rubout)
                  Kill the word behind point.   Word  boundaries  are
                  the same as those used by backward-word.
           unix-word-rubout (C-w)
                  Kill  the word behind point, using white space as a
                  word boundary.  The killed text  is  saved  on  the
                  kill-ring.
           delete-horizontal-space (M-\)
           yank-pop (M-y)
                  Rotate the kill ring, and yank the new  top.   Only
                  works following yank or yank-pop.

       Numeric Arguments
           digit-argument (M-0, M-1, ..., M--)
                  Add  this  digit to the argument already accumulat
                  ing, or start a new argument.  M-- starts  a  nega
                  tive argument.
           universal-argument
                  This  is  another  way  to specify an argument.  If
                  this command is followed by  one  or  more  digits,
                  optionally  with a leading minus sign, those digits
                  define the argument.  If the command is followed by
                  digits, executing universal-argument again ends the
                  numeric argument, but is otherwise ignored.   As  a
                  special  case,  if this command is immediately fol
                  lowed by a character that is  neither  a  digit  or
                  minus sign, the argument count for the next command
                  is multiplied by four.  The argument count is  ini
                  tially  one,  so  executing this function the first
                  time makes the argument count four, a  second  time
                  makes the argument count sixteen, and so on.

       Completing
           complete (TAB)
                  Attempt  to  perform  completion on the text before
                  point.  Bash attempts completion treating the  text
                  as a variable (if the text begins with $), username
                  (if the text begins with ~), hostname (if the  text
                  begins  with  @), or command (including aliases and
                  functions) in turn.  If none of  these  produces  a
                  match, filename completion is attempted.
           possible-completions (M-?)
                  List  the  possible  completions of the text before
                  point.
           insert-completions (M-*)
                  Insert all completions of  the  text  before  point
                  that  would have been generated by possible-comple
                  tions.
           menu-complete
                  Similar to complete, but replaces the  word  to  be
                  completed with a single match from the list of pos
                  sible completions.  Repeated execution of menu-com
                  plete  steps  through  the list of possible comple
                  tions, inserting each match in turn.  At the end of
                  the  list of completions, the bell is rung (subject
                  to the setting of bell-style) and the original text
                  is  restored.   An  argument of n moves n positions
                  forward in the list of matches; a negative argument
                  may  be  used  to  move  backward through the list.
                  This command is intended to be bound to TAB, but is
                  Attempt completion on the text before point, treat
                  ing it as a username.
           possible-username-completions (C-x ~)
                  List the possible completions of  the  text  before
                  point, treating it as a username.
           complete-variable (M-$)
                  Attempt completion on the text before point, treat
                  ing it as a shell variable.
           possible-variable-completions (C-x $)
                  List the possible completions of  the  text  before
                  point, treating it as a shell variable.
           complete-hostname (M-@)
                  Attempt completion on the text before point, treat
                  ing it as a hostname.
           possible-hostname-completions (C-x @)
                  List the possible completions of  the  text  before
                  point, treating it as a hostname.
           complete-command (M-!)
                  Attempt completion on the text before point, treat
                  ing it  as  a  command  name.   Command  completion
                  attempts   to   match  the  text  against  aliases,
                  reserved words, shell  functions,  shell  builtins,
                  and finally executable filenames, in that order.
           possible-command-completions (C-x !)
                  List  the  possible  completions of the text before
                  point, treating it as a command name.
           dynamic-complete-history (M-TAB)
                  Attempt completion on the text before  point,  com
                  paring the text against lines from the history list
                  for possible completion matches.
           complete-into-braces (M-{)
                  Perform filename completion and insert the list  of
                  possible  completions enclosed within braces so the
                  list is available to the shell (see Brace Expansion
                  above).

       Keyboard Macros
           start-kbd-macro (C-x ()
                  Begin  saving the characters typed into the current
                  keyboard macro.
           end-kbd-macro (C-x ))
                  Stop saving the characters typed into  the  current
                  keyboard macro and store the definition.
           call-last-kbd-macro (C-x e)
                  Re-execute the last keyboard macro defined, by mak
                  ing the characters in the macro appear as if  typed
                  at the keyboard.

       Miscellaneous
           re-read-init-file (C-x C-r)
                  Read  in  the  contents  of  the  inputrc file, and
                  incorporate any bindings  or  variable  assignments
                  line.
           revert-line (M-r)
                  Undo  all  changes made to this line.  This is like
                  executing the undo command enough times  to  return
                  the line to its initial state.
           tilde-expand (M-&)
                  Perform tilde expansion on the current word.
           set-mark (C-@, M-<space>)
                  Set  the  mark to the point.  If a numeric argument
                  is supplied, the mark is set to that position.
           exchange-point-and-mark (C-x C-x)
                  Swap the point with the mark.  The  current  cursor
                  position  is set to the saved position, and the old
                  cursor position is saved as the mark.
           character-search (C-])
                  A character is read and point is moved to the  next
                  occurrence  of  that  character.   A negative count
                  searches for previous occurrences.
           character-search-backward (M-C-])
                  A character is read and point is moved to the  pre
                  vious  occurrence  of  that  character.  A negative
                  count searches for subsequent occurrences.
           insert-comment (M-#)
                  Without a numeric argument, the value of the  read
                  line  comment-begin  variable  is  inserted  at the
                  beginning of the current line.  If a numeric  argu
                  ment  is  supplied,  this command acts as a toggle:
                  if the characters at the beginning of the  line  do
                  not  match the value of comment-begin, the value is
                  inserted, otherwise the characters in comment-begin
                  are  deleted  from  the  beginning of the line.  In
                  either case, the line is accepted as if  a  newline
                  had been typed.  The default value of comment-begin
                  causes this command to  make  the  current  line  a
                  shell  comment.   If  a numeric argument causes the
                  comment character to be removed, the line  will  be
                  executed by the shell.
           glob-complete-word (M-g)
                  The  word  before point is treated as a pattern for
                  pathname expansion,  with  an  asterisk  implicitly
                  appended.   This pattern is used to generate a list
                  of matching file names for possible completions.
           glob-expand-word (C-x *)
                  The word before point is treated as a  pattern  for
                  pathname  expansion,  and the list of matching file
                  names  is  inserted,  replacing  the  word.   If  a
                  numeric   argument  is  supplied,  an  asterisk  is
                  appended before pathname expansion.
           glob-list-expansions (C-x g)
                  The list of expansions that would have been  gener
                  ated by glob-expand-word is displayed, and the line
                  is redrawn.  If a numeric argument is supplied,  an
                  macros  and  the  strings they ouput.  If a numeric
                  argument is supplied, the output  is  formatted  in
                  such  a  way that it can be made part of an inputrc
                  file.
           display-shell-version (C-x C-v)
                  Display  version  information  about  the   current
                  instance of bash.

       Programmable Completion
           When  word  completion  is  attempted for an argument to a
           command for which a completion specification (a  compspec)
           has  been  defined  using  the complete builtin (see SHELL
           BUILTIN  COMMANDS  below),  the  programmable   completion
           facilities are invoked.

           First,  the command name is identified.  If a compspec has
           been defined for that command, the  compspec  is  used  to
           generate  the  list  of possible completions for the word.
           If the command word is a full pathname, a compspec for the
           full  pathname  is  searched for first.  If no compspec is
           found for the full pathname, an attempt is made to find  a
           compspec for the portion following the final slash.

           Once a compspec has been found, it is used to generate the
           list of matching words.  If a compspec is not  found,  the
           default  bash completion as described above under Complet
           ing is performed.

           First, the actions specified by  the  compspec  are  used.
           Only  matches  which  are  prefixed by the word being com
           pleted are returned.  When the -f or -d option is used for
           filename  or directory name completion, the shell variable
           FIGNORE is used to filter the matches.

           Any completions specified by a filename expansion  pattern
           to  the -G option are generated next.  The words generated
           by the pattern need not match the  word  being  completed.
           The  GLOBIGNORE  shell  variable is not used to filter the
           matches, but the FIGNORE variable is used.

           Next, the string specified  as  the  argument  to  the  -W
           option is considered.  The string is first split using the
           characters in the  IFS  special  variable  as  delimiters.
           Shell  quoting  is  honored.   Each  word is then expanded
           using brace  expansion,  tilde  expansion,  parameter  and
           variable   expansion,   command  substitution,  arithmetic
           expansion, and  pathname  expansion,  as  described  above
           under  EXPANSION.   The  results are split using the rules
           described above under Word Splitting.  The results of  the
           expansion  are  prefix-matched against the word being com
           pleted, and the matching words become the possible comple
           tions.
           tion or command has complete  freedom  in  generating  the
           matches.

           Any  function  specified  with  -F  is invoked first.  The
           function may use any of the  shell  facilities,  including
           the  compgen  builtin  described  below,  to  generate the
           matches.  It must put the possible completions in the COM
           PREPLY array variable.

           Next,  any command specified with the -C option is invoked
           in an environment equivalent to command substitution.   It
           should  print  a list of completions, one per line, to the
           standard output.  Backslash may be used to escape  a  new
           line, if necessary.

           After  all  of the possible completions are generated, any
           filter specified with the -X  option  is  applied  to  the
           list.  The filter is a pattern as used for pathname expan
           sion; a & in the pattern is replaced with the text of  the
           word  being  completed.  A literal & may be escaped with a
           backslash; the backslash is removed  before  attempting  a
           match.   Any  completion  that matches the pattern will be
           removed from the list.  A leading ! negates  the  pattern;
           in  this case any completion not matching the pattern will
           be removed.

           Finally, any prefix and suffix specified with the  -P  and
           -S  options  are  added  to  each member of the completion
           list, and the result is returned to the  readline  comple
           tion code as the list of possible completions.

           If  the  previously-applied  actions  do  not generate any
           matches, and the -o dirnames option was supplied  to  com
           plete  when  the compspec was defined, directory name com
           pletion is attempted.

           By default, if a compspec is found, whatever it  generates
           is returned to the completion code as the full set of pos
           sible completions.  The default bash completions  are  not
           attempted, and the readline default of filename completion
           is disabled.  If the -o default  option  was  supplied  to
           complete when the compspec was defined, readline's default
           completion will be performed if the compspec generates  no
           matches.

           When  a  compspec indicates that directory name completion
           is desired, the programmable  completion  functions  force
           readline  to  append  a slash to completed names which are
           symbolic links to directories, subject to the value of the
           mark-directories readline variable, regardless of the set
           ting of the mark-symlinked-directories readline  variable.

           file named by the value of HISTFILE is truncated, if  nec
           essary, to contain no more than the number of lines speci
           fied by the value of HISTFILESIZE.   When  an  interactive
           shell  exits, the last $HISTSIZE lines are copied from the
           history list to $HISTFILE.  If the histappend shell option
           is  enabled  (see  the  description  of  shopt under SHELL
           BUILTIN COMMANDS below), the lines  are  appended  to  the
           history  file,  otherwise the history file is overwritten.
           If  HISTFILE  is  unset,  or  if  the  history   file   is
           unwritable,  the  history  is not saved.  After saving the
           history, the history file is truncated to contain no  more
           than  HISTFILESIZE  lines.  If HISTFILESIZE is not set, no
           truncation is performed.

           The builtin command fc (see SHELL BUILTIN COMMANDS  below)
           may  be  used  to list or edit and re-execute a portion of
           the history list.  The history builtin may be used to dis
           play or modify the history list and manipulate the history
           file.  When using command-line  editing,  search  commands
           are  available in each editing mode that provide access to
           the history list.

           The shell allows control over which commands are saved  on
           the  history  list.   The HISTCONTROL and HISTIGNORE vari
           ables may be set to cause the shell to save only a  subset
           of  the  commands  entered.   The cmdhist shell option, if
           enabled, causes the shell to attempt to save each line  of
           a  multi-line  command  in  the same history entry, adding
           semicolons where necessary to preserve syntactic  correct
           ness.   The  lithist shell option causes the shell to save
           the command with embedded newlines instead of  semicolons.
           See the description of the shopt builtin below under SHELL
           BUILTIN COMMANDS for information on setting and  unsetting
           shell options.

## HISTORY EXPANSION

           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 fea
           ture 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 by default.

           History  expansions  introduce words from the history list
           into the input stream, making it easy to repeat  commands,
           insert  the  arguments to a previous command into the cur
           rent input  line,  or  fix  errors  in  previous  commands
           quickly.

           History  expansion  is  performed immediately after a com
           plete line is read, before the shell breaks it into words.

           Several shell options settable with the shopt builtin  may
           be  used  to tailor the behavior of history expansion.  If
           the histverify shell option is enabled (see  the  descrip
           tion  of  the  shopt builtin), and readline is being used,
           history substitutions are not immediately  passed  to  the
           shell parser.  Instead, the expanded line is reloaded into
           the readline editing buffer for further modification.   If
           readline is being used, and the histreedit shell option is
           enabled, a failed history substitution  will  be  reloaded
           into  the  readline editing buffer for correction.  The -p
           option to the history builtin command may be used  to  see
           what  a history expansion will do before using it.  The -s
           option to the history builtin may be used to add  commands
           to  the end of the history list without actually executing
           them, so that they are available for subsequent recall.

           The shell allows control of the various characters used by
           the  history  expansion  mechanism (see the description of
           histchars above under Shell Variables).

       Event Designators
           An event designator is a reference to a command line entry
           in the history list.

           !      Start  a history substitution, except when followed
                  by a blank, newline, = or (.
           !n     Refer to command line n.
           !-n    Refer to the current command line minus n.
           !!     Refer to the previous command.  This is  a  synonym
                  for `!-1'.
           !string
                  Refer  to  the  most  recent  command starting with
                  string.
           !?string[?]
                  Refer to the most recent command containing string.
                  The trailing ? may be omitted if string is followed
                  immediately by a newline.
           ^string1^string2^
                  Quick  substitution.   Repeat  the  last   command,
                  replacing  string1  with  string2.   Equivalent  to
                  ``!!:s/string1/string2/'' (see Modifiers below).
           !#     The entire command line typed so far.

       Word Designators
           Word designators are used to select desired words from the
           event.   A  :  separates  the event specification from the
           word designator.  It may be omitted if the word designator
           begins  with  a ^, $, *, -, or %.  Words are numbered from
           the beginning of the  line,  with  the  first  word  being
           denoted  by 0 (zero).  Words are inserted into the current
           line separated by single spaces.
           x*     Abbreviates x-$.
           x-     Abbreviates x-$ like x*, but omits the last word.

           If a word designator is supplied without an event specifi
           cation, the previous command is used as the event.

       Modifiers
           After the optional word designator,  there  may  appear  a
           sequence  of  one or more of the following modifiers, each
           preceded by a `:'.

           h      Remove a trailing file name component, leaving only
                  the head.
           t      Remove  all  leading  file name components, leaving
                  the tail.
           r      Remove a trailing suffix of the form .xxx,  leaving
                  the basename.
           e      Remove all but the trailing suffix.
           p      Print the new command but do not execute it.
           q      Quote  the substituted words, escaping further sub
                  stitutions.
           x      Quote the substituted words as with  q,  but  break
                  into words at blanks and newlines.
           s/old/new/
                  Substitute  new  for the first occurrence of old in
                  the event line.  Any delimiter can be used in place
                  of /.  The final delimiter is optional if it is the
                  last character of the event  line.   The  delimiter
                  may  be  quoted  in old and new with a single back
                  slash.  If & appears in new, it is replaced by old.
                  A  single  backslash  will  quote the &.  If old is
                  null, it is set to the last old substituted, or, if
                  no  previous  history substitutions took place, the
                  last string in a !?string[?]  search.
           &      Repeat the previous substitution.
           g      Cause changes to be applied over the  entire  event
                  line.  This is used in conjunction with `:s' (e.g.,
                  `:gs/old/new/') or `:&'.  If used  with  `:s',  any
                  delimiter  can be used in place of /, and the final
                  delimiter is optional if it is the  last  character
                  of the event line.

## SHELL BUILTIN COMMANDS

           Unless otherwise noted, each builtin command documented in
           this section as accepting options preceded by - accepts --
           to signify the end of the options.
           : [arguments]
                  No  effect; the command does nothing beyond expand
                  ing arguments and performing any specified redirec
                  tions.  A zero exit code is returned.

            .  filename [arguments]
                  unchanged.  The return status is the status of  the
                  last command exited within the script (0 if no com
                  mands are executed), and false if filename  is  not
                  found or cannot be read.

           alias [-p] [name[=value] ...]
                  Alias  with  no  arguments  or  with  the -p option
                  prints the  list  of  aliases  in  the  form  alias
                  name=value  on standard output.  When arguments are
                  supplied, an alias is defined for each  name  whose
                  value  is given.  A trailing space in  value causes
                  the next word to be checked for alias  substitution
                  when  the  alias is expanded.  For each name in the
                  argument list for which no value is  supplied,  the
                  name  and  value  of  the  alias is printed.  Alias
                  returns true unless a name is given  for  which  no
                  alias has been defined.

           bg [jobspec]
                  Resume the suspended job jobspec in the background,
                  as if it had been started with &.   If  jobspec  is
                  not  present, the shell's notion of the current job
                  is used.  bg jobspec returns 0 unless run when  job
                  control  is  disabled or, when run with job control
                  enabled, if jobspec was not found or started  with
                  out job control.

           bind [-m keymap] [-lpsvPSV]
           bind [-m keymap] [-q function] [-u function] [-r keyseq]
           bind [-m keymap] -f filename
           bind [-m keymap] -x keyseq:shell-command
           bind [-m keymap] keyseq:function-name
           bind readline-command
                  Display current readline key and function bindings,
                  bind a key  sequence  to  a  readline  function  or
                  macro, or set a readline variable.  Each non-option
                  argument is a command as it would appear in  .inpu
                  trc,  but each binding or command must be passed as
                  a    separate    argument;    e.g.,    '"\C-x\C-r":
                  re-read-init-file'.  Options, if supplied, have the
                  following meanings:
                  -m keymap
                         Use keymap as the keymap to be  affected  by
                         the  subsequent bindings.  Acceptable keymap
                         names are emacs, emacs-standard, emacs-meta,
                         emacs-ctlx,  vi,  vi-move,  vi-command,  and
                         vi-insert.  vi is equivalent to  vi-command;
                         emacs is equivalent to emacs-standard.
                  -l     List the names of all readline functions.
                  -p     Display readline function names and bindings
                         in such a way that they can be re-read.
                  -P     List current  readline  function  names  and
                         function.
                  -u function
                         Unbind all keys bound to the named function.
                  -r keyseq
                         Remove any current binding for keyseq.
                  -x keyseq:shell-command
                         Cause shell-command to be executed  whenever
                         keyseq is entered.

                  The return value is 0 unless an unrecognized option
                  is given or an error occurred.

           break [n]
                  Exit from within a for,  while,  until,  or  select
                  loop.   If  n is specified, break n levels.  n must
                  be >= 1.  If  n  is  greater  than  the  number  of
                  enclosing  loops,  all  enclosing loops are exited.
                  The return value is 0 unless the shell is not  exe
                  cuting a loop when break is executed.

           builtin shell-builtin [arguments]
                  Execute  the  specified  shell  builtin, passing it
                  arguments, and return its  exit  status.   This  is
                  useful  when  defining a function whose name is the
                  same as a shell builtin, retaining the  functional
                  ity  of  the  builtin  within the function.  The cd
                  builtin is commonly redefined this way.  The return
                  status  is  false  if  shell-builtin is not a shell
                  builtin command.

           cd [-L|-P] [dir]
                  Change the current directory to dir.  The  variable
                  HOME  is  the  default  dir.   The  variable CDPATH
                  defines the search path for the directory  contain
                  ing dir.  Alternative directory names in CDPATH 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. The -P option says to use the physical
                  directory structure instead of  following  symbolic
                  links  (see  also  the -P option to the set builtin
                  command); the -L option forces symbolic links to be
                  followed.   An argument of - is equivalent to $OLD
                  PWD.  The return value is true if the directory was
                  successfully changed; false otherwise.

           command [-pVv] command [arg ...]
                  Run  command with args suppressing the normal shell
                  function lookup. Only builtin commands or  commands
                  found  in  the 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
                  Generate   possible  completion  matches  for  word
                  according to the options, which may be  any  option
                  accepted by the complete builtin with the exception
                  of -p and -r, and write the matches to the standard
                  output.  When using the -F or -C options, the vari
                  ous shell variables set by the programmable comple
                  tion  facilities,  while  available,  will not have
                  useful values.

                  The matches will be generated in the same way as if
                  the programmable completion code had generated them
                  directly from a completion specification  with  the
                  same  flags.  If word is specified, only those com
                  pletions matching word will be displayed.

                  The return value is true unless an  invalid  option
                  is supplied, or no matches were generated.

           complete  [-abcdefgjksuv] [-o comp-option] [-A action] [-G
           globpat] [-W wordlist] [-P prefix] [-S suffix]
                  [-X  filterpat]  [-F  function]  [-C  command] name
                  [name ...]
           complete -pr [name ...]
                  Specify how arguments to each name should  be  com
                  pleted.   If  the  -p  option is supplied, or if no
                  options are supplied, existing completion  specifi
                  cations are printed in a way that allows them to be
                  reused as input.  The -r option removes  a  comple
                  tion  specification  for each name, or, if no names
                  are supplied, all completion specifications.

                  The process of applying these completion specifica
                  tions   when   word   completion  is  attempted  is
                  described above under Programmable Completion.

                  Other options, if  specified,  have  the  following
                  meanings.   The  arguments  to  the  -G, -W, and -X
                  options (and, if necessary, the -P and -S  options)
                  should  be  quoted  to  protect them from expansion
                  before the complete builtin is invoked.
                  -o comp-option
                          The comp-option controls several aspects of
                          the  compspec's  behavior beyond the simple
                          generation of completions.  comp-option may
                          be one of:
                          default Use   readline's  default  filename
                                  completion if the  compspec  gener
                                  ates no matches.
                          dirnames
                                  Perform  directory  name completion
                                  if  the   compspec   generates   no
                                  matches.

                          alias   Alias names.  May also be specified
                                  as -a.
                          arrayvar
                                  Array variable names.
                          binding Readline key binding names.
                          builtin Names  of  shell  builtin commands.
                                  May also be specified as -b.
                          command Command names.  May also be  speci
                                  fied as -c.
                          directory
                                  Directory names.  May also be spec
                                  ified as -d.
                          disabled
                                  Names of disabled shell builtins.
                          enabled Names of enabled shell builtins.
                          export  Names of exported shell  variables.
                                  May also be specified as -e.
                          file    File  names.  May also be specified
                                  as -f.
                          function
                                  Names of shell functions.
                          group   Group names.  May also be specified
                                  as -g.
                          helptopic
                                  Help topics as accepted by the help
                                  builtin.
                          hostname
                                  Hostnames, as taken from  the  file
                                  specified  by  the  HOSTFILE  shell
                                  variable.
                          job     Job  names,  if  job   control   is
                                  active.   May  also be specified as
                                  -j.
                          keyword Shell reserved words.  May also  be
                                  specified as -k.
                          running Names  of running jobs, if job con
                                  trol is active.
                          service Service names.  May also be  speci
                                  fied as -s.
                          setopt  Valid  arguments  for the -o option
                                  to the set builtin.
                          shopt   Shell option names as  accepted  by
                                  the shopt builtin.
                          signal  Signal names.
                          stopped Names  of stopped jobs, if job con
                                  trol is active.
                          user    User names.  May also be  specified
                                  as -u.
                          variable
                                  Names  of all shell variables.  May
                                  also be specified as -v.
                  -G globpat
                  -F function
                          The  shell function function is executed in
                          the current  shell  environment.   When  it
                          finishes,   the  possible  completions  are
                          retrieved from the value of  the  COMPREPLY
                          array variable.
                  -X filterpat
                          filterpat is a pattern as used for filename
                          expansion.  It is applied to  the  list  of
                          possible  completions generated by the pre
                          ceding options and arguments, and each com
                          pletion  matching filterpat is removed from
                          the list.  A leading ! in filterpat negates
                          the  pattern;  in this case, any completion
                          not matching filterpat is removed.
                  -P prefix
                          prefix is added at the  beginning  of  each
                          possible completion after all other options
                          have been applied.
                  -S suffix
                          suffix is appended to each possible comple
                          tion  after  all  other  options  have been
                          applied.

                  The return value is true unless an  invalid  option
                  is  supplied, an option other than -p or -r is sup
                  plied without a name argument, an attempt  is  made
                  to remove a completion specification for a name for
                  which no specification exists, or an  error  occurs
                  adding a completion specification.

           continue [n]
                  Resume  the  next  iteration  of the enclosing for,
                  while, until, or select loop.  If n  is  specified,
                  resume  at the nth enclosing loop.  n must be >= 1.
                  If n is greater than the number of enclosing loops,
                  the last enclosing loop (the ``top-level'' loop) is
                  resumed.  The return value is 0 unless the shell is
                  not executing a loop when continue is executed.

           declare [-afFirtx] [-p] [name[=value]]
           typeset [-afFirtx] [-p] [name[=value]]
                  Declare  variables and/or give them attributes.  If
                  no names are given then display the values of vari
                  ables.   The  -p option will display the attributes
                  and values of each name.  When -p  is  used,  addi
                  tional options are ignored.  The -F option inhibits
                  the display of function definitions; only the func
                  tion  name  and  attributes  are  printed.   The -F
                  option implies -f.  The following  options  can  be
                  used to restrict output to variables with the spec
                  ified attribute or to give variables attributes:
                  -x     Mark names for export to subsequent commands
                         via the environment.

                  Using `+' instead of `-' turns  off  the  attribute
                  instead, with the exception that +a may not be used
                  to destroy an array variable.  When used in a func
                  tion, makes each name local, as with the local com
                  mand.  The return value  is  0  unless  an  invalid
                  option is encountered, an attempt is made to define
                  a function using ``-f foo=bar'', an attempt is made
                  to  assign  a  value  to  a  readonly  variable, an
                  attempt is made to assign a value to an array vari
                  able  without  using the compound assignment syntax
                  (see Arrays above), one of the names is not a valid
                  shell variable name, an attempt is made to turn off
                  readonly status for a readonly variable, an attempt
                  is made to turn off array status for an array vari
                  able, or an attempt is made to display a  non-exis
                  tent function with -f.

           dirs [-clpv] [+n] [-n]
                  Without  options,  displays  the  list of currently
                  remembered directories.  The default display is  on
                  a  single  line  with  directory names separated by
                  spaces.  Directories are added to the list with the
                  pushd  command;  the  popd  command removes entries
                  from the list.
                  +n     Displays the nth  entry  counting  from  the
                         left  of the list shown by dirs when invoked
                         without options, starting with zero.
                  -n     Displays the nth  entry  counting  from  the
                         right of the list shown by dirs when invoked
                         without options, starting with zero.
                  -c     Clears the directory stack by  deleting  all
                         of the entries.
                  -l     Produces a longer listing; the default list
                         ing format uses a tilde to denote  the  home
                         directory.
                  -p     Print the directory stack with one entry per
                         line.
                  -v     Print the directory stack with one entry per
                         line, prefixing each entry with its index in
                         the stack.

                  The return value is 0 unless an invalid  option  is
                  supplied  or n indexes beyond the end of the direc
                  tory stack.

           disown [-ar] [-h] [jobspec ...]
                  Without options, each jobspec is removed  from  the
                  table  of  active jobs.  If the -h option is given,
                  each jobspec is not removed from the table, but  is
                  the -e option is given, interpretation of the  fol
                  lowing  backslash-escaped  characters  is  enabled.
                  The -E option disables the interpretation of  these
                  escape  characters,  even on systems where they are
                  interpreted by default.  The xpg_echo shell  option
                  may be used to dynamically determine whether or not
                  echo expands these escape  characters  by  default.
                  echo  does  not  interpret  --  to  mean the end of
                  options.   echo  interprets  the  following  escape
                  sequences:
                  \a     alert (bell)
                  \b     backspace
                  \c     suppress trailing newline
                  \e     an escape character
                  \f     form feed
                  \n     new line
                  \r     carriage return
                  \t     horizontal tab
                  \v     vertical tab
                  \\     backslash
                  \0nnn  the  eight-bit  character whose value is the
                         octal value nnn (zero to three octal digits)
                  \nnn   the  eight-bit  character whose value is the
                         octal value nnn (one to three octal digits)
                  \xHH   the eight-bit character whose value  is  the
                         hexadecimal value HH (one or two hex digits)

           enable [-adnps] [-f filename] [name ...]
                  Enable and disable builtin  shell  commands.   Dis
                  abling  a  builtin  allows a disk command which has
                  the same name as a shell  builtin  to  be  executed
                  without specifying a full pathname, even though the
                  shell normally searches for  builtins  before  disk
                  commands.   If  -n  is used, each name is disabled;
                  otherwise, names are enabled.  For example, to  use
                  the  test  binary found via the PATH instead of the
                  shell builtin version, run ``enable -n test''.  The
                  -f  option  means  to  load the new builtin command
                  name from shared object filename, on  systems  that
                  support dynamic loading.  The -d option will delete
                  a builtin previously loaded with -f.   If  no  name
                  arguments  are  given,  or if the -p option is sup
                  plied, a list of shell builtins is  printed.   With
                  no other option arguments, the list consists of all
                  enabled shell builtins.  If -n  is  supplied,  only
                  disabled  builtins are printed.  If -a is supplied,
                  the list printed includes  all  builtins,  with  an
                  indication  of  whether or not each is enabled.  If
                  -s is supplied, the output  is  restricted  to  the
                  POSIX  special  builtins.   The  return  value is 0
                  unless a name is not a shell builtin or there is an
                  error loading a new builtin from a shared object.
                  login(1) does.  The -c option causes command to  be
                  executed  with an empty environment.  If -a is sup
                  plied, the shell passes name as the zeroth argument
                  to the executed command.  If command cannot be exe
                  cuted for  some  reason,  a  non-interactive  shell
                  exits, unless the shell option execfail is enabled,
                  in which case it returns failure.   An  interactive
                  shell  returns  failure  if the file cannot be exe
                  cuted.  If command is not specified,  any  redirec
                  tions  take  effect  in  the current shell, and the
                  return status is 0.   If  there  is  a  redirection
                  error, the return status is 1.

           exit [n]
                  Cause  the  shell to exit with a status of n.  If n
                  is omitted, the exit status is  that  of  the  last
                  command  executed.   A  trap  on  EXIT  is executed
                  before the shell terminates.

           export [-fn] [name[=word]] ...
           export -p
                  The supplied names are marked for automatic  export
                  to  the  environment  of subsequently executed com
                  mands.  If the -f option is given, the names  refer
                  to  functions.  If no names are given, or if the -p
                  option is supplied, a list of all  names  that  are
                  exported  in  this shell is printed.  The -n option
                  causes the export property to be removed  from  the
                  named  variables.  export returns an exit status of
                  0 unless an invalid option is encountered,  one  of
                  the names is not a valid shell variable name, or -f
                  is supplied with a name that is not a function.

           fc [-e ename] [-nlr] [first] [last]
           fc -s [pat=rep] [cmd]
                  Fix Command.  In the first form, a  range  of  com
                  mands  from first to last is selected from the his
                  tory list.  First and last may be  specified  as  a
                  string  (to  locate the last command beginning with
                  that string) or as a number (an index into the his
                  tory  list,  where  a negative number is used as an
                  offset from the current command number).   If  last
                  is  not  specified it is set to the current command
                  for listing (so that ``fc -l -10'' prints the  last
                  10  commands)  and to first otherwise.  If first is
                  not specified it is set to the previous command for
                  editing and -16 for listing.

                  The  -n  option suppresses the command numbers when
                  listing.  The -r option reverses the order  of  the
                  commands.   If the -l option is given, the commands
                  are listed on standard output.  Otherwise, the edi
                  If  the  first  form is used, the return value is 0
                  unless an invalid 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  spec
                  ify  a valid history line, in which case fc returns
                  failure.

           fg [jobspec]
                  Resume jobspec in the foreground, and make  it  the
                  current  job.   If  jobspec  is  not  present,  the
                  shell's notion of the current  job  is  used.   The
                  return value is that of the command placed into the
                  foreground, or failure if run when job  control  is
                  disabled  or, when run with job control enabled, if
                  jobspec does not specify a  valid  job  or  jobspec
                  specifies  a  job that was started without job con
                  trol.

           getopts optstring name [args]
                  getopts is used by shell procedures to parse  posi
                  tional  parameters.   optstring contains the option
                  characters to be recognized; if a character is fol
                  lowed by a colon, the option is expected to have an
                  argument, which should  be  separated  from  it  by
                  white  space.   The colon and question mark charac
                  ters may not be used as  option  characters.   Each
                  time  it is invoked, getopts places the next option
                  in the shell variable name, initializing name if it
                  does  not exist, and the index of the next argument
                  to be processed into the variable  OPTIND.   OPTIND
                  is  initialized to 1 each time the shell or a shell
                  script is invoked.   When  an  option  requires  an
                  argument,  getopts  places  that  argument into the
                  variable OPTARG.  The shell does not  reset  OPTIND
                  automatically;  it  must  be manually reset between
                  multiple calls to getopts  within  the  same  shell
                  invocation  if  a  new  set  of parameters is to be
                  used.

                  When the end of  options  is  encountered,  getopts
                  exits  with  a  return  value  greater  than  zero.
                  OPTIND is set to the index of the first  non-option
                  argument, and name is set to ?.

                  getopts  normally parses the positional parameters,
                  but if more arguments are given  in  args,  getopts
                  parses those instead.

                  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  returns  true  if  an option, specified or
                  unspecified, is found.  It returns false if the end
                  of options is encountered or an error occurs.

           hash [-lr] [-p filename] [-dt] [name]
                  For each name, the full file name of the command is
                  determined by searching the  directories  in  $PATH
                  and  remembered.   If the -p option is supplied, no
                  path search is performed, and filename is  used  as
                  the  full  file name of the command.  The -r option
                  causes the shell to  forget  all  remembered  loca
                  tions.   The  -d  option causes the shell to forget
                  the remembered location of each name.   If  the  -t
                  option is supplied, the full pathname to which each
                  name corresponds  is  printed.   If  multiple  name
                  arguments are supplied with -t, the name is printed
                  before the hashed full  pathname.   The  -l  option
                  causes  output to be displayed in a format that may
                  be reused as input.  If no arguments are given,  or
                  if  only  -l  is supplied, information about remem
                  bered commands is printed.  The  return  status  is
                  true  unless  a  name  is  not  found or an invalid
                  option is supplied.

           help [-s] [pattern]
                  Display helpful information about builtin commands.
                  If  pattern  is specified, help gives detailed help
                  on all commands matching  pattern;  otherwise  help
                  for  all  the builtins and shell control structures
                  is printed.  The -s option restricts  the  informa
                  tion  displayed  to  a  short  usage synopsis.  The
                  return status is 0 unless no command  matches  pat
                  tern.

           history [n]
           history -c
           history -d offset
           history -anrw [filename]
           history -p arg [arg ...]
           history -s arg [arg ...]
                  With  no  options, display the command history list
                  with line numbers.  Lines listed with a * have been
                  modified.   An  argument of n lists only the last n
                  lines.  If filename is supplied, it is used as  the
                         bash session.
                  -r     Read  the  contents  of the history file and
                         use them as the current history.
                  -w     Write the current  history  to  the  history
                         file,  overwriting  the  history file's con
                         tents.
                  -p     Perform history substitution on the  follow
                         ing args and display the result on the stan
                         dard output.  Does not store the results  in
                         the  history  list.  Each arg must be quoted
                         to disable normal history expansion.
                  -s     Store the args in the history list as a sin
                         gle  entry.  The last command in the history
                         list is removed before the args are added.

                  The return value is 0 unless an invalid  option  is
                  encountered, an error occurs while reading or writ
                  ing the history file, an invalid offset is supplied
                  as an argument to -d, or the history expansion sup
                  plied as an argument to -p fails.

           jobs [-lnprs] [ jobspec ... ]
           jobs -x command [ args ... ]
                  The first form lists the active jobs.  The  options
                  have the following meanings:
                  -l     List  process  IDs in addition to the normal
                         information.
                  -p     List only the process ID of the  job's  pro
                         cess group leader.
                  -n     Display  information  only  about  jobs that
                         have changed status since the user was  last
                         notified of their status.
                  -r     Restrict output to running jobs.
                  -s     Restrict output to stopped jobs.

                  If jobspec is given, output is restricted to infor
                  mation about that job.   The  return  status  is  0
                  unless  an  invalid  option  is  encountered  or an
                  invalid jobspec is supplied.

                  If the -x option is  supplied,  jobs  replaces  any
                  jobspec  found  in  command or args with the corre
                  sponding process group  ID,  and  executes  command
                  passing it args, returning its exit status.

           kill  [-s  sigspec | -n signum | -sigspec] [pid | jobspec]
           ...
           kill -l [sigspec | exit_status]
                  Send  the  signal named by sigspec or signum to the
                  processes named by  pid  or  jobspec.   sigspec  is
                  either  a  signal  name such as SIGKILL or a signal
                  number; signum is a signal number.  If sigspec is a
                  Each arg is an arithmetic expression to  be  evalu
                  ated  (see ARITHMETIC EVALUATION).  If the last arg
                  evaluates to 0, let returns 1; 0 is returned other
                  wise.

           local [option] [name[=value] ...]
                  For  each  argument, a local variable named name is
                  created, and assigned value.  The option can be any
                  of  the options accepted by declare.  When local is
                  used within a function, it causes the variable name
                  to have a visible scope restricted to that function
                  and its children.  With no operands, local writes a
                  list of local variables to the standard output.  It
                  is an error to use local when not  within  a  func
                  tion.   The return status is 0 unless local is used
                  outside a function, an invalid name is supplied, or
                  name is a readonly variable.

           logout Exit a login shell.

           popd [-n] [+n] [-n]
                  Removes  entries from the directory stack.  With no
                  arguments,  removes  the  top  directory  from  the
                  stack,  and performs a cd to the new top directory.
                  Arguments, if supplied, have  the  following  mean
                  ings:
                  +n     Removes the nth entry counting from the left
                         of the list shown  by  dirs,  starting  with
                         zero.   For example: ``popd +0'' removes the
                         first directory, ``popd +1'' the second.
                  -n     Removes the  nth  entry  counting  from  the
                         right  of  the  list shown by dirs, starting
                         with zero.  For example: ``popd -0'' removes
                         the  last directory, ``popd -1'' the next to
                         last.
                  -n     Suppresses the normal  change  of  directory
                         when removing directories from the stack, so
                         that only the stack is manipulated.

                  If the popd command is successful, a dirs  is  per
                  formed  as  well, and the return status is 0.  popd
                  returns false if an invalid option is  encountered,
                  the directory stack is empty, a non-existent direc
                  tory stack entry is  specified,  or  the  directory
                  change fails.

           printf format [arguments]
                  Write  the formatted arguments to the standard out
                  put under the control of the format.  The format is
                  a  character  string  which contains three types of
                  objects: plain characters, which are simply  copied
                  to  standard  output,  character  escape sequences,
                  value is zero on success, non-zero on failure.

           pushd [-n] [dir]
           pushd [-n] [+n] [-n]
                  Adds a directory to the top of the directory stack,
                  or  rotates  the  stack,  making the new top of the
                  stack the current working directory.  With no argu
                  ments,   exchanges  the  top  two  directories  and
                  returns 0, unless the  directory  stack  is  empty.
                  Arguments,  if  supplied,  have the following mean
                  ings:
                  +n     Rotates the stack so that the nth  directory
                         (counting from the left of the list shown by
                         dirs, starting with zero) is at the top.
                  -n     Rotates the stack so that the nth  directory
                         (counting  from  the right of the list shown
                         by dirs, starting with zero) is at the  top.
                  -n     Suppresses  the  normal  change of directory
                         when adding directories  to  the  stack,  so
                         that only the stack is manipulated.
                  dir    Adds  dir to the directory stack at the top,
                         making it the new current working directory.

                  If  the pushd command is successful, a dirs is per
                  formed 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-existent directory stack ele
                  ment is specified, or the directory change  to  the
                  specified new current directory fails.

           pwd [-LP]
                  Print  the absolute pathname of the current working
                  directory.  The pathname printed contains  no  sym
                  bolic  links if the -P option is supplied or the -o
                  physical option  to  the  set  builtin  command  is
                  enabled.   If  the  -L option is used, the pathname
                  printed may contain  symbolic  links.   The  return
                  status  is  0  unless an error occurs while reading
                  the name of the current  directory  or  an  invalid
                  option is supplied.

           read  [-ers]  [-u  fd] [-t timeout] [-a aname] [-p prompt]
           [-n nchars] [-d delim] [name ...]
                  One  line  is read from the standard input, or from
                  the file descriptor fd supplied as an  argument  to
                  the  -u  option,  and the first word is assigned to
                  the first name, the second word to the second name,
                  and  so on, with leftover words and their interven
                  ing separators assigned to the last name.  If there
                  are  fewer  words  read  from the input stream than
                  names, the remaining names are assigned empty  val
                         minal, readline (see READLINE above) is used
                         to obtain the line.
                  -n nchars
                         read returns after reading nchars characters
                         rather than waiting for a complete  line  of
                         input.
                  -p prompt
                         Display  prompt on standard error, without a
                         trailing newline, before attempting to  read
                         any  input.  The prompt is displayed only if
                         input is coming from a terminal.
                  -r     Backslash does not act as an escape  charac
                         ter.  The backslash is considered to be part
                         of the line.  In  particular,  a  backslash-
                         newline  pair may not be used as a line con
                         tinuation.
                  -s     Silent mode.  If input is coming from a ter
                         minal, characters are not echoed.
                  -t timeout
                         Cause read to time out and return failure if
                         a complete line of input is not read  within
                         timeout  seconds.  This option has no effect
                         if read is not reading input from the termi
                         nal or a pipe.
                  -u fdFP
                         Read input from file descriptor fd.

                  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, read times out,
                  or an invalid file descriptor is  supplied  as  the
                  argument to -u.

           readonly [-apf] [name ...]
                  The  given names are marked readonly; the values of
                  these  names  may  not  be  changed  by  subsequent
                  assignment.   If  the  -f  option  is supplied, the
                  functions corresponding to the names are so marked.
                  The  -a  option  restricts the variables to arrays.
                  If no name arguments are given, or if the -p option
                  is  supplied,  a  list  of  all  readonly  names is
                  printed.  The -p option causes output  to  be  dis
                  played  in  a  format  that may be reused as input.
                  The return status is 0 unless an invalid option  is
                  encountered,  one of the names is not a valid shell
                  variable name, or -f is supplied with a  name  that
                  is not a function.

           return [n]
                  Causes  a  function  to  exit with the return value
                  specified by n.  If n is omitted, the return status
                  is  that  of the last command executed in the func
                  they  set or unset shell attributes.  Any arguments
                  remaining  after  the  options  are  processed  are
                  treated as values for the positional parameters and
                  are  assigned,  in  order,  to  $1,  $2,  ...   $n.
                  Options, if specified, have the following meanings:
                  -a      Automatically mark variables and  functions
                          which are modified or created for export to
                          the environment of subsequent commands.
                  -b      Report the status of terminated  background
                          jobs  immediately,  rather  than before the
                          next primary  prompt.   This  is  effective
                          only when job control is enabled.
                  -e      Exit  immediately  if a simple command (see
                          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 !.  A
                          trap on ERR, if set, is executed before the
                          shell exits.
                  -f      Disable pathname expansion.
                  -h      Remember  the  location of commands as they
                          are  looked  up  for  execution.   This  is
                          enabled by default.
                  -k      All  arguments  in  the  form of assignment
                          statements are placed  in  the  environment
                          for  a command, not just those that precede
                          the command name.
                  -m      Monitor  mode.   Job  control  is  enabled.
                          This  option  is on by default for interac
                          tive shells on systems that support it (see
                          JOB  CONTROL  above).  Background processes
                          run in a separate process group and a  line
                          containing  their  exit  status  is printed
                          upon their completion.
                  -n      Read commands  but  do  not  execute  them.
                          This  may  be  used to check a shell script
                          for syntax  errors.   This  is  ignored  by
                          interactive shells.
                  -o option-name
                          The  option-name  can be one of the follow
                          ing:
                          allexport
                                  Same as -a.
                          braceexpand
                                  Same as -B.
                          emacs   Use  an  emacs-style  command  line
                                  editing interface.  This is enabled
                                  by default when the shell is inter
                                  active, unless the shell is started
                                  with the --noediting option.

                          noclobber
                                  Same as -C.
                          noexec  Same as -n.
                          noglob  Same  as   -f.    nolog   Currently
                                  ignored.
                          notify  Same as -b.
                          nounset Same as -u.
                          onecmd  Same as -t.
                          physical
                                  Same as -P.
                          posix   Change  the  behavior of bash where
                                  the default operation differs  from
                                  the  POSIX 1003.2 standard to match
                                  the standard (posix mode).
                          privileged
                                  Same as -p.
                          verbose Same as -v.
                          vi      Use a vi-style command line editing
                                  interface.
                          xtrace  Same as -x.
                          If  -o is supplied with no option-name, the
                          values of the current options are  printed.
                          If  +o  is  supplied with no option-name, a
                          series of set commands to recreate the cur
                          rent  option  settings  is displayed on the
                          standard output.
                  -p      Turn on privileged mode.  In this mode, the
                          $ENV and $BASH_ENV files are not processed,
                          shell functions are not inherited from  the
                          environment, and the SHELLOPTS variable, if
                          it appears in the environment, is  ignored.
                          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 sup
                          plied, these  actions  are  taken  and  the
                          effective  user  id is set to the real user
                          id.   If  the  -p  option  is  supplied  at
                          startup,  the  effective  user  id  is  not
                          reset.  Turning this option off causes  the
                          effective  user  and group ids to be set to
                          the real user and group ids.
                  -t      Exit after reading and executing  one  com
                          mand.
                  -u      Treat unset variables as an error when per
                          forming parameter expansion.  If  expansion
                          is  attempted  on  an  unset  variable, the
                          shell prints an error message, and, if  not
                          interactive,  exits with a non-zero status.
                  -v      Print shell input lines as they are read.
                  -x      After expanding each simple  command,  dis
                          play the expanded value of PS4, followed by
                          the command and its expanded arguments.
                          It  uses  the  physical directory structure
                          instead.  By default, bash follows the log
                          ical  chain  of directories when performing
                          commands which change  the  current  direc
                          tory.
                  --      If  no  arguments  follow this option, then
                          the positional parameters are unset.   Oth
                          erwise,  the  positional parameters are set
                          to the args, even if  some  of  them  begin
                          with a -.
                  -       Signal   the  end  of  options,  cause  all
                          remaining args to be assigned to the  posi
                          tional  parameters.   The -x and -v options
                          are turned off.  If there are no args,  the
                          positional parameters remain unchanged.

                  The  options  are  off  by default unless otherwise
                  noted.  Using + rather than - causes these  options
                  to  be  turned off.  The options can also be speci
                  fied as arguments to an invocation  of  the  shell.
                  The current set of options may be found in $-.  The
                  return status is  always  true  unless  an  invalid
                  option is encountered.

           shift [n]
                  The  positional parameters from n+1 ... are renamed
                  to $1 ....  Parameters represented by  the  numbers
                  $# down to $#-n+1 are unset.  n must be a non-nega
                  tive number less than or equal to $#.  If n  is  0,
                  no  parameters  are changed.  If n is not given, it
                  is assumed to be 1.  If n is greater than  $#,  the
                  positional  parameters are not changed.  The return
                  status is greater than zero if n is greater than $#
                  or less than zero; otherwise 0.

           shopt [-pqsu] [-o] [optname ...]
                  Toggle the values of variables controlling optional
                  shell behavior.  With no options, or  with  the  -p
                  option,  a  list  of  all  settable options is dis
                  played, with an indication of whether or  not  each
                  is  set.   The  -p  option causes output to be dis
                  played in a form  that  may  be  reused  as  input.
                  Other options have the following meanings:
                  -s     Enable (set) each optname.
                  -u     Disable (unset) each optname.
                  -q     Suppresses  normal  output (quiet mode); the
                         return status indicates whether the  optname
                         is  set or unset.  If multiple optname argu
                         ments are given with -q, the  return  status
                         is  zero  if  all optnames are enabled; non-
                         zero otherwise.
                  -o     Restricts the values of optname to be  those
                  The list of shopt options is:

                  cdable_vars
                          If set, an argument to the cd builtin  com
                          mand  that is not a directory is assumed to
                          be the name of a variable  whose  value  is
                          the directory to change to.
                  cdspell If  set,  minor errors in the spelling of a
                          directory component in a cd command will be
                          corrected.   The  errors  checked  for  are
                          transposed characters, a missing character,
                          and  one  character too many.  If a correc
                          tion is found, the corrected file  name  is
                          printed,  and  the  command proceeds.  This
                          option is only used by interactive  shells.
                  checkhash
                          If set, bash checks that a command found in
                          the hash table exists before trying to exe
                          cute  it.   If  a  hashed command no longer
                          exists, a normal path search is  performed.
                  checkwinsize
                          If  set,  bash checks the window size after
                          each command and, if necessary, updates the
                          values of LINES and COLUMNS.
                  cmdhist If  set, bash attempts to save all lines of
                          a multiple-line command in the same history
                          entry.   This  allows  easy  re-editing  of
                          multi-line commands.
                  dotglob If set, bash includes  filenames  beginning
                          with  a  `.'  in  the  results  of pathname
                          expansion.
                  execfail
                          If set, a non-interactive  shell  will  not
                          exit  if  it cannot execute the file speci
                          fied as an argument  to  the  exec  builtin
                          command.   An  interactive  shell  does not
                          exit if exec fails.
                  expand_aliases
                          If set, aliases are expanded  as  described
                          above   under   ALIASES.   This  option  is
                          enabled by default for interactive  shells.
                  extglob If  set, the extended pattern matching fea
                          tures described above under Pathname Expan
                          sion are enabled.
                  histappend
                          If set, the history list is appended to the
                          file named by the  value  of  the  HISTFILE
                          variable  when the shell exits, rather than
                          overwriting the file.
                  histreedit
                          If set, and readline is being used, a  user
                          is  given  the  opportunity  to  re-edit  a

                  huponexit
                          If  set,  bash will send SIGHUP to all jobs
                          when an interactive login shell exits.
                  interactive_comments
                          If set, allow a word beginning  with  #  to
                          cause  that  word and all remaining charac
                          ters on that  line  to  be  ignored  in  an
                          interactive  shell  (see  COMMENTS  above).
                          This option is enabled by default.
                  lithist If set, and the cmdhist option is  enabled,
                          multi-line  commands  are saved to the his
                          tory with  embedded  newlines  rather  than
                          using  semicolon separators where possible.
                  login_shell
                          The shell sets this option if it is started
                          as  a  login  shell (see INVOCATION above).
                          The value may not be changed.
                  mailwarn
                          If set, and a file that  bash  is  checking
                          for  mail  has been accessed since the last
                          time it was checked, the message ``The mail
                          in mailfile has been read'' is displayed.
                  no_empty_cmd_completion
                          If  set,  and  readline is being used, bash
                          will not attempt to  search  the  PATH  for
                          possible  completions  when  completion  is
                          attempted on an empty line.
                  nocaseglob
                          If  set,  bash  matches  filenames   in   a
                          case-insensitive  fashion  when  performing
                          pathname expansion (see Pathname  Expansion
                          above).
                  nullglob
                          If set, bash allows patterns which match no
                          files (see  Pathname  Expansion  above)  to
                          expand  to a null string, rather than them
                          selves.
                  progcomp
                          If set, the programmable completion facili
                          ties  (see  Programmable  Completion above)
                          are enabled.  This  option  is  enabled  by
                          default.
                  promptvars
                          If set, prompt strings undergo variable and
                          parameter expansion after being expanded as
                          described  in PROMPTING above.  This option
                          is enabled by default.
                  restricted_shell
                          The shell sets this option if it is started
                          in  restricted  mode  (see RESTRICTED SHELL
                          below).  The  value  may  not  be  changed.
                          This  is  not  reset when the startup files
                          escape sequences by default.
           suspend [-f]
                  Suspend  the  execution  of  this  shell  until  it
                  receives  a 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.
           test expr
           [ expr ]
                  Return  a status of 0 or 1 depending on the evalua
                  tion of  the  conditional  expression  expr.   Each
                  operator  and  operand must be a separate argument.
                  Expressions are composed of the primaries described
                  above under CONDITIONAL EXPRESSIONS.

                  Expressions  may  be  combined  using the following
                  operators, listed in  decreasing  order  of  prece
                  dence.
                  ! expr True if expr is false.
                  ( expr )
                         Returns the value of expr.  This may be used
                         to override the normal precedence of  opera
                         tors.
                  expr1 -a expr2
                         True if both expr1 and expr2 are true.
                  expr1 -o expr2
                         True if either expr1 or expr2 is true.

                  test and [ evaluate conditional expressions using a
                  set of rules based on the number of arguments.

                  0 arguments
                         The expression is false.
                  1 argument
                         The expression is true if and  only  if  the
                         argument is not null.
                  2 arguments
                         If  the  first argument is !, the expression
                         is true if and only if the  second  argument
                         is  null.   If  the first argument is one of
                         the unary conditional operators listed above
                         under  CONDITIONAL  EXPRESSIONS, the expres
                         sion is true if the unary test is true.   If
                         the first argument is not a valid unary con
                         ditional operator, the expression is  false.
                  3 arguments
                         If  the second argument is one of the binary
                         conditional  operators  listed  above  under
                         CONDITIONAL  EXPRESSIONS,  the result of the
                         expression is the result of the binary  test
                         using  the  first  and  third  arguments  as
                         evaluated according to precedence using  the
                         rules listed above.
                  5 or more arguments
                         The   expression  is  parsed  and  evaluated
                         according  to  precedence  using  the  rules
                         listed above.

           times  Print the accumulated user and system times for the
                  shell and for processes run from  the  shell.   The
                  return status is 0.

           trap [-lp] [arg] [sigspec ...]
                  The command arg is to be read and executed when the
                  shell receives signal(s) sigspec.  If arg is absent
                  or  -,  all  specified  signals  are reset to their
                  original values (the values they had upon  entrance
                  to  the shell).  If arg is the null string the sig
                  nal specified by each sigspec  is  ignored  by  the
                  shell  and  by  the commands it invokes.  If arg is
                  not present and -p has been supplied, then the trap
                  commands  associated  with  each  sigspec  are dis
                  played.  If no arguments are supplied or if only -p
                  is  given, trap prints the list of commands associ
                  ated with each  signal  number.   Each  sigspec  is
                  either  a  signal  name defined in <signal.h>, or a
                  signal number.  If a sigspec is EXIT (0)  the  com
                  mand  arg is executed on exit from the shell.  If a
                  sigspec is DEBUG, the command arg is executed after
                  every simple command (see SHELL GRAMMAR above).  If
                  a sigspec is ERR, the command arg is executed when
                  ever  a  simple command has a non-zero exit status.
                  The ERR trap is not executed if the failed  command
                  is  part  of  an until or while loop, part of an if
                  statement, part of a && or || list, or if the  com
                  mand's  return  value is being inverted via !.  The
                  -l option causes the shell to print a list of  sig
                  nal names and their corresponding numbers.  Signals
                  ignored upon entry to the shell cannot  be  trapped
                  or reset.  Trapped signals are reset to their orig
                  inal values in a child process when it is  created.
                  The  return  status  is  false  if  any  sigspec is
                  invalid; otherwise trap returns true.

           type [-aftpP] name [name ...]
                  With no options, indicate how each  name  would  be
                  interpreted  if  used as a command name.  If the -t
                  option is used, type prints a string which  is  one
                  of  alias,  keyword,  function, builtin, or file if
                  name is an alias, shell  reserved  word,  function,
                  builtin,  or  disk file, respectively.  If the name
                  is not found, then nothing is printed, and an  exit
                  status  of  false is returned.  If the -p option is
                  type returns true  if  any  of  the  arguments  are
                  found, false if none are found.

           ulimit [-SHacdflmnpstuv [limit]]
                  Provides  control  over  the resources available to
                  the shell and to processes started by it,  on  sys
                  tems  that  allow  such  control.   The  -H  and -S
                  options specify that the hard or soft limit is  set
                  for  the  given  resource.   A hard limit cannot be
                  increased once it is  set;  a  soft  limit  may  be
                  increased  up  to  the value of the hard limit.  If
                  neither -H nor -S is specified, both the  soft  and
                  hard  limits  are set.  The value of limit can be a
                  number in the unit specified for  the  resource  or
                  one of the special values hard, soft, or unlimited,
                  which stand for the current hard limit, the current
                  soft  limit,  and no limit, respectively.  If limit
                  is omitted, the current value of the soft limit  of
                  the  resource  is  printed, unless the -H option is
                  given.  When more than one resource  is  specified,
                  the  limit  name  and  unit  are printed before the
                  value.  Other options are interpreted as follows:
                  -a     All current limits are reported
                  -c     The maximum size of core files created
                  -d     The maximum size of a process's data segment
                  -f     The  maximum  size  of  files created by the
                         shell
                  -l     The maximum size that  may  be  locked  into
                         memory
                  -m     The maximum resident set size
                  -n     The  maximum number of open file descriptors
                         (most systems do not allow this value to  be
                         set)
                  -p     The  pipe  size in 512-byte blocks (this may
                         not be set)
                  -s     The maximum stack size
                  -t     The maximum amount of cpu time in seconds
                  -u     The maximum number of processes available to
                         a single user
                  -v     The  maximum amount of virtual memory avail
                         able to the shell

                  If limit is given, it is the new value of the spec
                  ified 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  invalid  option  or
                  argument is supplied, or an error occurs while set
                  ting a new limit.

           unalias [-a] [name ...]
                  Remove  each name from the list of defined aliases.
                  If  -a  is  supplied,  all  alias  definitions  are
                  removed.   The  return  value is true unless a sup
                  plied name is not a defined alias.

           unset [-fv] [name ...]
                  For each name, remove the corresponding variable or
                  function.   If  no  options are supplied, or the -v
                  option is given, each name refers to a shell  vari
                  able.  Read-only variables may not be unset.  If -f
                  is specifed, each name refers to a shell  function,
                  and the function definition is removed.  Each unset
                  variable or function is removed from  the  environ
                  ment passed to subsequent commands.  If any of RAN
                  DOM, SECONDS, LINENO, HISTCMD, FUNCNAME, GROUPS, or
                  DIRSTACK are unset, they lose their special proper
                  ties, even if they  are  subsequently  reset.   The
                  exit status is true unless a name does not exist or
                  is readonly.

           wait [n]
                  Wait for the specified process and return its  ter
                  mination  status.   n  may be a process ID or a job
                  specification; if a job spec  is  given,  all  pro
                  cesses in that job's pipeline are waited for.  If n
                  is not given, all currently active child  processes
                  are  waited for, and the return status is zero.  If
                  n specifies a  non-existent  process  or  job,  the
                  return status is 127.  Otherwise, the return status
                  is the exit status  of  the  last  process  or  job
                  waited for.

## RESTRICTED SHELL

           If  bash  is started with the name rbash, or the -r option
           is supplied at invocation, the shell  becomes  restricted.
           A  restricted  shell is used to set up an environment more
           controlled than the standard shell.   It  behaves  identi
           cally  to  bash  with the exception that the following are
           disallowed or not performed:

           ·      changing directories with cd

           ·      setting or unsetting the  values  of  SHELL,  PATH,
                  ENV, or BASH_ENV

           ·      specifying command names containing /

           ·      specifying  a  file name containing a / as an argu
                  ment to the .  builtin command

           ·      Specifying a filename  containing  a  slash  as  an

           ·      adding or deleting builtin commands with the -f and
                  -d options to the enable builtin command

           ·      Using the enable builtin command to enable disabled
                  shell builtins

           ·      specifying the -p option  to  the  command  builtin
                  command

           ·      turning  off  restricted mode with set +r or set +o
                  restricted.

           These restrictions are enforced after  any  startup  files
           are read.

           When  a command that is found to be a shell script is exe
           cuted (see COMMAND EXECUTION above), rbash turns  off  any
           restrictions in the shell spawned to execute the script.

## SEE ALSO

           Bash Reference Manual, Brian Fox and Chet Ramey
           The Gnu Readline Library, Brian Fox and Chet Ramey
           The Gnu History Library, Brian Fox and Chet Ramey
           Portable  Operating System Interface (POSIX) Part 2: Shell
           and Utilities, IEEE
           sh(1), ksh(1), csh(1)
           emacs(1), vi(1)
           readline(3)

## FILES

           /bin/bash
                  The bash executable
           /etc/profile
                  The  systemwide  initialization  file, executed for
                  login shells
           ~/.bash_profile
                  The  personal  initialization  file,  executed  for
                  login shells
           ~/.bashrc
                  The individual per-interactive-shell startup file
           ~/.bash_logout
                  The  individual  login shell cleanup file, executed
                  when a login shell exits
           ~/.inputrc
                  Individual readline initialization file
           /etc/inputrc
                  System readline initialization file

## AUTHORS

           Brian Fox, Free Software Foundation
           bfox@gnu.org
           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
           A description of the bug behaviour
           A short script or `recipe' which exercises the bug

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

           Comments  and  bug  reports  concerning  this  manual page
           should be directed to chet@ins.CWRU.Edu.

## BUGS

           It's too big and too slow.

           There are some subtle differences between bash and  tradi
           tional  versions of sh, mostly because of the POSIX speci
           fication.

           Aliases are confusing in some uses.

           Shell  builtin  commands  and  functions  are  not   stop
           pable/restartable.

           Compound commands and command sequences of the form `a ; b
           ; c' are not handled gracefully when process suspension is
           attempted.   When  a process is stopped, the shell immedi
           ately executes the next command in the sequence.  It  suf
           fices  to place the sequence of commands between parenthe
           ses to force it into a subshell, which may be stopped as a
           unit.

           Commands  inside  of  $(...)  command substitution are not
           parsed until substitution is attempted.  This  will  delay
           error  reporting  until  some  time  after  the command is
           entered.

           Array variables may not (yet) be exported.

    GNU Bash-2.05b             2002 July 15                   BASH(1)