NAME
     bash - GNU Bourne-Again SHell

SYNOPSIS
     bash [options] [file]

COPYRIGHT
     Bash is Copyright (C) 1989, 1991, 1993, 1995,  1996  by  the
     Free Software Foundation, 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 documented
     in  the  description of the set builtin command, bash inter-
     prets the following options when it is invoked:

     -c string If the -c option is  present,  then  commands  are
               read  from  string.   If there are arguments after
               the string, they are assigned  to  the  positional
               parameters, starting with $0.
     -r        If the -r option is  present,  the  shell  becomes
               restricted (see RESTRICTED SHELL below).
     -i        If the -i option is present, the shell is interac-
               tive.
     -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.
     -D        A list of all double-quoted strings preceded by  $
               is  printed  on the standard ouput.  These are the
               strings that are subject to  language  translation
               when  the  current locale is not C or POSIX.  This
               implies the -n option; no commands  will  be  exe-
               cuted.
     --        A -- signals  the  end  of  options  and  disables
               further  option  processing.   Any arguments after
               the -- are treated as filenames and arguments.  An
               argument of - is equivalent to --.

     Bash also interprets a number  of  multi-character  options.
     These  options  must  appear  on the command line before the
     single-character options in order for them to be recognized.
     --dump-po-strings
          Equivalent to -D, but the output is in the GNU  gettext
          po (portable object) file format.
     --dump-strings
          Equivalent to -D.
     --help
          Display a usage message on  standard  output  and  exit
          successfully.
     --login
          Make bash act as if it had  been  invoked  as  a  login
          shell (see INVOCATION below).
     --noediting
          Do not use the GNU readline  library  to  read  command
          lines if interactive.
     --noprofile
          Do  not  read  either  the  system-wide  startup   file
          /etc/profile  or  any  of  the  personal initialization
          files ~/.bash_profile,  ~/.bash_login,  or  ~/.profile.
          By  default,  bash reads these files when it is invoked
          as a login shell (see INVOCATION below).
     --norc
          Do not read and  execute  the  personal  initialization
          file  ~/.bashrc  if  the  shell  is  interactive.  This
          option is on by default if the shell is invoked as sh.
     --posix
          Change the behavior of bash where the default operation
          differs  from  the  POSIX  1003.2 standard to match the
          standard.
     --rcfile file
          Execute commands from file instead of the standard per-
          sonal  initialization  file  ~/.bashrc  if the shell is
          interactive (see INVOCATION below).
     --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  com-
     mands.  If bash is invoked in this fashion, $0 is set to the
     name of the file, and the positional parameters are  set  to
     the  remaining  arguments.  Bash reads and executes commands
     from this file, then exits.  Bash's exit status is the  exit
     status  of  the  last command executed in the script.  If no
     commands are executed, the exit status is 0.

INVOCATION
     A login shell is one whose first character of argument  zero
     is a -, or one started with the --login option.

     An interactive shell is one 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 EXPAN-
     SION section.

     When bash is invoked as an interactive login shell, it first
     reads  and  executes commands from the file /etc/profile, if
     that file exists.  After reading that  file,  it  looks  for
     ~/.bash_profile,  ~/.bash_login,  and  ~/.profile,  in  that
     order, and reads and executes commands from  the  first  one
     that  exists and is readable.  The --noprofile option may be
     used when the shell is started to inhibit this behavior.

     When a login shell exits, bash reads and  executes  commands
     from the file ~/.bash_logout, if it exists.

     When an interactive shell that  is  not  a  login  shell  is
     started, bash reads and executes commands from ~/.bashrc, if
     that file exists.  This may be inhibited by using the --norc
     option.   The  --rcfile  file option will force bash to read
     and execute commands from file instead of ~/.bashrc.

     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 exe-
     cuted:

          if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
     but the value of the PATH variable is not used to search for
     the file name.

     If bash is invoked with the name sh, it tries to  mimic  the
     startup  behavior of historical versions of sh as closely as
     possible, while conforming to the POSIX  standard  as  well.
     When  invoked  as  an  interactive  login  shell,  it  first
     attempts to read and execute commands from /etc/profile  and
     ~/.profile,  in  that  order.  The --noprofile option may be
     used to inhibit this behavior.  When invoked as an  interac-
     tive  shell  with  the  name sh, bash looks for the variable
     ENV, expands its value  if  it  is  defined,  and  uses  the
     expanded  value  as  the name of a file to read and execute.
     Since a shell invoked as sh does not  attempt  to  read  and
     execute  commands from any other startup files, the --rcfile
     option has no effect.  A non-interactive shell invoked  with
     the name sh does not attempt to read any startup files. When
     invoked as sh, bash enters  posix  mode  after  the  startup
     files are read.

     When bash is started in posix mode, as with the --posix com-
     mand  line option, it follows the POSIX standard for startup
     files.  In this mode,  interactive  shells  expand  the  ENV
     variable  and  commands  are read and executed from the file
     whose name is the expanded value.  No  other  startup  files
     are read.

     Bash attempts to determine when  it  is  being  run  by  the
     remote shell daemon, usually rshd.  If bash determines it is
     being run by rshd,  it  reads  and  executes  commands  from
     ~/.bashrc, if that file exists and is readable.  It will not
     do this if invoked as sh.  The --norc option may be used  to
     inhibit  this  behavior, and the --rcfile option may be used
     to force another file to be read, but  rshd  does  not  gen-
     erally  invoke the shell with those options or allow them to
     be specified.

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 command  (see
     SHELL GRAMMAR below) or the third word of a case or for com-
     mand:

     ! case  do done elif else esac fi for function if in  select
     then until while { } time [[ ]]

SHELL GRAMMAR
  Simple Commands
     A simple command is a sequence of optional variable  assign-
     ments  followed  by  blank-separated words and redirections,
     and terminated by a control operator.  The first word speci-
     fies  the  command  to be executed.  The remaining words are
     passed as arguments to the invoked command.

     The return value of a simple command is its exit status,  or
     128+n if the command is terminated by signal n.

  Pipelines
     A pipeline is a sequence of one or more  commands  separated
     by the character |.  The format for a pipeline is:

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

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

     If the reserved word ! precedes a pipeline, the exit  status
     of  that  pipeline  is the logical NOT of the exit status of
     the last command.  Otherwise, the status of the pipeline  is
     the  exit  status  of the last command.  The shell waits for
     all commands in the pipeline to terminate before returning a
     value.

     If the time reserved word precedes a pipeline,  the  elapsed
     as  well  as  user and system time consumed by its execution
     are reported when the pipeline terminates.   The  -p  option
     changes  the  output format to that specified by POSIX.  The
     TIMEFORMAT variable may be  set  to  a  format  string  that
     specifies  how  the  timing information should be displayed;
     see the description  of  TIMEFORMAT  under  Shell  Variables
     below.

     Each command in a pipeline is executed as a separate process
     (i.e., in a subshell).

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

     If a command is terminated by the control  operator  &,  the
     shell  executes the command in the background in a subshell.
     The shell does not wait for the command to finish,  and  the
     return  status is 0.  Commands separated by a ; are executed
     sequentially; the shell waits for each command to  terminate
     in  turn.   The return status is the exit status of the last
     command executed.

     The control operators && and ||  denote  AND  lists  and  OR
     lists, respectively.  An AND list has the form

          command && command2

     command2 is executed if, and only  if,  command  returns  an
     exit status of zero.

     An OR list has the form

          command || command2

     command2 is executed if and only if command returns  a  non-
     zero  exit status.  The return status of AND and OR lists is
     the exit status of the last command executed in the list.

  Compound Commands
     A compound command is one of the following:

     (list)
          list is executed in a subshell.   Variable  assignments
          and  builtin  commands that affect the shell's environ-
          ment do not remain in effect  after  the  command  com-
          pletes.  The return status is the exit status of list.

     { list; }
          list is simply executed in the current  shell  environ-
          ment.   list must be terminated with a newline or semi-
          colon.  This is known as a group command.   The  return
          status is the exit status of list.

     ((expression))
          The expression is  evaluated  according  to  the  rules
          described  below  under  ARITHMETIC EVALUATION.  If the
          value of the expression is non-zero, the return  status
          is  0;  otherwise  the  return  status  is  1.  This is
          exactly equivalent to let "expression".

     [[ expression ]]
          Return a status of 0 or 1 depending on  the  evaluation
          of  the conditional expression expression.  Expressions
          are composed of the  primaries  described  below  under
          CONDITIONAL  EXPRESSIONS.   Word splitting and pathname
          expansion are not performed on the words between the [[
          and  ]]; tilde expansion, parameter and variable expan-
          sion, arithmetic expansion, command substitution,  pro-
          cess substitution, and quote removal are performed.

          When the == and != operators are used,  the  string  to
          the  right  of the operator is considered a pattern and
          matched according to the rules  described  below  under
          Pattern  Matching.  The return value is 0 if the string
          matches or does not match  the  pattern,  respectively,
          and 1 otherwise.  Any part of the pattern may be quoted
          to force it to be matched as a string.

          Expressions may be combined using the following  opera-
          tors, listed in decreasing order of precedence:

          ( expression )
               Returns the value of expression.  This may be used
               to override the normal precedence of operators.
          ! expression
               True if expression is false.
          expression1 && expression2
               True if both expression1 and expression2 are true.
          expression1 || expression2
               True if either expression1 or expression2 is true.

     The && and || operators do not execute  expression2  if  the
     value  of  expression1 is sufficient to determine the return
     value of the entire conditional expression.

     for name [ in word; ] do list ; done
          The list of words following in is expanded,  generating
          a list of items.  The variable name is set to each ele-
          ment of this list in turn, and list  is  executed  each
          time.   If the in word is omitted, the for command exe-
          cutes list once for each positional parameter  that  is
          set  (see  PARAMETERS below).  The return status is the
          exit status of the last command that executes.  If  the
          expansion of the items following in results in an empty
          list, no commands are executed, and the  return  status
          is 0.

     select name [ in word; ] do list ; done
          The list of words following in is expanded,  generating
          a  list of items.  The set of expanded words is printed
          on the standard error, each preceded by a  number.   If
          the  in  word is omitted, the positional parameters are
          printed (see PARAMETERS below).  The PS3 prompt is then
          displayed  and a line read from the standard input.  If
          the line consists of a number corresponding to  one  of
          the  displayed  words, then the value of name is set to
          that word.  If the line is empty, the words and  prompt
          are  displayed  again.   If  EOF  is  read, the command
          completes.  Any other value read causes name to be  set
          to null.  The line read is saved in the variable REPLY.
          The list is executed after each selection until a break
          or  return  command  is  executed.   The exit status of
          select is the exit status of the last command  executed
          in list, or zero if no commands were executed.

     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  match-
          ing  rules  as  for  pathname  expansion  (see Pathname
          Expansion  below).   When  a  match   is   found,   the
          corresponding list is executed.  After the first match,
          no subsequent matches are attempted.  The  exit  status
          is  zero  if  no pattern matches.  Otherwise, it is the
          exit status of the last command executed in list.

fi
     if list; then list; [ elif list; then list; ] ... [ else list;  ]
          The  if  list is executed.  If its exit status is zero,
          the then list is executed.  Otherwise, each  elif  list
          is  executed  in  turn, and if its exit status is zero,
          the corresponding then list is executed and the command
          completes.   Otherwise,  the  else list is executed, if
          present.  The exit status is the  exit  status  of  the
          last  command  executed, or zero if no condition tested
          true.

     while list; do list; done
     until list; do list; done
          The while command continuously executes the do list  as
          long as the last command in list returns an exit status
          of zero.  The until command is identical to  the  while
          command,  except  that the test is negated; the do list
          is executed as long as the last command in list returns
          a  non-zero  exit status.  The exit status of the while
          and until commands is the exit status of  the  last  do
          list command executed, or zero if none was executed.

     [ function ] name () { list; }
          This defines a function named name.  The  body  of  the
          function is the list of commands between { and }.  This
          list is executed whenever name is specified as the name
          of  a simple command.  The exit status of a function is
          the exit status of the last  command  executed  in  the
          body.  (See FUNCTIONS below.)

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 characters on that
     line to  be  ignored.   An  interactive  shell  without  the
     interactive_comments option enabled does not allow comments.
     The interactive_comments option is on by default in interac-
     tive 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 prevent
     reserved words from being recognized as such, and to prevent
     parameter expansion.

     Each of the metacharacters listed  above  under  DEFINITIONS
     has  special meaning to the shell and must be quoted if they
     are  to  represent  themselves.   There  are  three  quoting
     mechanisms:  the escape character, single quotes, and double
     quotes.

     A non-quoted backslash (\)  is  the  escape  character.   It
     preserves  the literal value of the next character that fol-
     lows, with the exception of <newline>.  If a \<newline> pair
     appears,  and the backslash is not itself quoted, the \<new-
     line> is treated as a line  continuation  (that  is,  it  is
     removed from the input stream and effectively ignored).

     Enclosing characters in single quotes preserves the  literal
     value  of  each character within the quotes.  A single quote
     may not occur between single quotes, even when preceded by a
     backslash.

     Enclosing characters in double quotes preserves the  literal
     value  of  all characters within the quotes, with the excep-
     tion of $, `, and \.  The characters $ and  `  retain  their
     special meaning within double quotes.  The backslash retains
     its special meaning only when followed by one of the follow-
     ing  characters:  $,  `, ", \, or <newline>.  A double quote
     may be quoted within double quotes by preceding  it  with  a
     backslash.

     The special parameters * and @ have special meaning when  in
     double quotes (see PARAMETERS below).

     Words of the form $'string' are treated specially.  The word
     expands   to   string,   with  backslash-escaped  characters
     replaced as specifed by  the  ANSI  C  standard.   Backslash
     escape sequences, if present, are decoded as follows:
          \a   alert (bell)
          \b   backspace
          \e   an escape character
          \f   form feed
          \n   new line
          \r   carriage return
          \t   horizontal tab
          \v   vertical tab
          \\   backslash
          \nnn the character whose ASCII code is the octal  value
               nnn (one to three digits)
          \xnnn
               the character whose ASCII code is the  hexadecimal
               value nnn (one to three digits)

     The translated 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 parameter is set if it has been  assigned  a  value.   The
     null  string  is  a valid value.  Once a variable is set, it
     may be unset only by using the unset  builtin  command  (see
     SHELL BUILTIN COMMANDS below).

     A variable may be assigned to by a statement of the form

          name=[value]

     If value is not given, the variable  is  assigned  the  null
     string.   All  values undergo tilde expansion, parameter and
     variable expansion, string expansion, command  substitution,
     arithmetic  expansion,  and  quote  removal  (see  EXPANSION
     below).  If the variable has its integer attribute set  (see
     declare  below in SHELL BUILTIN COMMANDS) then value is sub-
     ject to arithmetic expansion even if the $((...))  expansion
     is  not  used (see Arithmetic Expansion below).  Word split-
     ting is  not  performed,  with  the  exception  of  "$@"  as
     explained  below  under Special Parameters.  Pathname expan-
     sion is not performed.

  Positional Parameters
     A positional parameter is a parameter denoted by one or more
     digits,  other  than the single digit 0.  Positional parame-
     ters are assigned from the  shell's  arguments  when  it  is
     invoked,  and  may  be reassigned using the set builtin com-
     mand.  Positional parameters may not  be  assigned  to  with
     assignment   statements.    The  positional  parameters  are
     temporarily replaced when a shell function is executed  (see
     FUNCTIONS below).

     When a positional parameter consisting of more than a single
     digit is expanded, it must be enclosed in braces (see EXPAN-
     SION below).

  Special Parameters
     The shell treats several parameters specially.  These param-
     eters  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 param-
          eters  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  ()  sub-
          shell,  it  expands  to  the  process ID of the current
          shell, not the subshell.
     !    Expands to the process ID of the most recently executed
          background (asynchronous) command.
     0    Expands to the name of the shell or shell script.  This
          is  set  at  shell  initialization.  If bash is invoked
          with a file of commands, $0 is set to the name of  that
          file.   If  bash is started with the -c option, then $0
          is set to the first argument after  the  string  to  be
          executed,  if  one is present.  Otherwise, it is set to
          the file name used to invoke bash, as given by argument
          zero.
     _    At shell startup, set to the absolute file name of  the
          shell  or  shell script being executed as passed in the
          argument list.  Subsequently, expands to the last argu-
          ment  to  the  previous command, after expansion.  Also
          set to the full file name of each command executed  and
          placed  in  the  environment  exported to that command.
          When checking mail, this parameter holds  the  name  of
          the mail file currently being checked.

  Shell Variables
     The following variables are set by the shell:

     PPID The process ID of the shell's parent.  This variable is
          readonly.
     PWD  The current working directory as set by the cd command.
     OLDPWD
          The previous working directory as set by  the  cd  com-
          mand.
     REPLY
          Set to the line of input read by the read builtin  com-
          mand when no arguments are supplied.
     UID  Expands to the user ID of the current user, initialized
          at shell startup.  This variable is readonly.
     EUID Expands to the effective user ID of the  current  user,
          initialized   at   shell  startup.   This  variable  is
          readonly.
     GROUPS
          An array variable containing  the  list  of  groups  of
          which  the  current user is a member.  This variable is
          readonly.
     BASH Expands to the full  file  name  used  to  invoke  this
          instance of bash.
     BASH_VERSION
          Expands to a string  describing  the  version  of  this
          instance of bash.
     BASH_VERSINFO
          A readonly array variable whose  members  hold  version
          information  for  this  instance  of  bash.  The values
          assigned to the array members are as follows:

          BASH_VERSINFO[0]        The major version  number  (the
                                  release).
          BASH_VERSINFO[1]        The minor version  number  (the
                                  version).
          BASH_VERSINFO[2]        The patch level.
          BASH_VERSINFO[3]        The build version.
          BASH_VERSINFO[4]        The   release   status   (e.g.,
                                  beta1).
          BASH_VERSINFO[5]        The value of MACHTYPE.

     SHLVL
          Incremented by one each time an  instance  of  bash  is
          started.

     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
          special properties, even if it is subsequently reset.

     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  subse-
          quent  references  is  the  number of seconds since the
          assignment plus the  value  assigned.   If  SECONDS  is
          unset,  it  loses its special properties, even if it is
          subsequently reset.

     LINENO
          Each time this parameter is referenced, the shell  sub-
          stitutes  a  decimal  number  representing  the current
          sequential line  number  (starting  with  1)  within  a
          script  or function.  When not in a script or function,
          the value substituted is not guaranteed to be  meaning-
          ful.   If LINENO 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 subsequently reset.

     DIRSTACK
          An array variable (see  Arrays  below)  containing  the
          current  contents  of the directory stack.  Directories
          appear in the stack in the order they are displayed  by
          the  dirs  builtin.  Assigning to members of this array
          variable may be used to modify directories  already  in
          the stack, but the pushd and popd builtins must be used
          to add and  remove  directories.   Assignment  to  this
          variable  will  not  change  the current directory.  If
          DIRSTACK is unset, it  loses  its  special  properties,
          even if it is subsequently reset.

     PIPESTATUS
          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  con-
          tain only a single command).

     OPTARG
          The value of the last option argument processed by  the
          getopts  builtin  command  (see  SHELL BUILTIN COMMANDS
          below).

     OPTIND
          The index of the next argument to be processed  by  the
          getopts  builtin  command  (see  SHELL BUILTIN COMMANDS
          below).

     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 executing.  The
          default is system-dependent.

     OSTYPE
          Automatically  set  to  a  string  that  describes  the
          operating  system  on  which  bash  is  executing.  The
          default is system-dependent.

     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.

     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.

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

     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>''.
     PATH The search path for commands.  It is a  colon-separated
          list  of  directories in which the shell looks for com-
          mands (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:.''.
     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.
     CDPATH
          The search path for the cd command.  This is  a  colon-
          separated  list of directories in which the shell looks
          for destination directories specified by  the  cd  com-
          mand.  A sample value is ``.:~:/usr''.
     BASH_ENV
          If this parameter is set when bash is executing a shell
          script, its value is interpreted as a filename contain-
          ing commands to initialize the shell, as in  ~/.bashrc.
          The  value of BASH_ENV is subjected to parameter expan-
          sion, command substitution,  and  arithmetic  expansion
          before  being  interpreted as a file name.  PATH is not
          used to search for the resultant file name.
     MAIL If this parameter is set to a file name and  the  MAIL-
          PATH  variable is not set, bash informs the user of the
          arrival of mail in the specified file.
     MAILCHECK
          Specifies how often (in seconds) bash checks for  mail.
          The  default  is  60 seconds.  When it is time to check
          for mail, the shell does so before displaying the  pri-
          mary prompt.  If this variable is unset, the shell dis-
          ables mail checking.
     MAILPATH
          A colon-separated list of file names to be checked  for
          mail.  The message to be printed when mail arrives in a
          particular file may be specified by separating the file
          name  from  the  message  with a `?'.  When used in the
          text of the message, $_ expands  to  the  name  of  the
          current mailfile. Example:
          MAILPATH='/usr/spool/mail/bfox?"You                have
          mail":~/shell-mail?"$_ has mail!"'
          Bash supplies a default value for  this  variable,  but
          the  location  of  the  user mail files that it uses is
          system dependent (e.g., /usr/spool/mail/$USER).
     PS1  The value of this parameter is expanded (see  PROMPTING
          below)  and  used  as  the  primary prompt string.  The
          default value is ``\s-\v\$ ''.
     PS2  The value of this parameter is expanded as with PS1 and
          used  as  the  secondary prompt string.  The default is
          ``> ''.
     PS3  The value of this parameter is used as the  prompt  for
          the select command (see SHELL GRAMMAR above).
     PS4  The value of this parameter is expanded as with PS1 and
          the  value is printed before each command bash displays
          during an execution trace.  The first character of  PS4
          is replicated multiple times, as necessary, to indicate
          multiple levels of indirection.  The default is ``+ ''.
     TIMEFORMAT
          The value of this parameter is used as a format  string
          specifying  how  the  timing  information for pipelines
          prefixed  with  the  time  reserved  word   should   be
          displayed.    The  %  character  introduces  an  escape
          sequence that is expanded to  a  time  value  or  other
          information.   The  escape sequences and their meanings
          are as follows; the braces denote optional portions.

          %%        A literal %.
          %[p][l]R  The elapsed time in seconds.
          %[p][l]S  The number of CPU  seconds  spent  in  system
                    mode.
          %P        The CPU percentage, computed as (%U +  %S)  /
                    %R.

          The optional p is a digit specifying the precision, the
          number  of  fractional digits after a decimal point.  A
          value of 0 causes no decimal point or  fraction  to  be
          output.   At  most three places after the decimal point
          may be specified;  values  of  p  greater  than  3  are
          changed  to  3.   If p is not specified, the value 3 is
          used.

          The optional l specifies  a  longer  format,  including
          minutes,  of the form MMmSS.FFs.  The value of p deter-
          mines whether or not the fraction is included.

          If this variable is not set, bash acts as if it had the
          value   $'\nreal\t%3lR\nuser\t%3lU\nsys%3lS'.   If  the
          value is null, no timing information is  displayed.   A
          trailing  newline  is  added  when the format string is
          displayed.

     HISTSIZE
          The number of commands to remember in the command  his-
          tory (see HISTORY below).  The default value is 500.

     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  history
          file.  When this variable is assigned a value, the his-
          tory 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.

     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.

     LANG Used to determine the locale category for any  category
          not specifically selected with a variable starting with
          LC_.

     LC_ALL
          This variable overrides the value of LANG and any other
          LC_ variable specifying a locale category.

     LC_COLLATE
          This variable determines the collation order used  when
          sorting  the  results of pathname expansion, and deter-
          mines the behavior of  range  expressions,  equivalence
          classes, and collating sequences within pathname expan-
          sion and pattern matching.

     LC_CTYPE
          This variable determines the interpretation of  charac-
          ters and the behavior of character classes within path-
          name expansion and pattern matching.

     LC_MESSAGES
          This variable determines the locale used  to  translate
          double-quoted strings preceded by a $.

     PROMPT_COMMAND
          If set, the value is executed as  a  command  prior  to
          issuing each primary prompt.

     IGNOREEOF
          Controls the action of an interactive shell on  receipt
          of  an  EOF  character  as the sole input.  If set, the
          value is the number of consecutive EOF characters which
          must  be typed as the first characters on an input line
          before bash exits.  If the variable exists but does not
          have  a  numeric  value,  or  has no value, the default
          value is 10.  If it does not exist, EOF  signifies  the
          end of input to the shell.

     TMOUT
          If set to a value  greater  than  zero,  the  value  is
          interpreted  as the number of seconds to wait for input
          after issuing  the  primary  prompt.   Bash  terminates
          after  waiting for that number of seconds if input does
          not arrive.

     FCEDIT
          The default editor for the fc builtin command.

     FIGNORE
          A colon-separated list of suffixes to ignore when  per-
          forming  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  pattern  also
          matches  one  of  the  patterns  in  GLOBIGNORE,  it is
          removed from the list of matches.

     INPUTRC
          The filename for the readline startup file,  overriding
          the default of ~/.inputrc (see READLINE below).

     HISTCONTROL
          If set to a value of  ignorespace,  lines  which  begin
          with  a  space character are not entered on the history
          list.  If set to a value of ignoredups, lines  matching
          the  last  history  line  are  not entered.  A value of
          ignoreboth combines the two options.  If unset,  or  if
          set to any other value than those above, all lines read
          by the parser are saved on the history list, subject to
          the  value  of HISTIGNORE.  This variable's function is
          superseded by HISTIGNORE.  The  second  and  subsequent
          lines  of a multi-line compound command are not tested,
          and are added to the history regardless of the value of
          HISTCONTROL.

     HISTIGNORE
          A colon-separated list of patterns used to decide which
          command  lines  should  be  saved  on the history list.
          Each pattern is anchored at the beginning of  the  line
          and  must  fully  specify  the line (no implicit `*' is
          appended).  Each pattern is  tested  against  the  line
          after  the checks specified by HISTCONTROL are applied.
          In addition to the normal shell pattern matching  char-
          acters, `&' matches the previous history line.  `&' may
          be escaped using a backslash.  The backslash is removed
          before  attempting  a match.  The second and subsequent
          lines of a multi-line compound command are not  tested,
          and are added to the history regardless of the value of
          HISTIGNORE.

     histchars
          The two  or  three  characters  which  control  history
          expansion   and  tokenization  (see  HISTORY  EXPANSION
          below).  The first character is the  history  expansion
          character,  the  character which signals the start of a
          history expansion, normally `!'.  The second  character
          is  the  quick substitution character, which is used as
          shorthand for re-running the previous command  entered,
          substituting  one  string  for  another in the command.
          The default is `^'.  The optional  third  character  is
          the character which indicates that the remainder of the
          line is a comment when found as the first character  of
          a  word,  normally  `#'.  The history comment character
          causes history  substitution  to  be  skipped  for  the
          remaining  words  on the line.  It does not necessarily
          cause the shell parser to treat the rest of the line as
          a comment.

     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 file may be changed  interac-
          tively;  the next time hostname completion is attempted
          bash adds the contents of the new file to  the  already
          existing database.

     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 sub-
          string value provides functionality analogous 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 analo-
          gous to the % job identifier.

  Arrays
     Bash provides one-dimensional array variables.  Any variable
     may be used as an array; the declare builtin will explicitly
     declare an array.  There is no maximum limit on the size  of
     an  array,  nor  any  requirement that members be indexed or
     assigned contiguously.  Arrays are  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 members of
     an array.


     Arrays are assigned to using  compound  assignments  of  the
     form  name=(value1  ...  valuen), where each value is of the
     form [subscript]=string.  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  elements  may be
     assigned to using the  name[subscript]=value  syntax  intro-
     duced 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 single
     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[subscript]}.   If  subscript
     is  *  or  @, the expansion is the number of elements in the
     array.  Referencing an array variable without a subscript is
     equivalent to referencing element zero.

     The  unset  builtin  is  used  to  destroy  arrays.    unset
     name[subscript]  destroys  the  array  element at index sub-
     script.  unset name,  where  name  is  an  array,  or  unset
     name[subscript],  where  subscript  is  *  or @, removes the
     entire array.

     The declare, local, and readonly builtins each accept  a  -a
     option  to  specify an array.  The read builtin accepts a -a
     option to assign a list of  words  read  from  the  standard
     input  to  an  array.   The set and declare builtins display
     array values in a way that  allows  them  to  be  reused  as
     assignments.

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

     The order of expansions is: brace  expansion,  tilde  expan-
     sion,  parameter, variable and arithmetic expansion and com-
     mand substitution (done in a  left-to-right  fashion),  word
     splitting, and pathname expansion.
     On systems that can  support  it,  there  is  an  additional
     expansion available: process substitution.

     Only brace expansion, word splitting, and pathname expansion
     can  change  the  number  of  words  of the expansion; other
     expansions expand a single word to a single word.  The  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.  Pat-
     terns  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 preserved
     in the result.  It is strictly textual.  Bash does not apply
     any syntactic interpretation to the context of the expansion
     or the text between the braces.

     A correctly-formed brace  expansion  must  contain  unquoted
     opening and closing braces, and at least one unquoted comma.
     Any incorrectly formed brace expansion is left unchanged.  A
     {  or  , may be quoted with a backslash to prevent its being
     considered part of a brace expression.

     This construct is typically used as shorthand when the  com-
     mon  prefix of the strings to be generated is longer than in
     the above example:

          mkdir /usr/local/src/bash/{old,new,dist,bugs}
     or
          chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

     Brace expansion introduces  a  slight  incompatibility  with
     historical  versions  of  sh.   sh does not treat opening or
     closing braces specially when they appear as part of a word,
     and  preserves them in the output.  Bash removes braces from
     words as a consequence of brace expansion.  For  example,  a
     word  entered  to sh as file{1,2} appears identically in the
     output.  The same  word  is  output  as  file1  file2  after
     expansion  by  bash.   If  strict  compatibility  with sh is
     desired, start bash with the  +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  substi-
     tuted 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  vari-
     able  PWD replaces the tilde-prefix.  If the tilde-prefix 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  pre-
     fixed  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, MAILPATH,
     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 first
     `}'  not  escaped  by a backslash or within a quoted string,
     and not within an  embedded  arithmetic  expansion,  command
     substitution, or paramter expansion.

     ${parameter}
          The value of parameter is substituted.  The braces  are
          required  when parameter is a positional parameter with
          more than one digit, or when parameter is followed by a
          character which is not to be interpreted as part of its
          name.

     If the first character of parameter is an exclamation point,
     a  level  of  variable indirection is introduced.  Bash uses
     the value of the variable formed from the rest of  parameter
     as  the name of the variable; this variable is then expanded
     and that value used in the rest of the substitution,  rather
     than  the  value  of  parameter  itself.   This  is known as
     indirect expansion.

     In each of the cases below, word is subject to tilde  expan-
     sion,  parameter expansion, command substitution, and arith-
     metic 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 parameter.  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  stan-
          dard  error  and  the  shell, if it is not interactive,
          exits.  Otherwise, the value of  parameter  is  substi-
          tuted.
     ${parameter:+word}
          Use Alternate Value.  If parameter is  null  or  unset,
          nothing is substituted, otherwise the expansion of word
          is substituted.
     ${parameter:offset}
     ${parameter:offset:length}
          Substring Expansion.  Expands to up to  length  charac-
          ters of parameter, starting at the characters specified
          by offset.  If length is omitted, expands to  the  sub-
          string  of  parameter, starting at the character speci-
          fied 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 offset  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   ${parameter[offset]}.    Substring  indexing  is
          zero-based unless the positional parameters  are  used,
          in which case the indexing starts at 1.

     ${#parameter}
          The length in characters of the value of  parameter  is
          substituted.  If parameter is * or @, the value substi-
          tuted is  the  number  of  positional  parameters.   If
          parameter  is  an array name subscripted by * or @, the
          value substituted is the  number  of  elements  in  the
          array.

     ${parameter#word}
     ${parameter##word}
          The word is expanded to produce a pattern  just  as  in
          pathname  expansion.  If the pattern matches the begin-
          ning 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 long-
          est  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  parameter  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%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  parameter,  then  the
          result of the expansion is the expanded value of param-
          eter 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
          parameter 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 resul-
          tant 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  string.   If
          pattern  begins  with  %,  it  must match at the end of
          string.  If string is  null,  matches  of  pattern  are
          deleted and the / following pattern may be omitted.  If
          parameter is @ or  *,  the  substitution  operation  is
          applied  to  each positional parameter in turn, and the
          expansion is the resultant list.  If  parameter  is  an
          array  variable  subscripted with @ or *, the substitu-
          tion operation is applied to each member of  the  array
          in turn, and the expansion is the resultant list.

  Command Substitution
     Command substitution allows  the  output  of  a  command  to
     replace the command name.  There are two forms:

          $(command)
     or
          `command`

     Bash performs the expansion by executing command and replac-
     ing the command substitution with the standard output of the
     command, with any trailing newlines deleted.  Embedded  new-
     lines  are  not deleted, but they may be removed during word
     splitting.  The command  substitution  $(cat  file)  can  be
     replaced by the equivalent but faster $(< file).

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

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

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

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


          $((expression))

     The expression is  treated  as  if  it  were  within  double
     quotes,  but  a  double  quote inside the parentheses is not
     treated specially.  All tokens  in  the  expression  undergo
     parameter expansion, string expansion, command substitution,
     and quote removal.  Arithmetic substitutions may be nested.

     The evaluation is performed according to  the  rules  listed
     below   under   ARITHMETIC  EVALUATION.   If  expression  is
     invalid, bash prints a message  indicating  failure  and  no
     substitution occurs.

  Process Substitution
     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.

     When available, process substitution is performed simultane-
     ously with parameter and variable expansion, command substi-
     tution, and arithmetic expansion.

  Word Splitting
     The shell scans the results of parameter expansion,  command
     substitution,  and  arithmetic  expansion that did not occur
     within double quotes for word splitting.

     The shell treats each character of IFS as a  delimiter,  and
     splits  the  results  of  the other expansions into words on
     these characters.  If IFS is unset, or its value is  exactly
     <space><tab><newline>, the default, then any sequence of IFS
     characters serves to delimit words.   If  IFS  has  a  value
     other  than  the  default,  then sequences of the whitespace
     characters space and tab are ignored at  the  beginning  and
     end  of  the word, as long as the whitespace character is in
     the value of IFS (an IFS whitespace character).  Any charac-
     ter  in IFS that is not IFS whitespace, along with any adja-
     cent  IFS  whitespace  characters,  delimits  a  field.    A
     sequence  of  IFS whitespace characters is also treated as a
     delimiter.  If the value of IFS is null, no  word  splitting
     occurs.

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

     Note that if no expansion occurs, no splitting is performed.

  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 dis-
     abled, 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  per-
     formed  without regard to the case of alphabetic 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 charac-
     ter must always be matched explicitly.  In other cases,  the
     ``.''  character is not treated specially.  See the descrip-
     tion 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  pat-
     terns  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 patterns in GLOBIGNORE.  The dotglob
     option is disabled when GLOBIGNORE is unset.

     Pattern Matching

     Any character that appears in a pattern, other than the spe-
     cial  pattern  characters  described  below, matches itself.
     The NUL character may not occur in a pattern.   The  special
     pattern  characters must be quoted if they are to be matched
     literally.

     The special pattern characters have the following meanings:

     *    Matches any string, including the null string.
     ?    Matches any single character.
     [...]
          Matches any one of the enclosed characters.  A pair  of
          characters  separated  by a minus sign denotes a range;
          any character lexically between those  two  characters,
          inclusive,  is matched.  If the first character follow-
          ing the [ is a ! or a ^ then any character not enclosed
          is  matched.  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 standard:
          alnum alpha ascii blank cntrl digit graph  lower  print
          punct space upper xdigit
          A character class matches any  character  belonging  to
          that class.

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

          Within [ and ], the syntax [.symbol.] matches the  col-
          lating symbol symbol.

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

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

  Quote Removal
     After the preceding expansions, all unquoted occurrences  of
     the  characters  \, ', and " that did not result from one of
     the above expansions are removed.

REDIRECTION
     Before a command is executed, its input and  output  may  be
     redirected  using  a  special  notation  interpreted  by the
     shell.  Redirection may also be used to open and close files
     for  the current shell execution environment.  The following
     redirection operators may precede or appear anywhere  within
     a  simple command or may follow a command.  Redirections are
     processed in the order they appear, from left to right.

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

     The word following the redirection operator in the following
     descriptions,  unless otherwise noted, is subjected to brace
     expansion, tilde  expansion,  parameter  expansion,  command
     substitution, arithmetic expansion, quote removal, and path-
     name expansion.  If it expands to more than one  word,  bash
     reports an error.

     Note that the order of  redirections  is  significant.   For
     example, the command

          ls > dirlist 2>&1

     directs both standard output and standard error to the  file
     dirlist, while the command

          ls 2>&1 > dirlist

     directs only the standard output to  file  dirlist,  because
     the  standard error was duplicated as standard output before
     the standard output was redirected to dirlist.

     A failure to open or create a file causes the redirection to
     fail.

  Redirecting Input
     Redirection of input causes the file whose name results from
     the  expansion  of  word  to  be  opened for reading on file
     descriptor n, or the standard input (file descriptor 0) if n
     is not specified.

     The general format for redirecting input is:

          [n]<word

  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 filename whose name results from  the  expansion
     of  word  exists  and is a regular file.  If the redirection
     operator is >|, or the redirection operator  is  >  and  the
     noclobber  option 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  semanti-
     cally equivalent to

          >word 2>&1

  Here Documents
     This type of redirection instructs the shell to  read  input
     from  the  current  source until a line containing only word
     (with no trailing blanks) is seen.  All of the lines read up
     to that point are then used as the standard input for a com-
     mand.

     The format of here-documents is as follows:

          <<[-]word
                  here-document
          delimiter

     No  parameter  expansion,  command  substitution,   pathname
     expansion, or arithmetic expansion is performed on word.  If
     any characters in word are  quoted,  the  delimiter  is  the
     result  of quote removal on word, and the lines in the here-
     document are not expanded.  If word is unquoted,  all  lines
     of  the  here-document are subjected to parameter expansion,
     command substitution,  and  arithmetic  expansion.   In  the
     latter  case,  the pair \<newline> is ignored, and \ must be
     used to quote the characters \, $, and `.

     If the redirection operator is <<-,  then  all  leading  tab
     characters  are  stripped from input lines and the line con-
     taining delimiter.  This allows here-documents within  shell
     scripts to be indented in a natural fashion.

  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 descriptor 1)
     is used.  If the digits  in  word  do  not  specify  a  file
     descriptor  open for output, a redirection error occurs.  As
     a special case, if n is omitted, and word does not expand to
     one  or  more digits, the standard output and standard error
     are redirected as described previously.

  Opening File Descriptors for Reading and Writing
     The redirection operator

          [n]<>word


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

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 contain any valid shell input,
     including the metacharacters listed above, with  the  excep-
     tion  that the alias name may not contain =.  The first word
     of the replacement text is tested for aliases,  but  a  word
     that is identical to an alias being expanded is not expanded
     a second time.  This means that one may alias ls to  ls  -F,
     for  instance,  and  bash does not try to recursively expand
     the replacement text.  If the last character  of  the  alias
     value  is  a blank, then the next command word following the
     alias is also checked for alias expansion.

     Aliases are created and listed with the alias  command,  and
     removed with the unalias command.

     There is no mechanism for using arguments in the replacement
     text.   If  arguments are needed, a shell function should be
     used.

     Aliases are not expanded when the shell is not  interactive,
     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 complete
     line of input before executing any of the commands  on  that
     line.  Aliases are expanded when a command is read, not when
     it is executed.  Therefore, an alias definition appearing on
     the  same line as another command does not take effect until
     the next line of input is read.  The commands following  the
     alias  definition  on  that line are not affected by the new
     alias.  This behavior is also an issue  when  functions  are
     executed.   Aliases  are expanded when a function definition
     is read, not when the function is executed, because a  func-
     tion  definition  is itself a compound command.  As a conse-
     quence, aliases defined in  a  function  are  not  available
     until  after  that function is executed.  To be safe, always
     put alias definitions on a separate line,  and  do  not  use
     alias in compound commands.
     For almost every purpose, aliases are  superseded  by  shell
     functions.

FUNCTIONS
     A shell function, defined as  described  above  under  SHELL
     GRAMMAR,  stores  a  series of commands for later execution.
     Functions are executed in the context of the current  shell;
     no  new  process is created to interpret them (contrast this
     with the execution of a shell script).  When a  function  is
     executed,  the  arguments  to  the function become the posi-
     tional parameters during its execution.  The special parame-
     ter  # is updated to reflect the change.  Positional parame-
     ter 0 is unchanged.  All other aspects of the  shell  execu-
     tion  environment  are  identical between a function 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.

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

     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 automati-
     cally 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 long  integers
     with  no check for overflow, though division by 0 is trapped
     and flagged as an error.  The following list of operators is
     grouped into levels of equal-precedence operators.  The lev-
     els are listed in order of decreasing precedence.

     - +  unary minus and plus
     ! ~  logical and bitwise negation
     **   exponentiation
     * / %
          multiplication, division, remainder
     + -  addition, subtraction
     << >>
          left and right bitwise shifts
     <= >= < >
          comparison
     == !=
          equality and inequality
     &    bitwise AND
     ^    bitwise exclusive OR
     |    bitwise OR
     &&   logical AND
     ||   logical OR
     expr?expr:expr
          conditional evaluation
     = *= /= %= += -=
          assignment

     Shell variables are allowed as operands; parameter expansion
     is  performed  before the expression is evaluated. The value
     of a parameter is  coerced  to  a  long  integer  within  an
     expression.   A  shell  variable  need  not have its integer
     attribute turned on to be used in an expression.

     Constants with a leading 0 are interpreted as octal numbers.
     A  leading 0x or 0X denotes hexadecimal.  Otherwise, numbers
     take the form [base#]n,  where  base  is  a  decimal  number
     between  2 and 64 representing the arithmetic base, and n is
     a number in that base.  If base is omitted, then base 10  is
     used.   The  digits  greater  than  9 are represented by the
     lowercase letters, the uppercase letters, _, and @, in  that
     order.   If  base is less than or equal to 36, lowercase and
     uppercase letters may be used  interchangably  to  represent
     numbers between 10 and 35.

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

CONDITIONAL EXPRESSIONS
     Conditional expressions are used by the [[ compound  command
     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.

     -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.
     -f file
          True if file exists and is a regular file.
     -g file
          True if file exists and is set-group-id.
     -k file
          True if file exists and its ``sticky'' bit is set.
     -p file
          True if file exists and is a named pipe (FIFO).
     -r file
          True if file exists and is readable.
     -s file
          True if file exists and has a size greater than zero.
     -t fd
          True if file descriptor fd is open and refers to a ter-
          minal.
     -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.
     file1 -ot file2
          True if file1 is older than file2.
     file1 -ef file2
          True if file1 and file2 have 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 ==.
     string1 != string2
          True if the strings are not equal.
     string1 < string2
          True if string1 sorts before string2  lexicographically
          in the current locale.
     string1 > string2
          True if string1 sorts after  string2  lexicographically
          in the current locale.
     arg1 OP arg2
          OP is one of -eq, -ne, -lt, -le, -gt,  or  -ge.   These
          arithmetic  binary  operators  return  true  if arg1 is
          equal to, not equal to, less than, less than  or  equal
          to,  greater  than,  or  greater than or equal to arg2,
          respectively.  Arg1 and arg2 may be positive  or  nega-
          tive integers.

SIMPLE COMMAND EXPANSION
     When a simple command is executed, the  shell  performs  the
     following  expansions,  assignments,  and redirections, from
     left to right.

     1.   The words  that  the  parser  has  marked  as  variable
          assignments  (those  preceding  the  command  name) and
          redirections are saved for later processing.

     2.   The words that are not variable assignments or redirec-
          tions  are  expanded.  If any words remain after expan-
          sion, 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 under-
          goes tilde expansion, parameter expansion, command sub-
          stitution,  arithmetic  expansion,  and  quote  removal
          before being assigned to the variable.

     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 assign-
     ments attempts to assign a value to a readonly variable,  an
     error occurs, and the command exits with a non-zero status.

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

     If there is a command name left after  expansion,  execution
     proceeds  as described below.  Otherwise, the command exits.
     If one of the expansions contained a  command  substitution,
     the  exit  status  of  the command is the exit status of the
     last command substitution performed.  If there were no  com-
     mand 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 fol-
     lowing 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  FUNC-
     TIONS.   If  the  name  does not match a function, the shell
     searches for it in the list of shell builtins.  If  a  match
     is found, that builtin is invoked.

     If the name is neither a shell function nor a  builtin,  and
     contains  no slashes, bash searches each element of the PATH
     for a directory containing an executable file by that  name.
     Bash  uses  a  hash table to remember the full file names of
     executable files (see  hash  under  SHELL  BUILTIN  COMMANDS
     below).   A  full  search of the directories in PATH is per-
     formed only if the command is not found in the  hash  table.
     If  the  search  is  unsuccessful, the shell prints an error
     message and returns an exit status of 127.

     If the search is successful, or if the command name contains
     one or more slashes, the shell executes the named program in
     a separate execution environment.  Argument 0 is set to  the
     name  given,  and the remaining arguments to the command are
     set to the arguments given, if any.

     If this execution fails because the file is not  in  execut-
     able  format, and the file is not a directory, it is assumed
     to be a shell script, a file containing shell  commands.   A
     subshell is spawned to execute it.  This subshell reinitial-
     izes itself, so that the effect is as if  a  new  shell  had
     been  invoked  to handle the script, with the exception that
     the locations of commands remembered by the parent (see hash
     below  under  SHELL  BUILTIN  COMMANDS)  are retained by the
     child.

     If the program is a file beginning with #!, the remainder of
     the  first  line  specifies  an interpreter for the program.
     The shell executes the specified  interpreter  on  operating
     systems  that  do  not  handle  this executable format them-
     selves.  The arguments to the interpreter consist of a  sin-
     gle  optional argument following the interpreter name on the
     first line of the program, followed by the name of the  pro-
     gram, 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  inher-
          ited from the shell's parent

     +    current traps set by trap

     +    shell parameters that are set by variable assignment or
          with  set  or  inherited from the shell's parent in the
          environment

     +    shell functions defined during execution  or  inherited
          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
          jobs, the value of $$, and the value of $PPID

     When a simple command other than a builtin or shell function
     is  to  be  executed,  it is invoked in a separate execution
     environment that consists of the following.   Unless  other-
     wise noted, the values are inherited from the shell.


     +    the shell's open  files,  plus  any  modifications  and
          additions specified by redirections to the command

     +    the current working directory

     +    the file creation mode mask

     +    shell variables marked for export, along with variables
          exported for the command, passed in the environment

     +    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 parent at
     invocation.  Builtin commands that are invoked as part of  a
     pipeline  are  also  executed  in  a  subshell  environment.
     Changes made to the subshell environment cannot  affect  the
     shell's execution environment.

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  allows  you  to  manipulate  the  environment  in
     several  ways.   On  invocation,  the  shell  scans  its own
     environment and creates a parameter  for  each  name  found,
     automatically  marking  it  for  export  to child processes.
     Executed commands inherit the environment.  The  export  and
     declare  -x  commands  allow  parameters and functions to be
     added to and deleted from the environment.  If the value  of
     a  parameter  in  the environment is modified, the new value
     becomes part of the environment,  replacing  the  old.   The
     environment  inherited  by  any executed command consists of
     the shell's initial environment, whose values may  be  modi-
     fied  in the shell, less any pairs removed by the unset com-
     mand, plus any additions via the export and declare -x  com-
     mands.

     The environment for any simple command or  function  may  be
     augmented temporarily by prefixing it with parameter assign-
     ments, as described above in PARAMETERS.   These  assignment
     statements affect only the environment seen by that command.

     If the -k option is set (see the set builtin command below),
     then all parameter assignments are placed in the environment
     for a command, not just those that precede the command name.

     When bash invokes an external command, the variable _ is set
     to the full file name of the command and passed to that com-
     mand in its environment.

EXIT STATUS
     For the shell's purposes, a command which exits with a  zero
     exit status has succeeded.  An exit status of zero indicates
     success.  A non-zero exit status indicates failure.  When  a
     command terminates on a fatal signal, bash uses the value of
     128+signal as the exit status.

     If a command is not found, the child process created to exe-
     cute  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 exe-
     cuted,  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 interactive
     shell), and SIGINT is caught and handled (so that  the  wait
     builtin  is  interruptible).   In  all  cases,  bash ignores
     SIGQUIT.  If job control is in effect, bash ignores SIGTTIN,
     SIGTTOU, and SIGTSTP.

     Synchronous jobs started by bash have signal handlers set to
     the values inherited by the shell from its parent.  When job
     control is not in effect, asynchronous commands ignore  SIG-
     INT  and  SIGQUIT as well.  Commands run as a result of com-
     mand substitution ignore the keyboard-generated job  control
     signals SIGTTIN, SIGTTOU, and SIGTSTP.

     The shell exits by default upon receipt of a SIGHUP.  Before
     exiting,  it  resends  the  SIGHUP  to  all jobs, running or
     stopped.  Stopped jobs are sent SIGCONT to ensure that  they
     receive  the  SIGHUP.  To prevent the shell from sending the
     signal to a particular job, it should be  removed  from  the
     jobs  table  with the disown builtin (see SHELL BUILTIN COM-
     MANDS 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 wait-
     ing  for  an  asynchronous command via the wait builtin, the
     reception of a signal for which a trap  has  been  set  will
     cause  the  wait  builtin to return immediately with an exit
     status greater than 128, immediately after which the trap is
     executed.

JOB CONTROL
     Job control  refers  to  the  ability  to  selectively  stop
     (suspend)  the  execution of processes and continue (resume)
     their execution at a later point.  A user typically  employs
     this  facility via an interactive interface supplied jointly
     by the system's terminal driver and bash.

     The shell associates a job with each pipeline.  It  keeps  a
     table  of currently executing jobs, which may be listed with
     the jobs command.  When bash starts a job asynchronously (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  pipe-
     line  are  members  of  the  same  job.   Bash  uses the job
     abstraction as the basis for job control.

     To facilitate the implementation of the  user  interface  to
     job  control,  the  system maintains the notion of a current
     terminal process group ID.  Members of  this  process  group
     (processes  whose  process  group ID is equal to the current
     terminal process group ID) receive  keyboard-generated  sig-
     nals  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 ter-
     minal driver, which, unless caught, suspends the process.

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

     There are a number of ways to refer to a job in  the  shell.
     The  character % introduces a job name.  Job number n may be
     referred to as %n.  A job may also be referred  to  using  a
     prefix  of  the  name used to start it, or using a substring
     that appears in its command line.  For example,  %ce  refers
     to a stopped ce job.  If a prefix matches more than one job,
     bash reports an error.   Using  %?ce,  on  the  other  hand,
     refers  to  any  job containing the string ce in its command
     line.  If the substring matches  more  than  one  job,  bash
     reports  an  error.   The  symbols  %%  and  %+ refer to the
     shell's notion of the current job, which  is  the  last  job
     stopped  while  it  was  in the foreground or started in the
     background.  The previous job may be  referenced  using  %-.
     In  output  pertaining to jobs (e.g., the output of the jobs
     command), the current job is always flagged with  a  +,  and
     the previous job with a -.

     Simply naming a job can be used to bring it into  the  fore-
     ground:  %1  is a synonym for ``fg %1'', bringing job 1 from
     the background into the  foreground.   Similarly,  ``%1  &''
     resumes job 1 in the background, equivalent to ``bg %1''.

     The shell learns immediately whenever a job  changes  state.
     Normally,  bash  waits  until  it is about to print a prompt
     before reporting changes in a job's  status  so  as  to  not
     interrupt  any  other  output.   If the -b option to the set
     builtin  command  is  enabled,  bash  reports  such  changes
     immediately.

     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 customized
     by inserting a number of backslash-escaped  special  charac-
     ters that are decoded as follows:
          \a   an ASCII bell character (07)
          \d   the date in "Weekday  Month  Date"  format  (e.g.,
               "Tue May 26")
          \e   an ASCII escape character (033)
          \h   the hostname up to the first `.'
          \H   the hostname
          \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
          \u   the username of the current user
          \v   the version of bash (e.g., 2.00)
          \V   the release of bash, version +  patchlevel  (e.g.,
               2.00.0)
          \w   the current working directory
          \W   the basename of the current working directory
          \!   the history number of this command
          \#   the command number of this command
          \$   if the effective UID is 0, a #, otherwise a $
          \nnn the character corresponding to  the  octal  number
               nnn
          \\   a backslash
          \[   begin a sequence of non-printing characters, which
               could be used to embed a terminal control sequence
               into the prompt
          \]   end a sequence of non-printing characters

     The command number and the history number are  usually  dif-
     ferent:  the  history number of a command is its position in
     the history list, which may include commands  restored  from
     the  history  file  (see  HISTORY  below), while the command
     number is the position in the sequence of commands  executed
     during  the  current  shell  session.   After  the string is
     decoded, it is expanded  via  parameter  expansion,  command
     substitution,  arithmetic  expansion,  string 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 inter-
     face 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 prefix.  The combination M-C-x means
     ESC-Control-x, or press the Escape key then hold the Control
     key while pressing the x key.)

     Readline commands may be given numeric arguments, which nor-
     mally  act as a repeat count.  Sometimes, however, it is the
     sign of the argument that is significant.  Passing  a  nega-
     tive  argument  to a command that acts in the forward direc-
     tion (e.g., kill-line) causes that command to act in a back-
     ward direction. Commands whose behavior with arguments devi-
     ates 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 initializa-
     tion  file  (the  inputrc  file).   The name of this file is
     taken from the value of the INPUTRC variable.  If that vari-
     able  is  unset,  the default is ~/.inputrc.  When a program
     which uses the readline library starts up,  the  initializa-
     tion  file  is  read, and the key bindings and variables are
     set.  There are only a few basic constructs allowed  in  the
     readline  initialization  file.   Blank  lines  are ignored.
     Lines beginning with a # are comments.  Lines beginning with
     a $ indicate conditional constructs.  Other lines denote key
     bindings and variable settings.

     The default key-bindings may  be  changed  with  an  inputrc
     file.   Other  programs  that use this library may add their
     own commands and bindings.

     For example, placing

          M-Control-u: universal-argument
     or
          C-Meta-u: universal-argument
     into the inputrc would make M-C-u execute the readline  com-
     mand 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, keyname 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
     universal-argument,   M-DEL   is   bound   to  the  function
     backward-kill-word, and  C-o  is  bound  to  run  the  macro
     expressed  on  the  right  hand side (that is, to insert the
     text > output into the line).

     In the second form, "keyseq":function-name or macro,  keyseq
     differs  from  keyname  above  in  that  strings denoting an
     entire key sequence may be specified by placing the sequence
     within  double quotes.  Some GNU Emacs style key escapes can
     be used, as in the following example.

          "\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
     universal-argument.   C-x  C-r  is  bound  to  the  function
     re-read-init-file, and ESC [ 1 1 ~ is bound  to  insert  the
     text Function Key 1.  The full set of GNU Emacs style escape
     sequences is
          \C-  control prefix
          \M-  meta prefix
          \e   an escape character
          \\   backslash
          " \" literal "
          \'   literal '

     In addition to the  GNU  Emacs  style  escape  sequences,  a
     second set of backslash escapes is available:
          \a   alert (bell)
          \b   backspace
          \d   delete
          \f   form feed
          \n   newline
          \r   carriage return
          \t   horizontal tab
          \v   vertical tab
          \nnn the character whose ASCII code is the octal  value
               nnn (one to three digits)
          \xnnn
               the character whose ASCII code is the  hexadecimal
               value nnn (one to three 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.  Backslash
     will quote any other character in the macro text,  including
     " and '.

     Bash  allows  the  current  readline  key  bindings  to   be
     displayed  or  modified  with the bind builtin command.  The
     editing mode may be switched during interactive use by using
     the  -o option to the set builtin command (see SHELL BUILTIN
     COMMANDS below).

  Readline Variables
     Readline has variables that can be used to further customize
     its  behavior.   A  variable  may be set in the inputrc file
     with a statement of the form

          set variable-name value

     Except where noted, readline variables can take  the  values
     On or Off.  The variables and their default values are:

     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 audible, 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 command 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 generated 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  variable,  the  user is asked
          whether or not he wishes to view them;  otherwise  they
          are simply listed on the terminal.
     convert-meta (On)
          If set to On, readline will convert characters with the
          eighth  bit  set  to an ASCII key sequence by stripping
          the eighth bit and prepending an escape  character  (in
          effect, using escape as the meta prefix).
     disable-completion (Off)
          If set to On, readline will  inhibit  word  completion.
          Completion characters will be inserted into the line as
          if they had been mapped to self-insert.
     editing-mode (emacs)
          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  appli-
          cation  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  read-
          line attempts word completion.
     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 char-
          acters it  reads),  regardless  of  what  the  terminal
          claims it can support.  The name meta-flag is a synonym
          for this variable.
     keymap (emacs)
          Set the current readline keymap.  The set of valid key-
          map   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 (*).
     output-meta (Off)
          If set to On, readline will display characters with the
          eighth  bit set directly rather than as a meta-prefixed
          escape sequence.
     print-completions-horizontally (Off)
          If set to On, readline will  display  completions  with
          matches  sorted  horizontally  in  alphabetical  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 con-
     ditional  compilation  features  of the C preprocessor which
     allows key bindings and variable settings to be performed as
     the result of tests.  There are four parser directives used.

     $if  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  key-
               map  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  terminal-
               specific  key  bindings,  perhaps  to bind the key
               sequences output by the terminal's function  keys.
               The  word  on  the  right  side of the = is tested
               against 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  application  name,
               and an initialization file can test for a particu-
               lar  value.   This  could  be  used  to  bind  key
               sequences  to functions useful for a specific pro-
               gram.  For instance, the following command adds  a
               key  sequence  that quotes the current or previous
               word in Bash:

               $if Bash
               # Quote the current or previous word
               "\C-xq": "\eb\"\ef\""
               $endif

     $endif
          This command, as seen in  the  previous  example,  ter-
          minates an $if command.

     $else
          Commands in this branch of the $if directive  are  exe-
          cuted if the test fails.

     $include
          This directive takes a single filename as  an  argument
          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 command
     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 typ-
     ing  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 Escape character is used to
     terminate an incremental search.  Control-J will  also  ter-
     minate  the  search.   Control-G  will  abort an incremental
     search and restore the original line.  When  the  search  is
     terminated,  the  history entry containing the search string
     becomes the current line.  To find other matching entries in
     the  history  list, type Control-S or Control-R as appropri-
     ate.  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 ter-
     minate 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.

     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.  Command
     names without an accompanying key sequence  are  unbound  by
     default.

  Commands for Moving
     beginning-of-line (C-a)
          Move to the start of the current line.
     end-of-line (C-e)
          Move to the end of the line.
     forward-char (C-f)
          Move forward a character.
     backward-char (C-b)
          Move back a character.
     forward-word (M-f)
          Move forward to the end of the next  word.   Words  are
          composed   of   alphanumeric  characters  (letters  and
          digits).
     backward-word (M-b)
          Move back to the start of this, or the previous,  word.
          Words  are composed of alphanumeric characters (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,  mov-
          ing back in the list.
     next-history (C-n)
          Fetch the next command from the  history  list,  moving
          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 current cursor position (the  point).   This  is  a
          non-incremental search.
     history-search-backward
          Search backward through the history for the  string  of
          characters  between  the  start of the current line and
          the point.  This is a non-incremental search.
     yank-nth-arg (M-C-y)
          Insert the first argument to the previous command (usu-
          ally  the  second  word  on the previous line) at point
          (the current cursor position).   With  an  argument  n,
          insert  the  nth  word  from  the previous command (the
          words in the previous command begin with  word  0).   A
          negative  argument inserts the nth word from the end of
          the previous command.
     yank-last-arg (M-., M-_)
          Insert the last argument to the previous  command  (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 descrip-
          tion of history expansion.
     history-expand-line (M-^)
          Perform history expansion on  the  current  line.   See
          HISTORY  EXPANSION  below  for a description of history
          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.

  Commands for Changing Text
     delete-char (C-d)
          Delete the character under the cursor.  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.
     quoted-insert (C-q, C-v)
          Add the next character  typed  to  the  line  verbatim.
          This is how to insert characters like C-q, for example.
     tab-insert (C-v TAB)
          Insert a tab character.
     self-insert (a, b, A, 1, !, ...)
          Insert the character typed.
     transpose-chars (C-t)
          Drag the character before point forward over the  char-
          acter at point.  Point moves forward as well.  If point
          is at the end of the line, then transpose the two char-
          acters before point.  Negative arguments don't work.
     transpose-words (M-t)
          Drag the word behind the cursor past the word in  front
          of the cursor moving the cursor over that word as well.
     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.

  Killing and Yanking
     kill-line (C-k)
          Kill the text from the current cursor position  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 the cursor is.
     kill-word (M-d)
          Kill from the cursor 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 forward-word.
     backward-kill-word (M-Rubout)
          Kill the word behind the cursor.  Word  boundaries  are
          the same as those used by backward-word.
     unix-word-rubout (C-w)
          Kill the word behind the cursor, using white space as a
          word  boundary.  The word boundaries are different from
          backward-kill-word.
     delete-horizontal-space (M-\)
          Delete all spaces and tabs around point.
     kill-region
          Kill the text between the point and mark (saved  cursor
          position).  This text is referred to as the region.
     copy-region-as-kill
          Copy the text in the region to the kill buffer.
     copy-backward-word
          Copy the word before point to  the  kill  buffer.   The
          word boundaries are the same as backward-word.
     copy-forward-word
          Copy the word following point to the kill buffer.   The
          word boundaries are the same as forward-word.
     yank (C-y)
          Yank the top of the kill ring into the  buffer  at  the
          cursor.
     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 accumulating, or
          start a new argument.  M-- starts a negative 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, exe-
          cuting universal-argument again ends the numeric  argu-
          ment,  but is otherwise ignored.  As a special case, if
          this command is immediately  followed  by  a  character
          that  is  neither  a  digit or minus sign, the argument
          count for the next command is multiplied by four.   The
          argument  count  is  initially  one,  so executing this
          function the first time makes the argument count  four,
          a  second time makes the argument count sixteen, and so
          on.


  Completing
     complete (TAB)
          Attempt to perform completion on the text before point.
          Bash  attempts  completion treating the text as a vari-
          able (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-completions.
     menu-complete
          Similar to complete, but replaces the word to  be  com-
          pleted  with  a  single match from the list of possible
          completions.  Repeated execution of menu-complete steps
          through  the  list  of  possible completions, inserting
          each match in turn.  At the end of the list of  comple-
          tions,  the  bell  is  rung  and  the  original text is
          restored.  An argument of n moves n  positions  forward
          in the list of matches; a negative argument may be used
          to move backward through the  list.   This  command  is
          intended to be bound to TAB, but is unbound by default.
     complete-filename (M-/)
          Attempt filename completion on the text before point.
     possible-filename-completions (C-x /)
          List the possible completions of the text before point,
          treating it as a filename.
     complete-username (M-~)
          Attempt completion on the text before  point,  treating
          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,  treating
          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,  treating
          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,  treating
          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,  comparing
          the text against lines from the history list for possi-
          ble completion matches.
     complete-into-braces (M-{)
          Perform filename completion and return the list of pos-
          sible 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 key-
          board macro.
     end-kbd-macro (C-x ))
          Stop saving the characters typed into the current  key-
          board macro and store the definition.
     call-last-kbd-macro (C-x e)
          Re-execute the last keyboard macro defined,  by  making
          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  incor-
          porate  any  bindings  or  variable  assignments  found
          there.
     abort (C-g)
          Abort  the  current  editing  command  and   ring   the
          terminal's bell (subject to the setting of bell-style).
     do-uppercase-version (M-a, M-b, M-x, ...)
          If the metafied character x is lowercase, run the  com-
          mand that is bound to the corresponding uppercase char-
          acter.
     prefix-meta (ESC)
          Metafy the next character typed.  ESC f  is  equivalent
          to Meta-f.
     undo (C-_, C-x C-u)
          Incremental undo, separately remembered for each line.
     revert-line (M-r)
          Undo all changes made to this line.  This is like  exe-
          cuting 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 current point.  If a numeric  argu-
          ment 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 posi-
          tion  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  previous
          occurrence   of   that  character.   A  negative  count
          searches for subsequent occurrences.
     insert-comment (M-#)
          The value of the  readline  comment-begin  variable  is
          inserted  at the beginning of the current line, and the
          line is accepted as if a newline had been typed.   This
          makes the current line a shell comment.
     glob-expand-word (C-x *)
          The word before point is treated as a pattern for path-
          name  expansion, and the list of matching file names is
          inserted, replacing the word.
     glob-list-expansions (C-x g)
          The list of expansions that would have  been  generated
          by  glob-expand-word  is  displayed,  and  the  line is
          redrawn.
     dump-functions
          Print all of the functions and their  key  bindings  to
          the  readline  output stream.  If a numeric argument is
          supplied, the output is formatted in such a way that it
          can be made part of an inputrc file.
     dump-variables
          Print all of the settable readline variables and  their
          values  to  the  readline  output stream.  If a numeric
          argument is supplied, the output is formatted in such a
          way that it can be made part of an inputrc file.
     dump-macros
          Print all of the readline key sequences bound to 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.

HISTORY
     When the -o history option to the set  builtin  is  enabled,
     the  shell  provides access to the command history, the list
     of commands previously typed.  The text of the last HISTSIZE
     commands  (default  500)  is  saved  in a history list.  The
     shell stores each command  in  the  history  list  prior  to
     parameter  and  variable expansion (see EXPANSION above) but
     after history expansion is performed, subject to the  values
     of  the  shell  variables  HISTIGNORE  and  HISTCONTROL.  On
     startup, the history is initialized from the file  named  by
     the  variable  HISTFILE (default ~/.bash_history).  HISTFILE
     is truncated, if necessary, to contain no  more  than  HIST-
     FILESIZE  lines.   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 descrip-
     tion 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 can be used to display or
     modify  the  history  list  and manipulate the history file.
     When using the command-line  editing,  search  commands  are
     available  in  each  editing mode that provide access to the
     history list.

     The shell allows control over which commands  are  saved  on
     the  history list.  The HISTCONTROL and HISTIGNORE variables
     may be set to cause the shell to save only a subset  of  the
     commands  entered.   The  cmdhist  shell option, if enabled,
     causes the shell to attempt to save each line  of  a  multi-
     line  command  in  the same history entry, adding semicolons
     where necessary  to  preserve  syntactic  correctness.   The
     lithist  shell  option  causes the shell to save the command
     with embedded  newlines  instead  of  semicolons.   See  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 simi-
     lar to the history expansion in csh.  This section describes
     what syntax features are available.  This feature is enabled
     by default for interactive shells, and can be disabled using
     the +H option to the set builtin command (see SHELL  BUILTIN
     COMMANDS below).  Non-interactive shells do not perform his-
     tory 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  current
     input line, or fix errors in previous commands quickly.

     History expansion is performed immediately after a  complete
     line  is  read,  before  the shell breaks it into words.  It
     takes place in two parts.  The first is to  determine  which
     line  from the history list to use during substitution.  The
     second is to select portions of that line for inclusion into
     the  current one.  The line selected from the history is the
     event, and the portions of that line that are acted upon are
     words.   Various  modifiers  are available to manipulate the
     selected words.  The line is broken into words in  the  same
     fashion   as   when   reading   input,   so   that   several
     metacharacter-separated words surrounded by quotes are  con-
     sidered  one word.  History expansions are introduced by the
     appearance of the history expansion character, which is ! by
     default.  Only backslash (\) and single quotes can quote the
     history expansion character.

     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  description  of
     the shopt builtin), and readline is being used, history sub-
     stitutions 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  read-
     line  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 begin-
     ning of the line, with the first word  being  denoted  by  0
     (zero).   Words are inserted into the current line separated
     by single spaces.

     0 (zero)
          The zeroth word.  For the shell, this  is  the  command
          word.
     n    The nth word.
     ^    The first argument.  That is, word 1.
     $    The last argument.
     %    The word matched by the most recent `?string?' search.
     x-y  A range of words; `-y' abbreviates `0-y'.
     *    All of the words but the zeroth.  This is a synonym for
          `1-$'.   It  is  not an error to use * if there is just
          one word in the event; the empty string is returned  in
          that case.
     x*   Abbreviates x-$.
     x-   Abbreviates x-$ like x*, but omits the last word.

     If a word designator is supplied without an event specifica-
     tion, 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 substitu-
          tions.
     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  backslash.   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 delim-
          iter 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  expanding
          arguments and performing any specified redirections.  A
          zero exit code is returned.

      .  filename [arguments]
     source filename [arguments]
          Read and execute commands from filename in the  current
          shell  environment  and  return  the exit status of the
          last command executed from filename.  If filename  does
          not  contain  a  slash,  file names in PATH are used to
          find  the  directory  containing  filename.   The  file
          searched  for  in  PATH  need  not  be executable.  The
          current directory is searched if no file  is  found  in
          PATH.   If  the  sourcepath option to the shopt builtin
          command is turned off, the PATH is  not  searched.   If
          any  arguments are supplied, they become the positional
          parameters when filename is  executed.   Otherwise  the
          positional parameters are unchanged.  The return status
          is the status of the last  command  exited  within  the
          script  (0  if  no commands are executed), and false if
          filename is not found 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
          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 job-
          spec was not found or started without job control.

     bind [-m keymap] [-lpsvPSV]
     bind [-m keymap] [-q function] [-u function] [-r keyseq]
     bind [-m keymap] -f filename
     bind [-m keymap] keyseq:function-name
          Display current readline key and function bindings,  or
          bind  a  key  sequence to a readline function or macro.
          The binding syntax accepted is  identical  to  that  of
          .inputrc, but each binding must be passed as a separate
          argument;   e.g.,   '"\C-x\C-r":    re-read-init-file'.
          Options, if supplied, have the following meanings:
          -m keymap
               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-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 bindings.
          -v   Display readline variable names and values in such
               a way that they can be re-read.
          -V   List current readline variable names and values.
          -s   Display readline key sequences bound to macros and
               the  strings  they  output in such a way that they
               can be re-read.
          -S   Display readline key sequences bound to macros and
               the strings they output.
          -f filename
               Read key bindings from filename.
          -q function
               Query about which keys invoke the named function.
          -u function
               Unbind all keys bound to the named function.
          -r keyseq
               Remove any current binding for keyseq.

          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 executing a loop when break  is
          executed.

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

     cd [-LP] [dir]
          Change the current directory to dir.  The variable HOME
          is  the  default  dir.  The variable CDPATH defines the
          search path for the directory containing dir.  Alterna-
          tive 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  $OLDPWD.  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  all
          of  the  standard  utilities.   If  either the -V or -v
          option  is  supplied,  a  description  of  command   is
          printed.  The -v option causes a single word indicating
          the command or file name used to invoke command  to  be
          displayed;  the  -V  option  produces  a  more  verbose
          description.  If the -V or -v option is  supplied,  the
          exit  status  is  0 if command was found, and 1 if not.
          If neither option is supplied and an error occurred  or
          command  cannot be found, the exit status is 127.  Oth-
          erwise, the exit status of the command builtin  is  the
          exit status of command.

     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 [-afFirx] [-p] [name[=value]]
     typeset [-afFirx] [-p] [name[=value]]
          Declare variables and/or give them attributes.   If  no
          names  are  given then display the values of variables.
          The -p option will display the attributes and values of
          each  name.   When  -p  is used, additional options are
          ignored.  The -F option inhibits the display  of  func-
          tion definitions; only the function name and attributes
          are printed.  The -F option implies -f.  The  following
          options  can  be  used  to restrict output to variables
          with the  specified  attribute  or  to  give  variables
          attributes:
          -a   Each name is an array variable (see Arrays above).
          -f   Use function names only.
          -i   The variable is treated as an integer;  arithmetic
               evaluation  (see  ARITHMETIC  EVALUATION ) is per-
               formed when the variable is assigned a value.
          -r   Make names readonly.  These names cannot  then  be
               assigned  values  by  subsequent assignment state-
               ments or unset.
          -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  function,
          makes  each name local, as with the local command.  The
          return value is 0 unless an invalid option  is  encoun-
          tered,  an  attempt  is made to define a function using
          "-f foo=bar", an attempt is made to assign a value to a
          readonly variable, an attempt is made to assign a value
          to an array variable without using the compound assign-
          ment 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 variable,
          or  an  attempt is made to display a non-existent func-
          tion with -f.

     dirs [-clpv] [+n] [-n]
          Without options, displays the list of currently  remem-
          bered  directories.  The default display is on a single
          line with directory names separated by spaces.   Direc-
          tories  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  listing
               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  sup-
          plied  or  n  indexes  beyond  the end of the directory
          stack.

     disown [-ar] [-h] [jobspec ...]
          Without options, each jobspec is removed from the table
          of  active  jobs.  If the -h option is given, each job-
          spec is not removed from the table, but  is  marked  so
          that  SIGHUP  is  not  sent  to  the  job  if the shell
          receives a SIGHUP.  If no jobspec is present, and  nei-
          ther  the -a nor the -r option is supplied, the current
          job is used.  If no jobspec is supplied, the -a  option
          means to remove or mark all jobs; the -r option without
          a jobspec argument restricts operation to running jobs.
          The return value is 0 unless a jobspec does not specify
          a valid job.

     echo [-neE] [arg ...]
          Output the args, separated by  spaces,  followed  by  a
          newline.   The  return  status  is  always 0.  If -n is
          specified, the trailing newline is suppressed.  If  the
          -e  option  is  given,  interpretation of the following
          backslash-escaped characters is enabled.  The -E option
          disables the interpretation of these escape characters,
          even on systems where they are interpreted by  default.
          echo  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
          \nnn the character whose ASCII code is the octal  value
               nnn (one to three digits)
          \xnnn
               the character whose ASCII code is the  hexadecimal
               value nnn (one to three digits)

     enable [-adnps] [-f filename] [name ...]
          Enable and disable builtin shell commands.  Disabling a
          builtin  allows  a disk command which has the same name
          as a shell builtin to be  executed  with  specifying  a
          full  pathname, even though the shell normally searches
          for builtins before disk commands.  If -n is used, 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 com-
          mand  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 argu-
          ments are given, or if the -p  option  is  supplied,  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 buil-
          tins 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 a problem loading a new builtin from a shared
          object.

     eval [arg ...]
          The args are read and concatenated together into a sin-
          gle command.  This command is then read and executed by
          the shell, and its exit status is returned as the value
          of eval.  If there are no args, or only null arguments,
          eval returns 0.

     exec [-cl] [-a name] [command [arguments]]
          If command is specified, it replaces the shell.  No new
          process is created.  The arguments become the arguments
          to command.  If the -l option is  supplied,  the  shell
          places  a  dash  in  the  zeroth arg passed to command.
          This is what login(1) does.  The -c option causes  com-
          mand  to  be executed with an empty environment.  If -a
          is supplied, the shell passes name as the zeroth  argu-
          ment  to  the  executed  command.  If command cannot be
          executed  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 executed.  If
          command is not specified, any redirections 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 commands.  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 encoun-
          tered, one of the names is not a valid  shell  variable
          name, or -f is supplied with a name that is not a func-
          tion.

     fc [-e ename] [-nlr] [first] [last]
     fc -s [pat=rep] [cmd]
          Fix Command.  In the first form, a  range  of  commands
          from  first  to last is selected from the history 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 history list, where  a  nega-
          tive  number is used as an offset from the current com-
          mand 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 list-
          ing.  The -r option reverses the order of the commands.
          If the -l option is given, the commands are  listed  on
          standard  output.  Otherwise, the editor given by ename
          is invoked on a file  containing  those  commands.   If
          ename is not given, the value of the FCEDIT variable is
          used, and the value of EDITOR if FCEDIT is not set.  If
          neither  variable  is set, vi is used.  When editing is
          complete, the edited commands are echoed and executed.

          In the second form, command is re-executed  after  each
          instance  of pat is replaced by rep.  A useful alias to
          use with this is ``r=fc -s'', so that typing  ``r  cc''
          runs  the last command beginning with ``cc'' and typing
          ``r'' re-executes the last command.

          If the first form is used, the return value is 0 unless
          an  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 specify 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 control.

     getopts optstring name [args]
          getopts is used by shell procedures to parse positional
          parameters.   optstring  contains the option letters to
          be recognized; if a letter is followed by a colon,  the
          option is expected to have an argument, which should be
          separated from it by white  space.   Each  time  it  is
          invoked,  getopts  places  the next option in the shell
          variable name, initializing name if it does not  exist,
          and the index of the next argument to be processed into
          the variable OPTIND.  OPTIND is initialized to  1  each
          time  the  shell or a shell script is invoked.  When an
          option requires an argument, getopts places that  argu-
          ment  into  the  variable  OPTARG.   The shell does not
          reset OPTIND automatically; it must be  manually  reset
          between multiple calls to getopts within the same shell
          invocation if a new set of parameters is to be used.

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

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

          getopts can report errors in two ways.   If  the  first
          character of optstring is a colon, silent error report-
          ing is used.  In normal operation  diagnostic  messages
          are  printed  when  invalid  options  or missing option
          arguments are encountered.  If the variable  OPTERR  is
          set  to 0, no error messages will be displayed, even if
          the first character of optstring is not a colon.

          If an invalid option is seen,  getopts  places  ?  into
          name  and,  if  not silent, prints an error message and
          unsets OPTARG.  If getopts is silent, the option  char-
          acter  found is placed in OPTARG and no diagnostic mes-
          sage is printed.

          If a required argument is not found, and getopts is not
          silent,  a  question mark (?) is placed in name, OPTARG
          is unset, and a  diagnostic  message  is  printed.   If
          getopts  is  silent, then a colon (:) is placed in name
          and OPTARG is set to the option character found.

          getopts  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 [-r] [-p filename] [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 locations.  If no argu-
          ments are given, information about remembered  commands
          is printed.  The return status is true unless a name is
          not found or an invalid option is supplied.

     help [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
          return status is 0 unless no command matches pattern.

     history [-c] [n]
     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 modi-
          fied.  An argument of n lists only the  last  n  lines.
          If  filename is supplied, it is used as the name of the
          history file; if not, the value of  HISTFILE  is  used.
          Options, if supplied, have the following meanings:
          -a   Append the ``new'' history  lines  (history  lines
               entered  since  the  beginning of the current bash
               session) to the history file.
          -n   Read the history lines not already read  from  the
               history file into the current history list.  These
               are lines appended to the history file  since  the
               beginning of the current 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 contents.
          -c   Clear  the  history  list  by  deleting  all   the
               entries.
          -p   Perform history substitution on the following args
               and  display  the  result  on the standard 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  single
               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 or an error occurs while reading or writing
          the history file.

     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  infor-
               mation.
          -p   List only the process  ID  of  the  job's  process
               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  informa-
          tion  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 corresponding process
          group ID, and executes command passing it args, return-
          ing 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 signal name, the
          name may be given with or without the SIG  prefix.   If
          sigspec  is  not  present, then SIGTERM is assumed.  An
          argument of -l lists the signal names.   If  any  argu-
          ments  are  supplied when -l is given, the names of the
          signals corresponding to the arguments are listed,  and
          the return status is 0.  The exit_status argument to -l
          is a number specifying either a signal  number  or  the
          exit  status of a process terminated by a signal.  kill
          returns true if at least one  signal  was  successfully
          sent,  or false if an error occurs or an invalid option
          is encountered.

     let arg [arg ...]
          Each arg is an arithmetic expression  to  be  evaluated
          (see ARITHMETIC EVALUATION).  If the last arg evaluates
          to 0, let returns 1; 0 is returned otherwise.

     local [name[=value] ...]
          For each argument,  a  local  variable  named  name  is
          created, and assigned value.  When local is used within
          a function, it causes the variable name to have a visi-
          ble scope restricted to that function and its children.
          With no operands, local writes a list  of  local  vari-
          ables  to  the  standard output.  It is an error to use
          local when not within a function.  The return status is
          0  unless  local  is  used  outside  a  function, or an
          invalid name is supplied.

     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 meanings:
          +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  performed
          as  well,  and  the  return  status is 0.  popd returns
          false if an invalid option is encountered,  the  direc-
          tory  stack  is  empty,  a non-existent directory stack
          entry is specified, or the directory change fails.

     printf format [arguments]
          Write the formatted arguments to  the  standard  output
          under the control of the format.  The format is a char-
          acter string which contains  three  types  of  objects:
          plain  characters,  which are simply copied to standard
          output, character escape sequences, which are converted
          and  copied to the standard output, and format specifi-
          cations, each of which causes printing of the next suc-
          cessive   argument.    In   addition  to  the  standard
          printf(1) formats, %b causes printf to expand backslash
          escape  sequences in the corresponding argument, and %q
          causes printf to output the corresponding argument in a
          format that can be reused as shell input.

          The format is reused as necessary to consume all of the
          arguments.   If the format requires more arguments than
          are supplied, the extra format specifications behave as
          if  a  zero  value  or null string, as appropriate, had
          been supplied.

     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   arguments,
          exchanges the top two directories and returns 0, unless
          the directory stack is empty.  Arguments, if  supplied,
          have the following meanings:
          +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 performed
          as  well.   If  the first form is used, pushd returns 0
          unless the cd to dir  fails.   With  the  second  form,
          pushd  returns 0 unless the directory stack is empty, a
          non-existent directory stack element is  specified,  or
          the  directory  change  to  the  specified  new current
          directory fails.

     pwd [-LP]
          Print the absolute file name  of  the  current  working
          directory.   The file name printed contains no symbolic
          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, symbolic links  are  followed.   The
          return status is 0 unless an error occurs while reading
          the name of the current directory or an invalid  option
          is supplied.

     read [-er] [-a aname] [-p prompt] [name ...]
          One line is read from the standard input, and the first
          word  is assigned to the first name, the second word to
          the second name, and so on,  with  leftover  words  and
          their intervening separators assigned to the last name.
          If there are fewer words read from the  standard  input
          than  names,  the  remaining  names  are assigned empty
          values.  The characters in IFS are used  to  split  the
          line  into  words.  Options, if supplied, have the fol-
          lowing meanings:
          -r   A backslash-newline pair is not ignored,  and  the
               backslash is considered to be part of the line.
          -p   Display prompt, without a trailing newline, before
               attempting  to  read  any  input.   The  prompt is
               displayed only if input is coming from a terminal.
          -a   The words are assigned to  sequential  indices  of
               the array variable aname, starting at 0.  aname is
               unset before any new values are  assigned.   Other
               name arguments are ignored.
          -e   If the standard input is coming from  a  terminal,
               readline  (see  READLINE  above) is used to obtain
               the line.

          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.

     readonly [-apf] [name ...]
          The given names are  marked  readonly;  the  values  of
          these  names  may  not be changed by subsequent assign-
          ment.  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 displayed in a format thatmay 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  speci-
          fied  by n.  If n is omitted, the return status is that
          of the last command executed in the function body.   If
          used  outside  a  function,  but  during execution of a
          script by the . (source) command, it causes  the  shell
          to  stop  executing  that script and return either n or
          the exit status of the last command executed within the
          script  as the exit status of the script.  If used out-
          side a function and not during execution of a script by
          ., the return status is false.

     set [--abefhkmnptuvxBCHP] [-o option] [arg ...]
          Without options, the name and value of each shell vari-
          able  are  displayed  in a format that can be reused as
          input.  The output is sorted according to  the  current
          locale.   When options are specified, 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 fol-
          lowing meanings:
          -a      Automatically mark variables 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 pri-
                  mary 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 !.
          -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  state-
                  ments  are placed in the environment for a com-
                  mand, not just those that precede  the  command
                  name.
          -m      Monitor mode.  Job control  is  enabled.   This
                  option  is on by default for interactive 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 following:
                  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  interactive,  unless
                          the shell is started with the --noedit-
                          ing option.
                  errexit Same as -e.
                  hashall Same as -h.
                  histexpand
                          Same as -H.
                  history Enable command  history,  as  described
                          above under HISTORY.  This option is on
                          by default in interactive shells.
                  ignoreeof
                          The effect is as if the  shell  command
                          IGNOREEOF=10  had  been  executed  (see
                          Shell Variables above).
                  keyword Same as -k.
                  monitor Same as -m.
                  noclobber
                          Same as -C.
                  noexec  Same as -n.
                  noglob  Same as -f.
                  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.
                  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 current option
                  settings is displayed on the standard output.
          -p      Turn on privileged mode.   In  this  mode,  the
                  $ENV file is not processed, shell functions are
                  not inherited from  the  environment,  and  the
                  variable  The SHELLOPTS variable, if it appears
                  in  the  environment,  is  ignored.   This   is
                  enabled  automatically on startup if the effec-
                  tive user (group) id is not equal to  the  real
                  user  (group)  id.   Turning  this  option  off
                  causes the effective user and group ids  to  be

          -t      Exit after reading and executing one command.
          -u      Treat unset variables as an error when perform-
                  ing   parameter  expansion.   If  expansion  is
                  attempted  on  an  unset  variable,  the  shell
                  prints  an  error message, and, if not interac-
                  tive, exits with a non-zero status.
          -v      Print shell input lines as they are read.
          -x      After expanding each  simple  command,  display
                  the expanded value of PS4, followed by the com-
                  mand and its expanded arguments.
          -B      The shell performs brace expansion  (see  Brace
                  Expansion above).  This is on by default.
          -C      If set, bash does  not  overwrite  an  existing
                  file  with the >, >&, and <> redirection opera-
                  tors.  This may  be  overridden  when  creating
                  output  files by using the redirection operator
                  >| instead of >.
          -H      Enable  !  style  history  substitution.   This
                  option  is  on  by  default  when  the shell is
                  interactive.
          -P      If set, the  shell  does  not  follow  symbolic
                  links  when  executing commands such as cd that
                  change the current working directory.  It  uses
                  the  physical  directory structure instead.  By
                  default, bash  follows  the  logical  chain  of
                  directories   when  performing  commands  which
                  change the current directory.
          --      If no arguments follow this  option,  then  the
                  positional  parameters  are  unset.  Otherwise,
                  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 positional parame-
                  ters.  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 specified 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-negative  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  displayed,
          with  an indication of whether or not each is set.  The
          -p option causes output to be displayed in a form  that
          may be reused as input.  Other options have the follow-
          ing 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  arguments  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
               defined for the -o option to the set builtin.

          If either -s or -u is used with no  optname  arguments,
          the  display  is limited to those options which are set
          or unset, respectively.  Unless  otherwise  noted,  the
          shopt options are disabled (unset) by default.

          The return status when listing options is zero  if  all
          optnames are enabled, non-zero otherwise.  When setting
          or unsetting options, the return status is zero  unless
          an optname is not a valid shell option.

          The list of shopt options is:

          cdable_vars
                  If set, an argument to the cd  builtin  command
                  that  is  not  a directory is assumed to be the
                  name of a variable whose value is the directory
                  to change to.
          cdspell If set, minor  errors  in  the  spelling  of  a
                  directory  component  in  a  cd command will be
                  corrected.  The errors checked  for  are  tran-
                  sposed characters, a missing character, and one
                  character too many.  If a correction 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 execute 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 specified 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  features
                  described  above  under  Pathname Expansion are
                  enabled.
          histappend
                  If set, the history list  is  appended  to  the
                  file  named  by the value of the HISTFILE vari-
                  able  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 failed his-
                  tory substitution.
          histverify
                  If set, and readline is being used, the results
                  of  history  substitution  are  not immediately
                  passed  to  the  shell  parser.   Instead,  the
                  resulting  line  is  loaded  into  the readline
                  editing buffer, allowing further modification.
          hostcomplete
                  If set, and readline is being used,  bash  will
                  attempt  to  perform hostname completion when a
                  word containing a @  is  being  completed  (see
                  Completing  under  READLINE  above).   This  is
                  enabled by default.
          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 characters 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 history
                  with embedded newlines rather than using  semi-
                  colon separators where possible.
          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.
          nocaseglob
                  If   set,   bash   matches   filenames   in   a
                  case-insensitive  fashion when performing path-
                  name 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 themselves.
          promptvars
                  If set, prompt  strings  undergo  variable  and
                  parameter  expansion  after  being  expanded as
                  described in PROMPTING above.  This  option  is
                  enabled by default.
          shift_verbose
                  If set, the shift builtin prints an error  mes-
                  sage when the shift count exceeds the number of
                  positional parameters.
          sourcepath
                  If set, the source (.) builtin uses  the  value
                  of  PATH  to  find the directory containing the
                  file supplied as an argument.  This  option  is
                  enabled 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  evaluation
          of  the conditional expression expr.  Each operator and
          operand must be a separate argument.   Expressions  are
          composed  of the primaries described above under CONDI-
          TIONAL EXPRESSIONS.

          Expressions may be combined using the following  opera-
          tors, listed in decreasing order of precedence.
          ! expr
               True if expr is false.
          ( expr )
               Returns the value of expr.  This may  be  used  to
               override the normal precedence of operators.
          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 EXPRES-
               SIONS, the expression is true if the unary test is
               true.   If the first argument is not a valid unary
               conditional operator, the expression is false.
          3 arguments
               If the second argument is one of the binary condi-
               tional  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 operands.  If the  first  argu-
               ment  is  !, the value is the negation of the two-
               argument test using the  second  and  third  argu-
               ments.  If the first argument is exactly ( and the
               third argument is exactly ),  the  result  is  the
               one-argument  test of the second argument.  Other-
               wise, the expression is  false.   The  -a  and  -o
               operators  are considered binary operators in this
               case.
          4 arguments
               If the first argument is  !,  the  result  is  the
               negation of the three-argument expression composed
               of  the  remaining  arguments.    Otherwise,   the
               expression  is  parsed  and 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 signal specified
          by each sigspec is ignored by the shell and by the com-
          mands it invokes.  If arg is -p then the trap  commands
          associated  with  each  sigspec  are  displayed.  If no
          arguments are supplied or if only  -p  is  given,  trap
          prints the list of commands associated 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 command arg is executed on exit  from  the
          shell.   If a sigspec is DEBUG, the command arg is exe-
          cuted after every simple  command  (see  SHELL  GRAMMAR
          above).  The -l option causes the shell to print a list
          of signal names and their corresponding numbers.   Sig-
          nals  ignored upon entry to the shell cannot be trapped
          or reset.  Trapped signals are reset to their  original
          values  in  a  child  process  when it is created.  The
          return status is false if any sigspec is invalid;  oth-
          erwise trap returns true.

     type [-atp] name [name ...]
          With no options, indicate how each name would be inter-
          preted  if used as a command name.  If the -t option is
          used, type prints a string which is one of alias,  key-
          word,  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 used, type either returns the name
          of the disk file that would be executed  if  name  were
          specified as a command name, or nothing if type -t name
          would not return file.  If  a  command  is  hashed,  -p
          prints  the hashed value, not necessarily the file that
          appears first in PATH.  If the -a option is used,  type
          prints  all  of  the  places that contain an executable
          named name.  This includes aliases  and  functions,  if
          and  only if the -p option is not also used.  The table
          of hashed commands is  not  consulted  when  using  -a.
          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 systems that
          allow such control.  The value of limit can be a number
          in  the  unit  specified for the resource, or the value
          unlimited.  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.  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 available  to
               the shell

          If limit is given, it is the new value of the specified
          resource (the -a option is display only).  If no option
          is given, then -f is assumed.  Values are in  1024-byte
          increments,  except  for  -t,  which is in seconds, -p,
          which is in units of 512-byte blocks, and  -n  and  -u,
          which  are  unscaled  values.   The  return status is 0
          unless an invalid option is encountered, a  non-numeric
          argument  other than unlimited is supplied as limit, or
          an error occurs while setting a new limit.

     umask [-p] [-S] [mode]
          The user file-creation mask is set to  mode.   If  mode
          begins  with  a  digit,  it  is interpreted as an octal
          number; otherwise it is interpreted as a symbolic  mode
          mask  similar to that accepted by chmod(1).  If mode is
          omitted, or if the -S option is supplied,  the  current
          value of the mask is printed.  The -S option causes the
          mask to be printed in symbolic form; the default output
          is  an octal number.  If the -p option is supplied, and
          mode is omitted, the output is in a form  that  may  be
          reused  as  input.   The return status is 0 if the mode
          was successfully changed or if  no  mode  argument  was
          supplied, and false otherwise.

     unalias [-a] [name ...]
          Remove names from the list of defined aliases.   If  -a
          is  supplied,  all  alias definitions are removed.  The
          return value is true unless a supplied 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 variable.   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 environment  passed  to  subsequent
          commands.   If any of RANDOM, SECONDS, LINENO, HISTCMD,
          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  termina-
          tion status.  n may be a process ID or a job specifica-
          tion; if a job spec is given,  all  processes  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  con-
     trolled  than the standard shell.  It behaves identically to
     bash with the exception that the following are disallowed or
     not performed:

     +    changing directories with cd

     +    setting or unsetting the values of SHELL or PATH

     +    specifying command names containing /

     +    specifying a file name containing a / as an argument to
          the . builtin command

     +    importing function definitions from the shell  environ-
          ment at startup

     +    parsing the value of SHELLOPTS from the shell  environ-
          ment at startup

     +    redirecting output using the >, >|, <>, >&, &>, and  >>
          redirection operators

     +    using the exec builtin command  to  replace  the  shell
          with another command

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

     +    specifying the -p option to the command builtin command

     +    turning off restricted mode with set +r or set +o  res-
          tricted.

     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 Features, Brian Fox and Chet Ramey
     The Gnu Readline Library, Brian Fox and Chet Ramey
     The Gnu History Library, Brian Fox and Chet Ramey
Utilities, IEEE
     Portable Operating System Interface (POSIX)  Part  2:  Shell  and
     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
     ~/.inputrc
          Individual readline initialization file

AUTHORS
     Brian Fox, Free Software Foundation
     bfox@gnu.ai.MIT.Edu

     Chet Ramey, Case Western Reserve University
     chet@ins.CWRU.Edu

BUG REPORTS
     If you find a bug in bash, you should report it.  But first,
     you  should  make  sure that it really is a bug, and that it
     appears in the latest version of bash that you have.


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

     ALL bug reports should include:

     The version number of bash
     The hardware and operating system
     The compiler used to compile
     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 specifi-
     cation.

     Aliases are confusing in some uses.

     Shell   builtin   commands    and    functions    are    not
     stoppable/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 immediately
     executes  the  next command in the sequence.  It suffices to
     place the sequence of commands between parentheses 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.