bash command help


       bash - GNU Bourne-Again SHell
 

SYNOPSIS

       bash [options] [file]
 

COPYRIGHT

       Bash  is  Copyright  (C)  1989,  1991 by the Free Software
       Foundation, Inc.
 

DESCRIPTION

       Bash is an sh-compatible command language interpreter that
       executes  commands  read from the standard input or from a
       file.  Bash also incorporates  useful  features  from  the
       Korn and C shells (ksh and csh).
 
       Bash is ultimately intended to be a conformant implementa­
       tion 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 flags when it is invoked:
 
       -c string If  the  -c  flag  is present, then commands are
                 read from string.  If there are arguments  after
                 the  string, they are assigned to the positional
                 parameters, starting with .
       -i        If the -i flag is present, the shell is interac­
                 tive.
       -s        If  the  -s  flag 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.
       -         A  single  - signals the end of options and dis­
                 ables further option processing.  Any  arguments
                 after  the  - are treated as filenames and argu­
                 ments.  An argument of -- is  equivalent  to  an
                 argument of -.
 
       Bash  also interprets a number of multi-character options.
       These options must appear on the command line  before  the
       single-character options to be recognized.
 
       -norc     Do not read and execute the personal initializa­
                 tion file ~/.bashrc if the shell is interactive.
                 This  option  is  on  by default if the shell is
                 invoked as sh.
       -noprofile
                 Do not read either the system-wide startup  file
                 /etc/profile  or any of the personal initializa­
                 these files when it is invoked as a login  shell
                 (see INVOCATION below).
       -rcfile file
                 Execute  commands from file instead of the stan­
                 dard personal initialization file ~/.bashrc,  if
                 the shell is interactive (see INVOCATION below).
       -version  Show the version number of this instance of bash
                 when starting.
       -quiet    Do  not be verbose when starting up (do not show
                 the shell version  or  any  other  information).
                 This is the default.
       -login    Make  bash  act  as  if it had been invoked as a
                 login shell.
       -nobraceexpansion
                 Do not perform curly brace expansion (see  Brace
                 Expansion below).
       -nolineediting
                 Do not use the GNU readline library to read com­
                 mand lines if interactive.
       -posix    Change the behavior of bash  where  the  default
                 operation differs from the Posix 1003.2 standard
                 to match the standard
 

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,  is
       set to the name of the file, and the positional parameters
       are  set  to the remaining arguments.  Bash reads and exe­
       cutes commands from this file, then  exits.   Bash's  exit
       status  is the exit status of the last command executed in
       the script.
 

DEFINITIONS

       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

       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 { }
 

SHELL GRAMMAR

   Simple Commands
       A  simple  command  is  a  sequence  of  optional variable
       assignments followed by blank-separated words and redirec­
       tions,  and  terminated  by a control operator.  The first
       word specifies the command to be executed.  The  remaining
       words are passed as arguments to the invoked command.
 
       The  return  value of a simple command is its exit status,
       or 128+n if the command is terminated by signal n.
 
   Pipelines
       A pipeline is a sequence of one or more commands separated
       by the character |.  The format for a pipeline is:
 
              [ ! ] command [ | command2 ... ]
 
       The  standard  output of command is connected to the stan­
       dard input of  command2.   This  connection  is  performed
       before  any  redirections  specified  by  the command (see
       REDIRECTION below).
 
       If the reserved word !  precedes a pipeline, the exit 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.
 
       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 terminated by
       one of ;, &, or <newline>.
 
       Of these list operators, && and || have equal  precedence,
       followed by ; and &, which have equal precedence.
 
       If  a command is terminated by the control operator &, the
       shell executes the command in the  background  in  a  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
 
       The  control  operators  && and || denote AND lists and OR
       lists, respectively.  An AND list has the form
 
              command && command2
 
       command2 is executed if, and only if, command  returns  an
       exit status of zero.
 
       An OR list has the form
 
              command || command2
 
       command2  is  executed  if  and  only if command returns a
       non-zero exit status.  The return status  of  AND  and  OR
       lists  is  the exit status of the last command executed in
       the list.
 
   Compound Commands
       A compound command is one of the following:
 
       (list) list is executed in a subshell.   Variable  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.   This  is  known as a group command.  The
              return status is the exit status of list.
 
       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).
 
       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 the 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
              name  to be set to null.  The line read is saved in
              the variable REPLY.  The  list  is  executed  after
              each  selection  until a break or return command is
              executed.  The exit status of select  is  the  exit
              status  of  the  last  command executed in list, or
              zero if no commands were executed.
 
       case word in [ pattern [ | pattern ] ... ) list ;; ] ...
       esac
              A  case  command  first  expands word, and tries to
              match it against each pattern in  turn,  using  the
              same  matching rules as for pathname expansion (see
              Pathname Expansion below).  When a match is  found,
              the  corresponding  list  is  executed.   After the
              first match, no subsequent matches  are  attempted.
              The exit status is zero if no patterns are matches.
              Otherwise, it is the exit status of the  last  com­
              mand executed in list.
 
       if list then list [ elif list then list ] ... [ else list
       ] fi
              The if list is executed.  If  its  exit  status  is
              zero,  the  then list is executed.  Otherwise, each
              elif list is executed in turn, and if its exit sta­
              tus  is  zero,  the corresponding then list is exe­
              cuted and the command  completes.   Otherwise,  the
              else list is executed, if present.  The exit status
              is the exit status of the last command executed, or
              zero if no condition tested true.
 
       while list do list done
       until list do list done
              The while command continuously executes the do list
              as long as the last command in list returns an exit
              status  of zero.  The until command is identical to
              the while command, except that the test is negated;
              the do list is executed as long as the last command
              in list returns a non-zero exit status.   The  exit
              status  of the while and until commands is the exit
              status of the last do  list  command  executed,  or
              zero if none was executed.
 
       [ function ] name () { list; }
              This  defines  a  function named name.  The body of
              the function is the list of commands between {  and
              }.   This  list is executed whenever name is 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

       builtin  is  enabled,  a word beginning with # causes that
       word and all remaining  characters  on  that  line  to  be
       ignored.   An  interactive  shell  without the -o interac­
       tive-comments option enabled does not allow comments.
 

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
       they are to represent themselves.  There are three quoting
       mechanisms:  the escape character, single quotes, and dou­
       ble quotes.
 
       A non-quoted backslash (\) is the  escape  character.   It
       preserves  the  literal  value  of the next character that
       follows, with the exception of <newline>.  If a \<newline>
       pair  appears, and the backslash is not quoted, the \<new­
       line> is treated as a line continuation (that  is,  it  is
       effectively ignored).
 
       Enclosing  characters  in single quotes preserves the lit­
       eral value of each character within the quotes.  A  single
       quote  may not occur between single quotes, even when pre­
       ceded by a backslash.
 
       Enclosing characters in double quotes preserves  the  lit­
       eral  value  of all characters within the quotes, with the
       exception of $, `, and \.  The characters $ and  `  retain
       their special meaning within double quotes.  The backslash
       retains its special meaning only when followed by  one  of
       the  following  characters:  $,  `, ", \, or <newline>.  A
       double quote may be quoted within double quotes by preced­
       ing it with a backslash.
 
       The  special  parameters * and @ have special meaning when
       in double quotes (see PARAMETERS below).
 

PARAMETERS

       A parameter is an entity that stores values, somewhat like
       a variable in a conventional programming language.  It can
       be a name, a number, or  one  of  the  special  characters
       listed  below  under  Special Parameters.  For the shell's
       purposes, a variable is a parameter denoted by a name.
 
       A parameter is set if it has been assigned a  value.   The
       null  string is a valid value.  Once a variable is set, it
       may be unset only by using the unset builtin command  (see
 
              name=[value]
 
       If  value  is not given, the variable is assigned the null
       string.  All values undergo tilde expansion, parameter and
       variable   expansion,   command  substitution,  arithmetic
       expansion, and quote removal.  If the variable has its  -i
       attribute  set  (see  declare  below in SHELL BUILTIN COM­
       MANDS) then value is subject to arithmetic expansion  even
       if  the  $[...] syntax does not appear.  Word splitting is
       not performed, with the exception  of  "$@"  as  explained
       below under Special Parameters.  Pathname expansion is not
       performed.
 
   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 null or unset, the parameters are  separated  by
              spaces.
       @      Expands to the positional parameters, starting from
              one.   When  the  expansion  occurs  within  double
              quotes,  each parameter expands as 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
              flag).
       $      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
              invoked with a file of commands, $0 is set  to  the
              name  of that file.  If bash is started with the -c
              option, then $0 is set to the first argument  after
              the string to be executed, if one is present.  Oth­
              erwise, it is set to the pathname  used  to  invoke
              bash, as given by argument zero.
       _      Expands  to  the last argument to the previous com­
              mand, after expansion.  Also set to the full  path­
              name  of  each  command  executed and placed in the
              environment exported to that command.
 
   Shell Variables
       The following variables are set by the shell:
 
       PPID   The process ID of the shell's parent.
       PWD    The current working directory as set by the cd com­
              mand.
       OLDPWD The  previous  working  directory  as set by the cd
              command.
       REPLY  Set to the line of input read by the  read  builtin
              command when no arguments are supplied.
       UID    Expands  to  the  user ID of the current user, ini­
              tialized at shell startup.
       EUID   Expands to the effective user  ID  of  the  current
              user, initialized at shell startup.
       BASH   Expands  to  the  full pathname used to invoke this
              instance of bash.
       BASH_VERSION
              Expands to the version number of this  instance  of
              bash.
       SHLVL  Incremented by one each time an instance of bash is
              started.
       RANDOM Each time this parameter is  referenced,  a  random
              integer  is generated.  The sequence of random num­
              bers may be initialized by  assigning  a  value  to
              RANDOM.   If  RANDOM is unset, it loses its special
              properties, even if it is subsequently reset.
       SECONDS
              Each time this parameter is referenced, the  number
              of  seconds since shell invocation is returned.  If
              a value is assigned to SECONDS, the value  returned
              upon subsequent references is the number of seconds
              since the assignment plus the value  assigned.   If
              SECONDS  is unset, it loses its special properties,
              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.   When in a function, the
              value is not the number of the source line that the
              command  appears on (that information has been lost
              by the time the function is executed),  but  is  an
              approximation of the number of simple commands exe­
              cuted in the current function.  If LINENO is unset,
              it loses its special properties, even if it is sub­
              sequently 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.
       OPTARG The  value of the last option argument processed by
              the getopts builtin command (see SHELL BUILTIN COM­
              MANDS below).
       OPTIND The  index  of the next argument to be processed by
              the getopts builtin command (see SHELL BUILTIN COM­
              MANDS below).
       HOSTTYPE
              Automatically   set   to  a  string  that  uniquely
              describes the type of machine on which bash is exe­
              cuting.  The default is system-dependent.
       OSTYPE Automatically  set  to  a string that describes the
              operating system on which bash is  executing.   The
              default is system-dependent.
 
       The  following  variables  are used by the shell.  In some
       cases, bash assigns a default value to a  variable;  these
       cases are noted below.
 
       IFS    The  Internal Field Separator that is used for word
              splitting after expansion and to split  lines  into
              words  with  the read builtin command.  The default
              value is ``<space><tab><newline>''.
       PATH   The search path for commands.  It is a  colon-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:.''.
       HOME   The home directory of the current user; the default
              argument for the cd builtin command.
       CDPATH The  search  path  for  the  cd command.  This is a
              colon-separated list of directories  in  which  the
              shell  looks  for destination directories specified
              by the cd command.  A sample value is ``.:~:/usr''.
       ENV    If  this  parameter is set when bash is executing a
              shell, as in .bashrc.  The value  of  ENV  is  sub­
              jected  to  parameter  expansion, command substitu­
              tion, and arithmetic expansion before being  inter­
              preted  as  a pathname.  PATH is not used to search
              for the resultant pathname.
       MAIL   If this parameter is set  to  a  filename  and  the
              MAILPATH variable is not set, bash informs the user
              of the arrival of mail in the specified file.
       MAILCHECK
              Specifies how often (in seconds)  bash  checks  for
              mail.   The default is 60 seconds.  When it is time
              to check for mail, the shell does so before prompt­
              ing.  If this variable is unset, the shell disables
              mail checking.
       MAILPATH
              A colon-separated list of pathnames to  be  checked
              for  mail.  The message to be printed may be speci­
              fied by separating the pathname  from  the  message
              with  a `?'.  $_ stands for the name of the current
              mailfile.  Example:
              MAILPATH='/usr/spool/mail/bfox?"You            have
              mail":~/shell-mail?"$_ has mail!"'
              Bash  supplies  a  default value for this variable,
              but the location of the user  mail  files  that  it
              uses      is      system      dependent      (e.g.,
              /usr/spool/mail/$USER).
       MAIL_WARNING
              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 printed.
       PS1    The  value  of  this  parameter  is  expanded  (see
              PROMPTING below) and used  as  the  primary  prompt
              string.  The default value is ``bash\$ ''.
       PS2    The value of this parameter is expanded 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  and  the
              value  is printed before each command bash displays
              during an execution trace.  The first character  of
              PS4  is replicated multiple times, as necessary, to
              indicate  multiple  levels  of  indirection.    The
              default is ``+ ''.
       HISTSIZE
              The  number  of commands to remember in the command
              history (see HISTORY below).  The default value  is
              500.
       HISTFILE
              The  name  of  the file in which command history is
              saved.  (See HISTORY below.)  The default value  is
 
       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.
       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.
       PROMPT_COMMAND
              If set, the value is executed as a command prior to
              issuing each primary prompt.
       IGNOREEOF
              Controls  the  action of the shell on receipt of an
              EOF character as the sole input.  If set, the value
              is  the  number of consecutive EOF characters typed
              as the first characters on  an  input  line  before
              bash  exits.   If  the variable exists but does not
              have a numeric value, or has no value, the  default
              value  is  10.  If it does not exist, EOF signifies
              the end of input to the shell.   This  is  only  in
              effect for interactive shells.
       TMOUT  If  set  to a value greater than zero, the value is
              interpreted as the number of seconds  to  wait  for
              input  after issuing the primary prompt.  Bash ter­
              minates after waiting for that number of seconds if
              input does not arrive.
       FCEDIT The default editor for the fc builtin command.
       FIGNORE
              A  colon-separated  list of suffixes to ignore when
              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:~''.
       INPUTRC
              The  filename  for the readline startup file, over­
              riding the  default  of  ~/.inputrc  (see  READLINE
              below).
       notify If  set,  bash  reports  terminated background jobs
              immediately,  rather  than  waiting  until   before
              printing  the  next primary prompt (see also the -b
              option to the set builtin command).
       history_control
       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
 
       command_oriented_history
              If set, bash attempts to save all lines of a multi­
              ple-line command in the same history  entry.   This
              allows easy re-editing of multi-line commands.
 
       glob_dot_filenames
              If  set,  bash  includes filenames beginning with a
              `.' in the results of pathname expansion.
 
       allow_null_glob_expansion
              If set, bash allows pathname patterns  which  match
              no  files  (see Pathname Expansion below) to expand
              to a null string, rather than themselves.
 
       histchars
              The two or three characters which  control  history
              expansion  and  tokenization (see HISTORY EXPANSION
              below).  The first character is the history  expan­
              sion  character,  that is, the character which sig­
              nals the start of  a  history  expansion,  normally
              `!'.   The  second character is the quick substitu­
              tion character, which is used as shorthand for  re-
              running  the previous command entered, substituting
              one string for another in the command.  The default
              is  `^'.  The optional third character is the char­
              acter which signifies that  the  remainder  of  the
              line  is a comment, when found as the first charac­
              ter of a word, normally `#'.  The  history  comment
              character causes history substitution to be skipped
              for the remaining words on the line.  It  does  not
              necessarily  cause  the  shell  parser to treat the
              rest of the line as a comment.
 
       nolinks
              If set, the shell does not  follow  symbolic  links
              when  executing  commands  that  change the current
              working directory.  It uses the physical  directory
              structure  instead.   By  default, bash follows the
              logical chain of directories when  performing  com­
              mands  which  change the current directory, such as
              cd.  See also the description of the -P  option  to
              the set builtin ( SHELL BUILTIN COMMANDS below).
       hostname_completion_file
       HOSTFILE
              Contains  the  name of a file in the same format as
              /etc/hosts that should be read when the shell needs
              to  complete  a  hostname.  The file may be changed
              interactively; the next time hostname completion is
              attempted bash adds the contents of the new file to
              the already existing database.
 
              If set, bash does not overwrite  an  existing  file
              with the >, >&, and <> redirection operators.  This
              variable may be  overridden  when  creating  output
              files  by using the redirection operator >| instead
              of > (see also the -C option  to  the  set  builtin
              command).
 
       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 id (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 id.
 
       no_exit_on_failed_exec
              If this variable exists,  a  non-interactive  shell
              will  not exit if it cannot execute the file speci­
              fied in the exec builtin command.   An  interactive
              shell does not exit if exec fails.
 
       cdable_vars
              If  this is 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.
 

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, command, and arithmetic substi­
       tution (done in a left-to-right fashion), word  splitting,
       and pathname expansion.
 
       On  systems  that  can  support it, there is an additional
       sion  can  change  the  number  of words of the expansion;
       other expansions expand a single word to  a  single  word.
       The single exception to this is the expansion of ``$@'' 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 postam­
       ble.  The preamble is prepended to each  string  contained
       within  the  braces, and the postamble 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.
 
       This construct is typically used  as  shorthand  when  the
       common  prefix  of  the  strings to be generated is longer
       than in the above example:
 
              mkdir /usr/local/src/bash/{old,new,dist,bugs}
       or
              chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}
 
       Brace  expansion  introduces a slight incompatibility with
       traditional versions of sh, the Bourne shell.  sh does not
       treat opening or closing braces specially when they appear
       as part of a word, and preserves them in the output.  Bash
       removes braces from words as a consequence of brace expan­
       sion.  For example, a word  entered  to  sh  as  file{1,2}
       appears  identically in the output.  The same word is out­
       put as file1 file2 after expansion  by  bash.   If  strict
       compatibility  with  sh  is  desired,  start bash with the
       -nobraceexpansion flag  (see  OPTIONS  above)  or  disable
       brace  expansion with the +o braceexpand option to the set
       command (see SHELL BUILTIN COMMANDS below).
       If a word begins with a tilde character (`~'), all of  the
       characters  preceding  the first slash (or all characters,
       if there is no slash) are  treated  as  a  possible  login
       name.  If this login name is the null string, the tilde is
       replaced with the value of the parameter HOME.  If HOME is
       unset,  the home directory of the user executing the shell
       is substituted instead.
 
       If a `+' follows the tilde, the value of PWD replaces  the
       tilde  and  `+'.  If a `-' follows, the value of OLDPWD is
       substituted.  If the value following the tilde is a  valid
       login name, the tilde and login name are replaced with the
       home directory associated with that name.  If the name  is
       invalid,  or  the  tilde  expansion  fails,  the  word  is
       unchanged.
 
       Each variable assignment is checked for unquoted instances
       of  tildes following a : or =.  In these cases, tilde sub­
       stitution is also performed.  Consequently,  one  may  use
       pathnames  with  tildes  in assignments to PATH, MAILPATH,
       and CDPATH, and the shell assigns the expanded value.
 
   Parameter Expansion
       The `$' character introduces parameter expansion,  command
       substitution, or arithmetic expansion.  The parameter name
       or symbol to be expanded may be enclosed in braces,  which
       are  optional  but  serve  to  protect  the variable to be
       expanded from characters immediately  following  it  which
       could be interpreted as part of the name.
 
       ${parameter}
              The  value of parameter is substituted.  The braces
              are required when parameter is a positional parame­
              ter  with more than one digit, or when parameter is
              followed by a character which is not to  be  inter­
              preted as part of its name.
 
       In  each  of  the  cases  below,  word is subject to tilde
       expansion, parameter expansion, command substitution,  and
       arithmetic  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
              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}
              The length in characters of the value of  parameter
              is substituted.  If parameter is * or @, the length
              substituted is the length of * expanded within dou­
              ble quotes.
       ${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
              expansion is the value of parameter with the short­
              est  matching  pattern  deleted (the ``#'' case) or
              the longest matching pattern  deleted  (the  ``##''
              case).
 
       ${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 value of parameter, then
              the expansion is the value of  parameter  with  the
              shortest  matching pattern deleted (the ``%'' case)
              or the longest matching pattern deleted (the ``%%''
              case).
 
   Command Substitution
       Command  substitution  allows  the  output of a command to
       replace the command name.  There are two forms:
 
              $(command)
       or
              `command`
 
       Bash performs  the  expansion  by  executing  command  and
       replacing  the command substitution with the standard out­
       put of the command, with any trailing newlines deleted.
 
       When the old-style backquote form of substitution is used,
       backslash retains its literal meaning except when followed
       by $, `, or \.  When using the $(command) form, all  char­
       acters  between  the parentheses make up the command; none
       the  old  form,  escape  the  inner  backquotes with back­
       slashes.
 
       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.
       There are two formats for arithmetic expansion:
 
              $[expression]
 
              $((expression))
 
       The expression is treated as  if  it  were  within  double
       quotes,  but a double quote inside the braces or parenthe­
       ses is not treated specially.  All tokens in  the  expres­
       sion  undergo  parameter  expansion, command substitution,
       and  quote  removal.   Arithmetic  substitutions  may   be
       nested.
 
       The  evaluation is performed according to the rules listed
       below  under  ARITHMETIC  EVALUATION.   If  expression  is
       invalid,  bash  prints a message indicating failure and no
       substitution occurs.
 
   Process Substitution
       Process substitution is supported on systems that  support
       named  pipes  (FIFOs) or the /dev/fd method of naming open
       files.  It takes the form of <(list) or >(list).  The pro­
       cess  list  is run with its input or output connected to a
       FIFO or some file in /dev/fd.  The name of  this  file  is
       passed as an argument to the current command as the result
       of the expansion.  If the >(list) form is used, writing to
       the file will provide input for list.  If the <(list) form
       is used, the file passed as an argument should be read  to
       obtain the output of list.
 
       On  systems  that support it, process substitution is per­
       formed simultaneously with parameter and  variable  expan­
       sion, command substitution, and arithmetic expansion.
 
   Word Splitting
       The  shell  scans the results of parameter expansion, com­
       mand substitution, and arithmetic expansion that  did  not
       occur within double quotes for word splitting.
 
       The shell treats each character of IFS as a delimiter, and
       splits the results of the other expansions into  words  on
       these   characters.   If  the  value  of  IFS  is  exactly
       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.  IFS cannot be unset.
 
       Explicit null arguments ("" or '') are retained.  Implicit
       null arguments, resulting from the expansion of parameters
       that have no values, are removed.
 
       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  pathnames  matching the pattern.  If no matching
       pathnames   are   found,   and    the    shell    variable
       allow_null_glob_expansion  is  unset,  the  word  is  left
       unchanged.  If the variable is set,  and  no  matches  are
       found,  the  word  is removed.  When a pattern is used for
       pathname generation, the character ``.''  at the start  of
       a  name  or  immediately following a slash must be matched
       explicitly, unless the shell  variable  glob_dot_filenames
       is  set.   The  slash  character  must  always  be matched
       explicitly.  In other cases, the ``.''  character  is  not
       treated specially.
 
       The  special  pattern  characters have the following mean­
       ings:
 
       *      Matches any string, including the null string.
       ?      Matches any single character.
       [...]  Matches any one of the enclosed characters.  A pair
              of  characters  separated by a minus sign denotes a
              range; any character lexically  between  those  two
              characters,  inclusive,  is  matched.  If the first
              character following the [ is a !  or a ^  then  any
              character not enclosed is matched.  A - or ] may be
              matched by including it as the first or last  char­
              acter in the set.
 
   Quote Removal
       After  the  preceding expansions, all unquoted occurrences
       of the characters \, `, and " are removed.
 
       Before a command is executed, its input and output may  be
       redirected  using  a  special  notation interpreted by the
       shell.  Redirection may also be used  to  open  and  close
       files  for  the  current shell execution environment.  The
       following redirection operators may precede or appear any­
       where  within  a  simple  command or may follow a command.
       Redirections are processed in the order they appear,  from
       left to right.
 
       In the following descriptions, if the file descriptor 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 that follows the redirection operator in the fol­
       lowing descriptions is subjected to brace expansion, tilde
       expansion,  parameter  expansion,  command   substitution,
       arithmetic  expansion,  quote removal, and pathname expan­
       sion.  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.
 
   Redirecting Input
       Redirection  of  input  causes the file whose name results
       from the expansion of word to be  opened  for  reading  on
       file  descriptor n, or the standard input (file descriptor
       0) if n is not specified.
 
       The general format for redirecting input is:
 
              [n]<word
 
   Redirecting Output
       Redirection of output causes the file whose  name  results
       from  the  expansion  of  word to be opened for writing on
       file descriptor n, or the standard output (file descriptor
       1)  if  n is not specified.  If the file does not exist it
 
              [n]>word
 
       If  the  redirection operator is >|, then the value of the
       -C option to the set builtin command is  not  tested,  and
       file  creation is attempted.  (See also the description of
       noclobber under Shell Variables above.)
 
   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
       This type of redirection instructs the shell to read input
       from the current source until a line containing only  word
       (with  no trailing blanks) is seen.  All of the lines read
       up to that point are then used as the standard input for a
       command.
 
       The format of here-documents is as follows:
 
              <<[-]word
                      here-document
              delimiter
 
       No  parameter  expansion,  command  substitution, pathname
       result of quote removal on word,  and  the  lines  in  the
       here-document  are  not expanded.  Otherwise, all lines of
       the here-document are subjected  to  parameter  expansion,
       command  substitution,  and  arithmetic expansion.  In the
       latter case, the pair \<newline> is ignored, and \ must be
       used to quote the characters \, $, and `.
 
       If  the  redirection operator is <<-, then all leading tab
       characters are stripped from input lines and the line con­
       taining  delimiter.   This  allows  here-documents  within
       shell scripts to be indented in a natural fashion.
 
   Duplicating File Descriptors
       The redirection operator
 
              [n]<&word
 
       is used to duplicate  input  file  descriptors.   If  word
       expands to one or more digits, the file descriptor denoted
       by n is made to be a copy of  that  file  descriptor.   If
       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.  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 pre­
       viously.
 
   Opening File Descriptors for Reading and Writing
       The redirection operator
 
              [n]<>word
 
       causes the file whose name is the expansion of word to  be
       opened  for both reading and writing on file descriptor n,
       or as the standard input and standard output if n  is  not
       specified.  If the file does not exist, it is created.
 

FUNCTIONS

       A  shell  function, defined as described above under SHELL
       GRAMMAR, stores a series of commands for later  execution.
       Functions  are  executed  in  the  context  of the current
       shell; no new process is created to interpret  them  (con­
       trast  this with the execution of a shell script).  When a
       function is executed, the arguments to the function become
       Positional parameter 0 is unchanged.
 
       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 function execution.
 
       Function names and definitions may be listed with  the  -f
       option  to the declare or typeset builtin commands.  Func­
       tions may be exported so that subshells automatically 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.
 

ALIASES

       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,  as  in csh.  If arguments are needed, a shell
       function should be used.
 
       Aliases are not expanded when the shell  is  not  interac­
       tive.
 
       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
       nition appearing on the same line as another command  does
       not  take  effect  until  the  next line of input is read.
       This means that the commands following the  alias  defini­
       tion on that line are not affected by the new alias.  This
       behavior is also an issue  when  functions  are  executed.
       Aliases are expanded when the function definition is read,
       not when the function is executed, because a function def­
       inition  is  itself a compound command.  As a consequence,
       aliases defined in a  function  are  not  available  until
       after  that  function is executed.  To be safe, always put
       alias definitions on a separate line, and do not use alias
       in compound commands.
 
       Note that for almost every purpose, aliases are superseded
       by shell functions.
 

JOB CONTROL

       Job control refers to  the  ability  to  selectively  stop
       (suspend) the execution of processes and continue (resume)
       their execution  at  a  later  point.   A  user  typically
       employs  this  facility  via an interactive interface sup­
       plied jointly by the system's terminal driver and bash.
 
       The shell associates a job with each pipeline.  It keeps a
       table  of  currently  executing  jobs, which may be listed
       with the jobs command.   When  bash  starts  a  job  asyn­
       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 system maintains the notion of a current
       terminal process group ID.  Members of this process  group
       (processes  whose process group ID is equal to the current
       terminal process group ID) receive keyboard-generated sig­
       nals  such  as  SIGINT.  These processes are said to be in
       the foreground.  Background processes are those whose pro­
       cess  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 termi­
       nal.  Background processes  which  attempt  to  read  from
       (write  to) the terminal are sent a SIGTTIN (SIGTTOU) sig­
       nal by the terminal driver, which, unless caught, suspends
       the process.
 
       pend  character  (typically ^Z, Control-Z) while a process
       is running causes that process to be stopped  and  returns
       you  to bash.  Typing the delayed suspend character (typi­
       cally ^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.  You 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  fore­
       ground, or the kill command to kill it.  A ^Z takes effect
       immediately, and has the additional side effect of causing
       pending output and typeahead to be discarded.
 
       There are a number of ways to refer to a job in the shell.
       The character % introduces a job name.  Job number  n  may
       be referred to as %n.  A job may also be referred to using
       a prefix of the name used to start it,  or  using  a  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
       stopped while it was in the foreground.  The previous  job
       may  be referenced using %-.  In output pertaining to jobs
       (e.g., the output of the jobs command), the current job is
       always flagged with a +, and the previous job with a -.
 
       Simply naming a job can be used to bring it into the fore­
       ground: %1 is a synonym for ``fg %1'', bringing job 1 from
       the  background  into the foreground.  Similarly, ``%1 &''
       resumes job 1 in the background, equivalent to ``bg  %1''.
 
       The shell learns immediately whenever a job changes state.
       Normally, bash waits until it is about to print  a  prompt
       before  reporting  changes  in a job's status so as to not
       interrupt any other output.  If the -b option to  the  set
       builtin  command is set, bash reports such changes immedi­
       ately.  (See also the description of notify variable under
       Shell Variables above.)
 
       If  you  attempt  to exit bash while jobs are stopped, the
       shell prints a message warning you.  You may then use  the
       jobs  command to inspect their status.  If you do this, or
       try to exit again immediately, you are not  warned  again,
       and the stopped jobs are terminated.
 

SIGNALS

       When bash is interactive, it ignores SIGTERM (so that kill
       0 does not kill  an  interactive  shell),  and  SIGINT  is
       caught and handled (so that the wait builtin is interrupt­
       ible).  In all cases, bash ignores SIGQUIT.  If  job  con­
 
       Synchronous jobs started by bash have signals set  to  the
       values  inherited  by the shell from its parent.  When job
       control is not in effect, background  jobs  (jobs  started
       with  &)  ignore  SIGINT  and  SIGQUIT.  Commands run as a
       result of command substitution ignore the  keyboard-gener­
       ated job control signals SIGTTIN, SIGTTOU, and SIGTSTP.
 

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
       PATH for a directory containing an executable file by that
       name.   If the search is unsuccessful, the shell prints an
       error message and returns a nonzero exit status.
 
       If the search is successful, or if the command  name  con­
       tains  one  or  more slashes, the shell executes the named
       program.  Argument 0 is set to the  name  given,  and  the
       remaining  arguments  to  the command are set to the argu­
       ments given, if any.
 
       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.
 
       When a program is invoked it is given an array of  strings
       called  the  environment.   This  is  a list of name-value
       pairs, of the form name=value.
 
       The shell allows you to manipulate the environment in sev­
       eral  ways.   On invocation, the shell scans its own envi­
       ronment and creates a parameter for each name found, auto­
       matically  marking it for export to child processes.  Exe­
       cuted commands inherit the environment.   The  export  and
       declare  -x  commands allow parameters and functions to be
       added to and deleted from the environment.  If  the  value
       of  a  parameter  in  the environment is modified, the new
       value becomes part of the environment, replacing the  old.
       The environment inherited by any executed command consists
       of the shell's initial environment, whose  values  may  be
       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.
 
       If the -k flag is set (see the set builtin command below),
       then all parameter assignments are placed in the  environ­
       ment  for  a command, not just those that precede the com­
       mand name.
 
       When bash invokes an external command, the variable  _  is
       set  to  the  full  path name of the command and passed to
       that command in its environment.
 

EXIT STATUS

       For the purposes of the shell, a command which exits  with
       a  zero exit status has succeeded.  An exit status of zero
       indicates success.  A non-zero exit status indicates fail­
       ure.   When  a  command terminates on a fatal signal, bash
       uses the value of 128+signal as the exit status.
 
       If a command is not found, the child  process  created  to
       execute it returns a status of 127.  If a command is found
       but is not executable, the return status is 126.
 
       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.
 

PROMPTING

       When  executing  interactively,  bash displays the primary
       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:
              \t     the current time in HH:MM:SS format
              \d     the date  in  "Weekday  Month  Date"  format
                     (e.g., "Tue May 26")
              \n     newline
              \s     the  name  of  the shell, the basename of $0
                     (the portion following the final slash)
              \w     the current working directory
              \W     the basename of the current  working  direc­
                     tory
              \u     the username of the current user
              \h     the hostname
              \#     the command number of this command
              \!     the history number of this command
              \$     if  the effective UID is 0, a #, otherwise a
                     $
              \nnn   the character  corresponding  to  the  octal
                     number nnn
              \\     a backslash
              \[     begin a sequence of non-printing characters,
                     which could be used to embed a terminal con­
                     trol sequence into the prompt
              \]     end a sequence of non-printing characters
 
       The command number and the history number are usually dif­
       ferent: the history number of a command is its position in
       the history list, which may include commands restored from
       the history file (see HISTORY below),  while  the  command
       number  is  the  position in the sequence of commands exe­
       cuted during the current shell session.  After the  string
       is  decoded,  it is expanded via parameter expansion, com­
       mand substitution, arithmetic expansion, and  word  split­
       ting.
 

READLINE

       This  is the library that handles reading input when using
       an interactive shell, unless the -nolineediting option  is
       given.   By default, the line editing commands are similar
       to those of emacs.  A vi-style line editing  interface  is
       also available.
 
       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.)
       file.  The value of the shell variable INPUTRC, if set, is
       used  instead of ~/.inputrc.  Other programs that use this
       library may add their own commands and bindings.
 
       For example, placing
 
              M-Control-u: universal-argument
       or
              C-Meta-u: universal-argument
       into the ~/.inputrc would make M-C-u execute the  readline
       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  is customized by putting commands in an initial­
       ization file.  The name of this file  is  taken  from  the
       value of the INPUTRC variable.  If that variable is unset,
       the default is ~/.inputrc.  When a program which uses  the
       readline library starts up, the init file is read, and the
       key bindings and variables are set.  There are only a  few
       basic constructs allowed in the readline init file.  Blank
       lines are ignored.  Lines beginning with a # are comments.
       Lines  beginning with a $ indicate conditional constructs.
       Other lines denote key bindings and variable settings.
 
       The syntax for controlling key bindings in the  ~/.inputrc
       file  is  simple.  All that is required is the name of the
       command or the text of a macro and a key sequence to which
       it  should  be  bound. The name may be specified in one of
       two ways: as a symbolic key name, possibly with  Meta-  or
       Control-  prefixes,  or as a key sequence.  When using the
       form keyname:function-name or macro, keyname is  the  name
       of a key spelled out in English.  For example:
 
              Control-u: universal-argument
              Meta-Rubout: backward-kill-word
              Control-o: ">&output"
 
       In the above example, C-u is bound to the function 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
              "\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 escape sequences is
 
              \C-    control prefix
 
              \M-    meta prefix
 
              \e     an escape character
 
              \\     backslash
 
              \"     literal "
 
              \'     literal '
 
       When entering the text of a macro, single or double quotes
       should  be  used to indicate a macro definition.  Unquoted
       text is assumed to be a  function  name.   Backslash  will
       quote  any 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 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:
 
       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.
       editing-mode (emacs)
              Controls whether readline begins with a set of  key
              bindings  similar to emacs or vi.  editing-mode can
              be set to either emacs or vi.
       mark-modified-lines (Off)
              If set to On, history lines that have been modified
              are displayed with a preceding asterisk (*).
              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 in  vi  mode  when  the
              vi-comment command is executed.
       meta-flag (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.
       convert-meta (On)
              If set to On, readline will convert characters with
              the  eighth  bit  set  to  an ASCII key sequence by
              stripping the eighth bit and prepending  an  escape
              character (in effect, using escape as the meta pre­
              fix).
       output-meta (Off)
              If set to On, readline will display characters with
              the  eighth bit set directly rather than as a meta-
              prefixed escape sequence.
       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­
              able, the user is asked whether or not he wishes to
              view  them; otherwise they are simply listed on the
              terminal.
       keymap (emacs)
              Set the current readline keymap.  The set of  legal
              keymap  names is 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.  The default value is emacs; the
              value  of  editing-mode  also  affects  the default
              keymap.
       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.
       expand-tilde (Off)
              If set to on, tilde  expansion  is  performed  when
              readline attempts word completion.
 
       Readline  implements  a  facility similar in spirit to the
       conditional compilation features  of  the  C  preprocessor
       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 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
                     Bash:
                     $if Bash
                     # Quote the current or previous word
                     "\C-xq": "\eb\"\ef\""
                     $endif
 
       $endif This  command,  as you saw in the previous example,
              terminates an $if command.
 
       $else  Commands in this branch of the  $if  directive  are
              executed if the test fails.
 
       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
 
       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.
 
       The following is a list of the names of the  commands  and
       the default key sequences to which they are bound.
 
   Commands for Moving
       beginning-of-line (C-a)
              Move to the start of the current line.
       end-of-line (C-e)
              Move to the end of the line.
       forward-char (C-f)
              Move forward a character.
       backward-char (C-b)
              Move back a character.
       forward-word (M-f)
              Move  forward  to  the end of the next word.  Words
              are composed of  alphanumeric  characters  (letters
              and digits).
       backward-word (M-b)
              Move  back  to  the start of this, or the previous,
              word.  Words are composed of  alphanumeric  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.   By  default, this is
              unbound.
 
   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.
              Move  to  the  end  of the input history, i.e., the
              line currently being entered.
       reverse-search-history (C-r)
              Search backward starting at the  current  line  and
              moving `up' through the history as necessary.  This
              is an incremental search.
       forward-search-history (C-s)
              Search forward starting at  the  current  line  and
              moving  `down'  through  the  history as necessary.
              This is an incremental search.
       non-incremental-reverse-search-history (M-p)
              Search backward through the history starting at the
              current  line  using a non-incremental search for a
              string supplied by the user.
       non-incremental-forward-search-history (M-n)
              Search  forward  through  the   history   using   a
              non-incremental search for a string supplied by the
              user.
       history-search-forward
              Search forward through the history for  the  string
              of characters between the start of the current line
              and the current point.  This is  a  non-incremental
              search.  By default, this command is unbound.
       history-search-backward
              Search  backward through the history for the string
              of characters between the start of the current line
              and  the  current point.  This is a non-incremental
              search.  By default, this command is unbound.
       yank-nth-arg (M-C-y)
              Insert the first argument to the  previous  command
              (usually  the  second word on the previous line) at
              point (the current cursor position).  With an argu­
              ment  n, insert the nth word from the previous com­
              mand (the words in the previous command begin  with
              word  0).  A negative argument inserts the nth word
              from the end of the previous command.
       yank-last-arg (M-., M-_)
              Insert the last argument to  the  previous  command
              (the  last  word  on  the  previous line).  With an
              argument, behave exactly like yank-nth-arg.
       shell-expand-line (M-C-e)
              Expand the line the way  the  shell  does  when  it
              reads  it.   This performs alias and history expan­
              sion 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.
       insert-last-argument (M-., M-_)
              A synonym for yank-last-arg.
              Accept the current line for execution and fetch the
              next  line  relative  to  the current line from the
              history for editing.  Any argument is ignored.
 
   Commands for Changing Text
       delete-char (C-d)
              Delete the character under the cursor.  If point is
              at  the beginning of the line, there are no charac­
              ters in the line, and the last character typed  was
              not C-d, then return EOF.
       backward-delete-char (Rubout)
              Delete the character behind the cursor.  When given
              a numeric argument, save the deleted  text  on  the
              kill-ring.
       quoted-insert (C-q, C-v)
              Add  the  next  character that you type to the line
              verbatim.  This is how to  insert  characters  like
              C-q, for example.
       tab-insert (C-v TAB)
              Insert a tab character.
       self-insert (a, b, A, 1, !, ...)
              Insert the character typed.
       transpose-chars (C-t)
              Drag  the  character  before point forward over the
              character at point.  Point moves forward  as  well.
              If  point is at the end of the line, then transpose
              the two characters before  point.   Negative  argu­
              ments don't work.
       transpose-words (M-t)
              Drag  the  word  behind the cursor past the word in
              front of the cursor moving  the  cursor  over  that
              word as well.
       upcase-word (M-u)
              Uppercase  the current (or following) word.  With a
              negative argument, do the previous word, but do not
              move point.
       downcase-word (M-l)
              Lowercase  the current (or following) word.  With a
              negative argument, do the previous word, but do not
              move point.
       capitalize-word (M-c)
              Capitalize the current (or following) word.  With a
              negative argument, do the previous word, but do not
              move point.
 
   Killing and Yanking
       kill-line (C-k)
              Kill  the  text from the current cursor position to
              the end of the line.
       backward-kill-line (C-x C-Rubout)
              Kill backward to the beginning of the line.
       unix-line-discard (C-u)
       kill-whole-line
              Kill  all characters on the current line, no matter
              where the cursor is.  By default, this is  unbound.
       kill-word (M-d)
              Kill  from  the  cursor  to  the end of the current
              word, or if between words, to the end of  the  next
              word.   Word  boundaries are the same as those used
              by forward-word.
       backward-kill-word (M-Rubout)
              Kill the word behind the cursor.   Word  boundaries
              are the same as those used by backward-word.
       unix-word-rubout (C-w)
              Kill  the word behind the cursor, using white space
              as a word boundary.  The word boundaries  are  dif­
              ferent from backward-kill-word.
       delete-horizontal-space
              Delete  all  spaces  and  tabs  around  point.   By
              default, this is unbound.
       yank (C-y)
              Yank the top of the kill ring into  the  buffer  at
              the cursor.
       yank-pop (M-y)
              Rotate  the  kill-ring, and yank the new top.  Only
              works following yank or yank-pop.
 
   Numeric Arguments
       digit-argument (M-0, M-1, ..., M--)
              Add this digit to the argument  already  accumulat­
              ing,  or  start a new argument.  M-- starts a nega­
              tive argument.
       universal-argument
              Each time this is executed, the argument  count  is
              multiplied  by  four.   The  argument count is ini­
              tially one, so executing this  function  the  first
              time  makes  the  argument count four.  By default,
              this is not bound to a key.
 
   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
              Insert  all  completions  of  the text before point
              that would have been generated by  possible-comple­
              Attempt  filename  completion  on  the  text before
              point.
       possible-filename-completions (C-x /)
              List the possible completions of  the  text  before
              point, treating it as a filename.
       complete-username (M-~)
              Attempt completion on the text before point, 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,  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 return 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 save 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
 
       re-read-init-file (C-x C-r)
              Read  in the contents of your init file, and incor­
              porate any bindings or variable  assignments  found
              there.
       abort (C-g)
              Abort the current editing command and ring the ter­
              minal's   bell   (subject   to   the   setting   of
              bell-style).
       do-uppercase-version (M-a, M-b, ...)
              Run  the command that is bound to the corresponding
              uppercase character.
       prefix-meta (ESC)
              Metafy the next character typed.  ESC f is  equiva­
              lent to Meta-f.
       undo (C-_, C-x C-u)
              Incremental  undo,  separately  remembered for each
              line.
       revert-line (M-r)
              Undo all changes made to this line.  This  is  like
              typing  the undo command enough times to return the
              line to its initial state.
       tilde-expand (M-~)
              Perform tilde expansion on the current word.
       dump-functions
              Print all of the functions and their  key  bindings
              to  the readline output stream.  If a numeric argu­
              ment is supplied, the output is formatted in such a
              way that it can be made part of an inputrc file.
       display-shell-version (C-x C-v)
              Display   version  information  about  the  current
              instance of bash.
 

HISTORY

       When interactive, the shell provides access to the command
       history,  the list of commands previously typed.  The text
       of the last HISTSIZE commands (default 500) is saved in  a
       history  list.   The shell stores each command in the his­
       tory list prior to parameter and variable  expansion  (see
       EXPANSION above) but after history expansion is performed,
       subject to the values of the shell variables  command_ori­
       ented_history and HISTCONTROL.  On startup, the history is
       initialized from the file named by the  variable  HISTFILE
       (default ~/.bash_history).  HISTFILE is truncated, if nec­
       essary, to contain no more than HISTFILESIZE  lines.   The
       builtin  command fc (see SHELL BUILTIN COMMANDS below) may
       be used to list or edit and re-execute a  portion  of  the
       history  list.  The history builtin can be used to display
       the history list and manipulate the  history  file.   When
       using the command-line editing, search commands are avail­
       able in each editing mode that provide access to the  his­
       tory  list.   When  an  interactive  shell exits, the last
       HISTSIZE lines are copied from the history list  to  HIST­
 

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.
 
       History expansion is performed immediately  after  a  com­
       plete line is read, before the shell breaks it into words.
       It takes place in two parts.  The first  is  to  determine
       which line from the previous history to use during substi­
       tution.  The second is to select portions of that line for
       inclusion  into  the  current one.  The line selected from
       the previous history is the event,  and  the  portions  of
       that line that are acted upon are words.  The line is bro­
       ken into words in the same fashion as when reading  input,
       so  that  several metacharacter-separated words surrounded
       by quotes are considered as one word.  Only backslash  (\)
       and  single quotes can quote the history escape character,
       which is ! by default.
 
       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 (.
       !!     Refer to the previous command.  This is  a  synonym
              for `!-1'.
       !n     Refer to command line n.
       !-n    Refer to the current command line minus n.
       !string
              Refer  to  the  most  recent  command starting with
              string.
       !?string[?]
              Refer to the most recent command containing string.
       ^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
       A : separates the event specification from the word desig­
       nator.  It can be omitted if the  word  designator  begins
       by a 0 (zero).
 
       0 (zero)
              The  zeroth  word.  For the shell, this is the com­
              mand word.
       n      The nth word.
       ^      The first argument.  That is, word 1.
       $      The last argument.
       %      The word matched  by  the  most  recent  `?string?'
              search.
       x-y    A range of words; `-y' abbreviates `0-y'.
       *      All of the words but the zeroth.  This is a synonym
              for `1-$'.  It is not an error to use * if there is
              just  one  word  in  the event; the empty string is
              returned in that case.
       x*     Abbreviates x-$.
       x-     Abbreviates x-$ like x*, but omits the last word.
 
   Modifiers
       After the optional word designator, you can add a sequence
       of  one  or more of the following modifiers, each preceded
       by a `:'.
 
       h      Remove a trailing pathname component, leaving  only
              the head.
       r      Remove  a trailing suffix of the form .xxx, leaving
              the basename.
       e      Remove all but the trailing suffix.
       t      Remove all leading pathname components, leaving the
              tail.
       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