     This text is a brief description of the features that are present in
     the Bash shell.

     This is Edition 1.14, last updated 4 August 1994,
     of The GNU Bash Features Guide,
     for Bash, Version 1.14.

     Copyright (C) 1991, 1993 Free Software Foundation, Inc.

     This file is part of GNU Bash, the Bourne Again SHell.

     Bash is free software; you can redistribute it and/or modify it
     under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 1, or (at your option)
     any later version.

     Bash is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
     License for more details.

     You should have received a copy of the GNU General Public License
     along with Bash; see the file COPYING.  If not, write to the Free
     Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

Bash Features
*************

Bash contains features that appear in other popular shells, and some features that only appear in Bash.  Some of the shells that Bash has borrowed concepts from are the Bourne Shell (sh), the Korn Shell (ksh), and the C-shell (csh and its successor, tcsh). The following menu breaks the features up into categories based upon which one of these other shells inspired the feature.

This manual is meant as a brief introduction to features found in Bash.  The Bash manual page should be used as the definitive reference on shell behavior.

Bourne Shell Style Features
***************************

Bash is an acronym for Bourne Again SHell.  The Bourne shell is the traditional Unix shell originally written by Stephen Bourne. All of the Bourne shell builtin commands are available in Bash, and the rules for evaluation and quoting are taken from the Posix 1003.2 specification for the `standard' Unix shell.

This section briefly summarizes things which Bash inherits from the Bourne shell: shell control structures, builtins, variables, and other features.  It also lists the significant differences between Bash and the Bourne Shell.

Looping Constructs
==================

Note that wherever you see a ; in the description of a command's syntax, it may be replaced indiscriminately with one or more newlines.

Bash supports the following looping constructs.

until
     The syntax of the until command is:

          until TEST-COMMANDS; do CONSEQUENT-COMMANDS; done

     Execute CONSEQUENT-COMMANDS as long as the final command in TEST-COMMANDS has an exit status which is not zero.

while
     The syntax of the while command is:

          while TEST-COMMANDS; do CONSEQUENT-COMMANDS; done

     Execute CONSEQUENT-COMMANDS as long as the final command in TEST-COMMANDS has an exit status of zero.

for
     The syntax of the for command is:

          for NAME [in WORDS ...]; do COMMANDS; done

     Execute COMMANDS for each member in WORDS, with NAME bound to the current member.  If ``in WORDS'' is not present, ``in "$@"'' is assumed.

Conditional Constructs
======================

if
     The syntax of the if command is:

          if TEST-COMMANDS; then
            CONSEQUENT-COMMANDS;
          [elif MORE-TEST-COMMANDS; then
            MORE-CONSEQUENTS;]
          [else ALTERNATE-CONSEQUENTS;]
          fi

     Execute CONSEQUENT-COMMANDS only if the final command in TEST-COMMANDS has an exit status of zero. Otherwise, each elif list is executed in turn, and if its exit status is zero, the corresponding MORE-CONSEQUENTS is executed and the command completes. If ``else ALTERNATE-CONSEQUENTS'' is present, and the final command in the final if or elif clause has a non-zero exit status, then execute ALTERNATE-CONSEQUENTS.

case
     The syntax of the case command is:

          case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac

     Selectively execute COMMANDS based upon WORD matching PATTERN.  The `|' is used to separate multiple patterns.

     Here is an example using case in a script that could be used to describe an interesting feature of an animal:

          echo -n "Enter the name of an animal: "
          read ANIMAL
          echo -n "The $ANIMAL has "
          case $ANIMAL in
            horse | dog | cat) echo -n "four";;
            man | kangaroo ) echo -n "two";;
            *) echo -n "an unknown number of";;
          esac
          echo "legs."

Shell Functions
===============

Shell functions are a way to group commands for later execution using a single name for the group.  They are executed just like a "regular" command.  Shell functions are executed in the current shell context; no new process is created to interpret them.

Functions are declared using this syntax:

     [ function ] NAME () { COMMAND-LIST; }

This defines a function named NAME.  The BODY of the function is the COMMAND-LIST between { and }.  This list is executed whenever NAME is specified as the name of a command.  The exit status of a function is the exit status of the last command executed in the body.

When a function is executed, the arguments to the function become the positional parameters during its execution.  The special parameter # that gives the number of positional parameters is updated to reflect the change.  Positional parameter 0 is unchanged.

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

Bourne Shell Builtins
=====================

The following shell builtin commands are inherited from the Bourne shell.  These commands are implemented as specified by the Posix 1003.2 standard.

:
     Do nothing beyond expanding any arguments and performing redirections.

.
     Read and execute commands from the FILENAME argument in the current shell context.

break
     Exit from a for, while, or until loop.

cd
     Change the current working directory.

continue
     Resume the next iteration of an enclosing for, while, or until loop.

echo
     Print the arguments, separated by spaces, to the standard output.

eval
     The arguments are concatenated together into a single command, which is then read and executed.

exec
     If a COMMAND argument is supplied, it replaces the shell.  If no COMMAND is specified, redirections may be used to affect the current shell environment.

exit
     Exit the shell.

export
     Mark the arguments as variables to be passed to child processes in the environment.

getopts
     Parse options to shell scripts or functions.

hash
     Remember the full pathnames of commands specified as arguments, so they need not be searched for on subsequent invocations.

kill
     Send a signal to a process.

pwd
     Print the current working directory.

read
     Read a line from the shell input and use it to set the values of specified variables.

readonly
     Mark variables as unchangable.

return
     Cause a shell function to exit with a specified value.

shift
     Shift positional parameters to the left.

test
[
     Evaluate a conditional expression.

times
     Print out the user and system times used by the shell and its children.

trap
     Specify commands to be executed when the shell receives signals.

umask
     Set the shell process's file creation mask.

unset
     Cause shell variables to disappear.

wait
     Wait until child processes exit and report their exit status.

Bourne Shell Variables
======================

Bash uses certain shell variables in the same way as the Bourne shell. In some cases, Bash assigns a default value to the variable.

IFS
     A list of characters that separate fields; used when the shell splits words as part of expansion.

PATH
     A colon-separated list of directories in which the shell looks for commands.

HOME
     The current user's home directory.

CDPATH
     A colon-separated list of directories used as a search path for the cd command.

MAILPATH
     A colon-separated list of files which the shell periodically checks for new mail.    You can also specify what message is printed by separating the file name from the message with a ?.  When used in the text of the message, $_ stands for the name of the current mailfile.

PS1
     The primary prompt string.

PS2
     The secondary prompt string.

OPTIND
     The index of the last option processed by the getopts builtin.

OPTARG
     The value of the last option argument processed by the getopts builtin.

Other Bourne Shell Features
===========================

Bash implements essentially the same grammar, parameter and variable expansion, redirection, and quoting as the Bourne Shell.  Bash uses the Posix 1003.2 standard as the specification of how these features are to be implemented.  There are some differences between the traditional Bourne shell and the Posix standard; this section quickly details the differences of significance.  A number of these differences are explained in greater depth in subsequent sections.

Major Differences from the Bourne Shell
---------------------------------------

Bash implements the ! keyword to negate the return value of a pipeline.  Very useful when an if statement needs to act only if a test fails.

Bash includes brace expansion (see Brace Expansion).

Bash includes the Posix and ksh-style pattern removal %% and ## constructs to remove leading or trailing substrings from variables.

The Posix and ksh-style $() form of command substitution is implemented, and preferred to the Bourne shell's `` (which is also implemented for backwards compatibility).

Variables present in the shell's initial environment are automatically exported to child processes.  The Bourne shell does not normally do this unless the variables are explicitly marked using the export command.

The expansion ${#xx}, which returns the length of $xx, is supported.

The IFS variable is used to split only the results of expansion, not all words.  This closes a longstanding shell security hole.

It is possible to have a variable and a function with the same name; sh does not separate the two name spaces.

Bash functions are permitted to have local variables, and thus useful recursive functions may be written.

The noclobber option is available to avoid overwriting existing files with output redirection.

Bash allows you to write a function to override a builtin, and provides access to that builtin's functionality within the function via the builtin and command builtins.

The command builtin allows selective disabling of functions when command lookup is performed.

Individual builtins may be enabled or disabled using the enable builtin.

Functions may be exported to children via the environment.

The Bash read builtin will read a line ending in \ with the -r option, and will use the $REPLY variable as a default if no arguments are supplied.

The return builtin may be used to abort execution of scripts executed with the . or source builtins.

The umask builtin allows symbolic mode arguments similar to those accepted by chmod.

The test builtin is slightly different, as it implements the Posix 1003.2 algorithm, which specifies the behavior based on the number of arguments.

C-Shell Style Features
**********************

The C-Shell (csh) was created by Bill Joy at UC Berkeley.  It is generally considered to have better features for interactive use than the original Bourne shell.  Some of the csh features present in Bash include job control, history expansion, `protected' redirection, and several variables for controlling the interactive behaviour of the shell (e.g. IGNOREEOF).

See Using History Interactively for details on history expansion.

Tilde Expansion
===============

Bash has tilde (~) expansion, similar, but not identical, to that of csh.  The following table shows what unquoted words beginning with a tilde expand to.

~
     The current value of $HOME.

~/foo
     $HOME/foo

~fred/foo
     The subdirectory foo of the home directory of the user fred.

~+/foo
     $PWD/foo

~-
     $OLDPWD/foo

Bash will also tilde expand words following redirection operators and words following = in assignment statements.

Brace Expansion
===============

Brace expansion is a mechanism by which arbitrary strings may be generated.  This mechanism is similar to PATHNAME EXPANSION (see the Bash manual page for details), but the file names 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 POSTAMBLE. 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 preserved in the result.  It is strictly textual.  Bash does not apply any syntactic interpretation to the context of the expansion or the text between the braces.

A correctly-formed brace expansion must contain unquoted opening and closing braces, and at least one unquoted comma. Any incorrectly formed brace expansion is left unchanged.

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

C Shell Builtins
================

Bash has several builtin commands whose definition is very similar to csh.

pushd

          pushd [DIR | +N | -N]

     Save the current directory on a list and then cd to DIR.  With no arguments, exchanges the top two directories.

     +N
          Brings the Nth directory (counting from the left of the list printed by dirs) to the top of the list by rotating the stack.

     -N
          Brings the Nth directory (counting from the right of the list printed by dirs) to the top of the list by rotating the stack.

     DIR
          Makes the current working directory be the top of the stack, and then CDs to DIR.  You can see the saved directory list with the dirs command.

popd

          popd [+N | -N]

     Pops the directory stack, and cds to the new top directory.  When no arguments are given, removes the top directory from the stack and cds to the new top directory.  The elements are numbered from 0 starting at the first directory listed with dirs; i.e. popd is equivalent to popd +0.

     +N
          Removes the Nth directory (counting from the left of the list printed by dirs), starting with zero.

     -N
          Removes the Nth directory (counting from the right of the list printed by dirs), starting with zero.

dirs

          dirs [+N | -N] [-L]

     Display the list of currently remembered directories.  Directories find their way onto the list with the pushd command; you can get back up through the list with the popd command.

     +N
          Displays the Nth directory (counting from the left of the list printed by dirs when invoked without options), starting with zero.

     -N
          Displays the Nth directory (counting from the right of the list printed by dirs when invoked without options), starting with zero.

     -L
          Produces a longer listing; the default listing format uses a tilde to denote the home directory.

history

          history [N] [ [-w -r -a -n] [FILENAME]]

     Display the history list with line numbers.  Lines prefixed with with a * have been modified.  An argument of N says to list only the last N lines.  Option -w means write out the current history to the history file; -r means to read the current history file and make its contents the history list.  An argument of -a means to append the new history lines (history lines entered since the beginning of the current Bash session) to the history file.  Finally, the -n argument means to read the history lines not already read from the history file into the current history list.  These are lines appended to the history file since the beginning of the current Bash session.  If FILENAME is given, then it is used as the history file, else if $HISTFILE has a value, that is used, otherwise ~/.bash_history is used.

logout
     Exit a login shell.

source
     A synonym for . (see Bourne Shell Builtins)

C Shell Variables
=================

IGNOREEOF
     If this variable is set, it represents the number of consecutive EOFs Bash will read before exiting.  By default, Bash will exit upon reading a single EOF.

cdable_vars
     If this variable is set, Bash treats arguments to the cd command which are not directories as names of variables whose values are the directories to change to.

Korn Shell Style Features
*************************

This section describes features primarily inspired by the Korn Shell (ksh).  In some cases, the Posix 1003.2 standard has adopted these commands and variables from the Korn Shell; Bash implements those features using the Posix standard as a guide.

Korn Shell Constructs
=====================

Bash includes the Korn Shell select construct.  This construct allows the easy generation of menus.  It has almost the same syntax as the for command.

The syntax of the select command is:

     select NAME [in WORDS ...]; do COMMANDS; done

The list of words following in is expanded, generating a list of items.  The set of expanded words is printed on the standard error, each preceded by a number.  If the ``in WORDS'' is omitted, the positional parameters are printed.  The PS3 prompt is then displayed and a line is 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 prompt are displayed again.  If EOF is read, the select command completes.  Any other value read causes NAME to be set to null.  The line read is saved in the variable REPLY.

The COMMANDS are executed after each selection until a break or return command is executed, at which point the select command completes.

Korn Shell Builtins
===================

This section describes Bash builtin commands taken from ksh.

fc

          fc [-e ENAME] [-nlr] [FIRST] [LAST]
          fc -s [PAT=REP] [COMMAND]

     Fix Command.  In the first form, a range of commands from FIRST to LAST is selected from the history list.  Both FIRST and LAST may be specified as a string (to locate the most recent command beginning with that string) or as a number (an index into the history list, where a negative number is used as an offset from the current command number).  If LAST is not specified it is set to FIRST.  If FIRST is not specified it is set to the previous command for editing and -16 for listing.  If the -l flag is given, the commands are listed on standard output.  The -n flag suppresses the command numbers when listing.  The -r flag reverses the order of the listing.  Otherwise, the editor given by ENAME is invoked on a file containing those commands.  If ENAME is not given, the value of the following variable expansion is used: ${FCEDIT:-${EDITOR:-vi}}.  This says to use the value of the FCEDIT variable if set, or the value of the EDITOR variable if that is set, or vi if neither is set. When editing is complete, the edited commands are echoed and executed.

     In the second form, COMMAND is re-executed after each instance of PAT in the selected command is replaced by REP.

     A useful alias to use with the fc command is r='fc -s', so that typing r cc runs the last command beginning with cc and typing r re-executes the last command (see Aliases).

let
     The let builtin allows arithmetic to be performed on shell variables. For details, refer to Arithmetic Builtins.

typeset
     The typeset command is supplied for compatibility with the Korn shell; however, it has been made obsolete by the declare command (see Bash Builtins).

Korn Shell Variables
====================

REPLY
     The default variable for the read builtin.

RANDOM
     Each time this parameter is referenced, a random integer is generated.  Assigning a value to this variable seeds the random number generator.

SECONDS
     This variable expands to the number of seconds since the shell was started.  Assignment to this variable resets the count to the value assigned, and the expanded value becomes the value assigned plus the number of seconds since the assignment.

PS3
     The value of this variable is used as the prompt for the select command.

PS4
     This is the prompt printed before the command line is echoed when the -x option is set (see The Set Builtin).

PWD
     The current working directory as set by the cd builtin.

OLDPWD
     The previous working directory as set by the cd builtin.

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

Aliases
=======

The shell maintains a list of ALIASES that may be set and unset with the alias and unalias builtin commands.

The first word of each command, if unquoted, is checked to see if it has an alias.  If so, that word is replaced by the text of the alias. The alias name and the replacement text may contain any valid shell input, including shell metacharacters, 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 space or tab character, then the next command word following the alias is also checked for alias expansion.

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

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

Aliases are not expanded when the shell is not interactive.

The rules concerning the definition and use of aliases are somewhat confusing.  Bash always reads at least one complete line of input before executing any of the commands on that line.  Aliases are expanded when a command is read, not when it is executed.  Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. This means that the commands following the alias definition on that line are not affected by the new alias. This behavior is also an issue when functions are executed. Aliases are expanded when the function definition is read, not when the function is executed, because a function definition 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.

Alias Builtins
--------------

alias

          alias [NAME[=VALUE] ...]

     Without arguments, print the list of aliases on the standard output. If arguments are supplied, an alias is defined for each NAME whose VALUE is given.  If no VALUE is given, the name and value of the alias is printed.

unalias

          unalias [-a] [NAME ... ]

     Remove each NAME from the list of aliases.  If -a is supplied, all aliases are removed.

Bash Specific Features
**********************

This section describes the features unique to Bash.

Invoking Bash
=============

In addition to the single-character shell command-line options (see The Set Builtin), there are several multi-character options that you can use.  These options must appear on the command line before the single-character options to be recognized.

-norc
     Don't read the ~/.bashrc initialization file in an interactive shell.  This is on by default if the shell is invoked as sh.

-rcfile FILENAME
     Execute commands from FILENAME (instead of ~/.bashrc) in an interactive shell.

-noprofile
     Don't load the system-wide startup file /etc/profile or any of the personal initialization files ~/.bash_profile, ~/.bash_login, or ~/.profile when bash is invoked as a login shell.

-version
     Display the version number of this shell.

-login
     Make this shell act as if it were directly invoked from login. This is equivalent to exec - bash but can be issued from another shell, such as csh.  If you wanted to replace your current login shell with a Bash login shell, you would say exec bash -login.

-nobraceexpansion
     Do not perform curly brace expansion (see Brace Expansion).

-nolineediting
     Do not use the GNU Readline library (see Command Line Editing) to read interactive command lines.

-posix
     Change the behavior of Bash where the default operation differs from the Posix 1003.2 standard to match the standard.  This is intended to make Bash behave as a strict superset of that standard.

There are several single-character options you can give which are not available with the set builtin.

-c STRING
     Read and execute commands from STRING after processing the options, then exit.

-i
     Force the shell to run interactively.

-s
     If this 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.

An interactive shell is one whose input and output are both connected to terminals (as determined by isatty()), or one started with the -i option.

Bash Startup Files
==================

When and how Bash executes startup files.

     For Login shells (subject to the -noprofile option):

         On logging in:
            If /etc/profile exists, then source it.

            If ~/.bash_profile exists, then source it,
               else if ~/.bash_login exists, then source it,
                  else if ~/.profile exists, then source it.

         On logging out:
            If ~/.bash_logout exists, source it.

     For non-login interactive shells (subject to the -norc and -rcfile options):
         On starting up:
            If ~/.bashrc exists, then source it.

     For non-interactive shells:
         On starting up:
            If the environment variable ENV is non-null, expand the
            variable and source the file named by the value.  If Bash is
            not started in Posix mode, it looks for BASH_ENV before
            ENV.

So, typically, your ~/.bash_profile contains the line

     if [ -f ~/.bashrc ]; then source ~/.bashrc; fi

after (or before) any login specific initializations.

If Bash is invoked as sh, it tries to mimic the behavior of sh as closely as possible.  For a login shell, it attempts to source only /etc/profile and ~/.profile, in that order. The -noprofile option may still be used to disable this behavior. A shell invoked as sh does not attempt to source any other startup files.

When Bash is started in POSIX mode, as with the -posix command line option, it follows the Posix 1003.2 standard for startup files.  In this mode, the ENV variable is expanded and that file sourced; no other startup files are read.

Is This Shell Interactive?
==========================

You may wish to determine within a startup script whether Bash is running interactively or not.  To do this, examine the variable $PS1; it is unset in non-interactive shells, and set in interactive shells.  Thus:

     if [ -z "$PS1" ]; then
     	echo This shell is not interactive
     else
     	echo This shell is interactive
     fi

You can ask an interactive Bash to not run your ~/.bashrc file with the -norc flag.  You can change the name of the ~/.bashrc file to any other file name with -rcfile FILENAME.  You can ask Bash to not run your ~/.bash_profile file with the -noprofile flag.

Bash Builtin Commands
=====================

This section describes builtin commands which are unique to or have been extended in Bash.

builtin

          builtin [SHELL-BUILTIN [ARGS]]

     Run a shell builtin.  This is useful when you wish to rename a shell builtin to be a function, but need the functionality of the builtin within the function itself.

bind

          bind [-m KEYMAP] [-lvd] [-q NAME]
          bind [-m KEYMAP] -f FILENAME
          bind [-m KEYMAP] KEYSEQ:FUNCTION-NAME

     Display current Readline (see Command Line Editing) key and function bindings, or bind a key sequence to a Readline function or macro.  The binding syntax accepted is identical to that of .inputrc (see Readline Init File), but each binding must be passed as a separate argument: "\C-x\C-r":re-read-init-file. Options, if supplied, have the following meanings:

     -m keymap
          Use KEYMAP as the keymap to be affected by the subsequent bindings.  Acceptable KEYMAP names are emacs, emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move, vi-command, and vi-insert. vi is equivalent to vi-command; emacs is equivalent to emacs-standard.

     -l
          List the names of all readline functions

     -v
          List current function names and bindings

     -d
          Dump function names and bindings in such a way that they can be re-read

     -f filename
          Read key bindings from FILENAME

     -q
          Query about which keys invoke the named FUNCTION

command

          command [-pVv] COMMAND [ARGS ...]

     Runs COMMAND with ARG ignoring shell functions.  If you have a shell function called ls, and you wish to call the command ls, you can say command ls.  The -p option means to use a default value for $PATH that is guaranteed to find all of the standard utilities.

     If either the -V or -v option is supplied, a description of COMMAND is printed.  The -v option causes a single word indicating the command or file name used to invoke COMMAND to be printed; the -V option produces a more verbose description.

declare

          declare [-frxi] [NAME[=VALUE]]

     Declare variables and/or give them attributes.  If no NAMEs are given, then display the values of variables instead. -f means to use function names only.  -r says to make NAMEs readonly.  -x says to mark NAMEs for export.  -i says that the variable is to be treated as an integer; arithmetic evaluation (see Shell Arithmetic) is performed when the variable is assigned a value.  Using + instead of - turns off the attribute instead.  When used in a function, declare makes NAMEs local, as with the local command.

enable

          enable [-n] [-a] [NAME ...]

     Enable and disable builtin shell commands.  This allows you to use a disk command which has the same name as a shell builtin. If -n is used, the NAMEs become disabled.  Otherwise NAMEs are enabled.  For example, to use the test binary found via $PATH instead of the shell builtin version, type enable -n test.  The -a option means to list each builtin with an indication of whether or not it is enabled.

help

          help [PATTERN]

     Display helpful information about builtin commands.  If PATTERN is specified, help gives detailed help on all commands matching PATTERN, otherwise a list of the builtins is printed.

local

          local NAME[=VALUE]

     For each argument, create a local variable called NAME, and give it VALUE. local can only be used within a function; it makes the variable NAME have a visible scope restricted to that function and its children.

type

          type [-all] [-type | -path] [NAME ...]

     For each NAME, indicate how it would be interpreted if used as a command name.

     If the -type flag is used, type returns a single word which is one of ``alias'', ``function'', ``builtin'', ``file'' or ``keyword'', if NAME is an alias, shell function, shell builtin, disk file, or shell reserved word, respectively.

     If the -path flag is used, type either returns the name of the disk file that would be executed, or nothing if -type would not return ``file''.

     If the -all flag is used, returns all of the places that contain an executable named FILE.  This includes aliases and functions, if and only if the -path flag is not also used.

     Type accepts -a, -t, and -p as equivalent to -all, -type, and -path, respectively.

ulimit

          ulimit [-acdmstfpnuvSH] [LIMIT]

     Ulimit provides control over the resources available to processes started by the shell, on systems that allow such control.  If an option is given, it is interpreted as follows:

     -S
          change and report the soft limit associated with a resource (the default if the -H option is not given).

     -H
          change and report the hard limit associated with a resource.

     -a
          all current limits are reported.

     -c
          the maximum size of core files created.

     -d
          the maximum size of a process's data segment.

     -m
          the maximum resident set size.

     -s
          the maximum stack size.

     -t
          the maximum amount of cpu time in seconds.

     -f
          the maximum size of files created by the shell.

     -p
          the pipe buffer size.

     -n
          the maximum number of open file descriptors.

     -u
          the maximum number of processes available to a single user.

     -v
          the maximum amount of virtual memory available to the process.

     If LIMIT is given, it is the new value of the specified resource. Otherwise, the current value of the specified resource is printed.  If no option is given, then -f is assumed.  Values are in 1024-byte increments, except for -t, which is in seconds, -p, which is in units of 512-byte blocks, and -n and -u, which are unscaled values.

The Set Builtin
===============

This builtin is so overloaded that it deserves its own section.

set

          set [-abefhkmnptuvxldCHP] [-o OPTION] [ARGUMENT ...]

     -a
          Mark variables which are modified or created for export.

     -b
          Cause the status of terminated background jobs to be reported immediately, rather than before printing the next primary prompt.

     -e
          Exit immediately if a command exits with a non-zero status.

     -f
          Disable file name generation (globbing).

     -h
          Locate and remember (hash) commands as functions are defined, rather than when the function is executed.

     -k
          All keyword arguments are placed in the environment for a command, not just those that precede the command name.

     -m
          Job control is enabled (see Job Control).

     -n
          Read commands but do not execute them.

     -o OPTION-NAME

          Set the flag corresponding to OPTION-NAME:

          allexport
               same as -a.

          braceexpand
               the shell will perform brace expansion (see Brace Expansion).

          emacs
               use an emacs-style line editing interface (see Command Line Editing).

          errexit
               same as -e.

          histexpand
               same as -H.

          ignoreeof
               the shell will not exit upon reading EOF.

          interactive-comments
               allow a word beginning with a # to cause that word and all remaining characters on that line to be ignored in an interactive shell.

          monitor
               same as -m.

          noclobber
               same as -C.

          noexec
               same as -n.

          noglob
               same as -f.

          nohash
               same as -d.

          notify
               same as -b.

          nounset
               same as -u.

          physical
               same as -P.

          posix
               change the behavior of Bash where the default operation differs from the Posix 1003.2 standard to match the standard.  This is intended to make Bash behave as a strict superset of that standard.

          privileged
               same as -p.

          verbose
               same as -v.

          vi
               use a vi-style line editing interface.

          xtrace
               same as -x.

     -p
          Turn on privileged mode. In this mode, the $ENV file is not processed, and shell functions are not inherited from the environment.  This is enabled automatically on startup if the effective user (group) id is not equal to the real user (group) id.  Turning this option off causes the effective user and group ids to be set to the real user and group ids.

     -t
          Exit after reading and executing one command.

     -u
          Treat unset variables as an error when substituting.

     -v
          Print shell input lines as they are read.

     -x
          Print commands and their arguments as they are executed.

     -l
          Save and restore the binding of the NAME in a for command.

     -d
          Disable the hashing of commands that are looked up for execution. Normally, commands are remembered in a hash table, and once found, do not have to be looked up again.

     -C
          Disallow output redirection to existing files.

     -H
          Enable ! style history substitution.  This flag is on by default.

     -P
          If set, do not follow symbolic links when performing commands such as cd which change the current directory.  The physical directory is used instead.

     --
          If no arguments follow this flag, then the positional parameters are unset.  Otherwise, the positional parameters are set to the ARGUMENTS, even if some of them begin with a -.

     -
          Signal the end of options, cause all remaining ARGUMENTS to be assigned to the positional parameters.  The -x and -v  options are turned off. If there are no arguments, the positional parameters remain unchanged.

     Using + rather than - causes these flags to be turned off.  The flags can also be used upon invocation of the shell.  The current set of flags may be found in $-.  The remaining N ARGUMENTS are positional parameters and are assigned, in order, to $1, $2, ..  $N.  If no arguments are given, all shell variables are printed.

Bash Variables
==============

These variables are set or used by bash, but other shells do not normally treat them specially.

HISTCONTROL
history_control
     Set to a value of ignorespace, it means don't enter lines which begin with a space or tab into the history list.  Set to a value of ignoredups, it means don't enter lines which match the last entered line.  A value of ignoreboth combines the two options. Unset, or set to any other value than those above, means to save all lines on the history list.

HISTFILE
     The name of the file to which the command history is saved.

HISTSIZE
     If set, this is the maximum number of commands to remember in the history.

histchars
     Up to three characters which control history expansion, quick substitution, and tokenization (see History Interaction). The first character is the history-expansion-char, that is, the character which signifies the start of a history expansion, normally !.  The second character is the character which signifies `quick substitution' when seen as the first character on a line, normally ^.  The optional third character is the character which signifies the remainder of the line is a comment, when found as the first character of a word, usually #.  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.

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

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.  You can change the file interactively; the next time you attempt to complete a hostname, Bash will add the contents of the new file to the already existing database.

MAILCHECK
     How often (in seconds) that the shell should check for mail in the files specified in MAILPATH.

PROMPT_COMMAND
     If present, this contains a string which is a command to execute before the printing of each primary prompt ($PS1).

UID
     The numeric real user id of the current user.

EUID
     The numeric effective user id of the current user.

HOSTTYPE
     A string describing the machine Bash is running on.

OSTYPE
     A string describing the operating system Bash is running on.

FIGNORE
     A colon-separated list of suffixes to ignore when performing filename completion A file name whose suffix matches one of the entries in FIGNORE is excluded from the list of matched file names.  A sample value is .o:~

INPUTRC
     The name of the Readline startup file, overriding the default of ~/.inputrc.

BASH_VERSION
     The version number of the current instance of Bash.

IGNOREEOF
     Controls the action of the shell on receipt of an EOF character as the sole input.  If set, then the value of it is the number of consecutive EOF characters that can be read as the first characters on an input line before the shell will exit.  If the variable exists but does not have a numeric value (or has no value) then the default is 10. If the variable does not exist, then EOF signifies the end of input to the shell.  This is only in effect for interactive shells.

no_exit_on_failed_exec
     If this variable exists, the shell will not exit in the case that it couldn't execute the file specified in the exec command.

nolinks
     If present, says not to follow symbolic links when doing commands that change the current working directory.  By default, bash follows the logical chain of directories when performing commands such as cd which change the current directory.

     For example, if /usr/sys is a link to /usr/local/sys then:

          $ cd /usr/sys; echo $PWD
          /usr/sys
          $ cd ..; pwd
          /usr

     If nolinks exists, then:

          $ cd /usr/sys; echo $PWD
          /usr/local/sys
          $ cd ..; pwd
          /usr/local

     See also the description of the -P option to the set builtin, The Set Builtin.

Shell Arithmetic
================

Arithmetic Evaluation
---------------------

The shell allows arithmetic expressions to be evaluated, as one of the shell expansions or by the let builtin.

Evaluation is done in long integers with no check for overflow, though division by 0 is trapped and flagged as an error.  The following list of operators is grouped into levels of equal-precedence operators.  The levels are listed in order of decreasing precedence.

- +
     unary minus and plus

! ~
     logical and bitwise negation

* / %
     multiplication, division, remainder

+ -
     addition, subtraction

<< >>
     left and right bitwise shifts

<= >= < >
     comparison

== !=
     equality and inequality

&
     bitwise AND

^
     bitwise exclusive OR

|
     bitwise OR

&&
     logical AND

||
     logical OR

= *= /= %= += -= <<= >>= &= ^= |=
     assignment

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

Constants with a leading 0 are interpreted as octal numbers. A leading 0x or 0X denotes hexadecimal.  Otherwise, numbers take the form [BASE#]n, where BASE is a decimal number between 2 and 36 representing the arithmetic base, and N is a number in that base.  If BASE is omitted, then base 10 is used.

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

Arithmetic Expansion
--------------------

Arithmetic expansion allows the evaluation of an arithmetic 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 parentheses is not treated specially.  All tokens in the expression undergo parameter expansion, command substitution, and quote removal.  Arithmetic substitutions may be nested.

The evaluation is performed according to the rules listed above. If the expression is invalid, Bash prints a message indicating failure and no substitution occurs.

Arithmetic Builtins
-------------------

let

          let EXPRESSION [EXPRESSION]

     The let builtin allows arithmetic to be performed on shell variables.  Each EXPRESSION is evaluated according to the rules given previously (see Arithmetic Evaluation).  If the last EXPRESSION evaluates to 0, let returns 1; otherwise 0 is returned.

Controlling the Prompt
======================

The value of the variable $PROMPT_COMMAND is examined just before Bash prints each primary prompt.  If it is set and non-null, then the value is executed just as if you had typed it on the command line.

In addition, the following table describes the special characters which can appear in the PS1 variable:

\t
     the 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 $PWD.

\u
     your username.

\h
     the hostname.

\#
     the command number of this command.

\!
     the history number of this command.

\nnn
     the character corresponding to the octal number nnn.

\$
     if the effective uid is 0, #, otherwise $.

\\
     a backslash.

\[
     begin a sequence of non-printing characters.  This could be used to embed a terminal control sequence into the prompt.

\]
     end a sequence of non-printing characters.

Job Control
***********

This chapter disusses what job control is, how it works, and how Bash allows you to access its facilities.

Job Control Basics
==================

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

The shell associates a JOB with each pipeline.  It keeps a table of currently executing jobs, which may be listed with the jobs command.  When Bash starts a job asynchronously (in the background), it prints a line that looks like:

     [1] 25647

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

If the operating system on which Bash is running supports job control, Bash allows you to use it.  Typing the SUSPEND 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 (typically ^Y, Control-Y) causes the process to be stopped when it attempts to read input from the terminal, and control to be returned to Bash.  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 foreground, or the kill command to kill it.  A ^Z takes effect immediately, and has the additional side effect of causing pending output and typeahead to be discarded.

There are a number of ways to refer to a job in the shell.  The character % introduces a job name.  Job number n may be referred to as %n.  A job may also be referred to using a prefix of the name used to start it, or using a substring that appears in its command line.  For example, %ce refers to a stopped ce job. Using %?ce, on the other hand, refers to any job containing the string ce in its command line.  If the prefix or 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 foreground: %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 the -b option to the set builtin is set, Bash reports such changes immediately (see The Set Builtin). This feature is also controlled by the variable notify.

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.

Job Control Builtins
====================

bg

          bg [JOBSPEC]

     Place JOBSPEC into the background, as if it had been started with &.  If JOBSPEC is not supplied, the current job is used.

fg

          fg [JOBSPEC]

     Bring JOBSPEC into the foreground and make it the current job. If JOBSPEC is not supplied, the current job is used.

jobs

          jobs [-lpn] [JOBSPEC]
          jobs -x COMMAND [JOBSPEC]

     The first form lists the active jobs.  The -l option lists process IDs in addition to the normal information; the -p option lists only the process ID of the job's process group leader.  The -n option displays only jobs that have changed status since last notfied.  If JOBSPEC is given, output is restricted to information about that job. If JOBSPEC is not supplied, the status of all jobs is listed.

     If the -x option is supplied, jobs replaces any JOBSPEC found in COMMAND or ARGUMENTS with the corresponding process group ID, and executes COMMAND, passing it ARGUMENTs, returning its exit status.

suspend

          suspend [-f]

     Suspend the execution of this shell until it receives a SIGCONT signal.  The -f option means to suspend even if the shell is a login shell.

When job control is active, the kill and wait builtins also accept JOBSPEC arguments.

Job Control Variables
=====================

auto_resume
     This variable controls how the shell interacts with the user and job control.  If this variable exists then single word simple commands without redirects are treated as candidates for resumption of an existing job.  There is no ambiguity allowed; if you have more than one job beginning with the string that you have typed, then the most recently accessed job will be selected. The name of a stopped job, in this context, is the command line used to start it.  If this variable is 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 analogous to the %? job id (see Job Control Basics). 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.

notify
     Setting this variable to a value is equivalent to set -b; unsetting it is equivalent to set +b (see The Set Builtin).

     [file hsuser.texinfo not included]
     [file rluser.texinfo not included]