Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Glossary
MoreInfo
Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
FAQ
Copyright Info
Terms of Use
Privacy Info
Disclaimer
WorkBoard
Thanks
Donations
Advertising
Masthead / Impressum
Your Account

Communication
Feedback
Forums
Private Messages
Surveys

Features
HOWTOs
News Archive
Submit News
Topics
User Articles
Web Links

Google
Google


The Web
linux-tutorial.info

Who's Online
There are currently, 158 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here

  

bash



SYNOPSIS

       bash [options] [file]


COPYRIGHT

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


DESCRIPTION

       Bash is an sh-compatible command language interpreter that
       executes  commands  read from the standard input or from a
       file.  Bash also incorporates  useful  features  from  the
       Korn and C shells (ksh and csh).

       Bash  is intended to be a conformant implementation of the
       IEEE POSIX Shell and  Tools  specification  (IEEE  Working
       Group 1003.2).


OPTIONS

       In  addition  to  the single-character shell options docu­
       mented in the description of the set builtin command, bash
       interprets the following options when it is invoked:

       -c string If  the  -c option is present, then commands are
                 read from string.  If there are arguments  after
                 the  string, they are assigned to the positional
                 parameters, starting with $0.
       -i        If the -i option is present, the shell is inter­
                 active.
       -l        Make  bash  act  as  if it had been invoked as a
                 login shell (see INVOCATION below).
       -r        If the -r option is present, the  shell  becomes
                 restricted (see RESTRICTED SHELL below).
       -s        If  the -s option is present, or if no arguments
                 remain after option  processing,  then  commands
                 are  read  from the standard input.  This option
                 allows the positional parameters to be set  when
                 invoking an interactive shell.
       -v        Print shell input lines as they are read.
       -x        Print  commands  and their arguments as they are
                 executed.
       -D        A list of all double-quoted strings preceded  by
                 $  is  printed on the standard ouput.  These are
                 the strings that are subject to language  trans­
                 lation  when  the  current  locale  is  not C or
                 POSIX.  This implies the -n option; no  commands
                 will be executed.
       [-+]O [shopt_option]
                 shopt_option   is   one  of  the  shell  options
                 accepted by the shopt builtin (see SHELL BUILTIN
                 COMMANDS below).  If shopt_option is present, -O
                 sets the value of that option; +O unsets it.  If
                 shopt_option is not supplied, the names and val­

              Equivalent to -D, but the output is in the GNU get­
              text po (portable object) file format.
       --dump-strings
              Equivalent to -D.
       --help Display a usage message on standard output and exit
              successfully.
       --init-file file
       --rcfile file
              Execute commands from file instead of the  standard
              personal initialization file ~/.bashrc if the shell
              is interactive (see INVOCATION below).

       --login
              Equivalent to -l.

       --noediting
              Do not use the GNU readline library to read command
              lines when the shell is interactive.

       --noprofile
              Do  not  read  either  the system-wide startup file
              /etc/profile or any of the personal  initialization
              files  ~/.bash_profile,  ~/.bash_login,  or ~/.pro­
              file.  By default, bash reads these files  when  it
              is invoked as a login shell (see INVOCATION below).

       --norc Do not read and execute the personal initialization
              file  ~/.bashrc  if the shell is interactive.  This
              option is on by default if the shell is invoked  as
              sh.

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

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

       --verbose
              Equivalent to  -v.

       --version
              Show version information for this instance of  bash
              on the standard output and exit successfully.


ARGUMENTS

       If  arguments  remain after option processing, and neither
       the -c nor the -s option  has  been  supplied,  the  first
       argument  is  assumed  to be the name of a file containing
       shell commands.  If bash is invoked in this fashion, $0 is
       arguments and without the -c option whose  standard  input
       and  output are both connected to terminals (as determined
       by isatty(3)), or one started with the -i option.  PS1  is
       set  and  $- includes i if bash is interactive, allowing a
       shell script or a startup file to test this state.

       The following paragraphs describe how  bash  executes  its
       startup  files.   If  any of the files exist but cannot be
       read, bash reports an error.  Tildes are expanded in  file
       names  as  described  below  under  Tilde Expansion in the
       EXPANSION section.

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

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

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

       When bash is started non-interactively,  to  run  a  shell
       script, for example, it looks for the variable BASH_ENV in
       the environment, expands its value if  it  appears  there,
       and  uses the expanded value as the name of a file to read
       and execute.  Bash behaves as  if  the  following  command
       were executed:
              if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
       but  the  value of the PATH variable is not used to search
       for the file name.

       If bash is invoked with the name sh, it tries to mimic the
       startup  behavior  of historical versions of sh as closely
       as possible, while conforming to  the  POSIX  standard  as
       well.   When  invoked  as an interactive login shell, or a
       non-interactive shell with the --login  option,  it  first
       attempts  to  read  and execute commands from /etc/profile
       and ~/.profile, in that order.  The --noprofile option may
       be  used  to  inhibit  this  behavior.  When invoked as an
       interactive shell with the name sh,  bash  looks  for  the
       variable ENV, expands its value if it is defined, and uses

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

       If the shell is started with the effective user (group) id
       not equal to the real user (group) id, and the  -p  option
       is  not  supplied,  no startup files are read, shell func­
       tions are not inherited from the  environment,  the  SHEL­
       LOPTS  variable,  if  it  appears  in  the environment, is
       ignored, and the effective user id is set to the real user
       id.   If  the  -p  option  is  supplied at invocation, the
       startup behavior is the same, but the effective user id is
       not reset.


DEFINITIONS

       The  following definitions are used throughout the rest of
       this document.
       blank  A space or tab.
       word   A sequence of characters  considered  as  a  single
              unit by the shell.  Also known as a token.
       name   A  word  consisting only of alphanumeric characters
              and underscores, and beginning with  an  alphabetic
              character or an underscore.  Also referred to as an
              identifier.
       metacharacter
              A character that, when unquoted,  separates  words.
              One of the following:
              |  & ; ( ) < > space tab
       control operator
              A  token  that  performs a control function.  It is
              one of the following symbols:
              || & && ; ;; ( ) | <newline>


RESERVED WORDS

       Reserved words are words that have a  special  meaning  to
       the shell.  The following words are recognized as reserved
       when unquoted and either the first word of a  simple  com­
       mand (see SHELL GRAMMAR below) or the third word of a case
       or for command:

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


SHELL GRAMMAR

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

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

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

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

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

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

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

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

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

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

              command1 && command2

       command2  is executed if, and only if, command1 returns an
       exit status of zero.
       (list) list  is  executed in a subshell.  Variable assign­
              ments and builtin commands that affect the  shell's
              environment  do not remain in effect after the com­
              mand completes.  The return status is the exit sta­
              tus of list.

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

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

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

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

              Expressions may be  combined  using  the  following
              operators,  listed  in  decreasing  order of prece­
              dence:

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

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

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

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

       case  word  in [ [(] pattern [ | pattern ] ... ) list ;; ]
       ... esac
              A  case  command  first  expands word, and tries to
              match it against each pattern in  turn,  using  the
              same  matching rules as for pathname expansion (see
              Pathname Expansion below).  When a match is  found,
              the  corresponding  list  is  executed.   After the
              zero if no condition tested true.

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

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


COMMENTS

       In a non-interactive shell, or  an  interactive  shell  in
       which the interactive_comments option to the shopt builtin
       is enabled (see SHELL  BUILTIN  COMMANDS  below),  a  word
       beginning  with # causes that word and all remaining char­
       acters on that line to be ignored.  An  interactive  shell
       without  the  interactive_comments option enabled does not
       allow comments.  The interactive_comments option is on  by
       default in interactive shells.


QUOTING

       Quoting  is  used to remove the special meaning of certain
       characters or words to the shell.  Quoting can be used  to
       disable  special treatment for special characters, to pre­
       vent reserved words from being recognized as such, and  to
       prevent parameter expansion.

       Each  of the metacharacters listed above under DEFINITIONS
       has special meaning to the shell and must be quoted if  it
       is to represent itself.

       When  the  command  history expansion facilities are being
       used, the history expansion character, usually !, must  be
       quoted to prevent history expansion.

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

       A non-quoted backslash (\) is the  escape  character.   It
       their special meaning within double quotes.  The backslash
       retains  its  special meaning only when followed by one of
       the following characters: $, `, ",  \,  or  <newline>.   A
       double quote may be quoted within double quotes by preced­
       ing it with a backslash.

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

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

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

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


PARAMETERS

       A parameter is an entity that stores values.  It can be  a
       name,  a  number,  or one of the special characters listed
       below under Special Parameters.  For the shell's purposes,
       a  variable  is a parameter denoted by a name.  A variable
       has a value and zero or more attributes.   Attributes  are
       assigned  using  the  declare builtin command (see declare
       below in SHELL BUILTIN COMMANDS).

       A parameter is set if it has been assigned a  value.   The
       null  string is a valid value.  Once a variable is set, it
       may be unset only by using the unset builtin command  (see
       SHELL BUILTIN COMMANDS below).

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

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

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

   Special Parameters
       The  shell  treats  several  parameters  specially.  These
       parameters may only be referenced; assignment to  them  is
       not allowed.
       *      Expands to the positional parameters, starting from
              one.   When  the  expansion  occurs  within  double
              quotes,  it expands to a single word with the value
              of each parameter separated by the first  character
              of  the  IFS  special  variable.   That is, "$*" is
              equivalent to "$1c$2c...", where  c  is  the  first
              character of the value of the IFS variable.  If IFS
              is unset, the parameters are separated  by  spaces.
              If  IFS  is null, the parameters are joined without
              intervening separators.
       @      Expands to the positional parameters, starting from
              one.   When  the  expansion  occurs  within  double
              quotes, each parameter expands to a separate  word.
              That  is, "$@" is equivalent to "$1" "$2" ...  When
              there are no positional  parameters,  "$@"  and  $@
              expand to nothing (i.e., they are removed).
       #      Expands  to  the number of positional parameters in
              decimal.
       ?      Expands to the status of the most recently executed
              foreground pipeline.
       -      Expands  to  the  current option flags as specified
              upon invocation, by the  set  builtin  command,  or
              those  set  by  the  shell  itself  (such as the -i
              option).
       $      Expands to the process ID of the shell.   In  a  ()
              subshell,  it expands to the process ID of the cur­
              rent shell, not the subshell.
       !      Expands to the process ID of the most recently exe­
              cuted background (asynchronous) command.
       0      Expands  to  the name of the shell or shell script.
              This is set at shell initialization.   If  bash  is
              being checked.

   Shell Variables
       The following variables are set by the shell:

       BASH   Expands to the full file name used to  invoke  this
              instance of bash.
       BASH_VERSINFO
              A  readonly  array variable whose members hold ver­
              sion information for this instance  of  bash.   The
              values  assigned  to  the array members are as fol­
              lows:
              BASH_VERSINFO[0]        The  major  version  number
                                      (the release).
              BASH_VERSINFO[1]        The  minor  version  number
                                      (the version).
              BASH_VERSINFO[2]        The patch level.
              BASH_VERSINFO[3]        The build version.
              BASH_VERSINFO[4]        The release  status  (e.g.,
                                      beta1).
              BASH_VERSINFO[5]        The value of MACHTYPE.

       BASH_VERSION
              Expands  to a string describing the version of this
              instance of bash.

       COMP_CWORD
              An index into ${COMP_WORDS} of the word  containing
              the  current  cursor  position.   This  variable is
              available only in shell functions  invoked  by  the
              programmable   completion   facilities   (see  Pro­
              grammable Completion below).

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

       COMP_POINT
              The  index  of the current cursor position relative
              to the beginning of the current  command.   If  the
              current  cursor  position is at the end of the cur­
              rent command, the value of this variable  is  equal
              to  ${#COMP_LINE}.  This variable is available only
              in shell functions and external commands invoked by
              the  programmable  completion  facilities (see Pro­
              grammable Completion below).

       COMP_WORDS
              An array variable (see Arrays below) consisting  of
              the  individual  words in the current command line.
              unset,  it loses its special properties, even if it
              is subsequently reset.

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

       FUNCNAME
              The name of any currently-executing shell function.
              This  variable exists only when a shell function is
              executing.  Assignments to FUNCNAME have no  effect
              and  return an error status.  If FUNCNAME is unset,
              it loses its special properties, even if it is sub­
              sequently reset.

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

       HISTCMD
              The  history  number, or index in the history list,
              of the current command.  If HISTCMD  is  unset,  it
              loses  its special properties, even if it is subse­
              quently reset.

       HOSTNAME
              Automatically set to the name of the current  host.

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

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

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

       OLDPWD The  previous  working  directory  as set by the cd
              command.
              An array variable (see Arrays below)  containing  a
              list  of  exit  status values from the processes in
              the  most-recently-executed   foreground   pipeline
              (which may contain only a single command).

       PPID   The  process  ID of the shell's parent.  This vari­
              able is readonly.

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

       RANDOM Each  time  this  parameter is referenced, a random
              integer between 0  and  32767  is  generated.   The
              sequence  of  random  numbers may be initialized by
              assigning a value to RANDOM.  If RANDOM  is  unset,
              it loses its special properties, even if it is sub­
              sequently reset.

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

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

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

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

       UID    Expands to the user ID of the  current  user,  ini­
              tialized  at shell startup.  This variable is read­
              only.

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

              Used by the select builtin command to determine the
              terminal   width  when  printing  selection  lists.
              Automatically set upon receipt of a SIGWINCH.
       COMPREPLY
              An array variable from which bash reads the  possi­
              ble  completions  generated  by  a  shell  function
              invoked by  the  programmable  completion  facility
              (see Programmable Completion below).
       FCEDIT The default editor for the fc builtin command.
       FIGNORE
              A  colon-separated  list of suffixes to ignore when
              performing  filename   completion   (see   READLINE
              below).  A filename whose suffix matches one of the
              entries in FIGNORE is excluded  from  the  list  of
              matched filenames.  A sample value is ".o:~".
       GLOBIGNORE
              A colon-separated list of patterns defining the set
              of filenames to be ignored by  pathname  expansion.
              If  a filename matched by a pathname expansion pat­
              tern also matches one of the  patterns  in  GLOBIG­
              NORE, it is removed from the list of matches.
       HISTCONTROL
              If set to a value of ignorespace, lines which begin
              with a space character are not entered on the  his­
              tory  list.  If set to a value of ignoredups, lines
              matching the last history line are not entered.   A
              value  of  ignoreboth combines the two options.  If
              unset, or if set to  any  other  value  than  those
              above,  all  lines  read by the parser are saved on
              the history list, subject to the value  of  HISTIG­
              NORE.   This  variable's  function is superseded by
              HISTIGNORE.  The second and subsequent lines  of  a
              multi-line compound command are not tested, and are
              added to the history regardless  of  the  value  of
              HISTCONTROL.
       HISTFILE
              The  name  of  the file in which command history is
              saved (see HISTORY below).  The  default  value  is
              ~/.bash_history.   If unset, the command history is
              not saved when an interactive shell exits.
       HISTFILESIZE
              The maximum number of lines contained in  the  his­
              tory file.  When this variable is assigned a value,
              the history file is  truncated,  if  necessary,  to
              contain  no  more  than  that number of lines.  The
              default value is 500.  The  history  file  is  also
              truncated  to  this  size  after writing it when an
              interactive shell exits.
       HISTIGNORE
              A colon-separated list of patterns used  to  decide
              which  command lines should be saved on the history
              list.  Each pattern is anchored at the beginning of
              500.
       HOME   The home directory of the current user; the default
              argument for the cd builtin command.  The value  of
              this  variable  is  also used when performing tilde
              expansion.
       HOSTFILE
              Contains the name of a file in the same  format  as
              /etc/hosts that should be read when the shell needs
              to complete a hostname.  The list of possible host­
              name  completions may be changed while the shell is
              running;  the  next  time  hostname  completion  is
              attempted after the value is changed, bash adds the
              contents of the new file to the existing list.   If
              HOSTFILE is set, but has no value, bash attempts to
              read /etc/hosts to  obtain  the  list  of  possible
              hostname  completions.  When HOSTFILE is unset, the
              hostname list is cleared.
       IFS    The Internal Field Separator that is used for  word
              splitting  after  expansion and to split lines into
              words with the read builtin command.   The  default
              value is ``<space><tab><newline>''.
       IGNOREEOF
              Controls  the  action  of  an  interactive shell on
              receipt of an EOF character as the sole input.   If
              set,  the  value  is  the number of consecutive EOF
              characters which must be typed as the first charac­
              ters  on  an  input line before bash exits.  If the
              variable exists but does not have a numeric  value,
              or  has  no  value, the default value is 10.  If it
              does not exist, EOF signifies the end of  input  to
              the shell.
       INPUTRC
              The  filename  for the readline startup file, over­
              riding the  default  of  ~/.inputrc  (see  READLINE
              below).
       LANG   Used to determine the locale category for any cate­
              gory not  specifically  selected  with  a  variable
              starting with LC_.
       LC_ALL This  variable  overrides the value of LANG and any
              other LC_ variable specifying a locale category.
       LC_COLLATE
              This variable determines the collation  order  used
              when sorting the results of pathname expansion, and
              determines  the  behavior  of  range   expressions,
              equivalence classes, and collating sequences within
              pathname expansion and pattern matching.
       LC_CTYPE
              This  variable  determines  the  interpretation  of
              characters  and  the  behavior of character classes
              within pathname expansion and pattern matching.
       LC_MESSAGES
              This variable determines the locale used to  trans­
              playing  the  primary  prompt.  If this variable is
              unset, or set to a  value  that  is  not  a  number
              greater  than  or equal to zero, the shell disables
              mail checking.
       MAILPATH
              A colon-separated list of file names to be  checked
              for  mail.   The  message  to  be printed when mail
              arrives in a particular file may  be  specified  by
              separating  the  file  name from the message with a
              `?'.  When used in the  text  of  the  message,  $_
              expands to the name of the current mailfile.  Exam­
              ple:
              MAILPATH='/var/mail/bfox?"You                  have
              mail":~/shell-mail?"$_ has mail!"'
              Bash  supplies  a  default value for this variable,
              but the location of the user  mail  files  that  it
              uses is system dependent (e.g., /var/mail/$USER).
       OPTERR If set to the value 1, bash displays error messages
              generated by the getopts builtin command (see SHELL
              BUILTIN  COMMANDS below).  OPTERR is initialized to
              1 each time the shell is invoked or a shell  script
              is executed.
       PATH   The  search path for commands.  It is a colon-sepa­
              rated list of directories in which the shell  looks
              for  commands  (see  COMMAND EXECUTION below).  The
              default path is system-dependent, and is set by the
              administrator who installs bash.  A common value is
              ``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:.''.
       POSIXLY_CORRECT
              If  this  variable  is in the environment when bash
              starts, the shell enters posix mode before  reading
              the  startup  files,  as  if the --posix invocation
              option had been supplied.  If it is set  while  the
              shell  is  running,  bash enables posix mode, as if
              the command set -o posix had been executed.
       PROMPT_COMMAND
              If set, the value is executed as a command prior to
              issuing each primary prompt.
       PS1    The  value  of  this  parameter  is  expanded  (see
              PROMPTING below) and used  as  the  primary  prompt
              string.  The default value is ``\s-\v\$ ''.
       PS2    The value of this parameter is expanded as with PS1
              and used  as  the  secondary  prompt  string.   The
              default is ``> ''.
       PS3    The  value  of this parameter is used as the prompt
              for the select command (see SHELL GRAMMAR above).
       PS4    The value of this parameter is expanded as with PS1
              and  the  value is printed before each command bash
              displays during  an  execution  trace.   The  first
              character  of  PS4 is replicated multiple times, as
              necessary, to indicate multiple levels of  indirec­
              tion.  The default is ``+ ''.
                        mode.
              %P        The CPU percentage, computed as (%U + %S)
                        / %R.

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

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

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

       TMOUT  If set to a  value  greater  than  zero,  TMOUT  is
              treated   as  the  default  timeout  for  the  read
              builtin.  The select command  terminates  if  input
              does  not  arrive after TMOUT seconds when input is
              coming from a terminal.  In an  interactive  shell,
              the  value  is interpreted as the number of seconds
              to wait for input after issuing the primary prompt.
              Bash  terminates  after  waiting for that number of
              seconds if input does not arrive.

       auto_resume
              This variable controls how the shell interacts with
              the user and job control.  If this variable is set,
              single word simple  commands  without  redirections
              are  treated  as  candidates  for  resumption of an
              existing  stopped  job.   There  is  no   ambiguity
              allowed;  if  there  is more than one job beginning
              with  the  string  typed,  the  job  most  recently
              accessed  is  selected.  The name of a stopped job,
              in this context, is the command line used to  start
              it.  If set to the value exact, the string supplied
              must match the name of a stopped  job  exactly;  if
              set  to  substring,  the  string  supplied needs to
              match a substring of the name  of  a  stopped  job.
              The  substring  value provides functionality analo­
              gous to the %?  job  identifier  (see  JOB  CONTROL
              below).   If  set  to any other value, the supplied
              string must be a prefix of a  stopped  job's  name;
              this  provides functionality analogous to the % job
              identifier.
              normally `#'.  The history comment character causes
              history  substitution to be skipped for the remain­
              ing words on the line.   It  does  not  necessarily
              cause  the  shell  parser  to treat the rest of the
              line as a comment.

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

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

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

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


EXPANSION

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

       The order of expansions is: brace expansion, tilde  expan­
       sion,  parameter,  variable  and  arithmetic expansion and
       command substitution (done in  a  left-to-right  fashion),
       word splitting, and pathname expansion.

       On  systems  that  can  support it, there is an additional
       expansion available: process substitution.

       Only brace expansion, word splitting, and pathname  expan­
       sion  can  change  the  number  of words of the expansion;
       other expansions expand a single word to  a  single  word.
       The only exceptions to this are the expansions of "$@" and
       "${name[@]}" as explained above (see PARAMETERS).

   Brace Expansion
       Brace expansion is a mechanism by which arbitrary  strings
       may  be  generated.  This mechanism is similar to pathname
       expansion, but the filenames  generated  need  not  exist.
       Patterns to be brace expanded take the form of an optional
       preamble, followed by a series of comma-separated  strings
       between   a  pair  of  braces,  followed  by  an  optional
       postscript.  The preamble is prefixed to each string  con­
       tained  within  the  braces,  and  the  postscript is then
       appended to  each  resulting  string,  expanding  left  to
       right.

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

       Brace expansion is performed before any other  expansions,
       and  any  characters  special to other expansions are pre­
       served in the result.  It is strictly textual.  Bash  does
       not  apply  any syntactic interpretation to the context of
       the expansion or the text between the braces.

       A correctly-formed brace expansion must  contain  unquoted
       opening  and  closing  braces,  and  at least one unquoted
       comma.  Any incorrectly formed  brace  expansion  is  left
       unchanged.   A  {  or  , may be quoted with a backslash to
       prevent its being considered part of a  brace  expression.
       To avoid conflicts with parameter expansion, the string ${
       is not considered eligible for brace expansion.
       For example, a word entered to  sh  as  file{1,2}  appears
       identically  in  the  output.   The same word is output as
       file1 file2 after expansion by bash.  If  strict  compati­
       bility  with  sh is desired, start bash with the +B option
       or disable brace expansion with the +B option to  the  set
       command (see SHELL BUILTIN COMMANDS below).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              $((expression))

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

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

   Process Substitution
       Process  substitution is supported on systems that support
       named pipes (FIFOs) or the /dev/fd method of  naming  open
       files.  It takes the form of <(list) or >(list).  The pro­
       cess list is run with its input or output connected  to  a
       FIFO  or  some  file in /dev/fd.  The name of this file is
       passed as an argument to the current command as the result
       of the expansion.  If the >(list) form is used, writing to
       the file will provide input for list.  If the <(list) form
       is  used, the file passed as an argument should be read to
       obtain the output of list.

       IFS  has a value other than the default, then sequences of
       the whitespace characters space and tab are ignored at the
       beginning  and  end of the word, as long as the whitespace
       character is in the value of IFS (an IFS whitespace  char­
       acter).   Any character in IFS that is not IFS whitespace,
       along with any adjacent IFS whitespace characters,  delim­
       its  a  field.  A sequence of IFS whitespace characters is
       also treated as a delimiter.  If the value of IFS is null,
       no word splitting occurs.

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

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

   Pathname Expansion
       After word splitting, unless the -f option has  been  set,
       bash  scans  each word for the characters *, ?, and [.  If
       one of these characters appears, then the word is regarded
       as  a  pattern, and replaced with an alphabetically sorted
       list of file names matching the pattern.  If  no  matching
       file  names  are  found,  and the shell option nullglob is
       disabled, the word is left  unchanged.   If  the  nullglob
       option  is  set,  and  no  matches  are found, the word is
       removed.  If the shell option nocaseglob is  enabled,  the
       match  is  performed  without regard to the case of alpha­
       betic characters.  When a pattern  is  used  for  pathname
       expansion,  the character ``.''  at the start of a name or
       immediately following a slash must be matched  explicitly,
       unless  the  shell option dotglob is set.  When matching a
       pathname, the  slash  character  must  always  be  matched
       explicitly.   In  other cases, the ``.''  character is not
       treated specially.  See the  description  of  shopt  below
       under  SHELL  BUILTIN  COMMANDS  for  a description of the
       nocaseglob, nullglob, and dotglob shell options.

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

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

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

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

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

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

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

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

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

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

              ls > dirlist 2>&1

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

              ls 2>&1 > dirlist

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

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

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

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

       The general format for redirecting output is:

              [n]>word

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

   Appending Redirected Output
       Redirection of output in  this  fashion  causes  the  file
       whose name results from the expansion of word to be opened
       for appending on file descriptor n, or the standard output
       (file  descriptor  1)  if n is not specified.  If the file
       does not exist it is created.

       The general format for appending output is:

              [n]>>word

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

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

              &>word
       and
              >&word

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

              >word 2>&1

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

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

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

              <<<word

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

   Duplicating File Descriptors
       The redirection operator

              [n]<&word

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

       The operator

              [n]>&word

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

   Moving File Descriptors
       The redirection operator

              [n]<&digit-


              [n]<>word

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


ALIASES

       Aliases  allow  a string to be substituted for a word when
       it is used as the first word of  a  simple  command.   The
       shell  maintains  a  list  of  aliases that may be set and
       unset with the alias and  unalias  builtin  commands  (see
       SHELL  BUILTIN  COMMANDS  below).   The first word of each
       command, if unquoted, is checked  to  see  if  it  has  an
       alias.   If  so,  that word is replaced by the text of the
       alias.  The alias name and the replacement text  may  con­
       tain  any  valid shell input, including the metacharacters
       listed above, with the exception that the alias  name  may
       not  contain =.  The first word of the replacement text is
       tested for aliases, but a word that  is  identical  to  an
       alias  being expanded is not expanded a second time.  This
       means that one may alias ls to ls -F,  for  instance,  and
       bash  does  not  try to recursively expand the replacement
       text.  If the last character  of  the  alias  value  is  a
       blank,  then  the next command word following the alias is
       also checked for alias expansion.

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

       There  is no mechanism for using arguments in the replace­
       ment text.  If arguments  are  needed,  a  shell  function
       should be used (see FUNCTIONS below).

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

       The rules concerning the definition and use of aliases are
       somewhat  confusing.   Bash always reads at least one com­
       plete line of input before executing any of  the  commands
       on  that  line.   Aliases  are  expanded when a command is
       read, not when it is executed.  Therefore, an alias  defi­
       nition  appearing on the same line as another command does
       not take effect until the next line of input is read.  The
       commands  following  the alias definition on that line are
       not affected by the new alias.  This behavior is  also  an
       issue  when  functions are executed.  Aliases are expanded
       when a function definition is read, not when the  function
       is  executed,  because  a  function definition is itself a
       text of the current shell; no new process  is  created  to
       interpret  them  (contrast  this  with  the execution of a
       shell script).  When a function is executed, the arguments
       to  the  function  become the positional parameters during
       its execution.  The special  parameter  #  is  updated  to
       reflect  the change.  Positional parameter 0 is unchanged.
       The FUNCNAME variable is set to the name of  the  function
       while the function is executing.  All other aspects of the
       shell execution environment are identical between a  func­
       tion and its caller with the exception that the DEBUG trap
       (see the description  of  the  trap  builtin  under  SHELL
       BUILTIN  COMMANDS below) is not inherited unless the func­
       tion has been given the trace attribute (see the  descrip­
       tion of the declare builtin below).

       Variables  local  to the function may be declared with the
       local builtin command.  Ordinarily,  variables  and  their
       values are shared between the function and its caller.

       If  the  builtin command return is executed in a function,
       the function completes and execution resumes with the next
       command  after  the  function  call.  When a function com­
       pletes, the values of the positional  parameters  and  the
       special  parameter  #  are restored to the values they had
       prior to the function's execution.

       Function names and definitions may be listed with  the  -f
       option to the declare or typeset builtin commands.  The -F
       option to declare or typeset will list the function  names
       only.   Functions  may be exported so that subshells auto­
       matically have them defined with  the  -f  option  to  the
       export builtin.

       Functions  may  be  recursive.  No limit is imposed on the
       number of recursive calls.


ARITHMETIC EVALUATION

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

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

       Shell variables are allowed as operands; parameter  expan­
       sion  is  performed  before  the  expression is evaluated.
       Within an expression, shell variables may also  be  refer­
       enced  by  name without using the parameter expansion syn­
       tax.  The value of a variable is evaluated  as  an  arith­
       metic  expression when it is referenced.  A shell variable
       need not have its integer attribute turned on to  be  used
       in an expression.

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

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


CONDITIONAL EXPRESSIONS

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

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

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

       3.     Redirections are performed as described above under
              REDIRECTION.

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

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

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

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


COMMAND EXECUTION

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

       If  the  command  name  contains  no  slashes,  the  shell
       attempts  to  locate it.  If there exists a shell function
       by that name, that function is invoked as described  above
       in  FUNCTIONS.  If the name does not match a function, the
       shell searches for it in the list of shell builtins.  If a
       match is found, that builtin is invoked.

       If the name is neither a shell function nor a builtin, and
       contains no slashes, bash searches  each  element  of  the
       If  this  execution  fails because the file is not in exe­
       cutable format, and the file is not  a  directory,  it  is
       assumed to be a shell script, a file containing shell com­
       mands.  A subshell is spawned to execute  it.   This  sub­
       shell  reinitializes itself, so that the effect is as if a
       new shell had been invoked to handle the script, with  the
       exception that the locations of commands remembered by the
       parent (see hash below under SHELL BUILTIN  COMMANDS)  are
       retained by the child.

       If  the program is a file beginning with #!, the remainder
       of the first line specifies an interpreter  for  the  pro­
       gram.   The  shell  executes  the specified interpreter on
       operating systems that do not handle this executable  for­
       mat  themselves.  The arguments to the interpreter consist
       of a single optional argument  following  the  interpreter
       name  on  the  first  line of the program, followed by the
       name of the program, followed by the command arguments, if
       any.


COMMAND EXECUTION ENVIRONMENT

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

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

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

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

       ·      current traps set by trap

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

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

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

       ·      options enabled by shopt

       ·      shell aliases defined with alias

       ·      various process IDs, including those of  background

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

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

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

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

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


ENVIRONMENT

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

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

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

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

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

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

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

       Bash  itself  returns  the exit status of the last command
       executed, unless a syntax error occurs, in which  case  it
       exits  with  a  non-zero value.  See also the exit builtin
       command below.


SIGNALS

       When bash is interactive, in the absence of any traps,  it
       ignores  SIGTERM (so that kill 0 does not kill an interac­
       tive shell), and SIGINT is caught and handled (so that the
       wait  builtin  is  interruptible).   In  all  cases,  bash
       ignores SIGQUIT.   If  job  control  is  in  effect,  bash
       ignores SIGTTIN, SIGTTOU, and SIGTSTP.

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

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

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

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

              [1] 25647

       indicating that this job is job number 1 and that the pro­
       cess  ID  of  the  last process in the pipeline associated
       with this job is 25647.  All of the processes in a  single
       pipeline  are  members of the same job.  Bash uses the job
       abstraction as the basis for job control.

       To facilitate the implementation of the user interface  to
       job  control, the operating system maintains the notion of
       a current terminal process group ID.  Members of this pro­
       cess  group  (processes whose process group ID is equal to
       the current terminal process group ID)  receive  keyboard-
       generated  signals  such  as  SIGINT.  These processes are
       said to be in the foreground.   Background  processes  are
       those  whose process group ID differs from the terminal's;
       such processes are immune to  keyboard-generated  signals.
       Only  foreground  processes  are  allowed  to read from or
       write to the terminal.  Background processes which attempt
       to  read  from  (write to) the terminal are sent a SIGTTIN
       (SIGTTOU) signal by the  terminal  driver,  which,  unless
       caught, suspends the process.

       If  the operating system on which bash is running supports
       job control, bash contains facilities to use  it.   Typing
       the  suspend  character  (typically ^Z, Control-Z) while a
       process is running causes that process to be  stopped  and
       returns control to bash.  Typing the delayed suspend char­
       acter (typically ^Y, Control-Y) causes the process  to  be
       stopped  when it attempts to read input from the terminal,
       and control to be returned to bash.   The  user  may  then
       manipulate  the state of this job, using the bg command to
       continue it in the background, the fg command to  continue
       it  in  the foreground, or the kill command to kill it.  A
       ^Z takes effect immediately, and has the  additional  side
       effect  of causing pending output and typeahead to be dis­
       carded.

       There are a number of ways to refer to a job in the shell.
       The  character  % introduces a job name.  Job number n may
       be referred to as %n.  A job may also be referred to using
       a  prefix  of  the  name used to start it, or using a sub­
       string that appears in its command line.  For example, %ce
       refers to a stopped ce job.  If a prefix matches more than
       one job, bash reports an error.  Using %?ce, on the  other
       hand,  refers  to  any job containing the string ce in its
       command line.  If the substring matches more than one job,
       bash reports an error.  The symbols %% and %+ refer to the
       shell's notion of the current job, which is the  last  job
       before  reporting  changes  in a job's status so as to not
       interrupt any other output.  If the -b option to  the  set
       builtin  command  is  enabled,  bash  reports such changes
       immediately.  Any trap on SIGCHLD  is  executed  for  each
       child that exits.

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


PROMPTING

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

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


READLINE

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

   Readline Notation
       In this section,  the  emacs-style  notation  is  used  to
       denote  keystrokes.   Control  keys  are denoted by C-key,
       e.g., C-n  means  Control-N.   Similarly,  meta  keys  are
       denoted  by  M-key,  so  M-x  means Meta-X.  (On keyboards
       without a meta key, M-x  means  ESC  x,  i.e.,  press  the
       Escape  key  then the x key.  This makes ESC the meta pre­
       fix.  The combination M-C-x means ESC-Control-x, or  press
       the  Escape  key  then hold the Control key while pressing
       the x key.)

       Readline commands may be given  numeric  arguments,  which
       normally act as a repeat count.  Sometimes, however, it is
       the sign of the argument that is significant.   Passing  a
       negative  argument  to  a command that acts in the forward
       direction (e.g., kill-line) causes that command to act  in
       a  backward direction.  Commands whose behavior with argu­
       ments deviates from this are noted below.

       When a command is described  as  killing  text,  the  text
       deleted  is saved for possible future retrieval (yanking).
       The killed text is saved  in  a  kill  ring.   Consecutive
       kills  cause  the  text  to  be accumulated into one unit,
       which can be yanked all at once.  Commands  which  do  not
       kill text separate the chunks of text on the kill ring.

   Readline Initialization
       Readline  is customized by putting commands in an initial­
       ization file (the inputrc file).  The name of this file is
       taken  from the value of the INPUTRC environment variable.
       If  that  variable  is  unset,  readline  will  read  both
       /etc/inputrc  and  ~/.inputrc.   When a program which uses
       the readline library starts up, the initialization file is
       or
              C-Meta-u: universal-argument
       into the inputrc would make  M-C-u  execute  the  readline
       command universal-argument.

       The  following  symbolic  character  names are recognized:
       RUBOUT, DEL, ESC, LFD, NEWLINE, RET, RETURN,  SPC,  SPACE,
       and TAB.

       In  addition  to command names, readline allows keys to be
       bound to a string that is inserted when the key is pressed
       (a macro).

   Readline Key Bindings
       The  syntax  for  controlling  key bindings in the inputrc
       file is simple.  All that is required is the name  of  the
       command or the text of a macro and a key sequence to which
       it should be bound. The name may be specified  in  one  of
       two  ways:  as a symbolic key name, possibly with Meta- or
       Control- prefixes, or as a key sequence.

       When using the form keyname:function-name or  macro,  key­
       name  is  the  name  of a key spelled out in English.  For
       example:

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

       In the above example, C-u is bound to the function univer­
       sal-argument,   M-DEL  is  bound  to  the  function  back­
       ward-kill-word,  and  C-o  is  bound  to  run  the   macro
       expressed  on  the right hand side (that is, to insert the
       text ``> output'' into the line).

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

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

       In  this  example, C-u is again bound to the function uni­
       versal-argument.   C-x  C-r  is  bound  to  the   function
       re-read-init-file,  and ESC [ 1 1 ~ is bound to insert the
       text ``Function Key 1''.

       The full set of GNU Emacs style escape sequences is
              \r     carriage return
              \t     horizontal tab
              \v     vertical tab
              \nnn   the  eight-bit  character whose value is the
                     octal value nnn (one to three digits)
              \xHH   the eight-bit character whose value  is  the
                     hexadecimal value HH (one or two hex digits)

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

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

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

              set variable-name value

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

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

   Readline Conditional Constructs
       Readline implements a facility similar in  spirit  to  the
       conditional  compilation  features  of  the C preprocessor
       which allows key bindings and variable settings to be per­
       formed  as  the  result  of  tests.  There are four parser
       directives used.

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

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

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

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

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

              $include  /etc/inputrc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


HISTORY EXPANSION

       The  shell  supports  a  history expansion feature that is
       similar to the history expansion  in  csh.   This  section
       describes  what  syntax features are available.  This fea­
       ture is enabled by default for interactive shells, and can
       be disabled using the +H option to the set builtin command
       (see  SHELL  BUILTIN  COMMANDS  below).    Non-interactive
       shells do not perform history expansion by default.

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

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

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

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

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

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

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

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

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

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


SHELL BUILTIN COMMANDS

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

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

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

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

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

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

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

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

       cd [-L|-P] [dir]
              Change the current directory to dir.  The  variable
              HOME  is  the  default  dir.   The  variable CDPATH
              defines the search path for the directory  contain­
              ing dir.  Alternative directory names in CDPATH are
              separated by a colon (:).  A null directory name in
              CDPATH  is the same as the current directory, i.e.,
              ``.''.  If dir begins with a slash (/), then CDPATH
              is not used. The -P option says to use the physical
              directory structure instead of  following  symbolic
              links  (see  also  the -P option to the set builtin
              command); the -L option forces symbolic links to be
              followed.   An argument of - is equivalent to $OLD­
              PWD.  The return value is true if the directory was
              successfully changed; false otherwise.

       command [-pVv] command [arg ...]
              Run  command with args suppressing the normal shell
              function lookup. Only builtin commands or  commands
              found  in  the PATH are executed.  If the -p option
              is given, the search for command is performed using
              a default value for PATH that is guaranteed to find
              Generate   possible  completion  matches  for  word
              according to the options, which may be  any  option
              accepted by the complete builtin with the exception
              of -p and -r, and write the matches to the standard
              output.  When using the -F or -C options, the vari­
              ous shell variables set by the programmable comple­
              tion  facilities,  while  available,  will not have
              useful values.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              The  -n  option suppresses the command numbers when
              listing.  The -r option reverses the order  of  the
              commands.   If the -l option is given, the commands
              are listed on standard output.  Otherwise, the edi­
              If  the  first  form is used, the return value is 0
              unless an invalid option is encountered or first or
              last specify history lines out of range.  If the -e
              option is supplied, the return value is  the  value
              of the last command executed or failure if an error
              occurs with the temporary file of commands.  If the
              second  form  is used, the return status is that of
              the command re-executed, unless cmd does not  spec­
              ify  a valid history line, in which case fc returns
              failure.

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

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

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

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


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

              getopts  returns  true  if  an option, specified or
              unspecified, is found.  It returns false if the end
              of options is encountered or an error occurs.

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

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

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

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

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

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

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

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

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

       logout Exit a login shell.

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

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

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

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

              If  the pushd command is successful, a dirs is per­
              formed as well.  If the first form is  used,  pushd
              returns  0  unless  the  cd to dir fails.  With the
              second form, pushd returns 0 unless  the  directory
              stack is empty, a non-existent directory stack ele­
              ment is specified, or the directory change  to  the
              specified new current directory fails.

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

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

              If no names are supplied, the line read is assigned
              to the variable REPLY.  The return  code  is  zero,
              unless  end-of-file is encountered, read times out,
              or an invalid file descriptor is  supplied  as  the
              argument to -u.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


RESTRICTED SHELL

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

       ·      changing directories with cd

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

       ·      specifying command names containing /

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

       ·      Specifying a filename  containing  a  slash  as  an

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

       ·      Using the enable builtin command to enable disabled
              shell builtins

       ·      specifying the -p option  to  the  command  builtin
              command

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

       These restrictions are enforced after  any  startup  files
       are read.

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


SEE ALSO

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


FILES

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


AUTHORS

       Brian Fox, Free Software Foundation
       bfox@gnu.org
       bash@gnu.org   or   posted   to   the   Usenet   newsgroup
       gnu.bash.bug.

       ALL bug reports should include:

       The version number of bash
       The hardware and operating system
       The compiler used to compile
       A description of the bug behaviour
       A short script or `recipe' which exercises the bug

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

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


BUGS

       It's too big and too slow.

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

       Aliases are confusing in some uses.

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

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

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

       Array variables may not (yet) be exported.

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




Login
Nickname

Password

Security Code
Security Code
Type Security Code


Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!


Amazon Wish List

Did You Know?
You can help in many different ways.


Friends



Tell a Friend About Us

Bookmark and Share



Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.32 Seconds