Seth Woolley's Man Viewer

bash(1) - bash, bash - GNU Bourne-Again SHell - man 1 bash

([section] manual, -k keyword, -K [section] search, -f whatis)
man plain no title

BASH(1)                                                                BASH(1)



NAME
       bash - GNU Bourne-Again SHell

SYNOPSIS
       bash [options] [file(1,n)]

COPYRIGHT
       Bash is Copyright (C) 1989-2004 by the Free Software Foundation, Inc.

DESCRIPTION
       Bash  is  an  sh-compatible  command language interpreter that executes
       commands read(2,n,1 builtins) from the standard input or from a file.  Bash also incor-
       porates 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(1,8)  the
       description  of  the set(7,n,1 builtins) builtin command, bash interprets the following
       options when it is invoked:

       -c string(3,n) If the -c option is present,  then  commands  are  read(2,n,1 builtins)  from
                 string(3,n).   If  there  are arguments after the string(3,n), they are
                 assigned to the positional parameters, starting with $0.
       -i        If the -i option is present, the shell is interactive.
       -l        Make bash act as if(3,n) it had been invoked as a login(1,3,5) shell (see
                 INVOCATION below).
       -r        If  the  -r  option  is present, the shell becomes restricted
                 (see RESTRICTED SHELL below).
       -s        If the -s option is present, or if(3,n) no arguments remain  after
                 option  processing,  then commands are read(2,n,1 builtins) from the standard
                 input.  This option allows the positional  parameters  to  be
                 set(7,n,1 builtins) 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  sub-
                 ject to language translation when the current locale(3,5,7) is not C
                 or POSIX.  This implies the -n option; no  commands  will  be
                 executed.
       [-+]O [shopt_option]
                 shopt_option  is  one  of  the  shell options accepted by the
                 shopt  builtin  (see  SHELL  BUILTIN  COMMANDS  below).    If
                 shopt_option is present, -O sets the value of that option; +O
                 unsets it.  If shopt_option is not supplied,  the  names  and
                 values  of the shell options accepted by shopt are printed on
                 the standard output.  If the invocation  option  is  +O,  the
                 output  is displayed in(1,8) a format that may be reused as input.
       --        A -- signals the end of options and disables  further  option
                 processing.   Any arguments after the -- are treated as file-
                 names 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 to be recognized.

       --debugger
              Arrange for the debugger profile to be executed before the shell
              starts.   Turns  on extended debugging mode (see the description
              of the extdebug option to the shopt  builtin  below)  and  shell
              function tracing (see the description of the -o functrace option
              to the set(7,n,1 builtins) builtin below).
       --dump-po-strings
              Equivalent to -D, but the output is in(1,8) the GNU gettext(1,3) po  (por-
              table object) file(1,n) format.
       --dump-strings
              Equivalent to -D.
       --help Display  a  usage  message  on standard output and exit(3,n,1 builtins) success-
              fully.
       --init-file file(1,n)
       --rcfile file(1,n)
              Execute commands from file(1,n) instead of the standard personal ini-
              tialization  file(1,n)  ~/.bashrc  if(3,n)  the  shell is interactive (see
              INVOCATION below).

       --login
              Equivalent to -l.

       --noediting
              Do not use the GNU readline library to read(2,n,1 builtins) command  lines  when
              the shell is interactive.

       --noprofile
              Do  not read(2,n,1 builtins) either the system-wide startup file(1,n) /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(1,3,5)  shell  (see  INVOCATION
              below).

       --norc Do  not  read(2,n,1 builtins)  and  execute  the  personal  initialization  file(1,n)
              ~/.bashrc if(3,n) the shell is interactive.  This  option  is  on  by
              default if(3,n) the shell is invoked as sh.

       --posix
              Change  the behavior of bash where the default operation differs
              from the POSIX 1003.2 standard  to  match  the  standard  (posix
              mode).

       --restricted
              The shell becomes restricted (see RESTRICTED SHELL below).

       --verbose
              Equivalent to  -v.

       --version
              Show  version(1,3,5) information for this instance of bash on the stan-
              dard output and exit(3,n,1 builtins) 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(1,n) containing shell commands.  If bash is invoked  in(1,8)  this
       fashion,  $0 is set(7,n,1 builtins) to the name of the file(1,n), and the positional parame-
       ters are set(7,n,1 builtins) to the remaining arguments.  Bash reads and executes  com-
       mands  from this file(1,n), then exits.  Bash's exit(3,n,1 builtins) status is the exit(3,n,1 builtins) sta-
       tus of the last command executed in(1,8) the script.   If  no  commands  are
       executed,  the  exit(3,n,1 builtins) status is 0.  An attempt is first made to open(2,3,n) the
       file(1,n) in(1,8) the current directory, and, if(3,n) no file(1,n) is found, then the shell
       searches the directories in(1,8) PATH for the script.

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

       An interactive shell is one started without  non-option  arguments  and
       without the -c option whose standard input and error(8,n) are both connected
       to terminals (as determined by isatty(3)), or one started with  the  -i
       option.   PS1 is set(7,n,1 builtins) and $- includes i if(3,n) bash is interactive, allowing
       a shell script or a startup file(1,n) to test this state.

       The following paragraphs describe how bash executes its startup  files.
       If  any  of  the files exist but cannot be read(2,n,1 builtins), bash reports an error.
       Tildes are expanded in(1,8) file(1,n) names as described below under Tilde Expan-
       sion in(1,8) the EXPANSION section.

       When  bash is invoked as an interactive login(1,3,5) shell, or as a non-inter-
       active shell with the --login option, it first reads and executes  com-
       mands  from  the file(1,n) /etc/profile, if(3,n) that file(1,n) exists.  After reading
       that file(1,n), it looks for ~/.bash_profile, ~/.bash_login, and ~/.profile,
       in(1,8)  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(1,3,5)  shell  exits, bash reads and executes commands from the
       file(1,n) ~/.bash_logout, if(3,n) it exists.

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

       When bash is started non-interactively, to  run  a  shell  script,  for
       example, it looks for the variable BASH_ENV in(1,8) the environment, expands
       its value if(3,n) it appears there, and uses the expanded value as the  name
       of  a  file(1,n) to read(2,n,1 builtins) and execute.  Bash behaves as if(3,n) the following com-
       mand were executed:
              if(3,n) [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
       but the value of the PATH variable is not used to search for  the  file(1,n)
       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 interac-
       tive login(1,3,5) shell, or a non-interactive shell with the  --login  option,
       it  first  attempts  to read(2,n,1 builtins) and execute commands from /etc/profile and
       ~/.profile, in(1,8) that order.  The  --noprofile  option  may  be  used  to
       inhibit  this  behavior.  When invoked as an interactive shell with the
       name sh, bash looks for the variable ENV, expands its value  if(3,n)  it  is
       defined,  and uses the expanded value as the name of a file(1,n) to read(2,n,1 builtins) and
       execute.  Since a shell invoked as sh does not attempt to read(2,n,1 builtins) and exe-
       cute  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(2,n,1 builtins)  any  other  startup files.  When invoked as sh, bash
       enters posix mode after the startup files are read.

       When bash is started in(1,8) posix mode, as with the  --posix  command  line
       option, it follows the POSIX standard for startup files.  In this mode,
       interactive shells expand the ENV variable and commands  are  read(2,n,1 builtins)  and
       executed  from  the  file(1,n)  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(3,n) that file(1,n) exists and  is
       readable.  It will not do this if(3,n) invoked as sh.  The --norc option may
       be used to inhibit this behavior, and the --rcfile option may  be  used
       to  force  another  file(1,n) to be read(2,n,1 builtins), but rshd does not generally invoke
       the shell with those options or allow them to be specified.

       If the shell is started with the effective user (group) id not equal to
       the real user (group) id, and the -p option is not supplied, no startup
       files are read(2,n,1 builtins), shell functions are not inherited from the environment,
       the  SHELLOPTS  variable, if(3,n) it appears in(1,8) the environment, is ignored,
       and the effective user id is set(7,n,1 builtins) to the real user id.  If the -p option
       is  supplied  at  invocation, the startup behavior is the same, but the
       effective user id is not reset.

DEFINITIONS
       The following definitions are used throughout the rest  of  this  docu-
       ment.
       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  under-
              scores,  and beginning with an alphabetic character or an under-
              score.  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 fol-
              lowing 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 command:

       !  case  do done elif else esac fi for function if(3,n) in(1,8) select(2,7,2 select_tut) then until
       while { } time(1,2,n) [[ ]]

SHELL GRAMMAR
   Simple Commands
       A simple command is a sequence of optional  variable  assignments  fol-
       lowed  by  blank-separated  words and redirections, and terminated by a
       control operator.  The first word specifies the command to be executed,
       and  is  passed  as  argument  zero.  The remaining words are passed as
       arguments to the invoked command.

       The return value of a simple command is its exit(3,n,1 builtins) status,  or  128+n  if(3,n)
       the command is terminated by signal(2,7) n.

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

              [time(1,2,n) [-p]] [ ! ] command [ | command2 ... ]

       The standard output of command is connected via a pipe(2,8) to the  standard
       input  of  command2.   This connection is performed before any redirec-
       tions specified by the command (see REDIRECTION below).

       The return status of a pipeline is the exit(3,n,1 builtins) status of the last command,
       unless  the  pipefail  option  is enabled.  If pipefail is enabled, the
       pipeline's return status is the value of the last  (rightmost)  command
       to  exit(3,n,1 builtins)  with a non-zero status, or zero if(3,n) all commands exit(3,n,1 builtins) success-
       fully.  If the reserved word !  precedes a pipeline, the exit(3,n,1 builtins) status of
       that  pipeline  is the logical negation of the exit(3,n,1 builtins) status as described
       above.  The shell waits for all commands in(1,8) the pipeline  to  terminate
       before returning a value.

       If  the  time(1,2,n) reserved word precedes a pipeline, the elapsed as well as
       user and system time(1,2,n) 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(7,n,1 builtins)  to  a  format
       string(3,n)  that  specifies how the timing information should be displayed;
       see the description of TIMEFORMAT under Shell Variables below.

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

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

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

       A sequence of one or more newlines may appear in(1,8) a list  instead  of  a
       semicolon to delimit commands.

       If  a  command  is terminated by the control operator &, the shell exe-
       cutes the command in(1,8) the background in(1,8) 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(1,8) turn.  The return status is the exit(3,n,1 builtins) status of
       the last command executed.

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

              command1 && command2

       command2  is  executed if(3,n), and only if(3,n), command1 returns an exit(3,n,1 builtins) status
       of zero.

       An OR list has the form

              command1 || command2


       command2 is executed if(3,n) and only if(3,n) command1 returns  a  non-zero  exit(3,n,1 builtins)
       status.   The  return  status of AND and OR lists is the exit(3,n,1 builtins) status of
       the last command executed in(1,8) the list.

   Compound Commands
       A compound command is one of the following:

       (list) list is executed in(1,8) a subshell environment (see  COMMAND  EXECU-
              TION  ENVIRONMENT below).  Variable assignments and builtin com-
              mands that affect the  shell's  environment  do  not  remain  in(1,8)
              effect  after  the  command completes.  The return status is the
              exit(3,n,1 builtins) status of list.

       { list; }
              list is simply executed in(1,8) the current shell environment.   list
              must  be  terminated with a newline or semicolon.  This is known
              as a group command.  The return status is  the  exit(3,n,1 builtins)  status  of
              list.   Note that unlike the metacharacters ( and ), { and } are
              reserved words and must occur where a reserved word is permitted
              to  be  recognized.   Since they do not cause a word break, they
              must be separated from list by whitespace.

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

       [[ expression ]]
              Return  a  status  of  0 or 1 depending on the evaluation of the
              conditional expression expression.  Expressions are composed  of
              the  primaries  described  below  under CONDITIONAL EXPRESSIONS.
              Word splitting and pathname expansion are not performed  on  the
              words  between  the  [[  and  ]]; tilde expansion, parameter and
              variable expansion, arithmetic expansion, command  substitution,
              process  substitution,  and quote removal are performed.  Condi-
              tional operators such as -f must be unquoted to be recognized as
              primaries.

              When  the  == and != operators are used, the string(3,n) 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(3,n) the string(3,n) 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.

              An additional binary operator, =~, is available, with  the  same
              precedence  as  ==  and  !=.  When it is used, the string(3,n) to the
              right of the operator is considered an extended regular  expres-
              sion and matched accordingly (as in(1,8) regex(3,7)(3)).  The return value
              is 0 if(3,n) the string(3,n) matches the pattern, and 1 otherwise.  If the
              regular  expression  is syntactically incorrect, the conditional
              expression's return value is 2.  If the shell option  nocaseglob
              is enabled, the match is performed without regard to the case of
              alphabetic  characters.   Substrings  matched  by  parenthesized
              subexpressions  within  the  regular expression are saved in(1,8) the
              array variable BASH_REMATCH.  The element of  BASH_REMATCH  with
              index 0 is the portion of the string(3,n) matching the entire regular
              expression.  The element of BASH_REMATCH with  index  n  is  the
              portion  of the string(3,n) matching the nth parenthesized subexpres-
              sion.

              Expressions may  be  combined  using  the  following  operators,
              listed in(1,8) decreasing order of precedence:

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

              The && and || operators do not evaluate expression2 if(3,n) the value
              of  expression1  is  sufficient to determine the return value of
              the entire conditional expression.

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

       for (( expr1 ; expr2 ; expr3 )) ; do list ; done
              First, the arithmetic expression expr1 is evaluated according to
              the rules described  below  under  ARITHMETIC  EVALUATION.   The
              arithmetic  expression  expr2 is then evaluated repeatedly until
              it evaluates to zero.  Each time(1,2,n) expr2 evaluates to  a  non-zero
              value,  list  is executed and the arithmetic expression expr3 is
              evaluated.  If any expression is omitted, it behaves  as  if(3,n)  it
              evaluates to 1.  The return value is the exit(3,n,1 builtins) status of the last
              command in(1,8) list that is executed, or false if(3,n) any of the expres-
              sions is invalid.

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

       case word in(1,8) [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac
              A case command first expands word, and tries to match it against
              each pattern in(1,8) turn, using the same matching rules as for path-
              name 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(3,n,1 builtins) status  is
              zero if(3,n) no pattern matches.  Otherwise, it is the exit(3,n,1 builtins) status of
              the last command executed in(1,8) list.

       if(3,n) list; then list; [ elif list; then list; ] ... [ else list; ] fi
              The if(3,n) list is executed.  If its exit(3,n,1 builtins) status is zero,  the  then
              list  is  executed.   Otherwise,  each  elif list is executed in(1,8)
              turn, and if(3,n) its exit(3,n,1 builtins) status is  zero,  the  corresponding  then
              list is executed and the command completes.  Otherwise, the else
              list is executed, if(3,n) present.  The exit(3,n,1 builtins) status is the exit(3,n,1 builtins)  sta-
              tus of the last command executed, or zero if(3,n) 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(1,8) list returns an exit(3,n,1 builtins) 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(1,8) list returns a non-zero exit(3,n,1 builtins) status.  The exit(3,n,1 builtins) status
              of  the  while and until commands is the exit(3,n,1 builtins) status of the last
              do list command executed, or zero if(3,n) none was executed.

   Shell Function Definitions
       A shell function is an object that is called like a simple command  and
       executes  a  compound  command with a new set(7,n,1 builtins) of positional parameters.
       Shell functions are declared as follows:

       [ function ] name () compound-command [redirection]
              This defines a function named(5,8) name.  The reserved word  function
              is  optional.   If  the  function reserved word is supplied, the
              parentheses are optional.  The body of the function is the  com-
              pound  command  compound-command  (see Compound Commands above).
              That command is usually a list of commands between { and },  but
              may  be  any command listed under Compound Commands above.  com-
              pound-command is executed whenever name is specified as the name
              of  a  simple command.  Any redirections (see REDIRECTION below)
              specified when a function is  defined  are  performed  when  the
              function  is executed.  The exit(3,n,1 builtins) status of a function definition
              is zero unless a syntax error(8,n) occurs or a readonly function with
              the same name already exists.  When executed, the exit(3,n,1 builtins) status of
              a function is the exit(3,n,1 builtins) status of the last  command  executed  in(1,8)
              the body.  (See FUNCTIONS below.)

COMMENTS
       In a non-interactive shell, or an interactive shell in(1,8) which the inter-
       active_comments option to the  shopt  builtin  is  enabled  (see  SHELL
       BUILTIN  COMMANDS  below), a word beginning with # causes that word and
       all remaining characters on that line to be  ignored.   An  interactive
       shell  without  the  interactive_comments option enabled does not allow
       comments.  The interactive_comments option is on by default in(1,8) 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(3,n) it is to represent itself.

       When  the command history(1,3,n,1 builtins) expansion facilities are being used, the his-
       tory expansion character, usually !, must be quoted to prevent  history(1,3,n,1 builtins)
       expansion.

       There  are  three  quoting  mechanisms:  the  escape  character, single
       quotes, and double quotes.

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

       Enclosing characters in(1,8) 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(1,8) double quotes preserves the  literal  value  of
       all  characters  within  the quotes, with the exception of $, `, and \.
       The characters $ and `  retain  their  special  meaning  within  double
       quotes.   The  backslash retains its special meaning only when followed
       by one of the following characters: $, `, ", \, or <newline>.  A double
       quote  may  be quoted within double quotes by preceding it with a back-
       slash.  When command history(1,3,n,1 builtins) is being used, the double quote may not be
       used to quote the history(1,3,n,1 builtins) expansion character.

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

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

       The  expanded  result  is  single-quoted, as if(3,n) the dollar sign had not
       been present.

       A double-quoted string(3,n) preceded by a dollar sign  ($)  will  cause  the
       string(3,n)  to  be translated according to the current locale.  If the cur-
       rent locale(3,5,7) is C or POSIX, the dollar sign is ignored.  If  the  string(3,n)
       is translated and replaced, the replacement is double-quoted.

PARAMETERS
       A  parameter is an entity that stores values.  It can be a name, a num-
       ber, or one of the special characters listed below under Special Param-
       eters.   A variable is a parameter denoted by a name.  A variable has a
       value and zero or more attributes.  Attributes are assigned  using  the
       declare  builtin command (see declare below in(1,8) SHELL BUILTIN COMMANDS).

       A parameter is set(7,n,1 builtins) if(3,n) it has been assigned a value.  The null string(3,n) is
       a  valid  value.  Once a variable is set(7,n,1 builtins), 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, com-
       mand substitution, arithmetic expansion, and quote removal (see  EXPAN-
       SION below).  If the variable has its integer attribute set(7,n,1 builtins), then value
       is evaluated as an arithmetic expression even if(3,n) the $((...)) expansion
       is  not  used  (see Arithmetic Expansion below).  Word splitting is not
       performed, with the exception of "$@" as explained below under  Special
       Parameters.   Pathname  expansion  is not performed.  Assignment state-
       ments may also appear as arguments  to  the  alias,  declare,  typeset,
       export, readonly, and local builtin commands.

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

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

   Special Parameters
       The  shell  treats  several parameters specially.  These parameters may
       only be referenced; assignment to them is not allowed.
       *      Expands to the positional parameters, starting from  one.   When
              the  expansion occurs within double quotes, it expands to a sin-
              gle word with the value of each parameter separated by the first
              character of the IFS special variable.  That is, "$*" is equiva-
              lent to "$1c$2c...", where c is the first character of the value
              of  the IFS variable.  If IFS is unset, the parameters are sepa-
              rated 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(1,8) decimal.
       ?      Expands  to  the status of the most recently executed foreground
              pipeline.
       -      Expands to the current option flags as  specified  upon  invoca-
              tion,  by  the  set(7,n,1 builtins)  builtin  command, or those set(7,n,1 builtins) by the shell
              itself (such as the -i option).
       $      Expands to the process ID of the shell.  In a  ()  subshell,  it
              expands  to  the  process  ID of the current shell, not the sub-
              shell.
       !      Expands to the process ID of the most  recently  executed  back-
              ground (asynchronous) command.
       0      Expands  to  the name of the shell or shell script.  This is set(7,n,1 builtins)
              at shell initialization.  If bash is invoked with a file(1,n) of com-
              mands,  $0  is set(7,n,1 builtins) to the name of that file.  If bash is started
              with the -c option, then $0 is set(7,n,1 builtins) to the first  argument  after
              the  string(3,n) to be executed, if(3,n) one is present.  Otherwise, it is
              set(7,n,1 builtins) to the file(1,n) name used to invoke bash, as given  by  argument
              zero.
       _      At  shell startup, set(7,n,1 builtins) to the absolute file(1,n) name of the shell or
              shell script being executed as  passed  in(1,8)  the  argument  list.
              Subsequently,  expands to the last argument to the previous com-
              mand, after expansion.  Also set(7,n,1 builtins) to the full file(1,n) name  of  each
              command  executed and placed in(1,8) the environment exported to that
              command.  When checking mail(1,8), this parameter holds the  name  of
              the mail(1,8) file(1,n) currently being checked.

   Shell Variables
       The following variables are set(7,n,1 builtins) by the shell:

       BASH   Expands  to  the  full file(1,n) name used to invoke this instance of
              bash.
       BASH_ARGC
              An array variable whose values are the number of  parameters  in(1,8)
              each frame of the current bash execution call stack.  The number
              of parameters to  the  current  subroutine  (shell  function  or
              script  executed  with  . or source) is at the top of the stack.
              When a subroutine is executed, the number of  parameters  passed
              is pushed onto BASH_ARGC.
       BASH_ARGV
              An  array  variable containing all of the parameters in(1,8) the cur-
              rent bash execution call stack.  The final parameter of the last
              subroutine  call is at the top of the stack; the first parameter
              of the initial call is at the bottom.  When a subroutine is exe-
              cuted, the parameters supplied are pushed onto BASH_ARGV.
       BASH_COMMAND
              The  command  currently  being executed or about to be executed,
              unless the shell is executing a command as the result of a trap,
              in(1,8)  which  case  it  is the command executing at the time(1,2,n) of the
              trap.
       BASH_EXECUTION_STRING
              The command argument to the -c invocation option.
       BASH_LINENO
              An array variable whose members are the line numbers  in(1,8)  source
              files   corresponding   to   each   member   of  @var{FUNCNAME}.
              ${BASH_LINENO[$i]} is the line number in(1,8) the source  file(1,n)  where
              ${FUNCNAME[$i  +  1]} was called.  The corresponding source file(1,n)
              name is ${BASH_SOURCE[$i + 1]}.  Use LINENO to obtain  the  cur-
              rent line number.
       BASH_REMATCH
              An  array  variable  whose members are assigned by the =~ binary
              operator to the [[ conditional command.  The element with  index
              0  is  the  portion  of  the  string(3,n) matching the entire regular
              expression.  The element with index n  is  the  portion  of  the
              string(3,n) matching the nth parenthesized subexpression.  This vari-
              able is read-only.
       BASH_SOURCE
              An array variable whose members are the source filenames  corre-
              sponding to the elements in(1,8) the FUNCNAME array variable.
       BASH_SUBSHELL
              Incremented  by one each time(1,2,n) a subshell or subshell environment
              is spawned.  The initial value is 0.
       BASH_VERSINFO
              A readonly array variable whose members hold version(1,3,5) information
              for  this  instance  of  bash.  The values assigned to the array
              members are as follows:
              BASH_VERSINFO[0]        The major version(1,3,5) number (the  release).
              BASH_VERSINFO[1]        The  minor version(1,3,5) number (the version(1,3,5)).
              BASH_VERSINFO[2]        The patch level.
              BASH_VERSINFO[3]        The build version.
              BASH_VERSINFO[4]        The release status (e.g., beta1).
              BASH_VERSINFO[5]        The value of MACHTYPE.

       BASH_VERSION
              Expands to a string(3,n) describing the version(1,3,5) of this  instance  of
              bash.

       COMP_CWORD
              An  index  into ${COMP_WORDS} of the word containing the current
              cursor position.  This variable is available only in(1,8) shell func-
              tions  invoked  by  the  programmable completion facilities (see
              Programmable Completion below).

       COMP_LINE
              The current command line.  This variable is  available  only  in(1,8)
              shell  functions  and  external  commands  invoked  by  the pro-
              grammable completion  facilities  (see  Programmable  Completion
              below).

       COMP_POINT
              The  index of the current cursor position relative to the begin-
              ning of the current command.  If the current cursor position  is
              at the end of the current command, the value of this variable is
              equal to ${#COMP_LINE}.  This  variable  is  available  only  in(1,8)
              shell  functions  and  external  commands  invoked  by  the pro-
              grammable completion  facilities  (see  Programmable  Completion
              below).

       COMP_WORDBREAKS
              The  set(7,n,1 builtins)  of characters that the Readline library treats as word
              separators when performing word completion.  If  COMP_WORDBREAKS
              is  unset, it loses its special properties, even if(3,n) it is subse-
              quently reset.

       COMP_WORDS
              An array variable (see Arrays below) consisting of the  individ-
              ual  words in(1,8) the current command line.  This variable is avail-
              able only in(1,8) shell functions invoked by the programmable comple-
              tion facilities (see Programmable Completion below).

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

       EUID   Expands  to  the effective user ID of the current user, initial-
              ized at shell startup.  This variable is readonly.

       FUNCNAME
              An array variable containing the names of  all  shell  functions
              currently in(1,8) the execution call stack.  The element with index 0
              is the name of any currently-executing shell function.  The bot-
              tom-most  element  is  "main".  This variable exists only when a
              shell function is executing.  Assignments to  FUNCNAME  have  no
              effect  and  return  an  error(8,n) status.  If FUNCNAME is unset, it
              loses its special properties, even if(3,n) it is subsequently  reset.

       GROUPS An  array  variable  containing  the list of groups of which the
              current user is a member.  Assignments to GROUPS have no  effect
              and  return  an  error(8,n) status.  If GROUPS is unset, it loses its
              special properties, even if(3,n) it is subsequently reset.

       HISTCMD
              The history(1,3,n,1 builtins) number, or index in(1,8) the history(1,3,n,1 builtins) list, of the current
              command.   If HISTCMD is unset, it loses its special properties,
              even if(3,n) it is subsequently reset.

       HOSTNAME
              Automatically set(7,n,1 builtins) to the name of the current host.

       HOSTTYPE
              Automatically set(7,n,1 builtins) to a string(3,n) that uniquely describes  the  type
              of  machine  on which bash is executing.  The default is system-
              dependent.

       LINENO Each time(1,2,n) this parameter is referenced, the shell substitutes  a
              decimal  number  representing the current sequential line number
              (starting with 1) within a script or function.  When  not  in(1,8)  a
              script  or  function, the value substituted is not guaranteed to
              be meaningful.  If LINENO is unset, it loses its special proper-
              ties, even if(3,n) it is subsequently reset.

       MACHTYPE
              Automatically  set(7,n,1 builtins)  to  a string(3,n) that fully describes the system
              type on which bash is executing, in(1,8) the  standard  GNU  cpu-com-
              pany-system format.  The default is system-dependent.

       OLDPWD The previous working directory as set(7,n,1 builtins) by the cd command.

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

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

       OSTYPE Automatically  set(7,n,1 builtins) to a string(3,n) that describes the operating sys-
              tem on which bash is executing.  The  default  is  system-depen-
              dent.

       PIPESTATUS
              An  array  variable (see Arrays below) containing a list of exit(3,n,1 builtins)
              status values from the processes in(1,8)  the  most-recently-executed
              foreground pipeline (which may contain only a single command).

       PPID   The  process  ID  of the shell's parent.  This variable is read-
              only.

       PWD    The current working directory as set(7,n,1 builtins) by the cd command.

       RANDOM Each time(1,2,n) this parameter is referenced, a random(3,4,6) integer between
              0 and 32767 is generated.  The sequence of random(3,4,6) numbers may be
              initialized by assigning a value to RANDOM.  If RANDOM is unset,
              it  loses  its  special  properties,  even if(3,n) it is subsequently
              reset.

       REPLY  Set to the line of input read(2,n,1 builtins) by the read(2,n,1 builtins) builtin  command  when
              no arguments are supplied.

       SECONDS
              Each  time(1,2,n)  this  parameter is referenced, the number of seconds
              since shell invocation is returned.  If a value is  assigned  to
              SECONDS,  the  value  returned upon subsequent references is the
              number of seconds since the assignment plus the value  assigned.
              If SECONDS is unset, it loses its special properties, even if(3,n) it
              is subsequently reset.

       SHELLOPTS
              A colon-separated list of enabled shell options.  Each  word  in(1,8)
              the  list  is  a  valid  argument  for  the -o option to the set(7,n,1 builtins)
              builtin command (see SHELL BUILTIN COMMANDS below).  The options
              appearing  in(1,8)  SHELLOPTS are those reported as on by set(7,n,1 builtins) -o.  If
              this variable is in(1,8) the environment when bash  starts  up,  each
              shell  option  in(1,8)  the  list  will be enabled before reading any
              startup files.  This variable is read-only.

       SHLVL  Incremented by one each time(1,2,n) an instance of bash is started.

       UID    Expands to the user ID of the current user, initialized at shell
              startup.  This variable is readonly.

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

       BASH_ENV
              If this parameter is set(7,n,1 builtins) when bash is executing a shell  script,
              its  value  is  interpreted as a filename containing commands to
              initialize the shell, as in(1,8) ~/.bashrc.  The value of BASH_ENV is
              subjected  to  parameter  expansion,  command  substitution, and
              arithmetic expansion before being interpreted as  a  file(1,n)  name.
              PATH is not used to search for the resultant file(1,n) name.
       CDPATH The  search  path for the cd command.  This is a colon-separated
              list of directories in(1,8) which the  shell  looks  for  destination
              directories  specified  by  the  cd  command.  A sample value is
              ".:~:/usr".
       COLUMNS
              Used by the select(2,7,2 select_tut) builtin command  to  determine  the  terminal
              width  when  printing  selection  lists.  Automatically set(7,n,1 builtins) upon
              receipt of a SIGWINCH.
       COMPREPLY
              An array variable from which bash reads the possible completions
              generated  by  a shell function invoked by the programmable com-
              pletion facility (see Programmable Completion below).
       EMACS  If bash finds this variable in(1,8) the environment  when  the  shell
              starts  with  value "t", it assumes that the shell is running in(1,8)
              an emacs shell buffer and disables line editing.
       FCEDIT The default editor for the fc builtin command.
       FIGNORE
              A colon-separated list of suffixes  to  ignore  when  performing
              filename completion (see READLINE below).  A filename whose suf-
              fix matches one of the entries in(1,8) FIGNORE is excluded  from  the
              list of matched filenames.  A sample value is ".o:~".
       GLOBIGNORE
              A colon-separated list of patterns defining the set(7,n,1 builtins) of filenames
              to be ignored by pathname expansion.  If a filename matched by a
              pathname  expansion  pattern also matches one of the patterns in(1,8)
              GLOBIGNORE, it is removed from the list of matches.
       HISTCONTROL
              A colon-separated list of values controlling  how  commands  are
              saved  on  the  history(1,3,n,1 builtins)  list.   If  the list of values includes
              ignorespace, lines which begin with a space  character  are  not
              saved  in(1,8)  the history(1,3,n,1 builtins) list.  A value of ignoredups causes lines
              matching the previous history(1,3,n,1 builtins) entry to not be saved.  A value of
              ignoreboth is shorthand for ignorespace and ignoredups.  A value
              of erasedups causes all previous lines matching the current line
              to  be  removed from the history(1,3,n,1 builtins) list before that line is saved.
              Any value not in(1,8) the above list is ignored.  If  HISTCONTROL  is
              unset,  or does not include a valid value, all lines read(2,n,1 builtins) by the
              shell parser are saved on the history(1,3,n,1 builtins) list, subject to the value
              of  HISTIGNORE.  The second and subsequent lines of a multi-line
              compound command are not tested, and are added  to  the  history(1,3,n,1 builtins)
              regardless of the value of HISTCONTROL.
       HISTFILE
              The name of the file(1,n) in(1,8) which command history(1,3,n,1 builtins) is saved (see HIS-
              TORY below).  The default value is ~/.bash_history.   If  unset,
              the  command  history(1,3,n,1 builtins)  is  not  saved  when an interactive shell
              exits.
       HISTFILESIZE
              The maximum number of lines contained in(1,8) the history(1,3,n,1 builtins) file.  When
              this  variable  is  assigned  a value, the history(1,3,n,1 builtins) file(1,n) is trun-
              cated, if(3,n) necessary, to contain no  more  than  that  number  of
              lines.   The  default  value  is  500.  The history(1,3,n,1 builtins) file(1,n) is also
              truncated to this size after  writing  it  when  an  interactive
              shell exits.
       HISTIGNORE
              A  colon-separated list of patterns used to decide which command
              lines should be saved on the  history(1,3,n,1 builtins)  list.   Each  pattern  is
              anchored  at  the  beginning of the line and must match the com-
              plete line (no implicit  `*'  is  appended).   Each  pattern  is
              tested  against  the line after the checks specified by HISTCON-
              TROL are applied.  In  addition  to  the  normal  shell  pattern
              matching characters, `&' matches the previous history(1,3,n,1 builtins) 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(1,3,n,1 builtins) regardless of the value of HISTIGNORE.
       HISTSIZE
              The  number  of commands to remember in(1,8) the command history(1,3,n,1 builtins) (see
              HISTORY below).  The default value is 500.
       HISTTIMEFORMAT
              If this variable is set(7,n,1 builtins) and not null, its value  is  used  as  a
              format string(3,n) for strftime(3) to print the time(1,2,n) stamp associated
              with each history(1,3,n,1 builtins) entry displayed by the  history(1,3,n,1 builtins)  builtin.   If
              this  variable  is  set(7,n,1 builtins),  time(1,2,n) stamps are written to the history(1,3,n,1 builtins)
              file(1,n) so they may be preserved across shell sessions.
       HOME   The home directory of the current user; the default argument for
              the cd builtin command.  The value of this variable is also used
              when performing tilde expansion.
       HOSTFILE
              Contains the name of a file(1,n) in(1,8) the  same  format  as  /etc/hosts
              that should be read(2,n,1 builtins) when the shell needs to complete a hostname.
              The list of possible hostname completions may be  changed  while
              the  shell  is  running;  the  next  time(1,2,n) hostname completion is
              attempted after the value is changed, bash adds the contents  of
              the  new file(1,n) to the existing list.  If HOSTFILE is set(7,n,1 builtins), but has
              no value, bash attempts to read(2,n,1 builtins) /etc/hosts to obtain the list of
              possible  hostname  completions.   When  HOSTFILE  is unset, the
              hostname list is cleared.
       IFS    The Internal Field Separator that is  used  for  word  splitting
              after  expansion  and  to  split(1,n)  lines into words with the read(2,n,1 builtins)
              builtin  command.   The  default  value  is  ``<space><tab><new-
              line>''.
       IGNOREEOF
              Controls the action of an interactive shell on receipt of an EOF
              character as the sole input.  If set(7,n,1 builtins), the value is the number of
              consecutive  EOF  characters  which  must  be typed as the first
              characters on an input line before bash exits.  If the  variable
              exists  but  does not have a numeric value, or has no value, the
              default value is 10.  If it does not exist,  EOF  signifies  the
              end of input to the shell.
       INPUTRC
              The  filename  for  the  readline  startup  file(1,n), overriding the
              default of ~/.inputrc (see READLINE below).
       LANG   Used to determine the  locale(3,5,7)  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(3,5,7) category.
       LC_COLLATE
              This variable determines the collation order used  when  sorting
              the  results  of pathname expansion, and determines the behavior
              of  range  expressions,  equivalence  classes,   and   collating
              sequences within pathname expansion and pattern matching.
       LC_CTYPE
              This  variable  determines  the interpretation of characters and
              the behavior of character classes within pathname expansion  and
              pattern matching.
       LC_MESSAGES
              This  variable  determines  the locale(3,5,7) used to translate double-
              quoted strings preceded by a $.
       LC_NUMERIC
              This variable determines the locale(3,5,7)  category  used  for  number
              formatting.
       LINES  Used  by  the  select(2,7,2 select_tut)  builtin  command  to determine the column
              length for printing selection  lists.   Automatically  set(7,n,1 builtins)  upon
              receipt of a SIGWINCH.
       MAIL   If  this  parameter is set(7,n,1 builtins) to a file(1,n) name and the MAILPATH vari-
              able is not set(7,n,1 builtins), bash informs the user of the arrival of mail(1,8) in(1,8)
              the specified file.
       MAILCHECK
              Specifies  how  often  (in(1,8)  seconds)  bash checks for mail.  The
              default is 60 seconds.  When it is time(1,2,n) to check for  mail(1,8),  the
              shell  does  so  before  displaying the primary prompt.  If this
              variable is unset, or set(7,n,1 builtins) to  a  value  that  is  not  a  number
              greater than or equal to zero, the shell disables mail(1,8) checking.
       MAILPATH
              A colon-separated list of file(1,n) names to  be  checked  for  mail.
              The message to be printed when mail(1,8) arrives in(1,8) a particular file(1,n)
              may be specified by separating the file(1,n) name  from  the  message
              with a `?'.  When used in(1,8) the text of the message, $_ expands to
              the name of the current mailfile.  Example:
              MAILPATH='/var/mail(1,8)/bfox?"You  have  mail(1,8)":~/shell-mail?"$_  has
              mail(1,8)!"'
              Bash  supplies  a default value for this variable, but the loca-
              tion of the user mail(1,8) files that it  uses  is  system  dependent
              (e.g., /var/mail(1,8)/$USER).
       OPTERR If set(7,n,1 builtins) to the value 1, bash displays error(8,n) messages generated by
              the getopts builtin command (see SHELL BUILTIN COMMANDS  below).
              OPTERR  is  initialized to 1 each time(1,2,n) the shell is invoked or a
              shell script is executed.
       PATH   The search path for commands.  It is a colon-separated  list  of
              directories  in(1,8)  which the shell looks for commands (see COMMAND
              EXECUTION below).  A zero-length (null) directory  name  in(1,8)  the
              value of PATH indicates the current directory.  A null directory
              name may appear as two adjacent colons,  or  as  an  initial  or
              trailing  colon.   The  default path is system-dependent, and is
              set(7,n,1 builtins) by the administrator who installs bash.  A common  value  is
              ``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin''.
       POSIXLY_CORRECT
              If  this  variable  is  in(1,8) the environment when bash starts, the
              shell enters posix mode before reading the startup files, as  if(3,n)
              the  --posix  invocation option had been supplied.  If it is set(7,n,1 builtins)
              while the shell is running, bash enables posix mode, as  if(3,n)  the
              command set(7,n,1 builtins) -o posix had been executed.
       PROMPT_COMMAND
              If set(7,n,1 builtins), the value is executed as a command prior to issuing each
              primary prompt.
       PS1    The value of this parameter is expanded  (see  PROMPTING  below)
              and  used  as  the  primary prompt string.  The default value is
              ``\s-\v\$ ''.
       PS2    The value of this parameter is expanded as with PS1 and used  as
              the secondary prompt string.  The default is ``> ''.
       PS3    The value of this parameter is used as the prompt for the select(2,7,2 select_tut)
              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  mul-
              tiple  times, as necessary, to indicate multiple levels of indi-
              rection.  The default is ``+ ''.
       SHELL  The full pathname to the shell is kept in(1,8) this environment vari-
              able.   If  it is not set(7,n,1 builtins) when the shell starts, bash assigns to
              it the full pathname of the current user's login(1,3,5) shell.
       TIMEFORMAT
              The value of this parameter is used as a format string(3,n)  specify-
              ing  how  the timing information for pipelines prefixed with the
              time(1,2,n) reserved word should be displayed.  The % character  intro-
              duces  an  escape  sequence  that is expanded to a time(1,2,n) 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(1,2,n) in(1,8) seconds.
              %[p][l]U  The number of CPU seconds spent in(1,8) user mode.
              %[p][l]S  The number of CPU seconds spent in(1,8) system mode.
              %P        The CPU percentage, computed as (%U + %S) / %R.

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

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

              If this variable is not set(7,n,1 builtins), bash acts as if(3,n) 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(3,n) is displayed.

       TMOUT  If  set(7,n,1 builtins)  to  a  value greater than zero, TMOUT is treated as the
              default timeout(1,3x,3x cbreak) for the read(2,n,1 builtins) builtin.  The select(2,7,2 select_tut) command termi-
              nates if(3,n) input does not arrive after TMOUT seconds when input is
              coming from a terminal.  In an interactive shell, the  value  is
              interpreted  as  the  number  of seconds to wait for input after
              issuing the primary prompt.  Bash terminates after  waiting  for
              that number of seconds if(3,n) input does not arrive.

       auto_resume
              This variable controls how the shell interacts with the user and
              job control.  If this variable is set(7,n,1 builtins), single word  simple  com-
              mands without redirections are treated as candidates for resump-
              tion of an existing stopped job.  There is no ambiguity allowed;
              if(3,n)  there  is more than one job beginning with the string(3,n) typed,
              the job most recently accessed  is  selected.   The  name  of  a
              stopped  job, in(1,8) this context, is the command line used to start
              it.  If set(7,n,1 builtins) to the value exact, the string(3,n) supplied  must  match
              the  name  of  a  stopped  job exactly; if(3,n) set(7,n,1 builtins) to substring, the
              string(3,n) supplied needs to match a substring  of  the  name  of  a
              stopped  job.  The substring value provides functionality analo-
              gous to the %?  job identifier (see JOB CONTROL below).  If  set(7,n,1 builtins)
              to  any  other  value, the supplied string(3,n) must be a prefix of a
              stopped job's name; this provides functionality analogous to the
              % job identifier.

       histchars
              The  two or three characters which control history(1,3,n,1 builtins) expansion and
              tokenization (see HISTORY EXPANSION below).  The first character
              is  the history(1,3,n,1 builtins) expansion character, the character which signals
              the start of a history(1,3,n,1 builtins)  expansion,  normally  `!'.   The  second
              character  is the quick substitution character, which is used as
              shorthand for re-running the previous command  entered,  substi-
              tuting  one  string(3,n)  for another in(1,8) the command.  The default is
              `^'.  The optional third character is the character which  indi-
              cates  that the remainder of the line is a comment when found as
              the first character of a word, normally `#'.  The  history(1,3,n,1 builtins)  com-
              ment character causes history(1,3,n,1 builtins) 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.

   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(3,n) 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 [sub-
       script]=string(3,n).  Only string(3,n) 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 introduced above.

       Any  element  of  an  array may be referenced using ${name[subscript]}.
       The braces are required to avoid conflicts 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 sep-
       arate 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 expan-
       sion is the number of elements in(1,8)  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 subscript.  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(2,8) a -a option to
       specify an array.  The read(2,n,1 builtins) builtin accepts a -a  option  to  assign  a
       list  of  words  read(2,n,1 builtins) from the standard input to an array.  The set(7,n,1 builtins) and
       declare builtins display array values in(1,8) a way that allows them  to  be
       reused as assignments.

EXPANSION
       Expansion is performed on the command line after it has been split(1,n) into
       words.  There are seven kinds of expansion performed: brace  expansion,
       tilde  expansion,  parameter  and variable expansion, command substitu-
       tion, arithmetic expansion, word splitting, and pathname expansion.

       The order of expansions is: brace expansion, tilde  expansion,  parame-
       ter,  variable  and arithmetic expansion and command substitution (done
       in(1,8) a left-to-right fashion), word splitting, and pathname expansion.

       On systems that can support it, there is an additional expansion avail-
       able: 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 gener-
       ated.   This  mechanism is similar to pathname expansion, but the file-
       names generated need not exist.  Patterns to be brace expanded take the
       form of an optional preamble, followed by either a series of comma-sep-
       arated strings or a sequence expression between a pair of braces,  fol-
       lowed  by  an  optional  postscript.   The preamble is prefixed to each
       string(3,n) contained within the braces, and the postscript is then appended
       to each resulting string(3,n), expanding left to right.

       Brace  expansions  may  be nested.  The results of each expanded string(3,n)
       are not sorted;  left  to  right  order  is  preserved.   For  example,
       a{d,c,b}e expands into `ade ace abe'.

       A  sequence  expression takes the form {x..y}, where x and y are either
       integers or single characters.  When integers are supplied, the expres-
       sion  expands  to each number between x and y, inclusive.  When charac-
       ters are supplied, the expression expands  to  each  character  lexico-
       graphically between x and y, inclusive.  Note that both x and y must be
       of the same type.

       Brace expansion is performed before any other expansions, and any char-
       acters  special to other expansions are preserved in(1,8) 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  or  a  valid  sequence
       expression.   Any incorrectly formed brace expansion is left unchanged.
       A { or , may be quoted with a backslash to prevent its being considered
       part  of  a brace expression.  To avoid conflicts with parameter expan-
       sion, the string(3,n) ${ is not considered eligible for brace expansion.

       This construct is typically used as shorthand when the common prefix of
       the strings to be generated is longer than in(1,8) the above example:

              mkdir(1,2) /usr/local/src/bash/{old,new,dist,bugs}
       or
              chown(1,2) 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(1,8) the output.
       Bash removes braces from words as a  consequence  of  brace  expansion.
       For  example,  a word entered to sh as file(1,n){1,2} appears identically in(1,8)
       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(7,n,1 builtins) com-
       mand (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(3,n)
       there  is no unquoted slash) are considered a tilde-prefix.  If none of
       the characters in(1,8) the tilde-prefix are quoted, the  characters  in(1,8)  the
       tilde-prefix  following the tilde are treated as a possible login(1,3,5) name.
       If this login(1,3,5) name is the null string(3,n), the tilde is replaced  with  the
       value  of  the shell parameter HOME.  If HOME is unset, the home direc-
       tory of the user executing the shell is  substituted  instead.   Other-
       wise,  the  tilde-prefix is replaced with the home directory associated
       with the specified login(1,3,5) name.

       If the tilde-prefix is a `~+', the value  of  the  shell  variable  PWD
       replaces the tilde-prefix.  If the tilde-prefix is a `~-', the value of
       the shell variable OLDPWD, if(3,n) it is set(7,n,1 builtins), is substituted.  If the  char-
       acters  following  the tilde in(1,8) the tilde-prefix consist of a number N,
       optionally prefixed by a `+' or a `-',  the  tilde-prefix  is  replaced
       with the corresponding element from the directory stack, as it would be
       displayed by the dirs builtin invoked with the tilde-prefix as an argu-
       ment.   If  the characters following the tilde in(1,8) the tilde-prefix con-
       sist of a number without a leading `+' or `-', `+' is assumed.

       If the login(1,3,5) name is invalid, or the tilde expansion fails, the word is
       unchanged.

       Each variable assignment is checked for unquoted tilde-prefixes immedi-
       ately following a : or =.  In these cases, tilde expansion is also per-
       formed.   Consequently,  one  may use file(1,n) names with tildes in(1,8) assign-
       ments 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(1,8) 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(3,n),  and  not  within  an
       embedded arithmetic expansion, command substitution, or paramter expan-
       sion.

       ${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  vari-
       able  formed  from  the  rest of parameter as the name of the variable;
       this variable is then expanded and that value is used in(1,8)  the  rest  of
       the  substitution,  rather than the value of parameter itself.  This is
       known as indirect expansion.  The exceptions to this are the expansions
       of  ${!prefix*} and ${!name[@]} described below.  The exclamation point
       must immediately follow the left brace in(1,8) order to  introduce  indirec-
       tion.

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

       ${parameter:-word}
              Use  Default  Values.  If parameter is unset or null, the expan-
              sion 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 param-
              eter  is  then  substituted.   Positional parameters and special
              parameters may not be assigned to in(1,8) this way.
       ${parameter:?word}
              Display Error if(3,n) Null or Unset.  If parameter is null or  unset,
              the  expansion  of  word (or a message to that effect if(3,n) word is
              not present) is written to the standard error(8,n) and the shell,  if(3,n)
              it is not interactive, exits.  Otherwise, the value of parameter
              is substituted.
       ${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 characters of
              parameter starting at the character  specified  by  offset.   If
              length  is omitted, expands to the substring of parameter start-
              ing at the character specified by offset.  length and offset are
              arithmetic   expressions   (see  ARITHMETIC  EVALUATION  below).
              length must evaluate to a number greater than or equal to  zero.
              If  offset  evaluates  to  a number less(1,3) 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(1,8) which case the
              indexing starts at 1.

       ${!prefix*}
       ${!prefix@}
              Expands to the names of variables whose names begin with prefix,
              separated by the first character of the IFS special variable.

       ${!name[@]}
       ${!name[*]}
              If  name  is  an  array  variable,  expands to the list of array
              indices (keys) assigned in(1,8) name.   If  name  is  not  an  array,
              expands  to 0 if(3,n) name is set(7,n,1 builtins) and null otherwise.  When @ is used
              and the expansion appears within double quotes, each key expands
              to a separate word.

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

       ${parameter#word}
       ${parameter##word}
              The  word  is  expanded to produce a pattern just as in(1,8) pathname
              expansion.  If the pattern matches the beginning of the value of
              parameter,  then  the  result  of  the expansion is the expanded
              value of parameter with the shortest matching pattern (the ``#''
              case) or the longest matching pattern (the ``##'' case) deleted.
              If parameter is @ or *, the pattern removal operation is applied
              to  each  positional parameter in(1,8) 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(1,8) turn, and the expansion is the  resultant
              list.

       ${parameter%word}
       ${parameter%%word}
              The  word  is  expanded to produce a pattern just as in(1,8) 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 parameter with the shortest matching  pat-
              tern  (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(1,8)
              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(1,8)  turn,  and
              the expansion is the resultant list.

       ${parameter/pattern/string(3,n)}
       ${parameter//pattern/string(3,n)}
              The pattern is expanded to produce a pattern just as in(1,8) pathname
              expansion.  Parameter is expanded and the longest match of  pat-
              tern  against  its  value is replaced with string(3,n).  In the first
              form, only the first match is replaced.  The second form  causes
              all  matches  of pattern to be replaced with string(3,n).  If pattern
              begins with #, it must match at the beginning  of  the  expanded
              value  of parameter.  If pattern begins with %, it must match at
              the end of the expanded value of parameter.  If string(3,n) 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(1,8) turn, and the expan-
              sion is the resultant list.  If parameter is an  array  variable
              subscripted  with  @ or *, the substitution operation is applied
              to each member of the array in(1,8) turn, and the  expansion  is  the
              resultant list.

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


              $(command)
       or
              `command`

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

       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 sub-
       stitution.   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 expan-
       sion is:

              $((expression))

       The expression is treated as if(3,n) it were within  double  quotes,  but  a
       double  quote  inside  the  parentheses  is not treated specially.  All
       tokens in(1,8) the expression undergo parameter expansion, string(3,n) expansion,
       command  substitution, and quote removal.  Arithmetic expansions 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(5,8)  pipes
       (FIFOs)  or the /dev/fd method of naming open(2,3,n) files.  It takes the form
       of <(list) or >(list).  The process list is run with its input or  out-
       put connected to a FIFO or some file(1,n) in(1,8) /dev/fd.  The name of this file(1,n)
       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(1,n) will pro-
       vide input for list.  If the <(list) form is used, the file(1,n)  passed  as
       an argument should be read(2,n,1 builtins) to obtain the output of list.

       When  available,  process substitution is performed simultaneously with
       parameter and variable expansion, command substitution, and  arithmetic
       expansion.

   Word Splitting
       The  shell  scans the results of parameter expansion, command substitu-
       tion, 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(1,8) the value of IFS (an
       IFS whitespace character).  Any character in(1,8) IFS that is not IFS white-
       space,  along  with  any adjacent IFS whitespace characters, delimits a
       field.  A sequence of IFS whitespace characters is also  treated  as  a
       delimiter.  If the value of IFS is null, no word splitting occurs.

       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 argument results and is retained.

       Note that if(3,n) no expansion occurs, no splitting is performed.

   Pathname Expansion
       After word splitting, unless the -f option has  been  set(7,n,1 builtins),  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(1,n) names matching the pattern.  If no
       matching file(1,n) names are found, and the shell option  nullglob  is  dis-
       abled,  the word is left unchanged.  If the nullglob option is set(7,n,1 builtins), and
       no matches are found, the word  is  removed.   If  the  failglob  shell
       option  is  set(7,n,1 builtins),  and no matches are found, an error(8,n) message is printed
       and the command is not executed.  If the  shell  option  nocaseglob  is
       enabled,  the  match  is performed without regard to the case of alpha-
       betic characters.  When a pattern is used for pathname  expansion,  the
       character  ``.''   at  the  start  of a name or immediately following a
       slash must be matched explicitly, unless the shell  option  dotglob  is
       set.   When  matching  a  pathname,  the slash character must always be
       matched explicitly.  In  other  cases,  the  ``.''   character  is  not
       treated  specially.   See  the  description  of shopt below under SHELL
       BUILTIN COMMANDS for a description of the nocaseglob,  nullglob,  fail-
       glob(1,3,7,n), and dotglob shell options.

       The  GLOBIGNORE  shell variable may be used to restrict the set(7,n,1 builtins) of file(1,n)
       names matching a pattern.  If GLOBIGNORE is  set(7,n,1 builtins),  each  matching  file(1,n)
       name  that  also  matches  one of the patterns in(1,8) GLOBIGNORE is removed
       from the list of matches.  The file(1,n) names ``.''  and ``..''  are always
       ignored  when GLOBIGNORE is set(7,n,1 builtins) and not null.  However, setting GLOBIG-
       NORE to a non-null value has the effect of enabling the  dotglob  shell
       option, so all other file(1,n) names beginning with a ``.''  will match.  To
       get the old behavior of ignoring file(1,n) names  beginning  with  a  ``.'',
       make  ``.*''  one of the patterns in(1,8) GLOBIGNORE.  The dotglob option is
       disabled when GLOBIGNORE is unset.

       Pattern Matching

       Any character that appears in(1,8) a pattern, other than the special pattern
       characters  described below, matches itself.  The NUL character may not
       occur in(1,8) a pattern.  A backslash escapes the following  character;  the
       escaping  backslash  is  discarded  when matching.  The special pattern
       characters must be quoted if(3,n) they are to be matched literally.

       The special pattern characters have the following meanings:

       *      Matches any string(3,n), including the null string.
       ?      Matches any single character.
       [...]  Matches any one of the enclosed characters.  A pair  of  charac-
              ters separated by a hyphen denotes a range expression; any char-
              acter that sorts between those two characters, inclusive,  using
              the  current  locale(3,5,7)'s  collating sequence and character set(7,n,1 builtins), is
              matched.  If the first character following the [ is a !  or a  ^
              then  any  character not enclosed is matched.  The sorting order
              of characters in(1,8) range expressions is determined by the  current
              locale(3,5,7)  and  the value of the LC_COLLATE shell variable, if(3,n) set.
              A - may be matched by including it as the first or last  charac-
              ter in(1,8) the set.  A ] may be matched by including it as the first
              character in(1,8) the set.

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

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

              Within [ and ], the syntax [.symbol.] matches the collating sym-
              bol symbol.

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

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

   Quote Removal
       After the preceding expansions, all unquoted occurrences of the charac-
       ters \, ', 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(2,3,n) and close(2,7,n) 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(1,8) the order they appear, from left to right.

       In the following descriptions, if(3,n) the file(1,n) descriptor number  is  omit-
       ted,  and the first character of the redirection operator is <, the re-
       direction refers to the standard input (file(1,n)  descriptor  0).   If  the
       first  character  of  the  redirection  operator  is >, the redirection
       refers to the standard output (file(1,n) descriptor 1).

       The word following the redirection operator in(1,8) the  following  descrip-
       tions,  unless  otherwise noted, is subjected to brace expansion, tilde
       expansion, parameter expansion, command substitution, arithmetic expan-
       sion,  quote  removal,  pathname  expansion, and word splitting.  If it
       expands to more than one word, bash reports an error.

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

              ls > dirlist 2>&1

       directs  both  standard  output and standard error(8,n) to the file(1,n) dirlist,
       while the command

              ls 2>&1 > dirlist

       directs only the standard output to file(1,n) dirlist, because the  standard
       error(8,n)  was duplicated as standard output before the standard output was
       redirected to dirlist.

       Bash handles several filenames specially when they are used in(1,8) redirec-
       tions, as described in(1,8) the following table:

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

       A failure to open(2,3,n) or create a file(1,n) causes the redirection to fail.

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

       The general format for redirecting input is:

              [n]<word

   Redirecting Output
       Redirection of output causes the  file(1,n)  whose  name  results  from  the
       expansion of word to be opened for writing on file(1,n) descriptor n, or the
       standard output (file(1,n) descriptor 1) if(3,n) n is not specified.  If the file(1,n)
       does  not exist it is created; if(3,n) 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(7,n,1 builtins)
       builtin  has  been enabled, the redirection will fail if(3,n) the file(1,n) 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(7,n,1 builtins) builtin command is not enabled, the re-
       direction is attempted even if(3,n) the file(1,n) named(5,8) by word exists.

   Appending Redirected Output
       Redirection  of  output  in(1,8)  this  fashion  causes  the file(1,n) whose name
       results from the expansion of word to be opened for appending  on  file(1,n)
       descriptor  n,  or  the standard output (file(1,n) descriptor 1) if(3,n) n is not
       specified.  If the file(1,n) 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(1,n) descriptor 1) and the  stan-
       dard  error(8,n)  output  (file(1,n)  descriptor  2) to be redirected to the file(1,n)
       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 semantically equiva-
       lent to

              >word 2>&1

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

       The format of here-documents is:

              <<[-]word
                      here-document
              delimiter

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

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

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

              <<<word

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

   Duplicating File Descriptors
       The redirection operator

              [n]<&word

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

       The operator

              [n]>&word

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

   Moving File Descriptors
       The redirection operator

              [n]<&digit-

       moves the file(1,n) descriptor digit to file(1,n) descriptor n, or  the  standard
       input (file(1,n) descriptor 0) if(3,n) n is not specified.  digit is closed after
       being duplicated to n.

       Similarly, the redirection operator

              [n]>&digit-

       moves the file(1,n) descriptor digit to file(1,n) descriptor n, or  the  standard
       output (file(1,n) descriptor 1) if(3,n) n is not specified.

   Opening File Descriptors for Reading and Writing
       The redirection operator

              [n]<>word

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

ALIASES
       Aliases  allow a string(3,n) 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(7,n,1 builtins) and unset with the alias and unalias builtin
       commands (see SHELL BUILTIN COMMANDS below).  The first  word  of  each
       simple  command, if(3,n) unquoted, is checked to see if(3,n) it has an alias.  If
       so, that word is replaced by the text of the alias.  The characters  /,
       $,  `,  and = and any of the shell metacharacters or quoting characters
       listed above may not appear in(1,8) an alias name.  The replacement text may
       contain  any  valid  shell  input, including shell metacharacters.  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(1,8) the replacement text.   If
       arguments  are  needed,  a shell function should be used (see FUNCTIONS
       below).

       Aliases are not expanded when the shell is not interactive, unless  the
       expand_aliases  shell option is set(7,n,1 builtins) 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(2,n,1 builtins), 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(2,n,1 builtins), not  when  the
       function  is  executed,  because a function definition is itself a com-
       pound command.  As a consequence, aliases defined in(1,8) 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(1,8)  com-
       pound 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.  When the  name  of  a
       shell  function  is used as a simple command name, the list of commands
       associated with that function name is executed.  Functions are executed
       in(1,8)  the  context  of  the  current  shell; no new process is created to
       interpret them (contrast this with the execution of  a  shell  script).
       When  a  function is executed, the arguments to the function become the
       positional parameters during its execution.  The special parameter # is
       updated  to reflect the change.  Special parameter 0 is unchanged.  The
       first element of the FUNCNAME variable is set(7,n,1 builtins) to the name of the  func-
       tion  while  the function is executing.  All other aspects of the shell
       execution 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 unless the
       function has been given the trace(3x,n,3x _nc_tracebits) attribute (see the description of the
       declare builtin below) or  the  -o  functrace  shell  option  has  been
       enabled  with  the set(7,n,1 builtins) builtin (in(1,8) which case all functions inherit the
       DEBUG trap).

       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(1,8) a function,  the  function
       completes  and  execution resumes with the next command after the func-
       tion call.  Any command associated with the  RETURN  trap  is  executed
       before execution resumes.  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 type-
       set(7,n,1 builtins)  will  list the function names only (and optionally the source file(1,n)
       and line number, if(3,n) the extdebug shell option is  enabled)