diff options
Diffstat (limited to 'doc/bash.info')
| -rw-r--r-- | doc/bash.info | 11816 |
1 files changed, 11816 insertions, 0 deletions
diff --git a/doc/bash.info b/doc/bash.info new file mode 100644 index 0000000..39f3212 --- /dev/null +++ b/doc/bash.info @@ -0,0 +1,11816 @@ +This is bash.info, produced by makeinfo version 6.5 from +bashref.texi. + +This text is a brief description of the features that are present in the +Bash shell (version 5.0, 7 December 2018). + + This is Edition 5.0, last updated 7 December 2018, of 'The GNU Bash +Reference Manual', for 'Bash', Version 5.0. + + Copyright (C) 1988-2018 Free Software Foundation, Inc. + + Permission is granted to copy, distribute and/or modify this + document under the terms of the GNU Free Documentation License, + Version 1.3 or any later version published by the Free Software + Foundation; with no Invariant Sections, no Front-Cover Texts, and + no Back-Cover Texts. A copy of the license is included in the + section entitled "GNU Free Documentation License". +INFO-DIR-SECTION Basics +START-INFO-DIR-ENTRY +* Bash: (bash). The GNU Bourne-Again SHell. +END-INFO-DIR-ENTRY + + +File: bash.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) + +Bash Features +************* + +This text is a brief description of the features that are present in the +Bash shell (version 5.0, 7 December 2018). The Bash home page is +<http://www.gnu.org/software/bash/>. + + This is Edition 5.0, last updated 7 December 2018, of 'The GNU Bash +Reference Manual', for 'Bash', Version 5.0. + + 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, noting which +features were inspired by other shells and which are specific to Bash. + + 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. + +* Menu: + +* Introduction:: An introduction to the shell. +* Definitions:: Some definitions used in the rest of this + manual. +* Basic Shell Features:: The shell "building blocks". +* Shell Builtin Commands:: Commands that are a part of the shell. +* Shell Variables:: Variables used or set by Bash. +* Bash Features:: Features found only in Bash. +* Job Control:: What job control is and how Bash allows you + to use it. +* Command Line Editing:: Chapter describing the command line + editing features. +* Using History Interactively:: Command History Expansion +* Installing Bash:: How to build and install Bash on your system. +* Reporting Bugs:: How to report bugs in Bash. +* Major Differences From The Bourne Shell:: A terse list of the differences + between Bash and historical + versions of /bin/sh. +* GNU Free Documentation License:: Copying and sharing this documentation. +* Indexes:: Various indexes for this manual. + + +File: bash.info, Node: Introduction, Next: Definitions, Up: Top + +1 Introduction +************** + +* Menu: + +* What is Bash?:: A short description of Bash. +* What is a shell?:: A brief introduction to shells. + + +File: bash.info, Node: What is Bash?, Next: What is a shell?, Up: Introduction + +1.1 What is Bash? +================= + +Bash is the shell, or command language interpreter, for the GNU +operating system. The name is an acronym for the 'Bourne-Again SHell', +a pun on Stephen Bourne, the author of the direct ancestor of the +current Unix shell 'sh', which appeared in the Seventh Edition Bell Labs +Research version of Unix. + + Bash is largely compatible with 'sh' and incorporates useful features +from the Korn shell 'ksh' and the C shell 'csh'. It is intended to be a +conformant implementation of the IEEE POSIX Shell and Tools portion of +the IEEE POSIX specification (IEEE Standard 1003.1). It offers +functional improvements over 'sh' for both interactive and programming +use. + + While the GNU operating system provides other shells, including a +version of 'csh', Bash is the default shell. Like other GNU software, +Bash is quite portable. It currently runs on nearly every version of +Unix and a few other operating systems - independently-supported ports +exist for MS-DOS, OS/2, and Windows platforms. + + +File: bash.info, Node: What is a shell?, Prev: What is Bash?, Up: Introduction + +1.2 What is a shell? +==================== + +At its base, a shell is simply a macro processor that executes commands. +The term macro processor means functionality where text and symbols are +expanded to create larger expressions. + + A Unix shell is both a command interpreter and a programming +language. As a command interpreter, the shell provides the user +interface to the rich set of GNU utilities. The programming language +features allow these utilities to be combined. Files containing +commands can be created, and become commands themselves. These new +commands have the same status as system commands in directories such as +'/bin', allowing users or groups to establish custom environments to +automate their common tasks. + + Shells may be used interactively or non-interactively. In +interactive mode, they accept input typed from the keyboard. When +executing non-interactively, shells execute commands read from a file. + + A shell allows execution of GNU commands, both synchronously and +asynchronously. The shell waits for synchronous commands to complete +before accepting more input; asynchronous commands continue to execute +in parallel with the shell while it reads and executes additional +commands. The "redirection" constructs permit fine-grained control of +the input and output of those commands. Moreover, the shell allows +control over the contents of commands' environments. + + Shells also provide a small set of built-in commands ("builtins") +implementing functionality impossible or inconvenient to obtain via +separate utilities. For example, 'cd', 'break', 'continue', and 'exec' +cannot be implemented outside of the shell because they directly +manipulate the shell itself. The 'history', 'getopts', 'kill', or 'pwd' +builtins, among others, could be implemented in separate utilities, but +they are more convenient to use as builtin commands. All of the shell +builtins are described in subsequent sections. + + While executing commands is essential, most of the power (and +complexity) of shells is due to their embedded programming languages. +Like any high-level language, the shell provides variables, flow control +constructs, quoting, and functions. + + Shells offer features geared specifically for interactive use rather +than to augment the programming language. These interactive features +include job control, command line editing, command history and aliases. +Each of these features is described in this manual. + + +File: bash.info, Node: Definitions, Next: Basic Shell Features, Prev: Introduction, Up: Top + +2 Definitions +************* + +These definitions are used throughout the remainder of this manual. + +'POSIX' + A family of open system standards based on Unix. Bash is primarily + concerned with the Shell and Utilities portion of the POSIX 1003.1 + standard. + +'blank' + A space or tab character. + +'builtin' + A command that is implemented internally by the shell itself, + rather than by an executable program somewhere in the file system. + +'control operator' + A 'token' that performs a control function. It is a 'newline' or + one of the following: '||', '&&', '&', ';', ';;', ';&', ';;&', '|', + '|&', '(', or ')'. + +'exit status' + The value returned by a command to its caller. The value is + restricted to eight bits, so the maximum value is 255. + +'field' + A unit of text that is the result of one of the shell expansions. + After expansion, when executing a command, the resulting fields are + used as the command name and arguments. + +'filename' + A string of characters used to identify a file. + +'job' + A set of processes comprising a pipeline, and any processes + descended from it, that are all in the same process group. + +'job control' + A mechanism by which users can selectively stop (suspend) and + restart (resume) execution of processes. + +'metacharacter' + A character that, when unquoted, separates words. A metacharacter + is a 'space', 'tab', 'newline', or one of the following characters: + '|', '&', ';', '(', ')', '<', or '>'. + +'name' + A 'word' consisting solely of letters, numbers, and underscores, + and beginning with a letter or underscore. 'Name's are used as + shell variable and function names. Also referred to as an + 'identifier'. + +'operator' + A 'control operator' or a 'redirection operator'. *Note + Redirections::, for a list of redirection operators. Operators + contain at least one unquoted 'metacharacter'. + +'process group' + A collection of related processes each having the same process + group ID. + +'process group ID' + A unique identifier that represents a 'process group' during its + lifetime. + +'reserved word' + A 'word' that has a special meaning to the shell. Most reserved + words introduce shell flow control constructs, such as 'for' and + 'while'. + +'return status' + A synonym for 'exit status'. + +'signal' + A mechanism by which a process may be notified by the kernel of an + event occurring in the system. + +'special builtin' + A shell builtin command that has been classified as special by the + POSIX standard. + +'token' + A sequence of characters considered a single unit by the shell. It + is either a 'word' or an 'operator'. + +'word' + A sequence of characters treated as a unit by the shell. Words may + not include unquoted 'metacharacters'. + + +File: bash.info, Node: Basic Shell Features, Next: Shell Builtin Commands, Prev: Definitions, Up: Top + +3 Basic Shell 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, The rules for +evaluation and quoting are taken from the POSIX specification for the +'standard' Unix shell. + + This chapter briefly summarizes the shell's 'building blocks': +commands, control structures, shell functions, shell parameters, shell +expansions, redirections, which are a way to direct input and output +from and to named files, and how the shell executes commands. + +* Menu: + +* Shell Syntax:: What your input means to the shell. +* Shell Commands:: The types of commands you can use. +* Shell Functions:: Grouping commands by name. +* Shell Parameters:: How the shell stores values. +* Shell Expansions:: How Bash expands parameters and the various + expansions available. +* Redirections:: A way to control where input and output go. +* Executing Commands:: What happens when you run a command. +* Shell Scripts:: Executing files of shell commands. + + +File: bash.info, Node: Shell Syntax, Next: Shell Commands, Up: Basic Shell Features + +3.1 Shell Syntax +================ + +* Menu: + +* Shell Operation:: The basic operation of the shell. +* Quoting:: How to remove the special meaning from characters. +* Comments:: How to specify comments. + +When the shell reads input, it proceeds through a sequence of +operations. If the input indicates the beginning of a comment, the +shell ignores the comment symbol ('#'), and the rest of that line. + + Otherwise, roughly speaking, the shell reads its input and divides +the input into words and operators, employing the quoting rules to +select which meanings to assign various words and characters. + + The shell then parses these tokens into commands and other +constructs, removes the special meaning of certain words or characters, +expands others, redirects input and output as needed, executes the +specified command, waits for the command's exit status, and makes that +exit status available for further inspection or processing. + + +File: bash.info, Node: Shell Operation, Next: Quoting, Up: Shell Syntax + +3.1.1 Shell Operation +--------------------- + +The following is a brief description of the shell's operation when it +reads and executes a command. Basically, the shell does the following: + + 1. Reads its input from a file (*note Shell Scripts::), from a string + supplied as an argument to the '-c' invocation option (*note + Invoking Bash::), or from the user's terminal. + + 2. Breaks the input into words and operators, obeying the quoting + rules described in *note Quoting::. These tokens are separated by + 'metacharacters'. Alias expansion is performed by this step (*note + Aliases::). + + 3. Parses the tokens into simple and compound commands (*note Shell + Commands::). + + 4. Performs the various shell expansions (*note Shell Expansions::), + breaking the expanded tokens into lists of filenames (*note + Filename Expansion::) and commands and arguments. + + 5. Performs any necessary redirections (*note Redirections::) and + removes the redirection operators and their operands from the + argument list. + + 6. Executes the command (*note Executing Commands::). + + 7. Optionally waits for the command to complete and collects its exit + status (*note Exit Status::). + + +File: bash.info, Node: Quoting, Next: Comments, Prev: Shell Operation, Up: Shell Syntax + +3.1.2 Quoting +------------- + +* Menu: + +* Escape Character:: How to remove the special meaning from a single + character. +* Single Quotes:: How to inhibit all interpretation of a sequence + of characters. +* Double Quotes:: How to suppress most of the interpretation of a + sequence of characters. +* ANSI-C Quoting:: How to expand ANSI-C sequences in quoted strings. +* Locale Translation:: How to translate strings into different languages. + +Quoting is used to remove the special meaning of certain characters or +words to the shell. Quoting can be used to disable special treatment +for special characters, to prevent reserved words from being recognized +as such, and to prevent parameter expansion. + + Each of the shell metacharacters (*note Definitions::) has special +meaning to the shell and must be quoted if it is to represent itself. +When the command history expansion facilities are being used (*note +History Interaction::), the HISTORY EXPANSION character, usually '!', +must be quoted to prevent history expansion. *Note Bash History +Facilities::, for more details concerning history expansion. + + There are three quoting mechanisms: the ESCAPE CHARACTER, single +quotes, and double quotes. + + +File: bash.info, Node: Escape Character, Next: Single Quotes, Up: Quoting + +3.1.2.1 Escape Character +........................ + +A non-quoted backslash '\' is the Bash 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 itself is +not quoted, the '\newline' is treated as a line continuation (that is, +it is removed from the input stream and effectively ignored). + + +File: bash.info, Node: Single Quotes, Next: Double Quotes, Prev: Escape Character, Up: Quoting + +3.1.2.2 Single Quotes +..................... + +Enclosing characters in single quotes (''') preserves the literal value +of each character within the quotes. A single quote may not occur +between single quotes, even when preceded by a backslash. + + +File: bash.info, Node: Double Quotes, Next: ANSI-C Quoting, Prev: Single Quotes, Up: Quoting + +3.1.2.3 Double Quotes +..................... + +Enclosing characters in double quotes ('"') preserves the literal value +of all characters within the quotes, with the exception of '$', '`', +'\', and, when history expansion is enabled, '!'. When the shell is in +POSIX mode (*note Bash POSIX Mode::), the '!' has no special meaning +within double quotes, even when history expansion is enabled. The +characters '$' and '`' retain their special meaning within double quotes +(*note Shell Expansions::). The backslash retains its special meaning +only when followed by one of the following characters: '$', '`', '"', +'\', or 'newline'. Within double quotes, backslashes that are followed +by one of these characters are removed. Backslashes preceding +characters without a special meaning are left unmodified. A double +quote may be quoted within double quotes by preceding it with a +backslash. If enabled, history expansion will be performed unless an +'!' appearing in double quotes is escaped using a backslash. The +backslash preceding the '!' is not removed. + + The special parameters '*' and '@' have special meaning when in +double quotes (*note Shell Parameter Expansion::). + + +File: bash.info, Node: ANSI-C Quoting, Next: Locale Translation, Prev: Double Quotes, Up: Quoting + +3.1.2.4 ANSI-C Quoting +...................... + +Words of the form '$'STRING'' are treated specially. The word expands +to STRING, with backslash-escaped characters replaced as specified by +the ANSI C standard. Backslash escape sequences, if present, are +decoded as follows: + +'\a' + alert (bell) +'\b' + backspace +'\e' +'\E' + an escape character (not ANSI C) +'\f' + form feed +'\n' + newline +'\r' + carriage return +'\t' + horizontal tab +'\v' + vertical tab +'\\' + backslash +'\'' + single quote +'\"' + double quote +'\?' + question mark +'\NNN' + the eight-bit character whose value is the octal value NNN (one to + three octal digits) +'\xHH' + the eight-bit character whose value is the hexadecimal value HH + (one or two hex digits) +'\uHHHH' + the Unicode (ISO/IEC 10646) character whose value is the + hexadecimal value HHHH (one to four hex digits) +'\UHHHHHHHH' + the Unicode (ISO/IEC 10646) character whose value is the + hexadecimal value HHHHHHHH (one to eight hex digits) +'\cX' + a control-X character + +The expanded result is single-quoted, as if the dollar sign had not been +present. + + +File: bash.info, Node: Locale Translation, Prev: ANSI-C Quoting, Up: Quoting + +3.1.2.5 Locale-Specific Translation +................................... + +A double-quoted string preceded by a dollar sign ('$') will cause the +string to be translated according to the current locale. If the current +locale is 'C' or 'POSIX', the dollar sign is ignored. If the string is +translated and replaced, the replacement is double-quoted. + + Some systems use the message catalog selected by the 'LC_MESSAGES' +shell variable. Others create the name of the message catalog from the +value of the 'TEXTDOMAIN' shell variable, possibly adding a suffix of +'.mo'. If you use the 'TEXTDOMAIN' variable, you may need to set the +'TEXTDOMAINDIR' variable to the location of the message catalog files. +Still others use both variables in this fashion: +'TEXTDOMAINDIR'/'LC_MESSAGES'/LC_MESSAGES/'TEXTDOMAIN'.mo. + + +File: bash.info, Node: Comments, Prev: Quoting, Up: Shell Syntax + +3.1.3 Comments +-------------- + +In a non-interactive shell, or an interactive shell in which the +'interactive_comments' option to the 'shopt' builtin is enabled (*note +The Shopt Builtin::), a word beginning with '#' causes that word and all +remaining characters on that line to be ignored. An interactive shell +without the 'interactive_comments' option enabled does not allow +comments. The 'interactive_comments' option is on by default in +interactive shells. *Note Interactive Shells::, for a description of +what makes a shell interactive. + + +File: bash.info, Node: Shell Commands, Next: Shell Functions, Prev: Shell Syntax, Up: Basic Shell Features + +3.2 Shell Commands +================== + +A simple shell command such as 'echo a b c' consists of the command +itself followed by arguments, separated by spaces. + + More complex shell commands are composed of simple commands arranged +together in a variety of ways: in a pipeline in which the output of one +command becomes the input of a second, in a loop or conditional +construct, or in some other grouping. + +* Menu: + +* Simple Commands:: The most common type of command. +* Pipelines:: Connecting the input and output of several + commands. +* Lists:: How to execute commands sequentially. +* Compound Commands:: Shell commands for control flow. +* Coprocesses:: Two-way communication between commands. +* GNU Parallel:: Running commands in parallel. + + +File: bash.info, Node: Simple Commands, Next: Pipelines, Up: Shell Commands + +3.2.1 Simple Commands +--------------------- + +A simple command is the kind of command encountered most often. It's +just a sequence of words separated by 'blank's, terminated by one of the +shell's control operators (*note Definitions::). The first word +generally specifies a command to be executed, with the rest of the words +being that command's arguments. + + The return status (*note Exit Status::) of a simple command is its +exit status as provided by the POSIX 1003.1 'waitpid' function, or 128+N +if the command was terminated by signal N. + + +File: bash.info, Node: Pipelines, Next: Lists, Prev: Simple Commands, Up: Shell Commands + +3.2.2 Pipelines +--------------- + +A 'pipeline' is a sequence of one or more commands separated by one of +the control operators '|' or '|&'. + + The format for a pipeline is + [time [-p]] [!] COMMAND1 [ | or |& COMMAND2 ] ... + +The output of each command in the pipeline is connected via a pipe to +the input of the next command. That is, each command reads the previous +command's output. This connection is performed before any redirections +specified by the command. + + If '|&' is used, COMMAND1's standard error, in addition to its +standard output, is connected to COMMAND2's standard input through the +pipe; it is shorthand for '2>&1 |'. This implicit redirection of the +standard error to the standard output is performed after any +redirections specified by the command. + + The reserved word 'time' causes timing statistics to be printed for +the pipeline once it finishes. The statistics currently consist of +elapsed (wall-clock) time and user and system time consumed by the +command's execution. The '-p' option changes the output format to that +specified by POSIX. When the shell is in POSIX mode (*note Bash POSIX +Mode::), it does not recognize 'time' as a reserved word if the next +token begins with a '-'. The 'TIMEFORMAT' variable may be set to a +format string that specifies how the timing information should be +displayed. *Note Bash Variables::, for a description of the available +formats. The use of 'time' as a reserved word permits the timing of +shell builtins, shell functions, and pipelines. An external 'time' +command cannot time these easily. + + When the shell is in POSIX mode (*note Bash POSIX Mode::), 'time' may +be followed by a newline. In this case, the shell displays the total +user and system time consumed by the shell and its children. The +'TIMEFORMAT' variable may be used to specify the format of the time +information. + + If the pipeline is not executed asynchronously (*note Lists::), the +shell waits for all commands in the pipeline to complete. + + Each command in a pipeline is executed in its own subshell, which is +a separate process (*note Command Execution Environment::). If the +'lastpipe' option is enabled using the 'shopt' builtin (*note The Shopt +Builtin::), the last element of a pipeline may be run by the shell +process. + + The exit status of a pipeline is the exit status of the last command +in the pipeline, unless the 'pipefail' option is enabled (*note The Set +Builtin::). If 'pipefail' is enabled, the pipeline's return status is +the value of the last (rightmost) command to exit with a non-zero +status, or zero if all commands exit successfully. If the reserved word +'!' precedes the pipeline, the exit status is the logical negation of +the exit status as described above. The shell waits for all commands in +the pipeline to terminate before returning a value. + + +File: bash.info, Node: Lists, Next: Compound Commands, Prev: Pipelines, Up: Shell Commands + +3.2.3 Lists of Commands +----------------------- + +A 'list' is a sequence of one or more pipelines separated by one of the +operators ';', '&', '&&', or '||', and optionally terminated by one of +';', '&', or a 'newline'. + + Of these list operators, '&&' and '||' have equal precedence, +followed by ';' and '&', which have equal precedence. + + A sequence of one or more newlines may appear in a 'list' to delimit +commands, equivalent to a semicolon. + + If a command is terminated by the control operator '&', the shell +executes the command asynchronously in a subshell. This is known as +executing the command in the BACKGROUND, and these are referred to as +ASYNCHRONOUS commands. The shell does not wait for the command to +finish, and the return status is 0 (true). When job control is not +active (*note Job Control::), the standard input for asynchronous +commands, in the absence of any explicit redirections, is redirected +from '/dev/null'. + + Commands separated by a ';' are executed sequentially; the shell +waits for each command to terminate in turn. The return status is the +exit status of the last command executed. + + AND and OR lists are sequences of one or more pipelines separated by +the control operators '&&' and '||', respectively. AND and OR lists are +executed with left associativity. + + An AND list has the form + COMMAND1 && COMMAND2 + +COMMAND2 is executed if, and only if, COMMAND1 returns an exit status of +zero (success). + + An OR list has the form + COMMAND1 || COMMAND2 + +COMMAND2 is executed if, and only if, COMMAND1 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. + + +File: bash.info, Node: Compound Commands, Next: Coprocesses, Prev: Lists, Up: Shell Commands + +3.2.4 Compound Commands +----------------------- + +* Menu: + +* Looping Constructs:: Shell commands for iterative action. +* Conditional Constructs:: Shell commands for conditional execution. +* Command Grouping:: Ways to group commands. + +Compound commands are the shell programming language constructs. Each +construct begins with a reserved word or control operator and is +terminated by a corresponding reserved word or operator. Any +redirections (*note Redirections::) associated with a compound command +apply to all commands within that compound command unless explicitly +overridden. + + In most cases a list of commands in a compound command's description +may be separated from the rest of the command by one or more newlines, +and may be followed by a newline in place of a semicolon. + + Bash provides looping constructs, conditional commands, and +mechanisms to group commands and execute them as a unit. + + +File: bash.info, Node: Looping Constructs, Next: Conditional Constructs, Up: Compound Commands + +3.2.4.1 Looping Constructs +.......................... + +Bash supports the following looping constructs. + + Note that wherever a ';' appears in the description of a command's +syntax, it may be replaced with one or more newlines. + +'until' + The syntax of the 'until' command is: + + until TEST-COMMANDS; do CONSEQUENT-COMMANDS; done + + Execute CONSEQUENT-COMMANDS as long as TEST-COMMANDS has an exit + status which is not zero. The return status is the exit status of + the last command executed in CONSEQUENT-COMMANDS, or zero if none + was executed. + +'while' + The syntax of the 'while' command is: + + while TEST-COMMANDS; do CONSEQUENT-COMMANDS; done + + Execute CONSEQUENT-COMMANDS as long as TEST-COMMANDS has an exit + status of zero. The return status is the exit status of the last + command executed in CONSEQUENT-COMMANDS, or zero if none was + executed. + +'for' + The syntax of the 'for' command is: + + for NAME [ [in [WORDS ...] ] ; ] do COMMANDS; done + + Expand WORDS (*note Shell Expansions::), and execute COMMANDS once + for each member in the resultant list, with NAME bound to the + current member. If 'in WORDS' is not present, the 'for' command + executes the COMMANDS once for each positional parameter that is + set, as if 'in "$@"' had been specified (*note Special + Parameters::). + + The return status is the exit status of the last command that + executes. If there are no items in the expansion of WORDS, no + commands are executed, and the return status is zero. + + An alternate form of the 'for' command is also supported: + + for (( EXPR1 ; EXPR2 ; EXPR3 )) ; do COMMANDS ; done + + First, the arithmetic expression EXPR1 is evaluated according to + the rules described below (*note Shell Arithmetic::). The + arithmetic expression EXPR2 is then evaluated repeatedly until it + evaluates to zero. Each time EXPR2 evaluates to a non-zero value, + COMMANDS are executed and the arithmetic expression EXPR3 is + evaluated. If any expression is omitted, it behaves as if it + evaluates to 1. The return value is the exit status of the last + command in COMMANDS that is executed, or false if any of the + expressions is invalid. + + The 'break' and 'continue' builtins (*note Bourne Shell Builtins::) +may be used to control loop execution. + + +File: bash.info, Node: Conditional Constructs, Next: Command Grouping, Prev: Looping Constructs, Up: Compound Commands + +3.2.4.2 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 + + The TEST-COMMANDS list is executed, and if its return status is + zero, the CONSEQUENT-COMMANDS list is executed. If TEST-COMMANDS + returns a non-zero status, 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 + ALTERNATE-CONSEQUENTS is executed. The return status is the exit + status of the last command executed, or zero if no condition tested + true. + +'case' + The syntax of the 'case' command is: + + case WORD in + [ [(] PATTERN [| PATTERN]...) COMMAND-LIST ;;]... + esac + + 'case' will selectively execute the COMMAND-LIST corresponding to + the first PATTERN that matches WORD. The match is performed + according to the rules described below in *note Pattern Matching::. + If the 'nocasematch' shell option (see the description of 'shopt' + in *note The Shopt Builtin::) is enabled, the match is performed + without regard to the case of alphabetic characters. The '|' is + used to separate multiple patterns, and the ')' operator terminates + a pattern list. A list of patterns and an associated command-list + is known as a CLAUSE. + + Each clause must be terminated with ';;', ';&', or ';;&'. The WORD + undergoes tilde expansion, parameter expansion, command + substitution, arithmetic expansion, and quote removal (*note Shell + Parameter Expansion::) before matching is attempted. Each PATTERN + undergoes tilde expansion, parameter expansion, command + substitution, and arithmetic expansion. + + There may be an arbitrary number of 'case' clauses, each terminated + by a ';;', ';&', or ';;&'. The first pattern that matches + determines the command-list that is executed. It's a common idiom + to use '*' as the final pattern to define the default case, since + that pattern will always match. + + Here is an example using 'case' in a script that could be used to + describe one 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." + + + If the ';;' operator is used, no subsequent matches are attempted + after the first pattern match. Using ';&' in place of ';;' causes + execution to continue with the COMMAND-LIST associated with the + next clause, if any. Using ';;&' in place of ';;' causes the shell + to test the patterns in the next clause, if any, and execute any + associated COMMAND-LIST on a successful match. + + The return status is zero if no PATTERN is matched. Otherwise, the + return status is the exit status of the COMMAND-LIST executed. + +'select' + + The 'select' construct allows the easy generation of menus. It has + almost the same syntax as the 'for' command: + + 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 + output stream, each preceded by a number. If the 'in WORDS' is + omitted, the positional parameters are printed, as if 'in "$@"' had + been specified. The 'PS3' prompt is then displayed and a line is + read from the standard input. If the line consists of a number + corresponding to one of the displayed words, then the value of NAME + is set to that word. If the line is empty, the words and prompt + are displayed again. If 'EOF' is read, the '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' + command is executed, at which point the 'select' command completes. + + Here is an example that allows the user to pick a filename from the + current directory, and displays the name and index of the file + selected. + + select fname in *; + do + echo you picked $fname \($REPLY\) + break; + done + +'((...))' + (( EXPRESSION )) + + The arithmetic EXPRESSION is evaluated according to the rules + described below (*note Shell Arithmetic::). If the value of the + expression is non-zero, the return status is 0; otherwise the + return status is 1. This is exactly equivalent to + let "EXPRESSION" + *Note Bash Builtins::, for a full description of the 'let' builtin. + +'[[...]]' + [[ EXPRESSION ]] + + Return a status of 0 or 1 depending on the evaluation of the + conditional expression EXPRESSION. Expressions are composed of the + primaries described below in *note Bash Conditional Expressions::. + Word splitting and filename expansion are not performed on the + words between the '[[' and ']]'; tilde expansion, parameter and + variable expansion, arithmetic expansion, command substitution, + process substitution, and quote removal are performed. Conditional + operators such as '-f' must be unquoted to be recognized as + primaries. + + When used with '[[', the '<' and '>' operators sort + lexicographically using the current locale. + + When the '==' and '!=' operators are used, the string to the right + of the operator is considered a pattern and matched according to + the rules described below in *note Pattern Matching::, as if the + 'extglob' shell option were enabled. The '=' operator is identical + to '=='. If the 'nocasematch' shell option (see the description of + 'shopt' in *note The Shopt Builtin::) is enabled, the match is + performed without regard to the case of alphabetic characters. The + return value is 0 if the string matches ('==') or does not match + ('!=') the pattern, and 1 otherwise. Any part of the pattern may + be quoted to force the quoted portion to be matched as a string. + + An additional binary operator, '=~', is available, with the same + precedence as '==' and '!='. When it is used, the string to the + right of the operator is considered a POSIX extended regular + expression and matched accordingly (as in regex3)). The return + value is 0 if the string matches the pattern, and 1 otherwise. If + the regular expression is syntactically incorrect, the conditional + expression's return value is 2. If the 'nocasematch' shell option + (see the description of 'shopt' in *note The Shopt Builtin::) is + enabled, the match is performed without regard to the case of + alphabetic characters. Any part of the pattern may be quoted to + force the quoted portion to be matched as a string. Bracket + expressions in regular expressions must be treated carefully, since + normal quoting characters lose their meanings between brackets. If + the pattern is stored in a shell variable, quoting the variable + expansion forces the entire pattern to be matched as a string. + Substrings matched by parenthesized subexpressions within the + regular expression are saved in the array variable 'BASH_REMATCH'. + The element of 'BASH_REMATCH' with index 0 is the portion of the + string matching the entire regular expression. The element of + 'BASH_REMATCH' with index N is the portion of the string matching + the Nth parenthesized subexpression. + + For example, the following will match a line (stored in the shell + variable LINE) if there is a sequence of characters in the value + consisting of any number, including zero, of space characters, zero + or one instances of 'a', then a 'b': + [[ $line =~ [[:space:]]*?(a)b ]] + + That means values like 'aab' and ' aaaaaab' will match, as will a + line containing a 'b' anywhere in its value. + + Storing the regular expression in a shell variable is often a + useful way to avoid problems with quoting characters that are + special to the shell. It is sometimes difficult to specify a + regular expression literally without using quotes, or to keep track + of the quoting used by regular expressions while paying attention + to the shell's quote removal. Using a shell variable to store the + pattern decreases these problems. For example, the following is + equivalent to the above: + pattern='[[:space:]]*?(a)b' + [[ $line =~ $pattern ]] + + If you want to match a character that's special to the regular + expression grammar, it has to be quoted to remove its special + meaning. This means that in the pattern 'xxx.txt', the '.' matches + any character in the string (its usual regular expression meaning), + but in the pattern '"xxx.txt"' it can only match a literal '.'. + Shell programmers should take special care with backslashes, since + backslashes are used both by the shell and regular expressions to + remove the special meaning from the following character. The + following two sets of commands are _not_ equivalent: + pattern='\.' + + [[ . =~ $pattern ]] + [[ . =~ \. ]] + + [[ . =~ "$pattern" ]] + [[ . =~ '\.' ]] + + The first two matches will succeed, but the second two will not, + because in the second two the backslash will be part of the pattern + to be matched. In the first two examples, the backslash removes + the special meaning from '.', so the literal '.' matches. If the + string in the first examples were anything other than '.', say 'a', + the pattern would not match, because the quoted '.' in the pattern + loses its special meaning of matching any single character. + + Expressions may be combined using the following operators, listed + in decreasing order of precedence: + + '( EXPRESSION )' + Returns the value of EXPRESSION. This may be used to override + the normal precedence of operators. + + '! EXPRESSION' + True if EXPRESSION is false. + + 'EXPRESSION1 && EXPRESSION2' + True if both EXPRESSION1 and EXPRESSION2 are true. + + 'EXPRESSION1 || EXPRESSION2' + True if either EXPRESSION1 or EXPRESSION2 is true. + + The '&&' and '||' operators do not evaluate EXPRESSION2 if the + value of EXPRESSION1 is sufficient to determine the return value of + the entire conditional expression. + + +File: bash.info, Node: Command Grouping, Prev: Conditional Constructs, Up: Compound Commands + +3.2.4.3 Grouping Commands +......................... + +Bash provides two ways to group a list of commands to be executed as a +unit. When commands are grouped, redirections may be applied to the +entire command list. For example, the output of all the commands in the +list may be redirected to a single stream. + +'()' + ( LIST ) + + Placing a list of commands between parentheses causes a subshell + environment to be created (*note Command Execution Environment::), + and each of the commands in LIST to be executed in that subshell. + Since the LIST is executed in a subshell, variable assignments do + not remain in effect after the subshell completes. + +'{}' + { LIST; } + + Placing a list of commands between curly braces causes the list to + be executed in the current shell context. No subshell is created. + The semicolon (or newline) following LIST is required. + + In addition to the creation of a subshell, there is a subtle +difference between these two constructs due to historical reasons. The +braces are 'reserved words', so they must be separated from the LIST by +'blank's or other shell metacharacters. The parentheses are +'operators', and are recognized as separate tokens by the shell even if +they are not separated from the LIST by whitespace. + + The exit status of both of these constructs is the exit status of +LIST. + + +File: bash.info, Node: Coprocesses, Next: GNU Parallel, Prev: Compound Commands, Up: Shell Commands + +3.2.5 Coprocesses +----------------- + +A 'coprocess' is a shell command preceded by the 'coproc' reserved word. +A coprocess is executed asynchronously in a subshell, as if the command +had been terminated with the '&' control operator, with a two-way pipe +established between the executing shell and the coprocess. + + The format for a coprocess is: + coproc [NAME] COMMAND [REDIRECTIONS] + +This creates a coprocess named NAME. If NAME is not supplied, the +default name is COPROC. NAME must not be supplied if COMMAND is a +simple command (*note Simple Commands::); otherwise, it is interpreted +as the first word of the simple command. + + When the coprocess is executed, the shell creates an array variable +(*note Arrays::) named 'NAME' in the context of the executing shell. +The standard output of COMMAND is connected via a pipe to a file +descriptor in the executing shell, and that file descriptor is assigned +to 'NAME'[0]. The standard input of COMMAND is connected via a pipe to +a file descriptor in the executing shell, and that file descriptor is +assigned to 'NAME'[1]. This pipe is established before any redirections +specified by the command (*note Redirections::). The file descriptors +can be utilized as arguments to shell commands and redirections using +standard word expansions. Other than those created to execute command +and process substitutions, the file descriptors are not available in +subshells. + + The process ID of the shell spawned to execute the coprocess is +available as the value of the variable 'NAME'_PID. The 'wait' builtin +command may be used to wait for the coprocess to terminate. + + Since the coprocess is created as an asynchronous command, the +'coproc' command always returns success. The return status of a +coprocess is the exit status of COMMAND. + + +File: bash.info, Node: GNU Parallel, Prev: Coprocesses, Up: Shell Commands + +3.2.6 GNU Parallel +------------------ + +There are ways to run commands in parallel that are not built into Bash. +GNU Parallel is a tool to do just that. + + GNU Parallel, as its name suggests, can be used to build and run +commands in parallel. You may run the same command with different +arguments, whether they are filenames, usernames, hostnames, or lines +read from files. GNU Parallel provides shorthand references to many of +the most common operations (input lines, various portions of the input +line, different ways to specify the input source, and so on). Parallel +can replace 'xargs' or feed commands from its input sources to several +different instances of Bash. + + For a complete description, refer to the GNU Parallel documentation. +A few examples should provide a brief introduction to its use. + + For example, it is easy to replace 'xargs' to gzip all html files in +the current directory and its subdirectories: + find . -type f -name '*.html' -print | parallel gzip +If you need to protect special characters such as newlines in file +names, use find's '-print0' option and parallel's '-0' option. + + You can use Parallel to move files from the current directory when +the number of files is too large to process with one 'mv' invocation: + ls | parallel mv {} destdir + + As you can see, the {} is replaced with each line read from standard +input. While using 'ls' will work in most instances, it is not +sufficient to deal with all filenames. If you need to accommodate +special characters in filenames, you can use + + find . -depth 1 \! -name '.*' -print0 | parallel -0 mv {} destdir + +as alluded to above. + + This will run as many 'mv' commands as there are files in the current +directory. You can emulate a parallel 'xargs' by adding the '-X' +option: + find . -depth 1 \! -name '.*' -print0 | parallel -0 -X mv {} destdir + + GNU Parallel can replace certain common idioms that operate on lines +read from a file (in this case, filenames listed one per line): + while IFS= read -r x; do + do-something1 "$x" "config-$x" + do-something2 < "$x" + done < file | process-output + +with a more compact syntax reminiscent of lambdas: + cat list | parallel "do-something1 {} config-{} ; do-something2 < {}" | + process-output + + Parallel provides a built-in mechanism to remove filename extensions, +which lends itself to batch file transformations or renaming: + ls *.gz | parallel -j+0 "zcat {} | bzip2 >{.}.bz2 && rm {}" +This will recompress all files in the current directory with names +ending in .gz using bzip2, running one job per CPU (-j+0) in parallel. +(We use 'ls' for brevity here; using 'find' as above is more robust in +the face of filenames containing unexpected characters.) Parallel can +take arguments from the command line; the above can also be written as + + parallel "zcat {} | bzip2 >{.}.bz2 && rm {}" ::: *.gz + + If a command generates output, you may want to preserve the input +order in the output. For instance, the following command + { + echo foss.org.my ; + echo debian.org ; + echo freenetproject.org ; + } | parallel traceroute +will display as output the traceroute invocation that finishes first. +Adding the '-k' option + { + echo foss.org.my ; + echo debian.org ; + echo freenetproject.org ; + } | parallel -k traceroute +will ensure that the output of 'traceroute foss.org.my' is displayed +first. + + Finally, Parallel can be used to run a sequence of shell commands in +parallel, similar to 'cat file | bash'. It is not uncommon to take a +list of filenames, create a series of shell commands to operate on them, +and feed that list of commands to a shell. Parallel can speed this up. +Assuming that 'file' contains a list of shell commands, one per line, + + parallel -j 10 < file + +will evaluate the commands using the shell (since no explicit command is +supplied as an argument), in blocks of ten shell jobs at a time. + + +File: bash.info, Node: Shell Functions, Next: Shell Parameters, Prev: Shell Commands, Up: Basic Shell Features + +3.3 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. When the name of a shell function is used as a simple command +name, the list of commands associated with that function name is +executed. Shell functions are executed in the current shell context; no +new process is created to interpret them. + + Functions are declared using this syntax: + NAME () COMPOUND-COMMAND [ REDIRECTIONS ] + + or + + function NAME [()] COMPOUND-COMMAND [ REDIRECTIONS ] + + This defines a shell function named NAME. The reserved word +'function' is optional. If the 'function' reserved word is supplied, +the parentheses are optional. The BODY of the function is the compound +command COMPOUND-COMMAND (*note Compound Commands::). That command is +usually a LIST enclosed between { and }, but may be any compound command +listed above, with one exception: If the 'function' reserved word is +used, but the parentheses are not supplied, the braces are required. +COMPOUND-COMMAND is executed whenever NAME is specified as the name of a +command. When the shell is in POSIX mode (*note Bash POSIX Mode::), +NAME may not be the same as one of the special builtins (*note Special +Builtins::). Any redirections (*note Redirections::) associated with +the shell function are performed when the function is executed. + + A function definition may be deleted using the '-f' option to the +'unset' builtin (*note Bourne Shell Builtins::). + + The exit status of a function definition is zero unless a syntax +error occurs or a readonly function with the same name already exists. +When executed, the exit status of a function is the exit status of the +last command executed in the body. + + Note that for historical reasons, in the most common usage the curly +braces that surround the body of the function must be separated from the +body by 'blank's or newlines. This is because the braces are reserved +words and are only recognized as such when they are separated from the +command list by whitespace or another shell metacharacter. Also, when +using the braces, the LIST must be terminated by a semicolon, a '&', or +a newline. + + When a function is executed, the arguments to the function become the +positional parameters during its execution (*note Positional +Parameters::). The special parameter '#' that expands to the number of +positional parameters is updated to reflect the change. Special +parameter '0' is unchanged. The first element of the 'FUNCNAME' +variable is set to the name of the function while the function is +executing. + + All other aspects of the shell execution environment are identical +between a function and its caller with these exceptions: the 'DEBUG' and +'RETURN' traps are not inherited unless the function has been given the +'trace' attribute using the 'declare' builtin or the '-o functrace' +option has been enabled with the 'set' builtin, (in which case all +functions inherit the 'DEBUG' and 'RETURN' traps), and the 'ERR' trap is +not inherited unless the '-o errtrace' shell option has been enabled. +*Note Bourne Shell Builtins::, for the description of the 'trap' +builtin. + + The 'FUNCNEST' variable, if set to a numeric value greater than 0, +defines a maximum function nesting level. Function invocations that +exceed the limit cause the entire command to abort. + + If the builtin command 'return' is executed in a function, the +function completes and execution resumes with the next command after the +function call. Any command associated with the 'RETURN' trap is +executed before execution resumes. When a function completes, the +values of the positional parameters and the special parameter '#' are +restored to the values they had prior to the function's execution. If a +numeric argument is given to 'return', that is the function's return +status; otherwise the function's return status is the exit status of the +last command executed before the 'return'. + + Variables local to the function may be declared with the 'local' +builtin. These variables are visible only to the function and the +commands it invokes. This is particularly important when a shell +function calls other functions. + + Local variables "shadow" variables with the same name declared at +previous scopes. For instance, a local variable declared in a function +hides a global variable of the same name: references and assignments +refer to the local variable, leaving the global variable unmodified. +When the function returns, the global variable is once again visible. + + The shell uses DYNAMIC SCOPING to control a variable's visibility +within functions. With dynamic scoping, visible variables and their +values are a result of the sequence of function calls that caused +execution to reach the current function. The value of a variable that a +function sees depends on its value within its caller, if any, whether +that caller is the "global" scope or another shell function. This is +also the value that a local variable declaration "shadows", and the +value that is restored when the function returns. + + For example, if a variable VAR is declared as local in function +FUNC1, and FUNC1 calls another function FUNC2, references to VAR made +from within FUNC2 will resolve to the local variable VAR from FUNC1, +shadowing any global variable named VAR. + + The following script demonstrates this behavior. When executed, the +script displays + + In func2, var = func1 local + + func1() + { + local var='func1 local' + func2 + } + + func2() + { + echo "In func2, var = $var" + } + + var=global + func1 + + The 'unset' builtin also acts using the same dynamic scope: if a +variable is local to the current scope, 'unset' will unset it; otherwise +the unset will refer to the variable found in any calling scope as +described above. If a variable at the current local scope is unset, it +will remain so until it is reset in that scope or until the function +returns. Once the function returns, any instance of the variable at a +previous scope will become visible. If the unset acts on a variable at +a previous scope, any instance of a variable with that name that had +been shadowed will become visible. + + Function names and definitions may be listed with the '-f' option to +the 'declare' ('typeset') builtin command (*note Bash Builtins::). The +'-F' option to 'declare' or 'typeset' will list the function names only +(and optionally the source file and line number, if the 'extdebug' shell +option is enabled). Functions may be exported so that subshells +automatically have them defined with the '-f' option to the 'export' +builtin (*note Bourne Shell Builtins::). + + Functions may be recursive. The 'FUNCNEST' variable may be used to +limit the depth of the function call stack and restrict the number of +function invocations. By default, no limit is placed on the number of +recursive calls. + + +File: bash.info, Node: Shell Parameters, Next: Shell Expansions, Prev: Shell Functions, Up: Basic Shell Features + +3.4 Shell Parameters +==================== + +* Menu: + +* Positional Parameters:: The shell's command-line arguments. +* Special Parameters:: Parameters denoted by special characters. + +A PARAMETER is an entity that stores values. It can be a 'name', a +number, or one of the special characters listed below. A VARIABLE is a +parameter denoted by a 'name'. A variable has a VALUE and zero or more +ATTRIBUTES. Attributes are assigned using the 'declare' builtin command +(see the description of the 'declare' builtin in *note Bash Builtins::). + + 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. + + A variable may be assigned to by a statement of the form + NAME=[VALUE] +If VALUE is not given, the variable is assigned the null string. All +VALUEs undergo tilde expansion, parameter and variable expansion, +command substitution, arithmetic expansion, and quote removal (detailed +below). If the variable has its 'integer' attribute set, then VALUE is +evaluated as an arithmetic expression even if the '$((...))' expansion +is not used (*note Arithmetic Expansion::). Word splitting is not +performed, with the exception of '"$@"' as explained below. Filename +expansion is not performed. Assignment statements may also appear as +arguments to the 'alias', 'declare', 'typeset', 'export', 'readonly', +and 'local' builtin commands (DECLARATION commands). When in POSIX mode +(*note Bash POSIX Mode::), these builtins may appear in a command after +one or more instances of the 'command' builtin and retain these +assignment statement properties. + + In the context where an assignment statement is assigning a value to +a shell variable or array index (*note Arrays::), the '+=' operator can +be used to append to or add to the variable's previous value. This +includes arguments to builtin commands such as 'declare' that accept +assignment statements (DECLARATION commands). When '+=' is applied to a +variable for which the INTEGER attribute has been set, VALUE is +evaluated as an arithmetic expression and added to the variable's +current value, which is also evaluated. When '+=' is applied to an +array variable using compound assignment (*note Arrays::), the +variable's value is not unset (as it is when using '='), and new values +are appended to the array beginning at one greater than the array's +maximum index (for indexed arrays), or added as additional key-value +pairs in an associative array. When applied to a string-valued +variable, VALUE is expanded and appended to the variable's value. + + A variable can be assigned the NAMEREF attribute using the '-n' +option to the 'declare' or 'local' builtin commands (*note Bash +Builtins::) to create a NAMEREF, or a reference to another variable. +This allows variables to be manipulated indirectly. Whenever the +nameref variable is referenced, assigned to, unset, or has its +attributes modified (other than using or changing the nameref attribute +itself), the operation is actually performed on the variable specified +by the nameref variable's value. A nameref is commonly used within +shell functions to refer to a variable whose name is passed as an +argument to the function. For instance, if a variable name is passed to +a shell function as its first argument, running + declare -n ref=$1 +inside the function creates a nameref variable REF whose value is the +variable name passed as the first argument. References and assignments +to REF, and changes to its attributes, are treated as references, +assignments, and attribute modifications to the variable whose name was +passed as '$1'. + + If the control variable in a 'for' loop has the nameref attribute, +the list of words can be a list of shell variables, and a name reference +will be established for each word in the list, in turn, when the loop is +executed. Array variables cannot be given the nameref attribute. +However, nameref variables can reference array variables and subscripted +array variables. Namerefs can be unset using the '-n' option to the +'unset' builtin (*note Bourne Shell Builtins::). Otherwise, if 'unset' +is executed with the name of a nameref variable as an argument, the +variable referenced by the nameref variable will be unset. + + +File: bash.info, Node: Positional Parameters, Next: Special Parameters, Up: Shell Parameters + +3.4.1 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 parameter 'N' may be +referenced as '${N}', or as '$N' when 'N' consists of a single digit. +Positional parameters may not be assigned to with assignment statements. +The 'set' and 'shift' builtins are used to set and unset them (*note +Shell Builtin Commands::). The positional parameters are temporarily +replaced when a shell function is executed (*note Shell Functions::). + + When a positional parameter consisting of more than a single digit is +expanded, it must be enclosed in braces. + + +File: bash.info, Node: Special Parameters, Prev: Positional Parameters, Up: Shell Parameters + +3.4.2 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 is not within double quotes, each positional + parameter expands to a separate word. In contexts where it is + performed, those words are subject to further word splitting and + pathname expansion. When the expansion occurs within double + quotes, it expands to a single word with the value of each + parameter separated by the first character of the 'IFS' special + variable. That is, '"$*"' is equivalent to '"$1C$2C..."', where C + is the first character of the value of the 'IFS' variable. If + 'IFS' is unset, the parameters are separated by spaces. If 'IFS' + is null, the parameters are joined without intervening separators. + +'@' + ($@) Expands to the positional parameters, starting from one. In + contexts where word splitting is performed, this expands each + positional parameter to a separate word; if not within double + quotes, these words are subject to word splitting. In contexts + where word splitting is not performed, this expands to a single + word with each positional parameter separated by a space. When the + expansion occurs within double quotes, and word splitting is + performed, each parameter expands to a separate word. That is, + '"$@"' is equivalent to '"$1" "$2" ...'. If the double-quoted + expansion occurs within a word, the expansion of the first + parameter is joined with the beginning part of the original word, + and the expansion of the last parameter is joined with the last + part of the original word. 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 exit status of the most recently executed + foreground pipeline. + +'-' + ($-, a hyphen.) Expands to the current option flags as specified + upon invocation, by the 'set' builtin command, or those set by the + shell itself (such as the '-i' option). + +'$' + ($$) Expands to the process ID of the shell. In a '()' subshell, + it expands to the process ID of the invoking shell, not the + subshell. + +'!' + ($!) Expands to the process ID of the job most recently placed + into the background, whether executed as an asynchronous command or + using the 'bg' builtin (*note Job Control Builtins::). + +'0' + ($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 (*note Shell Scripts::), '$0' is set to the name of that + file. If Bash is started with the '-c' option (*note Invoking + Bash::), then '$0' is set to the first argument after the string to + be executed, if one is present. Otherwise, it is set to the + filename used to invoke Bash, as given by argument zero. + +'_' + ($_, an underscore.) At shell startup, set to the absolute + pathname used to invoke the shell or shell script being executed as + passed in the environment or argument list. Subsequently, expands + to the last argument to the previous simple command executed in the + foreground, after expansion. Also set to the full pathname used to + invoke each command executed and placed in the environment exported + to that command. When checking mail, this parameter holds the name + of the mail file. + + +File: bash.info, Node: Shell Expansions, Next: Redirections, Prev: Shell Parameters, Up: Basic Shell Features + +3.5 Shell Expansions +==================== + +Expansion is performed on the command line after it has been split into +'token's. There are seven kinds of expansion performed: + + * brace expansion + * tilde expansion + * parameter and variable expansion + * command substitution + * arithmetic expansion + * word splitting + * filename expansion + +* Menu: + +* Brace Expansion:: Expansion of expressions within braces. +* Tilde Expansion:: Expansion of the ~ character. +* Shell Parameter Expansion:: How Bash expands variables to their values. +* Command Substitution:: Using the output of a command as an argument. +* Arithmetic Expansion:: How to use arithmetic in shell expansions. +* Process Substitution:: A way to write and read to and from a + command. +* Word Splitting:: How the results of expansion are split into separate + arguments. +* Filename Expansion:: A shorthand for specifying filenames matching patterns. +* Quote Removal:: How and when quote characters are removed from + words. + + The order of expansions is: brace expansion; tilde expansion, +parameter and variable expansion, arithmetic expansion, and command +substitution (done in a left-to-right fashion); word splitting; and +filename expansion. + + On systems that can support it, there is an additional expansion +available: PROCESS SUBSTITUTION. This is performed at the same time as +tilde, parameter, variable, and arithmetic expansion and command +substitution. + + After these expansions are performed, quote characters present in the +original word are removed unless they have been quoted themselves (QUOTE +REMOVAL). + + Only brace expansion, word splitting, and filename expansion can +increase the number of words of the expansion; other expansions expand a +single word to a single word. The only exceptions to this are the +expansions of '"$@"' and '$*' (*note Special Parameters::), and +'"${NAME[@]}"' and '${NAME[*]}' (*note Arrays::). + + After all expansions, 'quote removal' (*note Quote Removal::) is +performed. + + +File: bash.info, Node: Brace Expansion, Next: Tilde Expansion, Up: Shell Expansions + +3.5.1 Brace Expansion +--------------------- + +Brace expansion is a mechanism by which arbitrary strings may be +generated. This mechanism is similar to FILENAME EXPANSION (*note +Filename Expansion::), but the filenames generated need not exist. +Patterns to be brace expanded take the form of an optional PREAMBLE, +followed by either a series of comma-separated strings or a sequence +expression between a pair of braces, followed by an optional POSTSCRIPT. +The preamble is prefixed to each string contained within the braces, and +the postscript is then appended to each resulting string, expanding left +to right. + + Brace expansions may be nested. The results of each expanded string +are not sorted; left to right order is preserved. For example, + bash$ echo a{d,c,b}e + ade ace abe + + A sequence expression takes the form '{X..Y[..INCR]}', where X and Y +are either integers or single characters, and INCR, an optional +increment, is an integer. When integers are supplied, the expression +expands to each number between X and Y, inclusive. Supplied integers +may be prefixed with '0' to force each term to have the same width. +When either X or Y begins with a zero, the shell attempts to force all +generated terms to contain the same number of digits, zero-padding where +necessary. When characters are supplied, the expression expands to each +character lexicographically between X and Y, inclusive, using the +default C locale. Note that both X and Y must be of the same type. +When the increment is supplied, it is used as the difference between +each term. The default increment is 1 or -1 as appropriate. + + 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 or a valid sequence +expression. Any incorrectly formed brace expansion is left unchanged. + + A { or ',' may be quoted with a backslash to prevent its being +considered part of a brace expression. To avoid conflicts with +parameter expansion, the string '${' is not considered eligible for +brace expansion, and inhibits brace expansion until the closing '}'.. + + 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}} + + +File: bash.info, Node: Tilde Expansion, Next: Shell Parameter Expansion, Prev: Brace Expansion, Up: Shell Expansions + +3.5.2 Tilde Expansion +--------------------- + +If a word begins with an unquoted tilde character ('~'), all of the +characters up to the first unquoted slash (or all characters, if there +is no unquoted slash) are considered a TILDE-PREFIX. If none of the +characters in the tilde-prefix are quoted, the characters in the +tilde-prefix following the tilde are treated as a possible LOGIN NAME. +If this login name is the null string, the tilde is replaced with the +value of the 'HOME' shell variable. If 'HOME' is unset, the home +directory of the user executing the shell is substituted instead. +Otherwise, the tilde-prefix is replaced with the home directory +associated with the specified login name. + + If the tilde-prefix is '~+', the value of the shell variable 'PWD' +replaces the tilde-prefix. If the tilde-prefix is '~-', the value of +the shell variable 'OLDPWD', if it is set, is substituted. + + If the characters following the tilde in the tilde-prefix consist of +a number N, optionally prefixed by a '+' or a '-', the tilde-prefix is +replaced with the corresponding element from the directory stack, as it +would be displayed by the 'dirs' builtin invoked with the characters +following tilde in the tilde-prefix as an argument (*note The Directory +Stack::). If the tilde-prefix, sans the tilde, consists of a number +without a leading '+' or '-', '+' is assumed. + + If the login name is invalid, or the tilde expansion fails, the word +is left unchanged. + + Each variable assignment is checked for unquoted tilde-prefixes +immediately following a ':' or the first '='. In these cases, tilde +expansion is also performed. Consequently, one may use filenames with +tildes in assignments to 'PATH', 'MAILPATH', and 'CDPATH', and the shell +assigns the expanded value. + + The following table shows how Bash treats unquoted tilde-prefixes: + +'~' + The value of '$HOME' +'~/foo' + '$HOME/foo' + +'~fred/foo' + The subdirectory 'foo' of the home directory of the user 'fred' + +'~+/foo' + '$PWD/foo' + +'~-/foo' + '${OLDPWD-'~-'}/foo' + +'~N' + The string that would be displayed by 'dirs +N' + +'~+N' + The string that would be displayed by 'dirs +N' + +'~-N' + The string that would be displayed by 'dirs -N' + + Bash also performs tilde expansion on words satisfying the conditions +of variable assignments (*note Shell Parameters::) when they appear as +arguments to simple commands. Bash does not do this, except for the +DECLARATION commands listed above, when in POSIX mode. + + +File: bash.info, Node: Shell Parameter Expansion, Next: Command Substitution, Prev: Tilde Expansion, Up: Shell Expansions + +3.5.3 Shell Parameter Expansion +------------------------------- + +The '$' character introduces parameter expansion, command substitution, +or arithmetic expansion. The parameter name or symbol to be expanded +may be enclosed in braces, which are optional but serve to protect the +variable to be expanded from characters immediately following it which +could be interpreted as part of the name. + + When braces are used, the matching ending brace is the first '}' not +escaped by a backslash or within a quoted string, and not within an +embedded arithmetic expansion, command substitution, or parameter +expansion. + + The basic form of parameter expansion is ${PARAMETER}. The value of +PARAMETER is substituted. The PARAMETER is a shell parameter as +described above (*note Shell Parameters::) or an array reference (*note +Arrays::). The braces are required when PARAMETER is a positional +parameter with more than one digit, or when PARAMETER is followed by a +character that is not to be interpreted as part of its name. + + If the first character of PARAMETER is an exclamation point (!), and +PARAMETER is not a NAMEREF, it introduces a level of indirection. Bash +uses the value formed by expanding the rest of PARAMETER as the new +PARAMETER; this is then expanded and that value is used in the rest of +the expansion, rather than the expansion of the original PARAMETER. +This is known as 'indirect expansion'. The value is subject to tilde +expansion, parameter expansion, command substitution, and arithmetic +expansion. If PARAMETER is a nameref, this expands to the name of the +variable referenced by PARAMETER instead of performing the complete +indirect expansion. The exceptions to this are the expansions of +${!PREFIX*} and ${!NAME[@]} described below. The exclamation point must +immediately follow the left brace in order to introduce indirection. + + In each of the cases below, WORD is subject to tilde expansion, +parameter expansion, command substitution, and arithmetic expansion. + + When not performing substring expansion, using the form described +below (e.g., ':-'), Bash tests for a parameter that is unset or null. +Omitting the colon results in a test only for a parameter that is unset. +Put another way, if the colon is included, the operator tests for both +PARAMETER's existence and that its value is not null; if the colon is +omitted, the operator tests only for existence. + +'${PARAMETER:-WORD}' + If PARAMETER is unset or null, the expansion of WORD is + substituted. Otherwise, the value of PARAMETER is substituted. + +'${PARAMETER:=WORD}' + If PARAMETER is unset or null, the expansion of WORD is assigned to + PARAMETER. The value of PARAMETER is then substituted. Positional + parameters and special parameters may not be assigned to in this + way. + +'${PARAMETER:?WORD}' + 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 PARAMETER is substituted. + +'${PARAMETER:+WORD}' + If PARAMETER is null or unset, nothing is substituted, otherwise + the expansion of WORD is substituted. + +'${PARAMETER:OFFSET}' +'${PARAMETER:OFFSET:LENGTH}' + This is referred to as Substring Expansion. It expands to up to + LENGTH characters of the value of PARAMETER starting at the + character specified by OFFSET. If PARAMETER is '@', an indexed + array subscripted by '@' or '*', or an associative array name, the + results differ as described below. If LENGTH is omitted, it + expands to the substring of the value of PARAMETER starting at the + character specified by OFFSET and extending to the end of the + value. LENGTH and OFFSET are arithmetic expressions (*note Shell + Arithmetic::). + + If OFFSET evaluates to a number less than zero, the value is used + as an offset in characters from the end of the value of PARAMETER. + If LENGTH evaluates to a number less than zero, it is interpreted + as an offset in characters from the end of the value of PARAMETER + rather than a number of characters, and the expansion is the + characters between OFFSET and that result. Note that a negative + offset must be separated from the colon by at least one space to + avoid being confused with the ':-' expansion. + + Here are some examples illustrating substring expansion on + parameters and subscripted arrays: + + $ string=01234567890abcdefgh + $ echo ${string:7} + 7890abcdefgh + $ echo ${string:7:0} + + $ echo ${string:7:2} + 78 + $ echo ${string:7:-2} + 7890abcdef + $ echo ${string: -7} + bcdefgh + $ echo ${string: -7:0} + + $ echo ${string: -7:2} + bc + $ echo ${string: -7:-2} + bcdef + $ set -- 01234567890abcdefgh + $ echo ${1:7} + 7890abcdefgh + $ echo ${1:7:0} + + $ echo ${1:7:2} + 78 + $ echo ${1:7:-2} + 7890abcdef + $ echo ${1: -7} + bcdefgh + $ echo ${1: -7:0} + + $ echo ${1: -7:2} + bc + $ echo ${1: -7:-2} + bcdef + $ array[0]=01234567890abcdefgh + $ echo ${array[0]:7} + 7890abcdefgh + $ echo ${array[0]:7:0} + + $ echo ${array[0]:7:2} + 78 + $ echo ${array[0]:7:-2} + 7890abcdef + $ echo ${array[0]: -7} + bcdefgh + $ echo ${array[0]: -7:0} + + $ echo ${array[0]: -7:2} + bc + $ echo ${array[0]: -7:-2} + bcdef + + If PARAMETER is '@', the result is LENGTH positional parameters + beginning at OFFSET. A negative OFFSET is taken relative to one + greater than the greatest positional parameter, so an offset of -1 + evaluates to the last positional parameter. It is an expansion + error if LENGTH evaluates to a number less than zero. + + The following examples illustrate substring expansion using + positional parameters: + + $ set -- 1 2 3 4 5 6 7 8 9 0 a b c d e f g h + $ echo ${@:7} + 7 8 9 0 a b c d e f g h + $ echo ${@:7:0} + + $ echo ${@:7:2} + 7 8 + $ echo ${@:7:-2} + bash: -2: substring expression < 0 + $ echo ${@: -7:2} + b c + $ echo ${@:0} + ./bash 1 2 3 4 5 6 7 8 9 0 a b c d e f g h + $ echo ${@:0:2} + ./bash 1 + $ echo ${@: -7:0} + + + If PARAMETER is an indexed array name subscripted by '@' or '*', + the result is the LENGTH members of the array beginning with + '${PARAMETER[OFFSET]}'. A negative OFFSET is taken relative to one + greater than the maximum index of the specified array. It is an + expansion error if LENGTH evaluates to a number less than zero. + + These examples show how you can use substring expansion with + indexed arrays: + + $ array=(0 1 2 3 4 5 6 7 8 9 0 a b c d e f g h) + $ echo ${array[@]:7} + 7 8 9 0 a b c d e f g h + $ echo ${array[@]:7:2} + 7 8 + $ echo ${array[@]: -7:2} + b c + $ echo ${array[@]: -7:-2} + bash: -2: substring expression < 0 + $ echo ${array[@]:0} + 0 1 2 3 4 5 6 7 8 9 0 a b c d e f g h + $ echo ${array[@]:0:2} + 0 1 + $ echo ${array[@]: -7:0} + + + Substring expansion applied to an associative array produces + undefined results. + + Substring indexing is zero-based unless the positional parameters + are used, in which case the indexing starts at 1 by default. If + OFFSET is 0, and the positional parameters are used, '$@' is + prefixed to the list. + +'${!PREFIX*}' +'${!PREFIX@}' + Expands to the names of variables whose names begin with PREFIX, + separated by the first character of the 'IFS' special variable. + When '@' is used and the expansion appears within double quotes, + each variable name expands to a separate word. + +'${!NAME[@]}' +'${!NAME[*]}' + If NAME is an array variable, expands to the list of array indices + (keys) assigned in NAME. If NAME is not an array, expands to 0 if + NAME is set and null otherwise. When '@' is used and the expansion + appears within double quotes, each key expands to a separate word. + +'${#PARAMETER}' + The length in characters of the expanded value of PARAMETER is + substituted. If PARAMETER is '*' or '@', the value substituted is + the number of positional parameters. If PARAMETER is an array name + subscripted by '*' or '@', the value substituted is the number of + elements in the array. If PARAMETER is an indexed array name + subscripted by a negative number, that number is interpreted as + relative to one greater than the maximum index of PARAMETER, so + negative indices count back from the end of the array, and an index + of -1 references the last element. + +'${PARAMETER#WORD}' +'${PARAMETER##WORD}' + The WORD is expanded to produce a pattern and matched according to + the rules described below (*note Pattern Matching::). If the + pattern matches the beginning of the expanded value of PARAMETER, + then the result of the expansion is the expanded value of PARAMETER + with the shortest matching pattern (the '#' case) or the longest + matching pattern (the '##' case) deleted. If PARAMETER is '@' or + '*', the pattern removal operation is applied to each positional + parameter in turn, and the expansion is the resultant list. If + PARAMETER is an array variable subscripted with '@' or '*', the + pattern removal operation is applied to each member of the array in + turn, and the expansion is the resultant list. + +'${PARAMETER%WORD}' +'${PARAMETER%%WORD}' + The WORD is expanded to produce a pattern and matched according to + the rules described below (*note Pattern Matching::). If the + pattern matches If the pattern matches a trailing portion of the + expanded value of PARAMETER, then the result of the expansion is + the value of PARAMETER with the shortest matching pattern (the '%' + case) or the longest matching pattern (the '%%' case) deleted. If + PARAMETER is '@' or '*', the pattern removal operation is applied + to each positional parameter in turn, and the expansion is the + resultant list. If PARAMETER is an array variable subscripted with + '@' or '*', the pattern removal operation is applied to each member + of the array in turn, and the expansion is the resultant list. + +'${PARAMETER/PATTERN/STRING}' + + The PATTERN is expanded to produce a pattern just as in filename + expansion. PARAMETER is expanded and the longest match of PATTERN + against its value is replaced with STRING. The match is performed + according to the rules described below (*note Pattern Matching::). + If PATTERN begins with '/', all matches of PATTERN are replaced + with STRING. Normally only the first match is replaced. If + PATTERN begins with '#', it must match at the beginning of the + expanded value of PARAMETER. If PATTERN begins with '%', it must + match at the end of the expanded value of PARAMETER. If STRING is + null, matches of PATTERN are deleted and the '/' following PATTERN + may be omitted. If the 'nocasematch' shell option (see the + description of 'shopt' in *note The Shopt Builtin::) is enabled, + the match is performed without regard to the case of alphabetic + characters. If PARAMETER is '@' or '*', the substitution operation + is applied to each positional parameter in turn, and the expansion + is the resultant list. If PARAMETER is an array variable + subscripted with '@' or '*', the substitution operation is applied + to each member of the array in turn, and the expansion is the + resultant list. + +'${PARAMETER^PATTERN}' +'${PARAMETER^^PATTERN}' +'${PARAMETER,PATTERN}' +'${PARAMETER,,PATTERN}' + This expansion modifies the case of alphabetic characters in + PARAMETER. The PATTERN is expanded to produce a pattern just as in + filename expansion. Each character in the expanded value of + PARAMETER is tested against PATTERN, and, if it matches the + pattern, its case is converted. The pattern should not attempt to + match more than one character. The '^' operator converts lowercase + letters matching PATTERN to uppercase; the ',' operator converts + matching uppercase letters to lowercase. The '^^' and ',,' + expansions convert each matched character in the expanded value; + the '^' and ',' expansions match and convert only the first + character in the expanded value. If PATTERN is omitted, it is + treated like a '?', which matches every character. If PARAMETER is + '@' or '*', the case modification operation is applied to each + positional parameter in turn, and the expansion is the resultant + list. If PARAMETER is an array variable subscripted with '@' or + '*', the case modification operation is applied to each member of + the array in turn, and the expansion is the resultant list. + +'${PARAMETER@OPERATOR}' + The expansion is either a transformation of the value of PARAMETER + or information about PARAMETER itself, depending on the value of + OPERATOR. Each OPERATOR is a single letter: + + 'Q' + The expansion is a string that is the value of PARAMETER + quoted in a format that can be reused as input. + 'E' + The expansion is a string that is the value of PARAMETER with + backslash escape sequences expanded as with the '$'...'' + quoting mechanism. + 'P' + The expansion is a string that is the result of expanding the + value of PARAMETER as if it were a prompt string (*note + Controlling the Prompt::). + 'A' + The expansion is a string in the form of an assignment + statement or 'declare' command that, if evaluated, will + recreate PARAMETER with its attributes and value. + 'a' + The expansion is a string consisting of flag values + representing PARAMETER's attributes. + + If PARAMETER is '@' or '*', the operation is applied to each + positional parameter in turn, and the expansion is the resultant + list. If PARAMETER is an array variable subscripted with '@' or + '*', the operation is applied to each member of the array in turn, + and the expansion is the resultant list. + + The result of the expansion is subject to word splitting and + pathname expansion as described below. + + +File: bash.info, Node: Command Substitution, Next: Arithmetic Expansion, Prev: Shell Parameter Expansion, Up: Shell Expansions + +3.5.4 Command Substitution +-------------------------- + +Command substitution allows the output of a command to replace the +command itself. Command substitution occurs when a command is enclosed +as follows: + $(COMMAND) +or + `COMMAND` + +Bash performs the expansion by executing COMMAND in a subshell +environment and replacing the command substitution with the standard +output of the command, with any trailing newlines deleted. Embedded +newlines are not deleted, but they may be removed during word splitting. +The command substitution '$(cat FILE)' can be replaced by the equivalent +but faster '$(< FILE)'. + + When the old-style backquote form of substitution is used, backslash +retains its literal meaning except when followed by '$', '`', or '\'. +The first backquote not preceded by a backslash terminates the command +substitution. When using the '$(COMMAND)' form, all characters between +the parentheses make up the command; none are treated specially. + + Command substitutions may be nested. To nest when using the +backquoted form, escape the inner backquotes with backslashes. + + If the substitution appears within double quotes, word splitting and +filename expansion are not performed on the results. + + +File: bash.info, Node: Arithmetic Expansion, Next: Process Substitution, Prev: Command Substitution, Up: Shell Expansions + +3.5.5 Arithmetic Expansion +-------------------------- + +Arithmetic expansion allows the evaluation of an arithmetic expression +and the substitution of the result. The format for arithmetic expansion +is: + + $(( EXPRESSION )) + + The expression is treated as if it were within double quotes, but a +double quote inside the parentheses is not treated specially. All +tokens in the expression undergo parameter and variable expansion, +command substitution, and quote removal. The result is treated as the +arithmetic expression to be evaluated. Arithmetic expansions may be +nested. + + The evaluation is performed according to the rules listed below +(*note Shell Arithmetic::). If the expression is invalid, Bash prints a +message indicating failure to the standard error and no substitution +occurs. + + +File: bash.info, Node: Process Substitution, Next: Word Splitting, Prev: Arithmetic Expansion, Up: Shell Expansions + +3.5.6 Process Substitution +-------------------------- + +Process substitution allows a process's input or output to be referred +to using a filename. It takes the form of + <(LIST) +or + >(LIST) +The process LIST is run asynchronously, and its input or output appears +as a filename. This filename 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. Note that no space may appear between the '<' or '>' +and the left parenthesis, otherwise the construct would be interpreted +as a redirection. Process substitution is supported on systems that +support named pipes (FIFOs) or the '/dev/fd' method of naming open +files. + + When available, process substitution is performed simultaneously with +parameter and variable expansion, command substitution, and arithmetic +expansion. + + +File: bash.info, Node: Word Splitting, Next: Filename Expansion, Prev: Process Substitution, Up: Shell Expansions + +3.5.7 Word Splitting +-------------------- + +The shell scans the results of parameter expansion, command +substitution, and arithmetic expansion that did not occur within double +quotes for word splitting. + + The shell treats each character of '$IFS' as a delimiter, and splits +the results of the other expansions into words using these characters as +field terminators. If 'IFS' is unset, or its value is exactly +'<space><tab><newline>', the default, then sequences of ' <space>', +'<tab>', and '<newline>' at the beginning and end of the results of the +previous expansions are ignored, and any sequence of 'IFS' characters +not at the beginning or end serves to delimit words. If 'IFS' has a +value other than the default, then sequences of the whitespace +characters 'space', 'tab', and 'newline' are ignored at the beginning +and end of the word, as long as the whitespace character is in the value +of 'IFS' (an 'IFS' whitespace character). Any character in 'IFS' that +is not 'IFS' whitespace, along with any adjacent 'IFS' whitespace +characters, delimits a field. A sequence of 'IFS' whitespace characters +is also treated as a delimiter. If the value of 'IFS' is null, no word +splitting occurs. + + Explicit null arguments ('""' or '''') are retained and passed to +commands as empty strings. Unquoted implicit null arguments, resulting +from the expansion of parameters that have no values, are removed. If a +parameter with no value is expanded within double quotes, a null +argument results and is retained and passed to a command as an empty +string. When a quoted null argument appears as part of a word whose +expansion is non-null, the null argument is removed. That is, the word +'-d''' becomes '-d' after word splitting and null argument removal. + + Note that if no expansion occurs, no splitting is performed. + + +File: bash.info, Node: Filename Expansion, Next: Quote Removal, Prev: Word Splitting, Up: Shell Expansions + +3.5.8 Filename Expansion +------------------------ + +* Menu: + +* Pattern Matching:: How the shell matches patterns. + +After word splitting, unless the '-f' option has been set (*note The Set +Builtin::), 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 filenames +matching the pattern (*note Pattern Matching::). If no matching +filenames are found, and the shell option 'nullglob' is disabled, the +word is left unchanged. If the 'nullglob' option is set, and no matches +are found, the word is removed. If the 'failglob' shell option is set, +and no matches are found, an error message is printed and the command is +not executed. If the shell option 'nocaseglob' is enabled, the match is +performed without regard to the case of alphabetic characters. + + When a pattern is used for filename expansion, the character '.' at +the start of a filename or immediately following a slash must be matched +explicitly, unless the shell option 'dotglob' is set. The filenames '.' +and '..' must always be matched explicitly, even if 'dotglob' is set. +In other cases, the '.' character is not treated specially. + + When matching a filename, the slash character must always be matched +explicitly by a slash in the pattern, but in other matching contexts it +can be matched by a special pattern character as described below (*note +Pattern Matching::). + + See the description of 'shopt' in *note The Shopt Builtin::, for a +description of the 'nocaseglob', 'nullglob', 'failglob', and 'dotglob' +options. + + The 'GLOBIGNORE' shell variable may be used to restrict the set of +file names matching a pattern. If 'GLOBIGNORE' is set, each matching +file name that also matches one of the patterns in 'GLOBIGNORE' is +removed from the list of matches. If the 'nocaseglob' option is set, +the matching against the patterns in 'GLOBIGNORE' is performed without +regard to case. The filenames '.' and '..' are always ignored when +'GLOBIGNORE' is set and not null. However, setting 'GLOBIGNORE' to a +non-null value has the effect of enabling the 'dotglob' shell option, so +all other filenames beginning with a '.' will match. To get the old +behavior of ignoring filenames beginning with a '.', make '.*' one of +the patterns in 'GLOBIGNORE'. The 'dotglob' option is disabled when +'GLOBIGNORE' is unset. + + +File: bash.info, Node: Pattern Matching, Up: Filename Expansion + +3.5.8.1 Pattern Matching +........................ + +Any character that appears in a pattern, other than the special pattern +characters described below, matches itself. The NUL character may not +occur in a pattern. A backslash escapes the following character; the +escaping backslash is discarded when matching. The special pattern +characters must be quoted if they are to be matched literally. + + The special pattern characters have the following meanings: +'*' + Matches any string, including the null string. When the 'globstar' + shell option is enabled, and '*' is used in a filename expansion + context, two adjacent '*'s used as a single pattern will match all + files and zero or more directories and subdirectories. If followed + by a '/', two adjacent '*'s will match only directories and + subdirectories. +'?' + Matches any single character. +'[...]' + Matches any one of the enclosed characters. A pair of characters + separated by a hyphen denotes a RANGE EXPRESSION; any character + that falls between those two characters, inclusive, using the + current locale's collating sequence and character set, is matched. + If the first character following the '[' is a '!' or a '^' then any + character not enclosed is matched. A '-' may be matched by + including it as the first or last character in the set. A ']' may + be matched by including it as the first character in the set. The + sorting order of characters in range expressions is determined by + the current locale and the values of the 'LC_COLLATE' and 'LC_ALL' + shell variables, if set. + + For example, in the default C locale, '[a-dx-z]' is equivalent to + '[abcdxyz]'. Many locales sort characters in dictionary order, and + in these locales '[a-dx-z]' is typically not equivalent to + '[abcdxyz]'; it might be equivalent to '[aBbCcDdxXyYz]', for + example. To obtain the traditional interpretation of ranges in + bracket expressions, you can force the use of the C locale by + setting the 'LC_COLLATE' or 'LC_ALL' environment variable to the + value 'C', or enable the 'globasciiranges' shell option. + + Within '[' and ']', CHARACTER CLASSES can be specified using the + syntax '[:'CLASS':]', where CLASS is one of the following classes + defined in the POSIX standard: + alnum alpha ascii blank cntrl digit graph lower + print punct space upper word xdigit + A character class matches any character belonging to that class. + The 'word' character class matches letters, digits, and the + character '_'. + + Within '[' and ']', an EQUIVALENCE CLASS can be specified using the + syntax '[='C'=]', which matches all characters with the same + collation weight (as defined by the current locale) as the + character C. + + Within '[' and ']', the syntax '[.'SYMBOL'.]' matches the collating + symbol SYMBOL. + + If the 'extglob' shell option is enabled using the 'shopt' builtin, +several extended pattern matching operators are recognized. In the +following description, a PATTERN-LIST is a list of one or more patterns +separated by a '|'. Composite patterns may be formed using one or more +of the following sub-patterns: + +'?(PATTERN-LIST)' + Matches zero or one occurrence of the given patterns. + +'*(PATTERN-LIST)' + Matches zero or more occurrences of the given patterns. + +'+(PATTERN-LIST)' + Matches one or more occurrences of the given patterns. + +'@(PATTERN-LIST)' + Matches one of the given patterns. + +'!(PATTERN-LIST)' + Matches anything except one of the given patterns. + + Complicated extended pattern matching against long strings is slow, +especially when the patterns contain alternations and the strings +contain multiple matches. Using separate matches against shorter +strings, or using arrays of strings instead of a single long string, may +be faster. + + +File: bash.info, Node: Quote Removal, Prev: Filename Expansion, Up: Shell Expansions + +3.5.9 Quote Removal +------------------- + +After the preceding expansions, all unquoted occurrences of the +characters '\', ''', and '"' that did not result from one of the above +expansions are removed. + + +File: bash.info, Node: Redirections, Next: Executing Commands, Prev: Shell Expansions, Up: Basic Shell Features + +3.6 Redirections +================ + +Before a command is executed, its input and output may be REDIRECTED +using a special notation interpreted by the shell. Redirection allows +commands' file handles to be duplicated, opened, closed, made to refer +to different files, and can change the files the command reads from and +writes to. Redirection may also be used to modify file handles in the +current shell execution environment. The following redirection +operators may precede or appear anywhere within a simple command or may +follow a command. Redirections are processed in the order they appear, +from left to right. + + Each redirection that may be preceded by a file descriptor number may +instead be preceded by a word of the form {VARNAME}. In this case, for +each redirection operator except >&- and <&-, the shell will allocate a +file descriptor greater than 10 and assign it to {VARNAME}. If >&- or +<&- is preceded by {VARNAME}, the value of VARNAME defines the file +descriptor to close. If {VARNAME} is supplied, the redirection persists +beyond the scope of the command, allowing the shell programmer to manage +the file descriptor himself. + + In the following descriptions, if the file descriptor number is +omitted, and the first character of the redirection operator is '<', the +redirection refers to the standard input (file descriptor 0). If the +first character of the redirection operator is '>', the redirection +refers to the standard output (file descriptor 1). + + The word following the redirection operator in the following +descriptions, unless otherwise noted, is subjected to brace expansion, +tilde expansion, parameter expansion, command substitution, arithmetic +expansion, quote removal, filename expansion, and word splitting. If it +expands to more than one word, Bash reports an error. + + Note that the order of redirections is significant. For example, the +command + ls > DIRLIST 2>&1 +directs both standard output (file descriptor 1) and standard error +(file descriptor 2) to the file DIRLIST, while the command + ls 2>&1 > DIRLIST +directs only the standard output to file DIRLIST, because the standard +error was made a copy of the standard output before the standard output +was redirected to DIRLIST. + + Bash handles several filenames specially when they are used in +redirections, as described in the following table. If the operating +system on which Bash is running provides these special files, bash will +use them; otherwise it will emulate them internally with the behavior +described below. + +'/dev/fd/FD' + If FD is a valid integer, file descriptor FD is duplicated. + +'/dev/stdin' + File descriptor 0 is duplicated. + +'/dev/stdout' + File descriptor 1 is duplicated. + +'/dev/stderr' + File descriptor 2 is duplicated. + +'/dev/tcp/HOST/PORT' + If HOST is a valid hostname or Internet address, and PORT is an + integer port number or service name, Bash attempts to open the + corresponding TCP socket. + +'/dev/udp/HOST/PORT' + If HOST is a valid hostname or Internet address, and PORT is an + integer port number or service name, Bash attempts to open the + corresponding UDP socket. + + A failure to open or create a file causes the redirection to fail. + + Redirections using file descriptors greater than 9 should be used +with care, as they may conflict with file descriptors the shell uses +internally. + +3.6.1 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 + +3.6.2 Redirecting Output +------------------------ + +Redirection of output causes the file whose name results from the +expansion of WORD to be opened for writing on file descriptor N, or the +standard output (file descriptor 1) if N is not specified. If the file +does not exist it is created; if it does exist it is truncated to zero +size. + + The general format for redirecting output is: + [N]>[|]WORD + + If the redirection operator is '>', and the 'noclobber' option to the +'set' builtin has been enabled, the redirection will fail if the file +whose name results from the expansion of WORD exists and is a regular +file. If the redirection operator is '>|', or the redirection operator +is '>' and the 'noclobber' option is not enabled, the redirection is +attempted even if the file named by WORD exists. + +3.6.3 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 + +3.6.4 Redirecting Standard Output and Standard Error +---------------------------------------------------- + +This construct 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. + + There are two formats for redirecting standard output and standard +error: + &>WORD +and + >&WORD +Of the two forms, the first is preferred. This is semantically +equivalent to + >WORD 2>&1 + When using the second form, WORD may not expand to a number or '-'. +If it does, other redirection operators apply (see Duplicating File +Descriptors below) for compatibility reasons. + +3.6.5 Appending Standard Output and Standard Error +-------------------------------------------------- + +This construct allows both the standard output (file descriptor 1) and +the standard error output (file descriptor 2) to be appended to the file +whose name is the expansion of WORD. + + The format for appending standard output and standard error is: + &>>WORD +This is semantically equivalent to + >>WORD 2>&1 + (see Duplicating File Descriptors below). + +3.6.6 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 (or file descriptor N if N is specified) for a +command. + + The format of here-documents is: + [N]<<[-]WORD + HERE-DOCUMENT + DELIMITER + + No parameter and variable expansion, command substitution, arithmetic +expansion, or filename expansion is performed on WORD. If any part of +WORD is quoted, the DELIMITER is the result of quote removal on WORD, +and the lines in the here-document are not expanded. If WORD is +unquoted, all lines of the here-document are subjected to parameter +expansion, command substitution, and arithmetic expansion, the character +sequence '\newline' is ignored, and '\' must be used to quote the +characters '\', '$', and '`'. + + If the redirection operator is '<<-', then all leading tab characters +are stripped from input lines and the line containing DELIMITER. This +allows here-documents within shell scripts to be indented in a natural +fashion. + +3.6.7 Here Strings +------------------ + +A variant of here documents, the format is: + [N]<<< WORD + + The WORD undergoes tilde expansion, parameter and variable expansion, +command substitution, arithmetic expansion, and quote removal. Pathname +expansion and word splitting are not performed. The result is supplied +as a single string, with a newline appended, to the command on its +standard input (or file descriptor N if N is specified). + +3.6.8 Duplicating File Descriptors +---------------------------------- + +The redirection operator + [N]<&WORD +is used to duplicate input file descriptors. If WORD expands to one or +more digits, the file descriptor denoted by N is made to be a copy of +that file descriptor. If the digits in WORD do not specify a file +descriptor open for input, a redirection error occurs. If WORD +evaluates to '-', file descriptor N is closed. If N is not specified, +the standard input (file descriptor 0) is used. + + The operator + [N]>&WORD +is used similarly to duplicate output file descriptors. If N is not +specified, the standard output (file descriptor 1) is used. If the +digits in WORD do not specify a file descriptor open for output, a +redirection error occurs. If WORD evaluates to '-', file descriptor N +is closed. As a special case, if N is omitted, and WORD does not expand +to one or more digits or '-', the standard output and standard error are +redirected as described previously. + +3.6.9 Moving File Descriptors +----------------------------- + +The redirection operator + [N]<&DIGIT- +moves the file descriptor DIGIT to file descriptor N, or the standard +input (file descriptor 0) if N is not specified. DIGIT is closed after +being duplicated to N. + + Similarly, the redirection operator + [N]>&DIGIT- +moves the file descriptor DIGIT to file descriptor N, or the standard +output (file descriptor 1) if N is not specified. + +3.6.10 Opening File Descriptors for Reading and Writing +------------------------------------------------------- + +The redirection operator + [N]<>WORD +causes the file whose name is the expansion of WORD to be opened for +both reading and writing on file descriptor N, or on file descriptor 0 +if N is not specified. If the file does not exist, it is created. + + +File: bash.info, Node: Executing Commands, Next: Shell Scripts, Prev: Redirections, Up: Basic Shell Features + +3.7 Executing Commands +====================== + +* Menu: + +* Simple Command Expansion:: How Bash expands simple commands before + executing them. +* Command Search and Execution:: How Bash finds commands and runs them. +* Command Execution Environment:: The environment in which Bash + executes commands that are not + shell builtins. +* Environment:: The environment given to a command. +* Exit Status:: The status returned by commands and how Bash + interprets it. +* Signals:: What happens when Bash or a command it runs + receives a signal. + + +File: bash.info, Node: Simple Command Expansion, Next: Command Search and Execution, Up: Executing Commands + +3.7.1 Simple Command Expansion +------------------------------ + +When a simple command is executed, the shell performs the following +expansions, assignments, and redirections, from left to right. + + 1. The words that the parser has marked as variable assignments (those + preceding the command name) and redirections are saved for later + processing. + + 2. The words that are not variable assignments or redirections are + expanded (*note Shell Expansions::). If any words remain after + expansion, the first word is taken to be the name of the command + and the remaining words are the arguments. + + 3. Redirections are performed as described above (*note + Redirections::). + + 4. The text after the '=' in each variable assignment undergoes tilde + expansion, parameter expansion, command substitution, arithmetic + expansion, and quote removal before being assigned to the variable. + + If no command name results, the variable assignments affect the +current shell environment. Otherwise, the variables are added to the +environment of the executed command and do not affect the current shell +environment. If any of the assignments attempts to assign a value to a +readonly variable, an error occurs, and the command exits with a +non-zero status. + + If no command name results, redirections are performed, but do not +affect the current shell environment. A redirection error causes the +command to exit with a non-zero status. + + If there is a command name left after expansion, execution proceeds +as described below. Otherwise, the command exits. If one of the +expansions contained a command substitution, the exit status of the +command is the exit status of the last command substitution performed. +If there were no command substitutions, the command exits with a status +of zero. + + +File: bash.info, Node: Command Search and Execution, Next: Command Execution Environment, Prev: Simple Command Expansion, Up: Executing Commands + +3.7.2 Command Search and 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. + + 1. 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 in *note Shell Functions::. + + 2. 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. + + 3. If the name is neither a shell function nor a builtin, and contains + no slashes, Bash searches each element of '$PATH' for a directory + containing an executable file by that name. Bash uses a hash table + to remember the full pathnames of executable files to avoid + multiple 'PATH' searches (see the description of 'hash' in *note + Bourne Shell Builtins::). A full search of the directories in + '$PATH' is performed only if the command is not found in the hash + table. If the search is unsuccessful, the shell searches for a + defined shell function named 'command_not_found_handle'. If that + function exists, it is invoked in a separate execution environment + with the original command and the original command's arguments as + its arguments, and the function's exit status becomes the exit + status of that subshell. If that function is not defined, the + shell prints an error message and returns an exit status of 127. + + 4. If the search is successful, or if the command name contains one or + more slashes, the shell executes the named program in a separate + execution environment. Argument 0 is set to the name given, and + the remaining arguments to the command are set to the arguments + supplied, if any. + + 5. If this execution fails because the file is not in executable + format, and the file is not a directory, it is assumed to be a + SHELL SCRIPT and the shell executes it as described in *note Shell + Scripts::. + + 6. If the command was not begun asynchronously, the shell waits for + the command to complete and collects its exit status. + + +File: bash.info, Node: Command Execution Environment, Next: Environment, Prev: Command Search and Execution, Up: Executing Commands + +3.7.3 Command Execution Environment +----------------------------------- + +The shell has an EXECUTION ENVIRONMENT, which consists of the following: + + * open files inherited by the shell at invocation, as modified by + redirections supplied to the 'exec' builtin + + * the current working directory as set by 'cd', 'pushd', or 'popd', + or inherited by the shell at invocation + + * the file creation mode mask as set by 'umask' or inherited from the + shell's parent + + * current traps set by 'trap' + + * shell parameters that are set by variable assignment or with 'set' + or inherited from the shell's parent in the environment + + * shell functions defined during execution or inherited from the + shell's parent in the environment + + * options enabled at invocation (either by default or with + command-line arguments) or by 'set' + + * options enabled by 'shopt' (*note The Shopt Builtin::) + + * shell aliases defined with 'alias' (*note Aliases::) + + * various process IDs, including those of background jobs (*note + Lists::), the value of '$$', and the value of '$PPID' + + When a simple command other than a builtin or shell function is to be +executed, it is invoked in a separate execution environment that +consists of the following. Unless otherwise noted, the values are +inherited from the shell. + + * the shell's open files, plus any modifications and additions + specified by redirections to the command + + * the current working directory + + * the file creation mode mask + + * shell variables and functions marked for export, along with + variables exported for the command, passed in the environment + (*note Environment::) + + * traps caught by the shell are reset to the values inherited from + the shell's parent, and traps ignored by the shell are ignored + + A command invoked in this separate environment cannot affect the +shell's execution environment. + + Command substitution, commands grouped with parentheses, and +asynchronous commands are invoked in a subshell environment that is a +duplicate of the shell environment, except that traps caught by the +shell are reset to the values that the shell inherited from its parent +at invocation. Builtin commands that are invoked as part of a pipeline +are also executed in a subshell environment. Changes made to the +subshell environment cannot affect the shell's execution environment. + + Subshells spawned to execute command substitutions inherit the value +of the '-e' option from the parent shell. When not in POSIX mode, Bash +clears the '-e' option in such subshells. + + If a command is followed by a '&' and job control is not active, the +default standard input for the command is the empty file '/dev/null'. +Otherwise, the invoked command inherits the file descriptors of the +calling shell as modified by redirections. + + +File: bash.info, Node: Environment, Next: Exit Status, Prev: Command Execution Environment, Up: Executing Commands + +3.7.4 Environment +----------------- + +When a program is invoked it is given an array of strings called the +ENVIRONMENT. This is a list of name-value pairs, of the form +'name=value'. + + Bash provides several ways to manipulate the environment. On +invocation, the shell scans its own environment and creates a parameter +for each name found, automatically marking it for EXPORT to child +processes. Executed commands inherit the environment. The 'export' and +'declare -x' commands allow parameters and functions to be added to and +deleted from the environment. If the value of a parameter in the +environment is modified, the new value becomes part of the environment, +replacing the old. The environment inherited by any executed command +consists of the shell's initial environment, whose values may be +modified in the shell, less any pairs removed by the 'unset' and 'export +-n' commands, 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 in +*note Shell Parameters::. These assignment statements affect only the +environment seen by that command. + + If the '-k' option is set (*note The Set Builtin::), then all +parameter assignments are placed in the environment for a command, not +just those that precede the command name. + + When Bash invokes an external command, the variable '$_' is set to +the full pathname of the command and passed to that command in its +environment. + + +File: bash.info, Node: Exit Status, Next: Signals, Prev: Environment, Up: Executing Commands + +3.7.5 Exit Status +----------------- + +The exit status of an executed command is the value returned by the +WAITPID system call or equivalent function. Exit statuses fall between +0 and 255, though, as explained below, the shell may use values above +125 specially. Exit statuses from shell builtins and compound commands +are also limited to this range. Under certain circumstances, the shell +will use special values to indicate specific failure modes. + + For the shell's purposes, a command which exits with a zero exit +status has succeeded. A non-zero exit status indicates failure. This +seemingly counter-intuitive scheme is used so there is one well-defined +way to indicate success and a variety of ways to indicate various +failure modes. When a command terminates on a fatal signal whose number +is N, Bash uses the value 128+N as the exit status. + + If a command is not found, the child process created to execute it +returns a status of 127. If a command is found but is not executable, +the return status is 126. + + If a command fails because of an error during expansion or +redirection, the exit status is greater than zero. + + The exit status is used by the Bash conditional commands (*note +Conditional Constructs::) and some of the list constructs (*note +Lists::). + + All of the Bash builtins return an exit status of zero if they +succeed and a non-zero status on failure, so they may be used by the +conditional and list constructs. All builtins return an exit status of +2 to indicate incorrect usage, generally invalid options or missing +arguments. + + +File: bash.info, Node: Signals, Prev: Exit Status, Up: Executing Commands + +3.7.6 Signals +------------- + +When Bash is interactive, in the absence of any traps, it ignores +'SIGTERM' (so that 'kill 0' does not kill an interactive shell), and +'SIGINT' is caught and handled (so that the 'wait' builtin is +interruptible). When Bash receives a 'SIGINT', it breaks out of any +executing loops. In all cases, Bash ignores 'SIGQUIT'. If job control +is in effect (*note Job Control::), Bash ignores 'SIGTTIN', 'SIGTTOU', +and 'SIGTSTP'. + + Non-builtin commands started by Bash have signal handlers set to the +values inherited by the shell from its parent. When job control is not +in effect, asynchronous commands ignore 'SIGINT' and 'SIGQUIT' in +addition to these inherited handlers. Commands run as a result of +command substitution ignore the keyboard-generated job control signals +'SIGTTIN', 'SIGTTOU', and 'SIGTSTP'. + + The shell exits by default upon receipt of a 'SIGHUP'. Before +exiting, an interactive shell resends the 'SIGHUP' to all jobs, running +or stopped. Stopped jobs are sent 'SIGCONT' to ensure that they receive +the 'SIGHUP'. To prevent the shell from sending the 'SIGHUP' signal to +a particular job, it should be removed from the jobs table with the +'disown' builtin (*note Job Control Builtins::) or marked to not receive +'SIGHUP' using 'disown -h'. + + If the 'huponexit' shell option has been set with 'shopt' (*note The +Shopt Builtin::), Bash sends a 'SIGHUP' to all jobs when an interactive +login shell exits. + + If Bash is waiting for a command to complete and receives a signal +for which a trap has been set, the trap will not be executed until the +command completes. When Bash is waiting for an asynchronous command via +the 'wait' builtin, the reception of a signal for which a trap has been +set will cause the 'wait' builtin to return immediately with an exit +status greater than 128, immediately after which the trap is executed. + + +File: bash.info, Node: Shell Scripts, Prev: Executing Commands, Up: Basic Shell Features + +3.8 Shell Scripts +================= + +A shell script is a text file containing shell commands. When such a +file is used as the first non-option argument when invoking Bash, and +neither the '-c' nor '-s' option is supplied (*note Invoking Bash::), +Bash reads and executes commands from the file, then exits. This mode +of operation creates a non-interactive shell. The shell first searches +for the file in the current directory, and looks in the directories in +'$PATH' if not found there. + + When Bash runs a shell script, it sets the special parameter '0' to +the name of the file, rather than the name of the shell, and the +positional parameters are set to the remaining arguments, if any are +given. If no additional arguments are supplied, the positional +parameters are unset. + + A shell script may be made executable by using the 'chmod' command to +turn on the execute bit. When Bash finds such a file while searching +the '$PATH' for a command, it spawns a subshell to execute it. In other +words, executing + filename ARGUMENTS +is equivalent to executing + bash filename ARGUMENTS + +if 'filename' is an executable shell script. This subshell +reinitializes itself, so that the effect is as if a new shell had been +invoked to interpret the script, with the exception that the locations +of commands remembered by the parent (see the description of 'hash' in +*note Bourne Shell Builtins::) are retained by the child. + + Most versions of Unix make this a part of the operating system's +command execution mechanism. If the first line of a script begins with +the two characters '#!', the remainder of the line specifies an +interpreter for the program. Thus, you can specify Bash, 'awk', Perl, +or some other interpreter and write the rest of the script file in that +language. + + The arguments to the interpreter consist of a single optional +argument following the interpreter name on the first line of the script +file, followed by the name of the script file, followed by the rest of +the arguments. Bash will perform this action on operating systems that +do not handle it themselves. Note that some older versions of Unix +limit the interpreter name and argument to a maximum of 32 characters. + + Bash scripts often begin with '#! /bin/bash' (assuming that Bash has +been installed in '/bin'), since this ensures that Bash will be used to +interpret the script, even if it is executed under another shell. + + +File: bash.info, Node: Shell Builtin Commands, Next: Shell Variables, Prev: Basic Shell Features, Up: Top + +4 Shell Builtin Commands +************************ + +* Menu: + +* Bourne Shell Builtins:: Builtin commands inherited from the Bourne + Shell. +* Bash Builtins:: Table of builtins specific to Bash. +* Modifying Shell Behavior:: Builtins to modify shell attributes and + optional behavior. +* Special Builtins:: Builtin commands classified specially by + POSIX. + +Builtin commands are contained within the shell itself. When the name +of a builtin command is used as the first word of a simple command +(*note Simple Commands::), the shell executes the command directly, +without invoking another program. Builtin commands are necessary to +implement functionality impossible or inconvenient to obtain with +separate utilities. + + This section briefly describes the builtins which Bash inherits from +the Bourne Shell, as well as the builtin commands which are unique to or +have been extended in Bash. + + Several builtin commands are described in other chapters: builtin +commands which provide the Bash interface to the job control facilities +(*note Job Control Builtins::), the directory stack (*note Directory +Stack Builtins::), the command history (*note Bash History Builtins::), +and the programmable completion facilities (*note Programmable +Completion Builtins::). + + Many of the builtins have been extended by POSIX or Bash. + + Unless otherwise noted, each builtin command documented as accepting +options preceded by '-' accepts '--' to signify the end of the options. +The ':', 'true', 'false', and 'test'/'[' builtins do not accept options +and do not treat '--' specially. The 'exit', 'logout', 'return', +'break', 'continue', 'let', and 'shift' builtins accept and process +arguments beginning with '-' without requiring '--'. Other builtins +that accept arguments but are not specified as accepting options +interpret arguments beginning with '-' as invalid options and require +'--' to prevent this interpretation. + + +File: bash.info, Node: Bourne Shell Builtins, Next: Bash Builtins, Up: Shell Builtin Commands + +4.1 Bourne Shell Builtins +========================= + +The following shell builtin commands are inherited from the Bourne +Shell. These commands are implemented as specified by the POSIX +standard. + +': (a colon)' + : [ARGUMENTS] + + Do nothing beyond expanding ARGUMENTS and performing redirections. + The return status is zero. + +'. (a period)' + . FILENAME [ARGUMENTS] + + Read and execute commands from the FILENAME argument in the current + shell context. If FILENAME does not contain a slash, the 'PATH' + variable is used to find FILENAME. When Bash is not in POSIX mode, + the current directory is searched if FILENAME is not found in + '$PATH'. If any ARGUMENTS are supplied, they become the positional + parameters when FILENAME is executed. Otherwise the positional + parameters are unchanged. If the '-T' option is enabled, 'source' + inherits any trap on 'DEBUG'; if it is not, any 'DEBUG' trap string + is saved and restored around the call to 'source', and 'source' + unsets the 'DEBUG' trap while it executes. If '-T' is not set, and + the sourced file changes the 'DEBUG' trap, the new value is + retained when 'source' completes. The return status is the exit + status of the last command executed, or zero if no commands are + executed. If FILENAME is not found, or cannot be read, the return + status is non-zero. This builtin is equivalent to 'source'. + +'break' + break [N] + + Exit from a 'for', 'while', 'until', or 'select' loop. If N is + supplied, the Nth enclosing loop is exited. N must be greater than + or equal to 1. The return status is zero unless N is not greater + than or equal to 1. + +'cd' + cd [-L|[-P [-e]] [-@] [DIRECTORY] + + Change the current working directory to DIRECTORY. If DIRECTORY is + not supplied, the value of the 'HOME' shell variable is used. Any + additional arguments following DIRECTORY are ignored. If the shell + variable 'CDPATH' exists, it is used as a search path: each + directory name in 'CDPATH' is searched for DIRECTORY, with + alternative directory names in 'CDPATH' separated by a colon (':'). + If DIRECTORY begins with a slash, 'CDPATH' is not used. + + The '-P' option means to not follow symbolic links: symbolic links + are resolved while 'cd' is traversing DIRECTORY and before + processing an instance of '..' in DIRECTORY. + + By default, or when the '-L' option is supplied, symbolic links in + DIRECTORY are resolved after 'cd' processes an instance of '..' in + DIRECTORY. + + If '..' appears in DIRECTORY, it is processed by removing the + immediately preceding pathname component, back to a slash or the + beginning of DIRECTORY. + + If the '-e' option is supplied with '-P' and the current working + directory cannot be successfully determined after a successful + directory change, 'cd' will return an unsuccessful status. + + On systems that support it, the '-@' option presents the extended + attributes associated with a file as a directory. + + If DIRECTORY is '-', it is converted to '$OLDPWD' before the + directory change is attempted. + + If a non-empty directory name from 'CDPATH' is used, or if '-' is + the first argument, and the directory change is successful, the + absolute pathname of the new working directory is written to the + standard output. + + The return status is zero if the directory is successfully changed, + non-zero otherwise. + +'continue' + continue [N] + + Resume the next iteration of an enclosing 'for', 'while', 'until', + or 'select' loop. If N is supplied, the execution of the Nth + enclosing loop is resumed. N must be greater than or equal to 1. + The return status is zero unless N is not greater than or equal to + 1. + +'eval' + eval [ARGUMENTS] + + The arguments are concatenated together into a single command, + which is then read and executed, and its exit status returned as + the exit status of 'eval'. If there are no arguments or only empty + arguments, the return status is zero. + +'exec' + exec [-cl] [-a NAME] [COMMAND [ARGUMENTS]] + + If COMMAND is supplied, it replaces the shell without creating a + new process. If the '-l' option is supplied, the shell places a + dash at the beginning of the zeroth argument passed to COMMAND. + This is what the 'login' program does. The '-c' option causes + COMMAND to be executed with an empty environment. If '-a' is + supplied, the shell passes NAME as the zeroth argument to COMMAND. + If COMMAND cannot be executed for some reason, a non-interactive + shell exits, unless the 'execfail' shell option is enabled. In + that case, it returns failure. An interactive shell returns + failure if the file cannot be executed. A subshell exits + unconditionally if 'exec' fails. If no COMMAND is specified, + redirections may be used to affect the current shell environment. + If there are no redirection errors, the return status is zero; + otherwise the return status is non-zero. + +'exit' + exit [N] + + Exit the shell, returning a status of N to the shell's parent. If + N is omitted, the exit status is that of the last command executed. + Any trap on 'EXIT' is executed before the shell terminates. + +'export' + export [-fn] [-p] [NAME[=VALUE]] + + Mark each NAME to be passed to child processes in the environment. + If the '-f' option is supplied, the NAMEs refer to shell functions; + otherwise the names refer to shell variables. The '-n' option + means to no longer mark each NAME for export. If no NAMES are + supplied, or if the '-p' option is given, a list of names of all + exported variables is displayed. The '-p' option displays output + in a form that may be reused as input. If a variable name is + followed by =VALUE, the value of the variable is set to VALUE. + + The return status is zero unless an invalid option is supplied, one + of the names is not a valid shell variable name, or '-f' is + supplied with a name that is not a shell function. + +'getopts' + getopts OPTSTRING NAME [ARGS] + + 'getopts' is used by shell scripts to parse positional parameters. + OPTSTRING contains the option characters to be recognized; if a + character is followed by a colon, the option is expected to have an + argument, which should be separated from it by whitespace. The + colon (':') and question mark ('?') may not be used as option + characters. Each time it is invoked, 'getopts' places the next + option in the shell variable NAME, initializing NAME if it does not + exist, and the index of the next argument to be processed into the + variable 'OPTIND'. 'OPTIND' is initialized to 1 each time the + shell or a shell script is invoked. When an option requires an + argument, 'getopts' places that argument into the variable + 'OPTARG'. The shell does not reset 'OPTIND' automatically; it must + be manually reset between multiple calls to 'getopts' within the + same shell invocation if a new set of parameters is to be used. + + When the end of options is encountered, 'getopts' exits with a + return value greater than zero. 'OPTIND' is set to the index of + the first non-option argument, and NAME is set to '?'. + + 'getopts' normally parses the positional parameters, but if more + arguments are given in ARGS, 'getopts' parses those instead. + + 'getopts' can report errors in two ways. If the first character of + OPTSTRING is a colon, SILENT error reporting is used. In normal + operation, diagnostic messages are printed when invalid options or + missing option arguments are encountered. If the variable 'OPTERR' + is set to 0, no error messages will be displayed, even if the first + character of 'optstring' is not a colon. + + If an invalid option is seen, 'getopts' places '?' into NAME and, + if not silent, prints an error message and unsets 'OPTARG'. If + 'getopts' is silent, the option character found is placed in + 'OPTARG' and no diagnostic message is printed. + + If a required argument is not found, and 'getopts' is not silent, a + question mark ('?') is placed in NAME, 'OPTARG' is unset, and a + diagnostic message is printed. If 'getopts' is silent, then a + colon (':') is placed in NAME and 'OPTARG' is set to the option + character found. + +'hash' + hash [-r] [-p FILENAME] [-dt] [NAME] + + Each time 'hash' is invoked, it remembers the full pathnames of the + commands specified as NAME arguments, so they need not be searched + for on subsequent invocations. The commands are found by searching + through the directories listed in '$PATH'. Any + previously-remembered pathname is discarded. The '-p' option + inhibits the path search, and FILENAME is used as the location of + NAME. The '-r' option causes the shell to forget all remembered + locations. The '-d' option causes the shell to forget the + remembered location of each NAME. If the '-t' option is supplied, + the full pathname to which each NAME corresponds is printed. If + multiple NAME arguments are supplied with '-t', the NAME is printed + before the hashed full pathname. The '-l' option causes output to + be displayed in a format that may be reused as input. If no + arguments are given, or if only '-l' is supplied, information about + remembered commands is printed. The return status is zero unless a + NAME is not found or an invalid option is supplied. + +'pwd' + pwd [-LP] + + Print the absolute pathname of the current working directory. If + the '-P' option is supplied, the pathname printed will not contain + symbolic links. If the '-L' option is supplied, the pathname + printed may contain symbolic links. The return status is zero + unless an error is encountered while determining the name of the + current directory or an invalid option is supplied. + +'readonly' + readonly [-aAf] [-p] [NAME[=VALUE]] ... + + Mark each NAME as readonly. The values of these names may not be + changed by subsequent assignment. If the '-f' option is supplied, + each NAME refers to a shell function. The '-a' option means each + NAME refers to an indexed array variable; the '-A' option means + each NAME refers to an associative array variable. If both options + are supplied, '-A' takes precedence. If no NAME arguments are + given, or if the '-p' option is supplied, a list of all readonly + names is printed. The other options may be used to restrict the + output to a subset of the set of readonly names. The '-p' option + causes output to be displayed in a format that may be reused as + input. If a variable name is followed by =VALUE, the value of the + variable is set to VALUE. The return status is zero unless an + invalid option is supplied, one of the NAME arguments is not a + valid shell variable or function name, or the '-f' option is + supplied with a name that is not a shell function. + +'return' + return [N] + + Cause a shell function to stop executing and return the value N to + its caller. If N is not supplied, the return value is the exit + status of the last command executed in the function. If 'return' + is executed by a trap handler, the last command used to determine + the status is the last command executed before the trap handler. + If 'return' is executed during a 'DEBUG' trap, the last command + used to determine the status is the last command executed by the + trap handler before 'return' was invoked. 'return' may also be + used to terminate execution of a script being executed with the '.' + ('source') builtin, returning either N or the exit status of the + last command executed within the script as the exit status of the + script. If N is supplied, the return value is its least + significant 8 bits. Any command associated with the 'RETURN' trap + is executed before execution resumes after the function or script. + The return status is non-zero if 'return' is supplied a non-numeric + argument or is used outside a function and not during the execution + of a script by '.' or 'source'. + +'shift' + shift [N] + + Shift the positional parameters to the left by N. The positional + parameters from N+1 ... '$#' are renamed to '$1' ... '$#'-N. + Parameters represented by the numbers '$#' to '$#'-N+1 are unset. + N must be a non-negative number less than or equal to '$#'. If N + is zero or greater than '$#', the positional parameters are not + changed. If N is not supplied, it is assumed to be 1. The return + status is zero unless N is greater than '$#' or less than zero, + non-zero otherwise. + +'test' +'[' + test EXPR + + Evaluate a conditional expression EXPR and return a status of 0 + (true) or 1 (false). Each operator and operand must be a separate + argument. Expressions are composed of the primaries described + below in *note Bash Conditional Expressions::. 'test' does not + accept any options, nor does it accept and ignore an argument of + '--' as signifying the end of options. + + When the '[' form is used, the last argument to the command must be + a ']'. + + Expressions may be combined using the following operators, listed + in decreasing order of precedence. The evaluation depends on the + number of arguments; see below. Operator precedence is used when + there are five or more arguments. + + '! EXPR' + True if EXPR is false. + + '( EXPR )' + Returns the value of EXPR. This may be used to override the + normal precedence of operators. + + 'EXPR1 -a EXPR2' + True if both EXPR1 and EXPR2 are true. + + 'EXPR1 -o EXPR2' + True if either EXPR1 or EXPR2 is true. + + The 'test' and '[' builtins evaluate conditional expressions using + a set of rules based on the number of arguments. + + 0 arguments + The expression is false. + + 1 argument + The expression is true if, and only if, the argument is not + null. + + 2 arguments + If the first argument is '!', the expression is true if and + only if the second argument is null. If the first argument is + one of the unary conditional operators (*note Bash Conditional + Expressions::), the expression is true if the unary test is + true. If the first argument is not a valid unary operator, + the expression is false. + + 3 arguments + The following conditions are applied in the order listed. + + 1. If the second argument is one of the binary conditional + operators (*note Bash Conditional Expressions::), the + result of the expression is the result of the binary test + using the first and third arguments as operands. The + '-a' and '-o' operators are considered binary operators + when there are three arguments. + 2. If the first argument is '!', the value is the negation + of the two-argument test using the second and third + arguments. + 3. If the first argument is exactly '(' and the third + argument is exactly ')', the result is the one-argument + test of the second argument. + 4. Otherwise, the expression is false. + + 4 arguments + If the first argument is '!', the result is the negation of + the three-argument expression composed of the remaining + arguments. Otherwise, the expression is parsed and evaluated + according to precedence using the rules listed above. + + 5 or more arguments + The expression is parsed and evaluated according to precedence + using the rules listed above. + + When used with 'test' or '[', the '<' and '>' operators sort + lexicographically using ASCII ordering. + +'times' + times + + Print out the user and system times used by the shell and its + children. The return status is zero. + +'trap' + trap [-lp] [ARG] [SIGSPEC ...] + + The commands in ARG are to be read and executed when the shell + receives signal SIGSPEC. If ARG is absent (and there is a single + SIGSPEC) or equal to '-', each specified signal's disposition is + reset to the value it had when the shell was started. If ARG is + the null string, then the signal specified by each SIGSPEC is + ignored by the shell and commands it invokes. If ARG is not + present and '-p' has been supplied, the shell displays the trap + commands associated with each SIGSPEC. If no arguments are + supplied, or only '-p' is given, 'trap' prints the list of commands + associated with each signal number in a form that may be reused as + shell input. The '-l' option causes the shell to print a list of + signal names and their corresponding numbers. Each SIGSPEC is + either a signal name or a signal number. Signal names are case + insensitive and the 'SIG' prefix is optional. + + If a SIGSPEC is '0' or 'EXIT', ARG is executed when the shell + exits. If a SIGSPEC is 'DEBUG', the command ARG is executed before + every simple command, 'for' command, 'case' command, 'select' + command, every arithmetic 'for' command, and before the first + command executes in a shell function. Refer to the description of + the 'extdebug' option to the 'shopt' builtin (*note The Shopt + Builtin::) for details of its effect on the 'DEBUG' trap. If a + SIGSPEC is 'RETURN', the command ARG is executed each time a shell + function or a script executed with the '.' or 'source' builtins + finishes executing. + + If a SIGSPEC is 'ERR', the command ARG is executed whenever a + pipeline (which may consist of a single simple command), a list, or + a compound command returns a non-zero exit status, subject to the + following conditions. The 'ERR' trap is not executed if the failed + command is part of the command list immediately following an + 'until' or 'while' keyword, part of the test following the 'if' or + 'elif' reserved words, part of a command executed in a '&&' or '||' + list except the command following the final '&&' or '||', any + command in a pipeline but the last, or if the command's return + status is being inverted using '!'. These are the same conditions + obeyed by the 'errexit' ('-e') option. + + Signals ignored upon entry to the shell cannot be trapped or reset. + Trapped signals that are not being ignored are reset to their + original values in a subshell or subshell environment when one is + created. + + The return status is zero unless a SIGSPEC does not specify a valid + signal. + +'umask' + umask [-p] [-S] [MODE] + + Set the shell process's file creation mask to MODE. If MODE begins + with a digit, it is interpreted as an octal number; if not, it is + interpreted as a symbolic mode mask similar to that accepted by the + 'chmod' command. If MODE is omitted, the current value of the mask + is printed. If the '-S' option is supplied without a MODE + argument, the mask is printed in a symbolic format. If the '-p' + option is supplied, and MODE is omitted, the output is in a form + that may be reused as input. The return status is zero if the mode + is successfully changed or if no MODE argument is supplied, and + non-zero otherwise. + + Note that when the mode is interpreted as an octal number, each + number of the umask is subtracted from '7'. Thus, a umask of '022' + results in permissions of '755'. + +'unset' + unset [-fnv] [NAME] + + Remove each variable or function NAME. If the '-v' option is + given, each NAME refers to a shell variable and that variable is + removed. If the '-f' option is given, the NAMEs refer to shell + functions, and the function definition is removed. If the '-n' + option is supplied, and NAME is a variable with the NAMEREF + attribute, NAME will be unset rather than the variable it + references. '-n' has no effect if the '-f' option is supplied. If + no options are supplied, each NAME refers to a variable; if there + is no variable by that name, any function with that name is unset. + Readonly variables and functions may not be unset. The return + status is zero unless a NAME is readonly. + + +File: bash.info, Node: Bash Builtins, Next: Modifying Shell Behavior, Prev: Bourne Shell Builtins, Up: Shell Builtin Commands + +4.2 Bash Builtin Commands +========================= + +This section describes builtin commands which are unique to or have been +extended in Bash. Some of these commands are specified in the POSIX +standard. + +'alias' + alias [-p] [NAME[=VALUE] ...] + + Without arguments or with the '-p' option, 'alias' prints the list + of aliases on the standard output in a form that allows them to be + reused as input. 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. Aliases are described in *note + Aliases::. + +'bind' + bind [-m KEYMAP] [-lpsvPSVX] + bind [-m KEYMAP] [-q FUNCTION] [-u FUNCTION] [-r KEYSEQ] + bind [-m KEYMAP] -f FILENAME + bind [-m KEYMAP] -x KEYSEQ:SHELL-COMMAND + bind [-m KEYMAP] KEYSEQ:FUNCTION-NAME + bind [-m KEYMAP] KEYSEQ:READLINE-COMMAND + + Display current Readline (*note Command Line Editing::) key and + function bindings, bind a key sequence to a Readline function or + macro, or set a Readline variable. Each non-option argument is a + command as it would appear in a Readline initialization file (*note + Readline Init File::), but each binding or command must be passed + as a separate argument; e.g., '"\C-x\C-r":re-read-init-file'. + + Options, if supplied, have the following meanings: + + '-m KEYMAP' + Use KEYMAP as the keymap to be affected by the subsequent + bindings. Acceptable KEYMAP names are 'emacs', + 'emacs-standard', 'emacs-meta', 'emacs-ctlx', 'vi', 'vi-move', + 'vi-command', and 'vi-insert'. 'vi' is equivalent to + 'vi-command' ('vi-move' is also a synonym); 'emacs' is + equivalent to 'emacs-standard'. + + '-l' + List the names of all Readline functions. + + '-p' + Display Readline function names and bindings in such a way + that they can be used as input or in a Readline initialization + file. + + '-P' + List current Readline function names and bindings. + + '-v' + Display Readline variable names and values in such a way that + they can be used as input or in a Readline initialization + file. + + '-V' + List current Readline variable names and values. + + '-s' + Display Readline key sequences bound to macros and the strings + they output in such a way that they can be used as input or in + a Readline initialization file. + + '-S' + Display Readline key sequences bound to macros and the strings + they output. + + '-f FILENAME' + Read key bindings from FILENAME. + + '-q FUNCTION' + Query about which keys invoke the named FUNCTION. + + '-u FUNCTION' + Unbind all keys bound to the named FUNCTION. + + '-r KEYSEQ' + Remove any current binding for KEYSEQ. + + '-x KEYSEQ:SHELL-COMMAND' + Cause SHELL-COMMAND to be executed whenever KEYSEQ is entered. + When SHELL-COMMAND is executed, the shell sets the + 'READLINE_LINE' variable to the contents of the Readline line + buffer and the 'READLINE_POINT' variable to the current + location of the insertion point. If the executed command + changes the value of 'READLINE_LINE' or 'READLINE_POINT', + those new values will be reflected in the editing state. + + '-X' + List all key sequences bound to shell commands and the + associated commands in a format that can be reused as input. + + The return status is zero unless an invalid option is supplied or + an error occurs. + +'builtin' + builtin [SHELL-BUILTIN [ARGS]] + + Run a shell builtin, passing it ARGS, and return its exit status. + This is useful when defining a shell function with the same name as + a shell builtin, retaining the functionality of the builtin within + the function. The return status is non-zero if SHELL-BUILTIN is + not a shell builtin command. + +'caller' + caller [EXPR] + + Returns the context of any active subroutine call (a shell function + or a script executed with the '.' or 'source' builtins). + + Without EXPR, 'caller' displays the line number and source filename + of the current subroutine call. If a non-negative integer is + supplied as EXPR, 'caller' displays the line number, subroutine + name, and source file corresponding to that position in the current + execution call stack. This extra information may be used, for + example, to print a stack trace. The current frame is frame 0. + + The return value is 0 unless the shell is not executing a + subroutine call or EXPR does not correspond to a valid position in + the call stack. + +'command' + command [-pVv] COMMAND [ARGUMENTS ...] + + Runs COMMAND with ARGUMENTS ignoring any shell function named + COMMAND. Only shell builtin commands or commands found by + searching the 'PATH' are executed. If there is a shell function + named 'ls', running 'command ls' within the function will execute + the external command 'ls' instead of calling the function + recursively. The '-p' option means to use a default value for + 'PATH' that is guaranteed to find all of the standard utilities. + The return status in this case is 127 if COMMAND cannot be found or + an error occurred, and the exit status of COMMAND otherwise. + + If either the '-V' or '-v' option is supplied, a description of + COMMAND is printed. The '-v' option causes a single word + indicating the command or file name used to invoke COMMAND to be + displayed; the '-V' option produces a more verbose description. In + this case, the return status is zero if COMMAND is found, and + non-zero if not. + +'declare' + declare [-aAfFgilnrtux] [-p] [NAME[=VALUE] ...] + + Declare variables and give them attributes. If no NAMEs are given, + then display the values of variables instead. + + The '-p' option will display the attributes and values of each + NAME. When '-p' is used with NAME arguments, additional options, + other than '-f' and '-F', are ignored. + + When '-p' is supplied without NAME arguments, 'declare' will + display the attributes and values of all variables having the + attributes specified by the additional options. If no other + options are supplied with '-p', 'declare' will display the + attributes and values of all shell variables. The '-f' option will + restrict the display to shell functions. + + The '-F' option inhibits the display of function definitions; only + the function name and attributes are printed. If the 'extdebug' + shell option is enabled using 'shopt' (*note The Shopt Builtin::), + the source file name and line number where each NAME is defined are + displayed as well. '-F' implies '-f'. + + The '-g' option forces variables to be created or modified at the + global scope, even when 'declare' is executed in a shell function. + It is ignored in all other cases. + + The following options can be used to restrict output to variables + with the specified attributes or to give variables attributes: + + '-a' + Each NAME is an indexed array variable (*note Arrays::). + + '-A' + Each NAME is an associative array variable (*note Arrays::). + + '-f' + Use function names only. + + '-i' + The variable is to be treated as an integer; arithmetic + evaluation (*note Shell Arithmetic::) is performed when the + variable is assigned a value. + + '-l' + When the variable is assigned a value, all upper-case + characters are converted to lower-case. The upper-case + attribute is disabled. + + '-n' + Give each NAME the NAMEREF attribute, making it a name + reference to another variable. That other variable is defined + by the value of NAME. All references, assignments, and + attribute modifications to NAME, except for those using or + changing the '-n' attribute itself, are performed on the + variable referenced by NAME's value. The nameref attribute + cannot be applied to array variables. + + '-r' + Make NAMEs readonly. These names cannot then be assigned + values by subsequent assignment statements or unset. + + '-t' + Give each NAME the 'trace' attribute. Traced functions + inherit the 'DEBUG' and 'RETURN' traps from the calling shell. + The trace attribute has no special meaning for variables. + + '-u' + When the variable is assigned a value, all lower-case + characters are converted to upper-case. The lower-case + attribute is disabled. + + '-x' + Mark each NAME for export to subsequent commands via the + environment. + + Using '+' instead of '-' turns off the attribute instead, with the + exceptions that '+a' and '+A' may not be used to destroy array + variables and '+r' will not remove the readonly attribute. When + used in a function, 'declare' makes each NAME local, as with the + 'local' command, unless the '-g' option is used. If a variable + name is followed by =VALUE, the value of the variable is set to + VALUE. + + When using '-a' or '-A' and the compound assignment syntax to + create array variables, additional attributes do not take effect + until subsequent assignments. + + The return status is zero unless an invalid option is encountered, + an attempt is made to define a function using '-f foo=bar', an + attempt is made to assign a value to a readonly variable, an + attempt is made to assign a value to an array variable without + using the compound assignment syntax (*note Arrays::), one of the + NAMES is not a valid shell variable name, an attempt is made to + turn off readonly status for a readonly variable, an attempt is + made to turn off array status for an array variable, or an attempt + is made to display a non-existent function with '-f'. + +'echo' + echo [-neE] [ARG ...] + + Output the ARGs, separated by spaces, terminated with a newline. + The return status is 0 unless a write error occurs. If '-n' is + specified, the trailing newline is suppressed. If the '-e' option + is given, interpretation of the following backslash-escaped + characters is enabled. The '-E' option disables the interpretation + of these escape characters, even on systems where they are + interpreted by default. The 'xpg_echo' shell option may be used to + dynamically determine whether or not 'echo' expands these escape + characters by default. 'echo' does not interpret '--' to mean the + end of options. + + 'echo' interprets the following escape sequences: + '\a' + alert (bell) + '\b' + backspace + '\c' + suppress further output + '\e' + '\E' + escape + '\f' + form feed + '\n' + new line + '\r' + carriage return + '\t' + horizontal tab + '\v' + vertical tab + '\\' + backslash + '\0NNN' + the eight-bit character whose value is the octal value NNN + (zero to three octal digits) + '\xHH' + the eight-bit character whose value is the hexadecimal value + HH (one or two hex digits) + '\uHHHH' + the Unicode (ISO/IEC 10646) character whose value is the + hexadecimal value HHHH (one to four hex digits) + '\UHHHHHHHH' + the Unicode (ISO/IEC 10646) character whose value is the + hexadecimal value HHHHHHHH (one to eight hex digits) + +'enable' + enable [-a] [-dnps] [-f FILENAME] [NAME ...] + + Enable and disable builtin shell commands. Disabling a builtin + allows a disk command which has the same name as a shell builtin to + be executed without specifying a full pathname, even though the + shell normally searches for builtins before disk commands. 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'. + + If the '-p' option is supplied, or no NAME arguments appear, a list + of shell builtins is printed. With no other arguments, the list + consists of all enabled shell builtins. The '-a' option means to + list each builtin with an indication of whether or not it is + enabled. + + The '-f' option means to load the new builtin command NAME from + shared object FILENAME, on systems that support dynamic loading. + The '-d' option will delete a builtin loaded with '-f'. + + If there are no options, a list of the shell builtins is displayed. + The '-s' option restricts 'enable' to the POSIX special builtins. + If '-s' is used with '-f', the new builtin becomes a special + builtin (*note Special Builtins::). + + The return status is zero unless a NAME is not a shell builtin or + there is an error loading a new builtin from a shared object. + +'help' + help [-dms] [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. + + Options, if supplied, have the following meanings: + + '-d' + Display a short description of each PATTERN + '-m' + Display the description of each PATTERN in a manpage-like + format + '-s' + Display only a short usage synopsis for each PATTERN + + The return status is zero unless no command matches PATTERN. + +'let' + let EXPRESSION [EXPRESSION ...] + + The 'let' builtin allows arithmetic to be performed on shell + variables. Each EXPRESSION is evaluated according to the rules + given below in *note Shell Arithmetic::. If the last EXPRESSION + evaluates to 0, 'let' returns 1; otherwise 0 is returned. + +'local' + local [OPTION] NAME[=VALUE] ... + + For each argument, a local variable named NAME is created, and + assigned VALUE. The OPTION can be any of the options accepted by + 'declare'. 'local' can only be used within a function; it makes + the variable NAME have a visible scope restricted to that function + and its children. If NAME is '-', the set of shell options is made + local to the function in which 'local' is invoked: shell options + changed using the 'set' builtin inside the function are restored to + their original values when the function returns. The return status + is zero unless 'local' is used outside a function, an invalid NAME + is supplied, or NAME is a readonly variable. + +'logout' + logout [N] + + Exit a login shell, returning a status of N to the shell's parent. + +'mapfile' + mapfile [-d DELIM] [-n COUNT] [-O ORIGIN] [-s COUNT] + [-t] [-u FD] [-C CALLBACK] [-c QUANTUM] [ARRAY] + + Read lines from the standard input into the indexed array variable + ARRAY, or from file descriptor FD if the '-u' option is supplied. + The variable 'MAPFILE' is the default ARRAY. Options, if supplied, + have the following meanings: + + '-d' + The first character of DELIM is used to terminate each input + line, rather than newline. If DELIM is the empty string, + 'mapfile' will terminate a line when it reads a NUL character. + '-n' + Copy at most COUNT lines. If COUNT is 0, all lines are + copied. + '-O' + Begin assigning to ARRAY at index ORIGIN. The default index + is 0. + '-s' + Discard the first COUNT lines read. + '-t' + Remove a trailing DELIM (default newline) from each line read. + '-u' + Read lines from file descriptor FD instead of the standard + input. + '-C' + Evaluate CALLBACK each time QUANTUM lines are read. The '-c' + option specifies QUANTUM. + '-c' + Specify the number of lines read between each call to + CALLBACK. + + If '-C' is specified without '-c', the default quantum is 5000. + When CALLBACK is evaluated, it is supplied the index of the next + array element to be assigned and the line to be assigned to that + element as additional arguments. CALLBACK is evaluated after the + line is read but before the array element is assigned. + + If not supplied with an explicit origin, 'mapfile' will clear ARRAY + before assigning to it. + + 'mapfile' returns successfully unless an invalid option or option + argument is supplied, ARRAY is invalid or unassignable, or ARRAY is + not an indexed array. + +'printf' + printf [-v VAR] FORMAT [ARGUMENTS] + + Write the formatted ARGUMENTS to the standard output under the + control of the FORMAT. The '-v' option causes the output to be + assigned to the variable VAR rather than being printed to the + standard output. + + The FORMAT is a character string which contains three types of + objects: plain characters, which are simply copied to standard + output, character escape sequences, which are converted and copied + to the standard output, and format specifications, each of which + causes printing of the next successive ARGUMENT. In addition to + the standard 'printf(1)' formats, 'printf' interprets the following + extensions: + + '%b' + Causes 'printf' to expand backslash escape sequences in the + corresponding ARGUMENT in the same way as 'echo -e' (*note + Bash Builtins::). + '%q' + Causes 'printf' to output the corresponding ARGUMENT in a + format that can be reused as shell input. + '%(DATEFMT)T' + Causes 'printf' to output the date-time string resulting from + using DATEFMT as a format string for 'strftime'(3). The + corresponding ARGUMENT is an integer representing the number + of seconds since the epoch. Two special argument values may + be used: -1 represents the current time, and -2 represents the + time the shell was invoked. If no argument is specified, + conversion behaves as if -1 had been given. This is an + exception to the usual 'printf' behavior. + + Arguments to non-string format specifiers are treated as C language + constants, except that a leading plus or minus sign is allowed, and + if the leading character is a single or double quote, the value is + the ASCII value of the following character. + + The FORMAT is reused as necessary to consume all of the ARGUMENTS. + If the FORMAT requires more ARGUMENTS than are supplied, the extra + format specifications behave as if a zero value or null string, as + appropriate, had been supplied. The return value is zero on + success, non-zero on failure. + +'read' + read [-ers] [-a ANAME] [-d DELIM] [-i TEXT] [-n NCHARS] + [-N NCHARS] [-p PROMPT] [-t TIMEOUT] [-u FD] [NAME ...] + + One line is read from the standard input, or from the file + descriptor FD supplied as an argument to the '-u' option, split + into words as described above in *note Word Splitting::, and the + first word is assigned to the first NAME, the second word to the + second NAME, and so on. If there are more words than names, the + remaining words and their intervening delimiters are assigned to + the last NAME. If there are fewer words read from the input stream + than names, the remaining names are assigned empty values. The + characters in the value of the 'IFS' variable are used to split the + line into words using the same rules the shell uses for expansion + (described above in *note Word Splitting::). The backslash + character '\' may be used to remove any special meaning for the + next character read and for line continuation. If no names are + supplied, the line read is assigned to the variable 'REPLY'. The + exit status is zero, unless end-of-file is encountered, 'read' + times out (in which case the status is greater than 128), a + variable assignment error (such as assigning to a readonly + variable) occurs, or an invalid file descriptor is supplied as the + argument to '-u'. + + Options, if supplied, have the following meanings: + + '-a ANAME' + The words are assigned to sequential indices of the array + variable ANAME, starting at 0. All elements are removed from + ANAME before the assignment. Other NAME arguments are + ignored. + + '-d DELIM' + The first character of DELIM is used to terminate the input + line, rather than newline. If DELIM is the empty string, + 'read' will terminate a line when it reads a NUL character. + + '-e' + Readline (*note Command Line Editing::) is used to obtain the + line. Readline uses the current (or default, if line editing + was not previously active) editing settings, but uses + Readline's default filename completion. + + '-i TEXT' + If Readline is being used to read the line, TEXT is placed + into the editing buffer before editing begins. + + '-n NCHARS' + 'read' returns after reading NCHARS characters rather than + waiting for a complete line of input, but honors a delimiter + if fewer than NCHARS characters are read before the delimiter. + + '-N NCHARS' + 'read' returns after reading exactly NCHARS characters rather + than waiting for a complete line of input, unless EOF is + encountered or 'read' times out. Delimiter characters + encountered in the input are not treated specially and do not + cause 'read' to return until NCHARS characters are read. The + result is not split on the characters in 'IFS'; the intent is + that the variable is assigned exactly the characters read + (with the exception of backslash; see the '-r' option below). + + '-p PROMPT' + Display PROMPT, without a trailing newline, before attempting + to read any input. The prompt is displayed only if input is + coming from a terminal. + + '-r' + If this option is given, backslash does not act as an escape + character. The backslash is considered to be part of the + line. In particular, a backslash-newline pair may not then be + used as a line continuation. + + '-s' + Silent mode. If input is coming from a terminal, characters + are not echoed. + + '-t TIMEOUT' + Cause 'read' to time out and return failure if a complete line + of input (or a specified number of characters) is not read + within TIMEOUT seconds. TIMEOUT may be a decimal number with + a fractional portion following the decimal point. This option + is only effective if 'read' is reading input from a terminal, + pipe, or other special file; it has no effect when reading + from regular files. If 'read' times out, 'read' saves any + partial input read into the specified variable NAME. If + TIMEOUT is 0, 'read' returns immediately, without trying to + read and data. The exit status is 0 if input is available on + the specified file descriptor, non-zero otherwise. The exit + status is greater than 128 if the timeout is exceeded. + + '-u FD' + Read input from file descriptor FD. + +'readarray' + readarray [-d DELIM] [-n COUNT] [-O ORIGIN] [-s COUNT] + [-t] [-u FD] [-C CALLBACK] [-c QUANTUM] [ARRAY] + + Read lines from the standard input into the indexed array variable + ARRAY, or from file descriptor FD if the '-u' option is supplied. + + A synonym for 'mapfile'. + +'source' + source FILENAME + + A synonym for '.' (*note Bourne Shell Builtins::). + +'type' + type [-afptP] [NAME ...] + + For each NAME, indicate how it would be interpreted if used as a + command name. + + If the '-t' option is used, 'type' prints 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 NAME is not found, then + nothing is printed, and 'type' returns a failure status. + + If the '-p' option is used, 'type' either returns the name of the + disk file that would be executed, or nothing if '-t' would not + return 'file'. + + The '-P' option forces a path search for each NAME, even if '-t' + would not return 'file'. + + If a command is hashed, '-p' and '-P' print the hashed value, which + is not necessarily the file that appears first in '$PATH'. + + If the '-a' option is used, 'type' returns all of the places that + contain an executable named FILE. This includes aliases and + functions, if and only if the '-p' option is not also used. + + If the '-f' option is used, 'type' does not attempt to find shell + functions, as with the 'command' builtin. + + The return status is zero if all of the NAMES are found, non-zero + if any are not found. + +'typeset' + typeset [-afFgrxilnrtux] [-p] [NAME[=VALUE] ...] + + The 'typeset' command is supplied for compatibility with the Korn + shell. It is a synonym for the 'declare' builtin command. + +'ulimit' + ulimit [-HSabcdefiklmnpqrstuvxPT] [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. + + '-H' + Change and report the hard limit associated with a resource. + + '-a' + All current limits are reported. + + '-b' + The maximum socket buffer size. + + '-c' + The maximum size of core files created. + + '-d' + The maximum size of a process's data segment. + + '-e' + The maximum scheduling priority ("nice"). + + '-f' + The maximum size of files written by the shell and its + children. + + '-i' + The maximum number of pending signals. + + '-k' + The maximum number of kqueues that may be allocated. + + '-l' + The maximum size that may be locked into memory. + + '-m' + The maximum resident set size (many systems do not honor this + limit). + + '-n' + The maximum number of open file descriptors (most systems do + not allow this value to be set). + + '-p' + The pipe buffer size. + + '-q' + The maximum number of bytes in POSIX message queues. + + '-r' + The maximum real-time scheduling priority. + + '-s' + The maximum stack size. + + '-t' + The maximum amount of cpu time in seconds. + + '-u' + The maximum number of processes available to a single user. + + '-v' + The maximum amount of virtual memory available to the shell, + and, on some systems, to its children. + + '-x' + The maximum number of file locks. + + '-P' + The maximum number of pseudoterminals. + + '-T' + The maximum number of threads. + + If LIMIT is given, and the '-a' option is not used, LIMIT is the + new value of the specified resource. The special LIMIT values + 'hard', 'soft', and 'unlimited' stand for the current hard limit, + the current soft limit, and no limit, respectively. A hard limit + cannot be increased by a non-root user once it is set; a soft limit + may be increased up to the value of the hard limit. Otherwise, the + current value of the soft limit for the specified resource is + printed, unless the '-H' option is supplied. When setting new + limits, if neither '-H' nor '-S' is supplied, both the hard and + soft limits are set. 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; '-P', '-T', + '-b', '-k', '-n' and '-u', which are unscaled values; and, when in + POSIX Mode (*note Bash POSIX Mode::), '-c' and '-f', which are in + 512-byte increments. + + The return status is zero unless an invalid option or argument is + supplied, or an error occurs while setting a new limit. + +'unalias' + unalias [-a] [NAME ... ] + + Remove each NAME from the list of aliases. If '-a' is supplied, + all aliases are removed. Aliases are described in *note Aliases::. + + +File: bash.info, Node: Modifying Shell Behavior, Next: Special Builtins, Prev: Bash Builtins, Up: Shell Builtin Commands + +4.3 Modifying Shell Behavior +============================ + +* Menu: + +* The Set Builtin:: Change the values of shell attributes and + positional parameters. +* The Shopt Builtin:: Modify shell optional behavior. + + +File: bash.info, Node: The Set Builtin, Next: The Shopt Builtin, Up: Modifying Shell Behavior + +4.3.1 The Set Builtin +--------------------- + +This builtin is so complicated that it deserves its own section. 'set' +allows you to change the values of shell options and set the positional +parameters, or to display the names and values of shell variables. + +'set' + set [--abefhkmnptuvxBCEHPT] [-o OPTION-NAME] [ARGUMENT ...] + set [+abefhkmnptuvxBCEHPT] [+o OPTION-NAME] [ARGUMENT ...] + + If no options or arguments are supplied, 'set' displays the names + and values of all shell variables and functions, sorted according + to the current locale, in a format that may be reused as input for + setting or resetting the currently-set variables. Read-only + variables cannot be reset. In POSIX mode, only shell variables are + listed. + + When options are supplied, they set or unset shell attributes. + Options, if specified, have the following meanings: + + '-a' + Each variable or function that is created or modified is given + the export attribute and marked for export to the environment + of subsequent commands. + + '-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 pipeline (*note Pipelines::), which may + consist of a single simple command (*note Simple Commands::), + a list (*note Lists::), or a compound command (*note Compound + Commands::) returns a non-zero status. The shell does not + exit if the command that fails is part of the command list + immediately following a 'while' or 'until' keyword, part of + the test in an 'if' statement, part of any command executed in + a '&&' or '||' list except the command following the final + '&&' or '||', any command in a pipeline but the last, or if + the command's return status is being inverted with '!'. If a + compound command other than a subshell returns a non-zero + status because a command failed while '-e' was being ignored, + the shell does not exit. A trap on 'ERR', if set, is executed + before the shell exits. + + This option applies to the shell environment and each subshell + environment separately (*note Command Execution + Environment::), and may cause subshells to exit before + executing all the commands in the subshell. + + If a compound command or shell function executes in a context + where '-e' is being ignored, none of the commands executed + within the compound command or function body will be affected + by the '-e' setting, even if '-e' is set and a command returns + a failure status. If a compound command or shell function + sets '-e' while executing in a context where '-e' is ignored, + that setting will not have any effect until the compound + command or the command containing the function call completes. + + '-f' + Disable filename expansion (globbing). + + '-h' + Locate and remember (hash) commands as they are looked up for + execution. This option is enabled by default. + + '-k' + All arguments in the form of assignment statements are placed + in the environment for a command, not just those that precede + the command name. + + '-m' + Job control is enabled (*note Job Control::). All processes + run in a separate process group. When a background job + completes, the shell prints a line containing its exit status. + + '-n' + Read commands but do not execute them. This may be used to + check a script for syntax errors. This option is ignored by + interactive shells. + + '-o OPTION-NAME' + + Set the option corresponding to OPTION-NAME: + + 'allexport' + Same as '-a'. + + 'braceexpand' + Same as '-B'. + + 'emacs' + Use an 'emacs'-style line editing interface (*note + Command Line Editing::). This also affects the editing + interface used for 'read -e'. + + 'errexit' + Same as '-e'. + + 'errtrace' + Same as '-E'. + + 'functrace' + Same as '-T'. + + 'hashall' + Same as '-h'. + + 'histexpand' + Same as '-H'. + + 'history' + Enable command history, as described in *note Bash + History Facilities::. This option is on by default in + interactive shells. + + 'ignoreeof' + An interactive shell will not exit upon reading EOF. + + 'keyword' + Same as '-k'. + + 'monitor' + Same as '-m'. + + 'noclobber' + Same as '-C'. + + 'noexec' + Same as '-n'. + + 'noglob' + Same as '-f'. + + 'nolog' + Currently ignored. + + 'notify' + Same as '-b'. + + 'nounset' + Same as '-u'. + + 'onecmd' + Same as '-t'. + + 'physical' + Same as '-P'. + + 'pipefail' + If set, the return value of a pipeline is the value of + the last (rightmost) command to exit with a non-zero + status, or zero if all commands in the pipeline exit + successfully. This option is disabled by default. + + 'posix' + Change the behavior of Bash where the default operation + differs from the POSIX standard to match the standard + (*note Bash POSIX Mode::). 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. This also + affects the editing interface used for 'read -e'. + + 'xtrace' + Same as '-x'. + + '-p' + Turn on privileged mode. In this mode, the '$BASH_ENV' and + '$ENV' files are not processed, shell functions are not + inherited from the environment, and the 'SHELLOPTS', + 'BASHOPTS', 'CDPATH' and 'GLOBIGNORE' variables, if they + appear in the environment, are ignored. If the shell is + started with the effective user (group) id not equal to the + real user (group) id, and the '-p' option is not supplied, + these actions are taken and the effective user id is set to + the real user id. If the '-p' option is supplied at startup, + the effective user id is not reset. Turning this option off + causes the effective user and group ids to be set to the real + user and group ids. + + '-t' + Exit after reading and executing one command. + + '-u' + Treat unset variables and parameters other than the special + parameters '@' or '*' as an error when performing parameter + expansion. An error message will be written to the standard + error, and a non-interactive shell will exit. + + '-v' + Print shell input lines as they are read. + + '-x' + Print a trace of simple commands, 'for' commands, 'case' + commands, 'select' commands, and arithmetic 'for' commands and + their arguments or associated word lists after they are + expanded and before they are executed. The value of the 'PS4' + variable is expanded and the resultant value is printed before + the command and its expanded arguments. + + '-B' + The shell will perform brace expansion (*note Brace + Expansion::). This option is on by default. + + '-C' + Prevent output redirection using '>', '>&', and '<>' from + overwriting existing files. + + '-E' + If set, any trap on 'ERR' is inherited by shell functions, + command substitutions, and commands executed in a subshell + environment. The 'ERR' trap is normally not inherited in such + cases. + + '-H' + Enable '!' style history substitution (*note History + Interaction::). This option is on by default for interactive + shells. + + '-P' + If set, do not resolve symbolic links when performing commands + such as 'cd' which change the current directory. The physical + directory is used instead. By default, Bash follows the + logical chain of directories when performing commands which + change the current directory. + + For example, if '/usr/sys' is a symbolic link to + '/usr/local/sys' then: + $ cd /usr/sys; echo $PWD + /usr/sys + $ cd ..; pwd + /usr + + If 'set -P' is on, then: + $ cd /usr/sys; echo $PWD + /usr/local/sys + $ cd ..; pwd + /usr/local + + '-T' + If set, any trap on 'DEBUG' and 'RETURN' are inherited by + shell functions, command substitutions, and commands executed + in a subshell environment. The 'DEBUG' and 'RETURN' traps are + normally not inherited in such cases. + + '--' + If no arguments follow this option, 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 options to be turned off. + The options can also be used upon invocation of the shell. The + current set of options may be found in '$-'. + + The remaining N ARGUMENTS are positional parameters and are + assigned, in order, to '$1', '$2', ... '$N'. The special parameter + '#' is set to N. + + The return status is always zero unless an invalid option is + supplied. + + +File: bash.info, Node: The Shopt Builtin, Prev: The Set Builtin, Up: Modifying Shell Behavior + +4.3.2 The Shopt Builtin +----------------------- + +This builtin allows you to change additional shell optional behavior. + +'shopt' + shopt [-pqsu] [-o] [OPTNAME ...] + + Toggle the values of settings controlling optional shell behavior. + The settings can be either those listed below, or, if the '-o' + option is used, those available with the '-o' option to the 'set' + builtin command (*note The Set Builtin::). With no options, or + with the '-p' option, a list of all settable options is displayed, + with an indication of whether or not each is set; if OPTNAMES are + supplied, the output is restricted to those options. The '-p' + option causes output to be displayed in a form that may be reused + as input. Other options have the following meanings: + + '-s' + Enable (set) each OPTNAME. + + '-u' + Disable (unset) each OPTNAME. + + '-q' + Suppresses normal output; the return status indicates whether + the OPTNAME is set or unset. If multiple OPTNAME arguments + are given with '-q', the return status is zero if all OPTNAMES + are enabled; non-zero otherwise. + + '-o' + Restricts the values of OPTNAME to be those defined for the + '-o' option to the 'set' builtin (*note The Set Builtin::). + + If either '-s' or '-u' is used with no OPTNAME arguments, 'shopt' + shows only those options which are set or unset, respectively. + + Unless otherwise noted, the 'shopt' options are disabled (off) by + default. + + The return status when listing options is zero if all OPTNAMES are + enabled, non-zero otherwise. When setting or unsetting options, + the return status is zero unless an OPTNAME is not a valid shell + option. + + The list of 'shopt' options is: + + 'assoc_expand_once' + If set, the shell suppresses multiple evaluation of + associative array subscripts during arithmetic expression + evaluation, while executing builtins that can perform variable + assignments, and while executing builtins that perform array + dereferencing. + + 'autocd' + If set, a command name that is the name of a directory is + executed as if it were the argument to the 'cd' command. This + option is only used by interactive shells. + + 'cdable_vars' + If this is set, an argument to the 'cd' builtin command that + is not a directory is assumed to be the name of a variable + whose value is the directory to change to. + + 'cdspell' + If set, minor errors in the spelling of a directory component + in a 'cd' command will be corrected. The errors checked for + are transposed characters, a missing character, and a + character too many. If a correction is found, the corrected + path is printed, and the command proceeds. This option is + only used by interactive shells. + + 'checkhash' + If this is set, Bash checks that a command found in the hash + table exists before trying to execute it. If a hashed command + no longer exists, a normal path search is performed. + + 'checkjobs' + If set, Bash lists the status of any stopped and running jobs + before exiting an interactive shell. If any jobs are running, + this causes the exit to be deferred until a second exit is + attempted without an intervening command (*note Job + Control::). The shell always postpones exiting if any jobs + are stopped. + + 'checkwinsize' + If set, Bash checks the window size after each external + (non-builtin) command and, if necessary, updates the values of + 'LINES' and 'COLUMNS'. This option is enabled by default. + + 'cmdhist' + If set, Bash attempts to save all lines of a multiple-line + command in the same history entry. This allows easy + re-editing of multi-line commands. This option is enabled by + default, but only has an effect if command history is enabled + (*note Bash History Facilities::). + + 'compat31' + If set, Bash changes its behavior to that of version 3.1 with + respect to quoted arguments to the conditional command's '=~' + operator and with respect to locale-specific string comparison + when using the '[[' conditional command's '<' and '>' + operators. Bash versions prior to bash-4.1 use ASCII + collation and strcmp(3); bash-4.1 and later use the current + locale's collation sequence and strcoll(3). + + 'compat32' + If set, Bash changes its behavior to that of version 3.2 with + respect to locale-specific string comparison when using the + '[[' conditional command's '<' and '>' operators (see previous + item) and the effect of interrupting a command list. Bash + versions 3.2 and earlier continue with the next command in the + list after one terminates due to an interrupt. + + 'compat40' + If set, Bash changes its behavior to that of version 4.0 with + respect to locale-specific string comparison when using the + '[[' conditional command's '<' and '>' operators (see + description of 'compat31') and the effect of interrupting a + command list. Bash versions 4.0 and later interrupt the list + as if the shell received the interrupt; previous versions + continue with the next command in the list. + + 'compat41' + If set, Bash, when in POSIX mode, treats a single quote in a + double-quoted parameter expansion as a special character. The + single quotes must match (an even number) and the characters + between the single quotes are considered quoted. This is the + behavior of POSIX mode through version 4.1. The default Bash + behavior remains as in previous versions. + + 'compat42' + If set, Bash does not process the replacement string in the + pattern substitution word expansion using quote removal. + + 'compat43' + If set, Bash does not print a warning message if an attempt is + made to use a quoted compound array assignment as an argument + to 'declare', makes word expansion errors non-fatal errors + that cause the current command to fail (the default behavior + is to make them fatal errors that cause the shell to exit), + and does not reset the loop state when a shell function is + executed (this allows 'break' or 'continue' in a shell + function to affect loops in the caller's context). + + 'compat44' + If set, Bash saves the positional parameters to BASH_ARGV and + BASH_ARGC before they are used, regardless of whether or not + extended debugging mode is enabled. + + 'complete_fullquote' + If set, Bash quotes all shell metacharacters in filenames and + directory names when performing completion. If not set, Bash + removes metacharacters such as the dollar sign from the set of + characters that will be quoted in completed filenames when + these metacharacters appear in shell variable references in + words to be completed. This means that dollar signs in + variable names that expand to directories will not be quoted; + however, any dollar signs appearing in filenames will not be + quoted, either. This is active only when bash is using + backslashes to quote completed filenames. This variable is + set by default, which is the default Bash behavior in versions + through 4.2. + + 'direxpand' + If set, Bash replaces directory names with the results of word + expansion when performing filename completion. This changes + the contents of the readline editing buffer. If not set, Bash + attempts to preserve what the user typed. + + 'dirspell' + If set, Bash attempts spelling correction on directory names + during word completion if the directory name initially + supplied does not exist. + + 'dotglob' + If set, Bash includes filenames beginning with a '.' in the + results of filename expansion. The filenames '.' and '..' + must always be matched explicitly, even if 'dotglob' is set. + + 'execfail' + If this is set, a non-interactive shell will not exit if it + cannot execute the file specified as an argument to the 'exec' + builtin command. An interactive shell does not exit if 'exec' + fails. + + 'expand_aliases' + If set, aliases are expanded as described below under Aliases, + *note Aliases::. This option is enabled by default for + interactive shells. + + 'extdebug' + If set at shell invocation, arrange to execute the debugger + profile before the shell starts, identical to the '--debugger' + option. If set after invocation, behavior intended for use by + debuggers is enabled: + + 1. The '-F' option to the 'declare' builtin (*note Bash + Builtins::) displays the source file name and line number + corresponding to each function name supplied as an + argument. + + 2. If the command run by the 'DEBUG' trap returns a non-zero + value, the next command is skipped and not executed. + + 3. If the command run by the 'DEBUG' trap returns a value of + 2, and the shell is executing in a subroutine (a shell + function or a shell script executed by the '.' or + 'source' builtins), the shell simulates a call to + 'return'. + + 4. 'BASH_ARGC' and 'BASH_ARGV' are updated as described in + their descriptions (*note Bash Variables::). + + 5. Function tracing is enabled: command substitution, shell + functions, and subshells invoked with '( COMMAND )' + inherit the 'DEBUG' and 'RETURN' traps. + + 6. Error tracing is enabled: command substitution, shell + functions, and subshells invoked with '( COMMAND )' + inherit the 'ERR' trap. + + 'extglob' + If set, the extended pattern matching features described above + (*note Pattern Matching::) are enabled. + + 'extquote' + If set, '$'STRING'' and '$"STRING"' quoting is performed + within '${PARAMETER}' expansions enclosed in double quotes. + This option is enabled by default. + + 'failglob' + If set, patterns which fail to match filenames during filename + expansion result in an expansion error. + + 'force_fignore' + If set, the suffixes specified by the 'FIGNORE' shell variable + cause words to be ignored when performing word completion even + if the ignored words are the only possible completions. *Note + Bash Variables::, for a description of 'FIGNORE'. This option + is enabled by default. + + 'globasciiranges' + If set, range expressions used in pattern matching bracket + expressions (*note Pattern Matching::) behave as if in the + traditional C locale when performing comparisons. That is, + the current locale's collating sequence is not taken into + account, so 'b' will not collate between 'A' and 'B', and + upper-case and lower-case ASCII characters will collate + together. + + 'globstar' + If set, the pattern '**' used in a filename expansion context + will match all files and zero or more directories and + subdirectories. If the pattern is followed by a '/', only + directories and subdirectories match. + + 'gnu_errfmt' + If set, shell error messages are written in the standard GNU + error message format. + + 'histappend' + If set, the history list is appended to the file named by the + value of the 'HISTFILE' variable when the shell exits, rather + than overwriting the file. + + 'histreedit' + If set, and Readline is being used, a user is given the + opportunity to re-edit a failed history substitution. + + 'histverify' + If set, and Readline is being used, the results of history + substitution are not immediately passed to the shell parser. + Instead, the resulting line is loaded into the Readline + editing buffer, allowing further modification. + + 'hostcomplete' + If set, and Readline is being used, Bash will attempt to + perform hostname completion when a word containing a '@' is + being completed (*note Commands For Completion::). This + option is enabled by default. + + 'huponexit' + If set, Bash will send 'SIGHUP' to all jobs when an + interactive login shell exits (*note Signals::). + + 'inherit_errexit' + If set, command substitution inherits the value of the + 'errexit' option, instead of unsetting it in the subshell + environment. This option is enabled when POSIX mode is + enabled. + + 'interactive_comments' + Allow a word beginning with '#' to cause that word and all + remaining characters on that line to be ignored in an + interactive shell. This option is enabled by default. + + 'lastpipe' + If set, and job control is not active, the shell runs the last + command of a pipeline not executed in the background in the + current shell environment. + + 'lithist' + If enabled, and the 'cmdhist' option is enabled, multi-line + commands are saved to the history with embedded newlines + rather than using semicolon separators where possible. + + 'localvar_inherit' + If set, local variables inherit the value and attributes of a + variable of the same name that exists at a previous scope + before any new value is assigned. The NAMEREF attribute is + not inherited. + + 'localvar_unset' + If set, calling 'unset' on local variables in previous + function scopes marks them so subsequent lookups find them + unset until that function returns. This is identical to the + behavior of unsetting local variables at the current function + scope. + + 'login_shell' + The shell sets this option if it is started as a login shell + (*note Invoking Bash::). The value may not be changed. + + 'mailwarn' + If set, and a file that Bash is checking for mail has been + accessed since the last time it was checked, the message '"The + mail in MAILFILE has been read"' is displayed. + + 'no_empty_cmd_completion' + If set, and Readline is being used, Bash will not attempt to + search the 'PATH' for possible completions when completion is + attempted on an empty line. + + 'nocaseglob' + If set, Bash matches filenames in a case-insensitive fashion + when performing filename expansion. + + 'nocasematch' + If set, Bash matches patterns in a case-insensitive fashion + when performing matching while executing 'case' or '[[' + conditional commands, when performing pattern substitution + word expansions, or when filtering possible completions as + part of programmable completion. + + 'nullglob' + If set, Bash allows filename patterns which match no files to + expand to a null string, rather than themselves. + + 'progcomp' + If set, the programmable completion facilities (*note + Programmable Completion::) are enabled. This option is + enabled by default. + + 'progcomp_alias' + If set, and programmable completion is enabled, Bash treats a + command name that doesn't have any completions as a possible + alias and attempts alias expansion. If it has an alias, Bash + attempts programmable completion using the command word + resulting from the expanded alias. + + 'promptvars' + If set, prompt strings undergo parameter expansion, command + substitution, arithmetic expansion, and quote removal after + being expanded as described below (*note Controlling the + Prompt::). This option is enabled by default. + + 'restricted_shell' + The shell sets this option if it is started in restricted mode + (*note The Restricted Shell::). The value may not be changed. + This is not reset when the startup files are executed, + allowing the startup files to discover whether or not a shell + is restricted. + + 'shift_verbose' + If this is set, the 'shift' builtin prints an error message + when the shift count exceeds the number of positional + parameters. + + 'sourcepath' + If set, the 'source' builtin uses the value of 'PATH' to find + the directory containing the file supplied as an argument. + This option is enabled by default. + + 'xpg_echo' + If set, the 'echo' builtin expands backslash-escape sequences + by default. + + The return status when listing options is zero if all OPTNAMES are + enabled, non-zero otherwise. When setting or unsetting options, + the return status is zero unless an OPTNAME is not a valid shell + option. + + +File: bash.info, Node: Special Builtins, Prev: Modifying Shell Behavior, Up: Shell Builtin Commands + +4.4 Special Builtins +==================== + +For historical reasons, the POSIX standard has classified several +builtin commands as _special_. When Bash is executing in POSIX mode, +the special builtins differ from other builtin commands in three +respects: + + 1. Special builtins are found before shell functions during command + lookup. + + 2. If a special builtin returns an error status, a non-interactive + shell exits. + + 3. Assignment statements preceding the command stay in effect in the + shell environment after the command completes. + + When Bash is not executing in POSIX mode, these builtins behave no +differently than the rest of the Bash builtin commands. The Bash POSIX +mode is described in *note Bash POSIX Mode::. + + These are the POSIX special builtins: + break : . continue eval exec exit export readonly return set + shift trap unset + + +File: bash.info, Node: Shell Variables, Next: Bash Features, Prev: Shell Builtin Commands, Up: Top + +5 Shell Variables +***************** + +* Menu: + +* Bourne Shell Variables:: Variables which Bash uses in the same way + as the Bourne Shell. +* Bash Variables:: List of variables that exist in Bash. + +This chapter describes the shell variables that Bash uses. Bash +automatically assigns default values to a number of variables. + + +File: bash.info, Node: Bourne Shell Variables, Next: Bash Variables, Up: Shell Variables + +5.1 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. + +'CDPATH' + A colon-separated list of directories used as a search path for the + 'cd' builtin command. + +'HOME' + The current user's home directory; the default for the 'cd' builtin + command. The value of this variable is also used by tilde + expansion (*note Tilde Expansion::). + +'IFS' + A list of characters that separate fields; used when the shell + splits words as part of expansion. + +'MAIL' + If this parameter is set to a filename or directory name and the + 'MAILPATH' variable is not set, Bash informs the user of the + arrival of mail in the specified file or Maildir-format directory. + +'MAILPATH' + A colon-separated list of filenames which the shell periodically + checks for new mail. Each list entry can specify the message that + is printed when new mail arrives in the mail file by separating the + filename from the message with a '?'. When used in the text of the + message, '$_' expands to the name of the current mail file. + +'OPTARG' + The value of the last option argument processed by the 'getopts' + builtin. + +'OPTIND' + The index of the last option argument processed by the 'getopts' + builtin. + +'PATH' + A colon-separated list of directories in which the shell looks for + commands. A zero-length (null) directory name in the value of + 'PATH' indicates the current directory. A null directory name may + appear as two adjacent colons, or as an initial or trailing colon. + +'PS1' + The primary prompt string. The default value is '\s-\v\$ '. *Note + Controlling the Prompt::, for the complete list of escape sequences + that are expanded before 'PS1' is displayed. + +'PS2' + The secondary prompt string. The default value is '> '. 'PS2' is + expanded in the same way as 'PS1' before being displayed. + + +File: bash.info, Node: Bash Variables, Prev: Bourne Shell Variables, Up: Shell Variables + +5.2 Bash Variables +================== + +These variables are set or used by Bash, but other shells do not +normally treat them specially. + + A few variables used by Bash are described in different chapters: +variables for controlling the job control facilities (*note Job Control +Variables::). + +'BASH' + The full pathname used to execute the current instance of Bash. + +'BASHOPTS' + A colon-separated list of enabled shell options. Each word in the + list is a valid argument for the '-s' option to the 'shopt' builtin + command (*note The Shopt Builtin::). The options appearing in + 'BASHOPTS' are those reported as 'on' by 'shopt'. If this variable + is in the environment when Bash starts up, each shell option in the + list will be enabled before reading any startup files. This + variable is readonly. + +'BASHPID' + Expands to the process ID of the current Bash process. This + differs from '$$' under certain circumstances, such as subshells + that do not require Bash to be re-initialized. Assignments to + 'BASHPID' have no effect. If 'BASHPID' is unset, it loses its + special properties, even if it is subsequently reset. + +'BASH_ALIASES' + An associative array variable whose members correspond to the + internal list of aliases as maintained by the 'alias' builtin. + (*note Bourne Shell Builtins::). Elements added to this array + appear in the alias list; however, unsetting array elements + currently does not cause aliases to be removed from the alias list. + If 'BASH_ALIASES' is unset, it loses its special properties, even + if it is subsequently reset. + +'BASH_ARGC' + An array variable whose values are the number of parameters in each + frame of the current bash execution call stack. The number of + parameters to the current subroutine (shell function or script + executed with '.' or 'source') is at the top of the stack. When a + subroutine is executed, the number of parameters passed is pushed + onto 'BASH_ARGC'. The shell sets 'BASH_ARGC' only when in extended + debugging mode (see *note The Shopt Builtin:: for a description of + the 'extdebug' option to the 'shopt' builtin). Setting 'extdebug' + after the shell has started to execute a script, or referencing + this variable when 'extdebug' is not set, may result in + inconsistent values. + +'BASH_ARGV' + An array variable containing all of the parameters in the current + bash execution call stack. The final parameter of the last + subroutine call is at the top of the stack; the first parameter of + the initial call is at the bottom. When a subroutine is executed, + the parameters supplied are pushed onto 'BASH_ARGV'. The shell + sets 'BASH_ARGV' only when in extended debugging mode (see *note + The Shopt Builtin:: for a description of the 'extdebug' option to + the 'shopt' builtin). Setting 'extdebug' after the shell has + started to execute a script, or referencing this variable when + 'extdebug' is not set, may result in inconsistent values. + +'BASH_ARGV0' + When referenced, this variable expands to the name of the shell or + shell script (identical to '$0'; *Note Special Parameters::, for + the description of special parameter 0). Assignment to + 'BASH_ARGV0' causes the value assigned to also be assigned to '$0'. + If 'BASH_ARGV0' is unset, it loses its special properties, even if + it is subsequently reset. + +'BASH_CMDS' + An associative array variable whose members correspond to the + internal hash table of commands as maintained by the 'hash' builtin + (*note Bourne Shell Builtins::). Elements added to this array + appear in the hash table; however, unsetting array elements + currently does not cause command names to be removed from the hash + table. If 'BASH_CMDS' is unset, it loses its special properties, + even if it is subsequently reset. + +'BASH_COMMAND' + The command currently being executed or about to be executed, + unless the shell is executing a command as the result of a trap, in + which case it is the command executing at the time of the trap. + +'BASH_COMPAT' + The value is used to set the shell's compatibility level. *Note + The Shopt Builtin::, for a description of the various compatibility + levels and their effects. The value may be a decimal number (e.g., + 4.2) or an integer (e.g., 42) corresponding to the desired + compatibility level. If 'BASH_COMPAT' is unset or set to the empty + string, the compatibility level is set to the default for the + current version. If 'BASH_COMPAT' is set to a value that is not + one of the valid compatibility levels, the shell prints an error + message and sets the compatibility level to the default for the + current version. The valid compatibility levels correspond to the + compatibility options accepted by the 'shopt' builtin described + above (for example, COMPAT42 means that 4.2 and 42 are valid + values). The current version is also a valid value. + +'BASH_ENV' + If this variable is set when Bash is invoked to execute a shell + script, its value is expanded and used as the name of a startup + file to read before executing the script. *Note Bash Startup + Files::. + +'BASH_EXECUTION_STRING' + The command argument to the '-c' invocation option. + +'BASH_LINENO' + An array variable whose members are the line numbers in source + files where each corresponding member of FUNCNAME was invoked. + '${BASH_LINENO[$i]}' is the line number in the source file + ('${BASH_SOURCE[$i+1]}') where '${FUNCNAME[$i]}' was called (or + '${BASH_LINENO[$i-1]}' if referenced within another shell + function). Use 'LINENO' to obtain the current line number. + +'BASH_LOADABLES_PATH' + A colon-separated list of directories in which the shell looks for + dynamically loadable builtins specified by the 'enable' command. + +'BASH_REMATCH' + An array variable whose members are assigned by the '=~' binary + operator to the '[[' conditional command (*note Conditional + Constructs::). The element with index 0 is the portion of the + string matching the entire regular expression. The element with + index N is the portion of the string matching the Nth parenthesized + subexpression. This variable is read-only. + +'BASH_SOURCE' + An array variable whose members are the source filenames where the + corresponding shell function names in the 'FUNCNAME' array variable + are defined. The shell function '${FUNCNAME[$i]}' is defined in + the file '${BASH_SOURCE[$i]}' and called from + '${BASH_SOURCE[$i+1]}' + +'BASH_SUBSHELL' + Incremented by one within each subshell or subshell environment + when the shell begins executing in that environment. The initial + value is 0. + +'BASH_VERSINFO' + A readonly array variable (*note Arrays::) whose members hold + version information for this instance of Bash. The values assigned + to the array members are as follows: + + 'BASH_VERSINFO[0]' + The major version number (the RELEASE). + + 'BASH_VERSINFO[1]' + The minor version number (the VERSION). + + 'BASH_VERSINFO[2]' + The patch level. + + 'BASH_VERSINFO[3]' + The build version. + + 'BASH_VERSINFO[4]' + The release status (e.g., BETA1). + + 'BASH_VERSINFO[5]' + The value of 'MACHTYPE'. + +'BASH_VERSION' + The version number of the current instance of Bash. + +'BASH_XTRACEFD' + If set to an integer corresponding to a valid file descriptor, Bash + will write the trace output generated when 'set -x' is enabled to + that file descriptor. This allows tracing output to be separated + from diagnostic and error messages. The file descriptor is closed + when 'BASH_XTRACEFD' is unset or assigned a new value. Unsetting + 'BASH_XTRACEFD' or assigning it the empty string causes the trace + output to be sent to the standard error. Note that setting + 'BASH_XTRACEFD' to 2 (the standard error file descriptor) and then + unsetting it will result in the standard error being closed. + +'CHILD_MAX' + Set the number of exited child status values for the shell to + remember. Bash will not allow this value to be decreased below a + POSIX-mandated minimum, and there is a maximum value (currently + 8192) that this may not exceed. The minimum value is + system-dependent. + +'COLUMNS' + Used by the 'select' command to determine the terminal width when + printing selection lists. Automatically set if the 'checkwinsize' + option is enabled (*note The Shopt Builtin::), or in an interactive + shell upon receipt of a 'SIGWINCH'. + +'COMP_CWORD' + An index into '${COMP_WORDS}' of the word containing the current + cursor position. This variable is available only in shell + functions invoked by the programmable completion facilities (*note + Programmable Completion::). + +'COMP_LINE' + The current command line. This variable is available only in shell + functions and external commands invoked by the programmable + completion facilities (*note Programmable Completion::). + +'COMP_POINT' + The index of the current cursor position relative to the beginning + of the current command. If the current cursor position is at the + end of the current command, the value of this variable is equal to + '${#COMP_LINE}'. This variable is available only in shell + functions and external commands invoked by the programmable + completion facilities (*note Programmable Completion::). + +'COMP_TYPE' + Set to an integer value corresponding to the type of completion + attempted that caused a completion function to be called: TAB, for + normal completion, '?', for listing completions after successive + tabs, '!', for listing alternatives on partial word completion, + '@', to list completions if the word is not unmodified, or '%', for + menu completion. This variable is available only in shell + functions and external commands invoked by the programmable + completion facilities (*note Programmable Completion::). + +'COMP_KEY' + The key (or final key of a key sequence) used to invoke the current + completion function. + +'COMP_WORDBREAKS' + The set of characters that the Readline library treats as word + separators when performing word completion. If 'COMP_WORDBREAKS' + is unset, it loses its special properties, even if it is + subsequently reset. + +'COMP_WORDS' + An array variable consisting of the individual words in the current + command line. The line is split into words as Readline would split + it, using 'COMP_WORDBREAKS' as described above. This variable is + available only in shell functions invoked by the programmable + completion facilities (*note Programmable Completion::). + +'COMPREPLY' + An array variable from which Bash reads the possible completions + generated by a shell function invoked by the programmable + completion facility (*note Programmable Completion::). Each array + element contains one possible completion. + +'COPROC' + An array variable created to hold the file descriptors for output + from and input to an unnamed coprocess (*note Coprocesses::). + +'DIRSTACK' + An array variable containing the current contents of the directory + stack. Directories appear in the stack in the order they are + displayed by the 'dirs' builtin. Assigning to members of this + array variable may be used to modify directories already in the + stack, but the 'pushd' and 'popd' builtins must be used to add and + remove directories. Assignment to this variable will not change + the current directory. If 'DIRSTACK' is unset, it loses its + special properties, even if it is subsequently reset. + +'EMACS' + If Bash finds this variable in the environment when the shell + starts with value 't', it assumes that the shell is running in an + Emacs shell buffer and disables line editing. + +'ENV' + Similar to 'BASH_ENV'; used when the shell is invoked in POSIX Mode + (*note Bash POSIX Mode::). + +'EPOCHREALTIME' + Each time this parameter is referenced, it expands to the number of + seconds since the Unix Epoch as a floating point value with + micro-second granularity (see the documentation for the C library + function TIME for the definition of Epoch). Assignments to + 'EPOCHREALTIME' are ignored. If 'EPOCHREALTIME' is unset, it loses + its special properties, even if it is subsequently reset. + +'EPOCHSECONDS' + Each time this parameter is referenced, it expands to the number of + seconds since the Unix Epoch (see the documentation for the C + library function TIME for the definition of Epoch). Assignments to + 'EPOCHSECONDS' are ignored. If 'EPOCHSECONDS' is unset, it loses + its special properties, even if it is subsequently reset. + +'EUID' + The numeric effective user id of the current user. This variable + is readonly. + +'EXECIGNORE' + A colon-separated list of shell patterns (*note Pattern Matching::) + defining the list of filenames to be ignored by command search + using 'PATH'. Files whose full pathnames match one of these + patterns are not considered executable files for the purposes of + completion and command execution via 'PATH' lookup. This does not + affect the behavior of the '[', 'test', and '[[' commands. Full + pathnames in the command hash table are not subject to + 'EXECIGNORE'. Use this variable to ignore shared library files + that have the executable bit set, but are not executable files. + The pattern matching honors the setting of the 'extglob' shell + option. + +'FCEDIT' + The editor used as a default by the '-e' option to the 'fc' builtin + command. + +'FIGNORE' + A colon-separated list of suffixes to ignore when performing + filename completion. A filename whose suffix matches one of the + entries in 'FIGNORE' is excluded from the list of matched + filenames. A sample value is '.o:~' + +'FUNCNAME' + An array variable containing the names of all shell functions + currently in the execution call stack. The element with index 0 is + the name of any currently-executing shell function. The + bottom-most element (the one with the highest index) is '"main"'. + This variable exists only when a shell function is executing. + Assignments to 'FUNCNAME' have no effect. If 'FUNCNAME' is unset, + it loses its special properties, even if it is subsequently reset. + + This variable can be used with 'BASH_LINENO' and 'BASH_SOURCE'. + Each element of 'FUNCNAME' has corresponding elements in + 'BASH_LINENO' and 'BASH_SOURCE' to describe the call stack. For + instance, '${FUNCNAME[$i]}' was called from the file + '${BASH_SOURCE[$i+1]}' at line number '${BASH_LINENO[$i]}'. The + 'caller' builtin displays the current call stack using this + information. + +'FUNCNEST' + If set to a numeric value greater than 0, defines a maximum + function nesting level. Function invocations that exceed this + nesting level will cause the current command to abort. + +'GLOBIGNORE' + A colon-separated list of patterns defining the set of file names + to be ignored by filename expansion. If a file name matched by a + filename expansion pattern also matches one of the patterns in + 'GLOBIGNORE', it is removed from the list of matches. The pattern + matching honors the setting of the 'extglob' shell option. + +'GROUPS' + An array variable containing the list of groups of which the + current user is a member. Assignments to 'GROUPS' have no effect. + If 'GROUPS' is unset, it loses its special properties, even if it + is subsequently reset. + +'histchars' + Up to three characters which control history expansion, quick + substitution, and tokenization (*note History Interaction::). The + first character is the HISTORY EXPANSION character, 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 indicates that 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. + +'HISTCONTROL' + A colon-separated list of values controlling how commands are saved + on the history list. If the list of values includes 'ignorespace', + lines which begin with a space character are not saved in the + history list. A value of 'ignoredups' causes lines which match the + previous history entry to not be saved. A value of 'ignoreboth' is + shorthand for 'ignorespace' and 'ignoredups'. A value of + 'erasedups' causes all previous lines matching the current line to + be removed from the history list before that line is saved. Any + value not in the above list is ignored. If 'HISTCONTROL' is unset, + or does not include a valid value, all lines read by the shell + parser are saved on the history list, subject to the value of + 'HISTIGNORE'. The second and subsequent lines of a multi-line + compound command are not tested, and are added to the history + regardless of the value of 'HISTCONTROL'. + +'HISTFILE' + The name of the file to which the command history is saved. The + default value is '~/.bash_history'. + +'HISTFILESIZE' + The maximum number of lines contained in the history file. When + this variable is assigned a value, the history file is truncated, + if necessary, to contain no more than that number of lines by + removing the oldest entries. The history file is also truncated to + this size after writing it when a shell exits. If the value is 0, + the history file is truncated to zero size. Non-numeric values and + numeric values less than zero inhibit truncation. The shell sets + the default value to the value of 'HISTSIZE' after reading any + startup files. + +'HISTIGNORE' + A colon-separated list of patterns used to decide which command + lines should be saved on the history list. Each pattern is + anchored at the beginning of the line and must match the complete + line (no implicit '*' is appended). Each pattern is tested against + the line after the checks specified by 'HISTCONTROL' are applied. + In addition to the normal shell pattern matching characters, '&' + matches the previous history line. '&' may be escaped using a + backslash; the backslash is removed before attempting a match. The + second and subsequent lines of a multi-line compound command are + not tested, and are added to the history regardless of the value of + 'HISTIGNORE'. The pattern matching honors the setting of the + 'extglob' shell option. + + 'HISTIGNORE' subsumes the function of 'HISTCONTROL'. A pattern of + '&' is identical to 'ignoredups', and a pattern of '[ ]*' is + identical to 'ignorespace'. Combining these two patterns, + separating them with a colon, provides the functionality of + 'ignoreboth'. + +'HISTSIZE' + The maximum number of commands to remember on the history list. If + the value is 0, commands are not saved in the history list. + Numeric values less than zero result in every command being saved + on the history list (there is no limit). The shell sets the + default value to 500 after reading any startup files. + +'HISTTIMEFORMAT' + If this variable is set and not null, its value is used as a format + string for STRFTIME to print the time stamp associated with each + history entry displayed by the 'history' builtin. If this variable + is set, time stamps are written to the history file so they may be + preserved across shell sessions. This uses the history comment + character to distinguish timestamps from other history lines. + +'HOSTFILE' + Contains the name of a file in the same format as '/etc/hosts' that + should be read when the shell needs to complete a hostname. The + list of possible hostname completions may be changed while the + shell is running; the next time hostname completion is attempted + after the value is changed, Bash adds the contents of the new file + to the existing list. If 'HOSTFILE' is set, but has no value, or + does not name a readable file, Bash attempts to read '/etc/hosts' + to obtain the list of possible hostname completions. When + 'HOSTFILE' is unset, the hostname list is cleared. + +'HOSTNAME' + The name of the current host. + +'HOSTTYPE' + A string describing the machine Bash is running on. + +'IGNOREEOF' + Controls the action of the shell on receipt of an 'EOF' character + as the sole input. If set, the value denotes the number of + consecutive 'EOF' characters that can be read as the first + character 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. + +'INPUTRC' + The name of the Readline initialization file, overriding the + default of '~/.inputrc'. + +'INSIDE_EMACS' + If Bash finds this variable in the environment when the shell + starts, it assumes that the shell is running in an Emacs shell + buffer and may disable line editing depending on the value of + 'TERM'. + +'LANG' + Used to determine the locale category for any category not + specifically selected with a variable starting with 'LC_'. + +'LC_ALL' + This variable overrides the value of 'LANG' and any other 'LC_' + variable specifying a locale category. + +'LC_COLLATE' + This variable determines the collation order used when sorting the + results of filename expansion, and determines the behavior of range + expressions, equivalence classes, and collating sequences within + filename expansion and pattern matching (*note Filename + Expansion::). + +'LC_CTYPE' + This variable determines the interpretation of characters and the + behavior of character classes within filename expansion and pattern + matching (*note Filename Expansion::). + +'LC_MESSAGES' + This variable determines the locale used to translate double-quoted + strings preceded by a '$' (*note Locale Translation::). + +'LC_NUMERIC' + This variable determines the locale category used for number + formatting. + +'LC_TIME' + This variable determines the locale category used for data and time + formatting. + +'LINENO' + The line number in the script or shell function currently + executing. + +'LINES' + Used by the 'select' command to determine the column length for + printing selection lists. Automatically set if the 'checkwinsize' + option is enabled (*note The Shopt Builtin::), or in an interactive + shell upon receipt of a 'SIGWINCH'. + +'MACHTYPE' + A string that fully describes the system type on which Bash is + executing, in the standard GNU CPU-COMPANY-SYSTEM format. + +'MAILCHECK' + How often (in seconds) that the shell should check for mail in the + files specified in the 'MAILPATH' or 'MAIL' variables. The default + is 60 seconds. When it is time to check for mail, the shell does + so before displaying the primary prompt. If this variable is + unset, or set to a value that is not a number greater than or equal + to zero, the shell disables mail checking. + +'MAPFILE' + An array variable created to hold the text read by the 'mapfile' + builtin when no variable name is supplied. + +'OLDPWD' + The previous working directory as set by the 'cd' builtin. + +'OPTERR' + If set to the value 1, Bash displays error messages generated by + the 'getopts' builtin command. + +'OSTYPE' + A string describing the operating system Bash is running on. + +'PIPESTATUS' + An array variable (*note Arrays::) containing a list of exit status + values from the processes in the most-recently-executed foreground + pipeline (which may contain only a single command). + +'POSIXLY_CORRECT' + If this variable is in the environment when Bash starts, the shell + enters POSIX mode (*note Bash POSIX Mode::) before reading the + startup files, as if the '--posix' invocation option had been + supplied. If it is set while the shell is running, Bash enables + POSIX mode, as if the command + set -o posix + had been executed. When the shell enters POSIX mode, it sets this + variable if it was not already set. + +'PPID' + The process ID of the shell's parent process. This variable is + readonly. + +'PROMPT_COMMAND' + If set, the value is interpreted as a command to execute before the + printing of each primary prompt ('$PS1'). + +'PROMPT_DIRTRIM' + If set to a number greater than zero, the value is used as the + number of trailing directory components to retain when expanding + the '\w' and '\W' prompt string escapes (*note Controlling the + Prompt::). Characters removed are replaced with an ellipsis. + +'PS0' + The value of this parameter is expanded like PS1 and displayed by + interactive shells after reading a command and before the command + is executed. + +'PS3' + The value of this variable is used as the prompt for the 'select' + command. If this variable is not set, the 'select' command prompts + with '#? ' + +'PS4' + The value of this parameter is expanded like PS1 and the expanded + value is the prompt printed before the command line is echoed when + the '-x' option is set (*note The Set Builtin::). The first + character of the expanded value is replicated multiple times, as + necessary, to indicate multiple levels of indirection. The default + is '+ '. + +'PWD' + The current working directory as set by the 'cd' builtin. + +'RANDOM' + Each time this parameter is referenced, a random integer between 0 + and 32767 is generated. Assigning a value to this variable seeds + the random number generator. + +'READLINE_LINE' + The contents of the Readline line buffer, for use with 'bind -x' + (*note Bash Builtins::). + +'READLINE_POINT' + The position of the insertion point in the Readline line buffer, + for use with 'bind -x' (*note Bash Builtins::). + +'REPLY' + The default variable for the 'read' builtin. + +'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. + +'SHELL' + The full pathname to the shell is kept in this environment + variable. If it is not set when the shell starts, Bash assigns to + it the full pathname of the current user's login shell. + +'SHELLOPTS' + A colon-separated list of enabled shell options. Each word in the + list is a valid argument for the '-o' option to the 'set' builtin + command (*note The Set Builtin::). The options appearing in + 'SHELLOPTS' are those reported as 'on' by 'set -o'. If this + variable is in the environment when Bash starts up, each shell + option in the list will be enabled before reading any startup + files. This variable is readonly. + +'SHLVL' + Incremented by one each time a new instance of Bash is started. + This is intended to be a count of how deeply your Bash shells are + nested. + +'TIMEFORMAT' + The value of this parameter is used as a format string specifying + how the timing information for pipelines prefixed with the 'time' + reserved word should be displayed. The '%' character introduces an + escape sequence that is expanded to a time value or other + information. The escape sequences and their meanings are as + follows; the braces denote optional portions. + + '%%' + A literal '%'. + + '%[P][l]R' + The elapsed time in seconds. + + '%[P][l]U' + The number of CPU seconds spent in user mode. + + '%[P][l]S' + The number of CPU seconds spent in system mode. + + '%P' + The CPU percentage, computed as (%U + %S) / %R. + + The optional P is a digit specifying the precision, the number of + fractional digits after a decimal point. A value of 0 causes no + decimal point or fraction to be output. At most three places after + the decimal point may be specified; values of P greater than 3 are + changed to 3. If P is not specified, the value 3 is used. + + The optional 'l' specifies a longer format, including minutes, of + the form MMmSS.FFs. The value of P determines whether or not the + fraction is included. + + If this variable is not set, Bash acts as if it had the value + $'\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS' + If the value is null, no timing information is displayed. A + trailing newline is added when the format string is displayed. + +'TMOUT' + If set to a value greater than zero, 'TMOUT' is treated as the + default timeout for the 'read' builtin (*note Bash Builtins::). + The 'select' command (*note Conditional Constructs::) terminates if + input does not arrive after 'TMOUT' seconds when input is coming + from a terminal. + + In an interactive shell, the value is interpreted as the number of + seconds to wait for a line of input after issuing the primary + prompt. Bash terminates after waiting for that number of seconds + if a complete line of input does not arrive. + +'TMPDIR' + If set, Bash uses its value as the name of a directory in which + Bash creates temporary files for the shell's use. + +'UID' + The numeric real user id of the current user. This variable is + readonly. + + +File: bash.info, Node: Bash Features, Next: Job Control, Prev: Shell Variables, Up: Top + +6 Bash Features +*************** + +This chapter describes features unique to Bash. + +* Menu: + +* Invoking Bash:: Command line options that you can give + to Bash. +* Bash Startup Files:: When and how Bash executes scripts. +* Interactive Shells:: What an interactive shell is. +* Bash Conditional Expressions:: Primitives used in composing expressions for + the 'test' builtin. +* Shell Arithmetic:: Arithmetic on shell variables. +* Aliases:: Substituting one command for another. +* Arrays:: Array Variables. +* The Directory Stack:: History of visited directories. +* Controlling the Prompt:: Customizing the various prompt strings. +* The Restricted Shell:: A more controlled mode of shell execution. +* Bash POSIX Mode:: Making Bash behave more closely to what + the POSIX standard specifies. + + +File: bash.info, Node: Invoking Bash, Next: Bash Startup Files, Up: Bash Features + +6.1 Invoking Bash +================= + + bash [long-opt] [-ir] [-abefhkmnptuvxdBCDHP] [-o OPTION] + [-O SHOPT_OPTION] [ARGUMENT ...] + bash [long-opt] [-abefhkmnptuvxdBCDHP] [-o OPTION] + [-O SHOPT_OPTION] -c STRING [ARGUMENT ...] + bash [long-opt] -s [-abefhkmnptuvxdBCDHP] [-o OPTION] + [-O SHOPT_OPTION] [ARGUMENT ...] + + All of the single-character options used with the 'set' builtin +(*note The Set Builtin::) can be used as options when the shell is +invoked. In addition, 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. + +'--debugger' + Arrange for the debugger profile to be executed before the shell + starts. Turns on extended debugging mode (see *note The Shopt + Builtin:: for a description of the 'extdebug' option to the 'shopt' + builtin). + +'--dump-po-strings' + A list of all double-quoted strings preceded by '$' is printed on + the standard output in the GNU 'gettext' PO (portable object) file + format. Equivalent to '-D' except for the output format. + +'--dump-strings' + Equivalent to '-D'. + +'--help' + Display a usage message on standard output and exit successfully. + +'--init-file FILENAME' +'--rcfile FILENAME' + Execute commands from FILENAME (instead of '~/.bashrc') in an + interactive shell. + +'--login' + Equivalent to '-l'. + +'--noediting' + Do not use the GNU Readline library (*note Command Line Editing::) + to read command lines when the shell is interactive. + +'--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. + +'--norc' + Don't read the '~/.bashrc' initialization file in an interactive + shell. This is on by default if the shell is invoked as 'sh'. + +'--posix' + Change the behavior of Bash where the default operation differs + from the POSIX standard to match the standard. This is intended to + make Bash behave as a strict superset of that standard. *Note Bash + POSIX Mode::, for a description of the Bash POSIX mode. + +'--restricted' + Make the shell a restricted shell (*note The Restricted Shell::). + +'--verbose' + Equivalent to '-v'. Print shell input lines as they're read. + +'--version' + Show version information for this instance of Bash on the standard + output and exit successfully. + + There are several single-character options that may be supplied at +invocation which are not available with the 'set' builtin. + +'-c' + Read and execute commands from the first non-option argument + COMMAND_STRING, then exit. If there are arguments after the + COMMAND_STRING, the first argument is assigned to '$0' and any + remaining arguments are assigned to the positional parameters. The + assignment to '$0' sets the name of the shell, which is used in + warning and error messages. + +'-i' + Force the shell to run interactively. Interactive shells are + described in *note Interactive Shells::. + +'-l' + Make this shell act as if it had been directly invoked by login. + When the shell is interactive, this is equivalent to starting a + login shell with 'exec -l bash'. When the shell is not + interactive, the login shell startup files will be executed. 'exec + bash -l' or 'exec bash --login' will replace the current shell with + a Bash login shell. *Note Bash Startup Files::, for a description + of the special behavior of a login shell. + +'-r' + Make the shell a restricted shell (*note The Restricted Shell::). + +'-s' + If this option is present, or if no arguments remain after option + processing, then commands are read from the standard input. This + option allows the positional parameters to be set when invoking an + interactive shell or when reading input through a pipe. + +'-D' + A list of all double-quoted strings preceded by '$' is printed on + the standard output. These are the strings that are subject to + language translation when the current locale is not 'C' or 'POSIX' + (*note Locale Translation::). This implies the '-n' option; no + commands will be executed. + +'[-+]O [SHOPT_OPTION]' + SHOPT_OPTION is one of the shell options accepted by the 'shopt' + builtin (*note The Shopt Builtin::). If SHOPT_OPTION is present, + '-O' sets the value of that option; '+O' unsets it. If + SHOPT_OPTION is not supplied, the names and values of the shell + options accepted by 'shopt' are printed on the standard output. If + the invocation option is '+O', the output is displayed in a format + that may be reused as input. + +'--' + A '--' signals the end of options and disables further option + processing. Any arguments after the '--' are treated as filenames + and arguments. + + A _login_ shell is one whose first character of argument zero is '-', +or one invoked with the '--login' option. + + An _interactive_ shell is one started without non-option arguments, +unless '-s' is specified, without specifying the '-c' option, and whose +input and output are both connected to terminals (as determined by +'isatty(3)'), or one started with the '-i' option. *Note Interactive +Shells::, for more information. + + 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 (*note Shell Scripts::). +When Bash is invoked in this fashion, '$0' is set to the name of the +file, and the positional parameters are set to the remaining arguments. +Bash reads and executes commands from this file, then exits. Bash's +exit status is the exit status of the last command executed in the +script. If no commands are executed, the exit status is 0. + + +File: bash.info, Node: Bash Startup Files, Next: Interactive Shells, Prev: Invoking Bash, Up: Bash Features + +6.2 Bash Startup Files +====================== + +This section describes how Bash executes its startup files. If any of +the files exist but cannot be read, Bash reports an error. Tildes are +expanded in filenames as described above under Tilde Expansion (*note +Tilde Expansion::). + + Interactive shells are described in *note Interactive Shells::. + +Invoked as an interactive login shell, or with '--login' +........................................................ + +When Bash is invoked as an interactive login shell, or as a +non-interactive shell with the '--login' option, it first reads and +executes commands from the file '/etc/profile', if that file exists. +After reading that file, it looks for '~/.bash_profile', +'~/.bash_login', and '~/.profile', in that order, and reads and executes +commands from the first one that exists and is readable. The +'--noprofile' option may be used when the shell is started to inhibit +this behavior. + + When an interactive login shell exits, or a non-interactive login +shell executes the 'exit' builtin command, Bash reads and executes +commands from the file '~/.bash_logout', if it exists. + +Invoked as an interactive non-login shell +......................................... + +When an interactive shell that is not a login shell is started, Bash +reads and executes commands from '~/.bashrc', if that file exists. This +may be inhibited by using the '--norc' option. The '--rcfile FILE' +option will force Bash to read and execute commands from FILE instead of +'~/.bashrc'. + + So, typically, your '~/.bash_profile' contains the line + if [ -f ~/.bashrc ]; then . ~/.bashrc; fi +after (or before) any login-specific initializations. + +Invoked non-interactively +......................... + +When Bash is started non-interactively, to run a shell script, for +example, it looks for the variable 'BASH_ENV' in the environment, +expands its value if it appears there, and uses the expanded value as +the name of a file to read and execute. Bash behaves as if the +following command were executed: + if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi +but the value of the 'PATH' variable is not used to search for the +filename. + + As noted above, if a non-interactive shell is invoked with the +'--login' option, Bash attempts to read and execute commands from the +login shell startup files. + +Invoked with name 'sh' +...................... + +If Bash is invoked with the name 'sh', it tries to mimic the startup +behavior of historical versions of 'sh' as closely as possible, while +conforming to the POSIX standard as well. + + When invoked as an interactive login shell, or as a non-interactive +shell with the '--login' option, it first attempts to read and execute +commands from '/etc/profile' and '~/.profile', in that order. The +'--noprofile' option may be used to inhibit this behavior. When invoked +as an interactive shell with the name 'sh', Bash looks for the variable +'ENV', expands its value if it is defined, and uses the expanded value +as the name of a file to read and execute. Since a shell invoked as +'sh' does not attempt to read and execute commands from any other +startup files, the '--rcfile' option has no effect. A non-interactive +shell invoked with the name 'sh' does not attempt to read any other +startup files. + + When invoked as 'sh', Bash enters POSIX mode after the startup files +are read. + +Invoked in POSIX mode +..................... + +When Bash is started in POSIX mode, as with the '--posix' command line +option, it follows the POSIX standard for startup files. In this mode, +interactive shells expand the 'ENV' variable and commands are read and +executed from the file whose name is the expanded value. No other +startup files are read. + +Invoked by remote shell daemon +.............................. + +Bash attempts to determine when it is being run with its standard input +connected to a network connection, as when executed by the remote shell +daemon, usually 'rshd', or the secure shell daemon 'sshd'. If Bash +determines it is being run in this fashion, it reads and executes +commands from '~/.bashrc', if that file exists and is readable. It will +not do this if invoked as 'sh'. The '--norc' option may be used to +inhibit this behavior, and the '--rcfile' option may be used to force +another file to be read, but neither 'rshd' nor 'sshd' generally invoke +the shell with those options or allow them to be specified. + +Invoked with unequal effective and real UID/GIDs +................................................ + +If Bash is started with the effective user (group) id not equal to the +real user (group) id, and the '-p' option is not supplied, no startup +files are read, shell functions are not inherited from the environment, +the 'SHELLOPTS', 'BASHOPTS', 'CDPATH', and 'GLOBIGNORE' variables, if +they appear in the environment, are ignored, and the effective user id +is set to the real user id. If the '-p' option is supplied at +invocation, the startup behavior is the same, but the effective user id +is not reset. + + +File: bash.info, Node: Interactive Shells, Next: Bash Conditional Expressions, Prev: Bash Startup Files, Up: Bash Features + +6.3 Interactive Shells +====================== + +* Menu: + +* What is an Interactive Shell?:: What determines whether a shell is Interactive. +* Is this Shell Interactive?:: How to tell if a shell is interactive. +* Interactive Shell Behavior:: What changes in a interactive shell? + + +File: bash.info, Node: What is an Interactive Shell?, Next: Is this Shell Interactive?, Up: Interactive Shells + +6.3.1 What is an Interactive Shell? +----------------------------------- + +An interactive shell is one started without non-option arguments, unless +'-s' is specified, without specifying the '-c' option, and whose input +and error output are both connected to terminals (as determined by +'isatty(3)'), or one started with the '-i' option. + + An interactive shell generally reads from and writes to a user's +terminal. + + The '-s' invocation option may be used to set the positional +parameters when an interactive shell is started. + + +File: bash.info, Node: Is this Shell Interactive?, Next: Interactive Shell Behavior, Prev: What is an Interactive Shell?, Up: Interactive Shells + +6.3.2 Is this Shell Interactive? +-------------------------------- + +To determine within a startup script whether or not Bash is running +interactively, test the value of the '-' special parameter. It contains +'i' when the shell is interactive. For example: + + case "$-" in + *i*) echo This shell is interactive ;; + *) echo This shell is not interactive ;; + esac + + Alternatively, startup scripts may 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 + + +File: bash.info, Node: Interactive Shell Behavior, Prev: Is this Shell Interactive?, Up: Interactive Shells + +6.3.3 Interactive Shell Behavior +-------------------------------- + +When the shell is running interactively, it changes its behavior in +several ways. + + 1. Startup files are read and executed as described in *note Bash + Startup Files::. + + 2. Job Control (*note Job Control::) is enabled by default. When job + control is in effect, Bash ignores the keyboard-generated job + control signals 'SIGTTIN', 'SIGTTOU', and 'SIGTSTP'. + + 3. Bash expands and displays 'PS1' before reading the first line of a + command, and expands and displays 'PS2' before reading the second + and subsequent lines of a multi-line command. Bash expands and + displays 'PS0' after it reads a command but before executing it. + See *note Controlling the Prompt::, for a complete list of prompt + string escape sequences. + + 4. Bash executes the value of the 'PROMPT_COMMAND' variable as a + command before printing the primary prompt, '$PS1' (*note Bash + Variables::). + + 5. Readline (*note Command Line Editing::) is used to read commands + from the user's terminal. + + 6. Bash inspects the value of the 'ignoreeof' option to 'set -o' + instead of exiting immediately when it receives an 'EOF' on its + standard input when reading a command (*note The Set Builtin::). + + 7. Command history (*note Bash History Facilities::) and history + expansion (*note History Interaction::) are enabled by default. + Bash will save the command history to the file named by '$HISTFILE' + when a shell with history enabled exits. + + 8. Alias expansion (*note Aliases::) is performed by default. + + 9. In the absence of any traps, Bash ignores 'SIGTERM' (*note + Signals::). + + 10. In the absence of any traps, 'SIGINT' is caught and handled (*note + Signals::). 'SIGINT' will interrupt some shell builtins. + + 11. An interactive login shell sends a 'SIGHUP' to all jobs on exit if + the 'huponexit' shell option has been enabled (*note Signals::). + + 12. The '-n' invocation option is ignored, and 'set -n' has no effect + (*note The Set Builtin::). + + 13. Bash will check for mail periodically, depending on the values of + the 'MAIL', 'MAILPATH', and 'MAILCHECK' shell variables (*note Bash + Variables::). + + 14. Expansion errors due to references to unbound shell variables + after 'set -u' has been enabled will not cause the shell to exit + (*note The Set Builtin::). + + 15. The shell will not exit on expansion errors caused by VAR being + unset or null in '${VAR:?WORD}' expansions (*note Shell Parameter + Expansion::). + + 16. Redirection errors encountered by shell builtins will not cause + the shell to exit. + + 17. When running in POSIX mode, a special builtin returning an error + status will not cause the shell to exit (*note Bash POSIX Mode::). + + 18. A failed 'exec' will not cause the shell to exit (*note Bourne + Shell Builtins::). + + 19. Parser syntax errors will not cause the shell to exit. + + 20. Simple spelling correction for directory arguments to the 'cd' + builtin is enabled by default (see the description of the 'cdspell' + option to the 'shopt' builtin in *note The Shopt Builtin::). + + 21. The shell will check the value of the 'TMOUT' variable and exit if + a command is not read within the specified number of seconds after + printing '$PS1' (*note Bash Variables::). + + +File: bash.info, Node: Bash Conditional Expressions, Next: Shell Arithmetic, Prev: Interactive Shells, Up: Bash Features + +6.4 Bash Conditional Expressions +================================ + +Conditional expressions are used by the '[[' compound command and the +'test' and '[' builtin commands. The 'test' and '[' commands determine +their behavior based on the number of arguments; see the descriptions of +those commands for any other command-specific actions. + + Expressions may be unary or binary, and are formed from the following +primaries. Unary expressions are often used to examine the status of a +file. There are string operators and numeric comparison operators as +well. Bash handles several filenames specially when they are used in +expressions. If the operating system on which Bash is running provides +these special files, Bash will use them; otherwise it will emulate them +internally with this behavior: If the FILE argument to one of the +primaries is of the form '/dev/fd/N', then file descriptor N is checked. +If the FILE argument to one of the primaries is one of '/dev/stdin', +'/dev/stdout', or '/dev/stderr', file descriptor 0, 1, or 2, +respectively, is checked. + + When used with '[[', the '<' and '>' operators sort lexicographically +using the current locale. The 'test' command uses ASCII ordering. + + Unless otherwise specified, primaries that operate on files follow +symbolic links and operate on the target of the link, rather than the +link itself. + +'-a FILE' + True if FILE exists. + +'-b FILE' + True if FILE exists and is a block special file. + +'-c FILE' + True if FILE exists and is a character special file. + +'-d FILE' + True if FILE exists and is a directory. + +'-e FILE' + True if FILE exists. + +'-f FILE' + True if FILE exists and is a regular file. + +'-g FILE' + True if FILE exists and its set-group-id bit is set. + +'-h FILE' + True if FILE exists and is a symbolic link. + +'-k FILE' + True if FILE exists and its "sticky" bit is set. + +'-p FILE' + True if FILE exists and is a named pipe (FIFO). + +'-r FILE' + True if FILE exists and is readable. + +'-s FILE' + True if FILE exists and has a size greater than zero. + +'-t FD' + True if file descriptor FD is open and refers to a terminal. + +'-u FILE' + True if FILE exists and its set-user-id bit is set. + +'-w FILE' + True if FILE exists and is writable. + +'-x FILE' + True if FILE exists and is executable. + +'-G FILE' + True if FILE exists and is owned by the effective group id. + +'-L FILE' + True if FILE exists and is a symbolic link. + +'-N FILE' + True if FILE exists and has been modified since it was last read. + +'-O FILE' + True if FILE exists and is owned by the effective user id. + +'-S FILE' + True if FILE exists and is a socket. + +'FILE1 -ef FILE2' + True if FILE1 and FILE2 refer to the same device and inode numbers. + +'FILE1 -nt FILE2' + True if FILE1 is newer (according to modification date) than FILE2, + or if FILE1 exists and FILE2 does not. + +'FILE1 -ot FILE2' + True if FILE1 is older than FILE2, or if FILE2 exists and FILE1 + does not. + +'-o OPTNAME' + True if the shell option OPTNAME is enabled. The list of options + appears in the description of the '-o' option to the 'set' builtin + (*note The Set Builtin::). + +'-v VARNAME' + True if the shell variable VARNAME is set (has been assigned a + value). + +'-R VARNAME' + True if the shell variable VARNAME is set and is a name reference. + +'-z STRING' + True if the length of STRING is zero. + +'-n STRING' +'STRING' + True if the length of STRING is non-zero. + +'STRING1 == STRING2' +'STRING1 = STRING2' + True if the strings are equal. When used with the '[[' command, + this performs pattern matching as described above (*note + Conditional Constructs::). + + '=' should be used with the 'test' command for POSIX conformance. + +'STRING1 != STRING2' + True if the strings are not equal. + +'STRING1 < STRING2' + True if STRING1 sorts before STRING2 lexicographically. + +'STRING1 > STRING2' + True if STRING1 sorts after STRING2 lexicographically. + +'ARG1 OP ARG2' + 'OP' is one of '-eq', '-ne', '-lt', '-le', '-gt', or '-ge'. These + arithmetic binary operators return true if ARG1 is equal to, not + equal to, less than, less than or equal to, greater than, or + greater than or equal to ARG2, respectively. ARG1 and ARG2 may be + positive or negative integers. When used with the '[[' command, + ARG1 and ARG2 are evaluated as arithmetic expressions (*note Shell + Arithmetic::). + + +File: bash.info, Node: Shell Arithmetic, Next: Aliases, Prev: Bash Conditional Expressions, Up: Bash Features + +6.5 Shell Arithmetic +==================== + +The shell allows arithmetic expressions to be evaluated, as one of the +shell expansions or by using the '((' compound command, the 'let' +builtin, or the '-i' option to the 'declare' builtin. + + Evaluation is done in fixed-width integers with no check for +overflow, though division by 0 is trapped and flagged as an error. The +operators and their precedence, associativity, and values are the same +as in the C language. The following list of operators is grouped into +levels of equal-precedence operators. The levels are listed in order of +decreasing precedence. + +'ID++ ID--' + variable post-increment and post-decrement + +'++ID --ID' + variable pre-increment and pre-decrement + +'- +' + unary minus and plus + +'! ~' + logical and bitwise negation + +'**' + exponentiation + +'* / %' + multiplication, division, remainder + +'+ -' + addition, subtraction + +'<< >>' + left and right bitwise shifts + +'<= >= < >' + comparison + +'== !=' + equality and inequality + +'&' + bitwise AND + +'^' + bitwise exclusive OR + +'|' + bitwise OR + +'&&' + logical AND + +'||' + logical OR + +'expr ? expr : expr' + conditional operator + +'= *= /= %= += -= <<= >>= &= ^= |=' + assignment + +'expr1 , expr2' + comma + + Shell variables are allowed as operands; parameter expansion is +performed before the expression is evaluated. Within an expression, +shell variables may also be referenced by name without using the +parameter expansion syntax. A shell variable that is null or unset +evaluates to 0 when referenced by name without using the parameter +expansion syntax. The value of a variable is evaluated as an arithmetic +expression when it is referenced, or when a variable which has been +given the INTEGER attribute using 'declare -i' is assigned a value. A +null value evaluates to 0. 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 the optional BASE is a decimal number between 2 +and 64 representing the arithmetic base, and N is a number in that base. +If BASE'#' is omitted, then base 10 is used. When specifying N, the +digits greater than 9 are represented by the lowercase letters, the +uppercase letters, '@', and '_', in that order. If BASE is less than or +equal to 36, lowercase and uppercase letters may be used interchangeably +to represent numbers between 10 and 35. + + Operators are evaluated in order of precedence. Sub-expressions in +parentheses are evaluated first and may override the precedence rules +above. + + +File: bash.info, Node: Aliases, Next: Arrays, Prev: Shell Arithmetic, Up: Bash Features + +6.6 Aliases +=========== + +ALIASES allow a string to be substituted for a word when it is used as +the first word of a simple command. The shell maintains a list of +aliases that may be set and unset with the 'alias' and 'unalias' builtin +commands. + + The first word of each simple 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 characters '/', '$', '`', '=' and any of the shell +metacharacters or quoting characters listed above may not appear in an +alias name. The replacement text may contain any valid shell input, +including shell metacharacters. The first word of the replacement text +is tested for aliases, but a word that is identical to an alias being +expanded is not expanded a second time. This means that one may alias +'ls' to '"ls -F"', for instance, and Bash does not try to recursively +expand the replacement text. If the last character of the alias value +is a BLANK, then the next command word following the alias is also +checked for alias expansion. + + Aliases are created and listed with the 'alias' command, and removed +with the 'unalias' command. + + There is no mechanism for using arguments in the replacement text, as +in 'csh'. If arguments are needed, a shell function should be used +(*note Shell Functions::). + + Aliases are not expanded when the shell is not interactive, unless +the 'expand_aliases' shell option is set using 'shopt' (*note The Shopt +Builtin::). + + The rules concerning the definition and use of aliases are somewhat +confusing. Bash always reads at least one complete line of input, and +all lines that make up a compound command, before executing any of the +commands on that line or the compound command. Aliases are expanded +when a command is read, not when it is executed. Therefore, an alias +definition appearing on the same line as another command does not take +effect until the next line of input is read. The commands following the +alias definition on that line are not affected by the new alias. This +behavior is also an issue when functions are executed. Aliases are +expanded when a function definition is read, not when the function is +executed, because a function definition is itself a 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. + + For almost every purpose, shell functions are preferred over aliases. + + +File: bash.info, Node: Arrays, Next: The Directory Stack, Prev: Aliases, Up: Bash Features + +6.7 Arrays +========== + +Bash provides one-dimensional indexed and associative array variables. +Any variable may be used as an indexed array; the 'declare' builtin will +explicitly declare an array. There is no maximum limit on the size of +an array, nor any requirement that members be indexed or assigned +contiguously. Indexed arrays are referenced using integers (including +arithmetic expressions (*note Shell Arithmetic::)) and are zero-based; +associative arrays use arbitrary strings. Unless otherwise noted, +indexed array indices must be non-negative integers. + + An indexed array is created automatically if any variable is assigned +to using the syntax + NAME[SUBSCRIPT]=VALUE + +The SUBSCRIPT is treated as an arithmetic expression that must evaluate +to a number. To explicitly declare an array, use + declare -a NAME +The syntax + declare -a NAME[SUBSCRIPT] +is also accepted; the SUBSCRIPT is ignored. + +Associative arrays are created using + declare -A NAME. + + Attributes may be specified for an array variable using the 'declare' +and 'readonly' builtins. Each attribute applies to all members of an +array. + + Arrays are assigned to using compound assignments of the form + NAME=(VALUE1 VALUE2 ... ) +where each VALUE is of the form '[SUBSCRIPT]='STRING. Indexed array +assignments do not require anything but STRING. When assigning to +indexed arrays, if the optional subscript is supplied, that index is +assigned to; otherwise the index of the element assigned is the last +index assigned to by the statement plus one. Indexing starts at zero. + + When assigning to an associative array, the subscript is required. + + This syntax is also accepted by the 'declare' builtin. Individual +array elements may be assigned to using the 'NAME[SUBSCRIPT]=VALUE' +syntax introduced above. + + When assigning to an indexed array, if NAME is subscripted by a +negative number, that number is interpreted as relative to one greater +than the maximum index of NAME, so negative indices count back from the +end of the array, and an index of -1 references the last element. + + Any element of an array may be referenced using '${NAME[SUBSCRIPT]}'. +The braces are required to avoid conflicts with the shell's filename +expansion operators. If the SUBSCRIPT is '@' or '*', the word expands +to all members of the array NAME. These subscripts differ only when the +word appears within double quotes. If the word is double-quoted, +'${NAME[*]}' expands to a single word with the value of each array +member separated by the first character of the 'IFS' variable, and +'${NAME[@]}' expands each element of NAME to a separate word. When +there are no array members, '${NAME[@]}' expands to nothing. If the +double-quoted expansion occurs within a word, the expansion of the first +parameter is joined with the beginning part of the original word, and +the expansion of the last parameter is joined with the last part of the +original word. This is analogous to the expansion of the special +parameters '@' and '*'. '${#NAME[SUBSCRIPT]}' expands to the length of +'${NAME[SUBSCRIPT]}'. If SUBSCRIPT is '@' or '*', the expansion is the +number of elements in the array. If the SUBSCRIPT used to reference an +element of an indexed array evaluates to a number less than zero, it is +interpreted as relative to one greater than the maximum index of the +array, so negative indices count back from the end of the array, and an +index of -1 refers to the last element. + + Referencing an array variable without a subscript is equivalent to +referencing with a subscript of 0. Any reference to a variable using a +valid subscript is legal, and 'bash' will create an array if necessary. + + An array variable is considered set if a subscript has been assigned +a value. The null string is a valid value. + + It is possible to obtain the keys (indices) of an array as well as +the values. ${!NAME[@]} and ${!NAME[*]} expand to the indices assigned +in array variable NAME. The treatment when in double quotes is similar +to the expansion of the special parameters '@' and '*' within double +quotes. + + The 'unset' builtin is used to destroy arrays. 'unset +NAME[SUBSCRIPT]' destroys the array element at index SUBSCRIPT. +Negative subscripts to indexed arrays are interpreted as described +above. Unsetting the last element of an array variable does not unset +the variable. 'unset NAME', where NAME is an array, removes the entire +array. A subscript of '*' or '@' also removes the entire array. + + When using a variable name with a subscript as an argument to a +command, such as with 'unset', without using the word expansion syntax +described above, the argument is subject to the shell's filename +expansion. If filename expansion is not desired, the argument should be +quoted. + + The 'declare', 'local', and 'readonly' builtins each accept a '-a' +option to specify an indexed array and a '-A' option to specify an +associative array. If both options are supplied, '-A' takes precedence. +The 'read' builtin accepts a '-a' option to assign a list of words read +from the standard input to an array, and can read values from the +standard input into individual array elements. The 'set' and 'declare' +builtins display array values in a way that allows them to be reused as +input. + + +File: bash.info, Node: The Directory Stack, Next: Controlling the Prompt, Prev: Arrays, Up: Bash Features + +6.8 The Directory Stack +======================= + +* Menu: + +* Directory Stack Builtins:: Bash builtin commands to manipulate + the directory stack. + +The directory stack is a list of recently-visited directories. The +'pushd' builtin adds directories to the stack as it changes the current +directory, and the 'popd' builtin removes specified directories from the +stack and changes the current directory to the directory removed. The +'dirs' builtin displays the contents of the directory stack. The +current directory is always the "top" of the directory stack. + + The contents of the directory stack are also visible as the value of +the 'DIRSTACK' shell variable. + + +File: bash.info, Node: Directory Stack Builtins, Up: The Directory Stack + +6.8.1 Directory Stack Builtins +------------------------------ + +'dirs' + dirs [-clpv] [+N | -N] + + Display the list of currently remembered directories. Directories + are added to the list with the 'pushd' command; the 'popd' command + removes directories from the list. The current directory is always + the first directory in the stack. + + '-c' + Clears the directory stack by deleting all of the elements. + '-l' + Produces a listing using full pathnames; the default listing + format uses a tilde to denote the home directory. + '-p' + Causes 'dirs' to print the directory stack with one entry per + line. + '-v' + Causes 'dirs' to print the directory stack with one entry per + line, prefixing each entry with its index in the stack. + '+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. + +'popd' + popd [-n] [+N | -N] + + When no arguments are given, 'popd' removes the top directory from + the stack and performs a 'cd' to the new top directory. The + elements are numbered from 0 starting at the first directory listed + with 'dirs'; that is, 'popd' is equivalent to 'popd +0'. + + '-n' + Suppresses the normal change of directory when removing + directories from the stack, so that only the stack is + manipulated. + '+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. + +'pushd' + pushd [-n] [+N | -N | DIR] + + Save the current directory on the top of the directory stack and + then 'cd' to DIR. With no arguments, 'pushd' exchanges the top two + directories and makes the new top the current directory. + + '-n' + Suppresses the normal change of directory when rotating or + adding directories to the stack, so that only the stack is + manipulated. + '+N' + Brings the Nth directory (counting from the left of the list + printed by 'dirs', starting with zero) 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', starting with zero) to the top of the list + by rotating the stack. + 'DIR' + Makes DIR be the top of the stack, making it the new current + directory as if it had been supplied as an argument to the + 'cd' builtin. + + +File: bash.info, Node: Controlling the Prompt, Next: The Restricted Shell, Prev: The Directory Stack, Up: Bash Features + +6.9 Controlling the Prompt +========================== + +The value of the variable 'PROMPT_COMMAND' is examined just before Bash +prints each primary prompt. If 'PROMPT_COMMAND' is set and has a +non-null value, then the value is executed just as if it had been typed +on the command line. + + In addition, the following table describes the special characters +which can appear in the prompt variables 'PS0', 'PS1', 'PS2', and 'PS4': + +'\a' + A bell character. +'\d' + The date, in "Weekday Month Date" format (e.g., "Tue May 26"). +'\D{FORMAT}' + The FORMAT is passed to 'strftime'(3) and the result is inserted + into the prompt string; an empty FORMAT results in a + locale-specific time representation. The braces are required. +'\e' + An escape character. +'\h' + The hostname, up to the first '.'. +'\H' + The hostname. +'\j' + The number of jobs currently managed by the shell. +'\l' + The basename of the shell's terminal device name. +'\n' + A newline. +'\r' + A carriage return. +'\s' + The name of the shell, the basename of '$0' (the portion following + the final slash). +'\t' + The time, in 24-hour HH:MM:SS format. +'\T' + The time, in 12-hour HH:MM:SS format. +'\@' + The time, in 12-hour am/pm format. +'\A' + The time, in 24-hour HH:MM format. +'\u' + The username of the current user. +'\v' + The version of Bash (e.g., 2.00) +'\V' + The release of Bash, version + patchlevel (e.g., 2.00.0) +'\w' + The current working directory, with '$HOME' abbreviated with a + tilde (uses the '$PROMPT_DIRTRIM' variable). +'\W' + The basename of '$PWD', with '$HOME' abbreviated with a tilde. +'\!' + The history number of this command. +'\#' + The command number of this command. +'\$' + If the effective uid is 0, '#', otherwise '$'. +'\NNN' + The character whose ASCII code is the octal value NNN. +'\\' + 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. + + The command number and the history number are usually different: the +history number of a command is its position in the history list, which +may include commands restored from the history file (*note Bash History +Facilities::), while the command number is the position in the sequence +of commands executed during the current shell session. + + After the string is decoded, it is expanded via parameter expansion, +command substitution, arithmetic expansion, and quote removal, subject +to the value of the 'promptvars' shell option (*note The Shopt +Builtin::). + + +File: bash.info, Node: The Restricted Shell, Next: Bash POSIX Mode, Prev: Controlling the Prompt, Up: Bash Features + +6.10 The Restricted Shell +========================= + +If Bash is started with the name 'rbash', or the '--restricted' or '-r' +option is supplied at invocation, the shell becomes restricted. A +restricted shell is used to set up an environment more controlled than +the standard shell. A restricted shell behaves identically to 'bash' +with the exception that the following are disallowed or not performed: + + * Changing directories with the 'cd' builtin. + * Setting or unsetting the values of the 'SHELL', 'PATH', 'ENV', or + 'BASH_ENV' variables. + * Specifying command names containing slashes. + * Specifying a filename containing a slash as an argument to the '.' + builtin command. + * Specifying a filename containing a slash as an argument to the '-p' + option to the 'hash' builtin command. + * Importing function definitions from the shell environment at + startup. + * Parsing the value of 'SHELLOPTS' from the shell environment at + startup. + * Redirecting output using the '>', '>|', '<>', '>&', '&>', and '>>' + redirection operators. + * Using the 'exec' builtin to replace the shell with another command. + * Adding or deleting builtin commands with the '-f' and '-d' options + to the 'enable' builtin. + * Using the 'enable' builtin command to enable disabled shell + builtins. + * Specifying the '-p' option to the 'command' builtin. + * Turning off restricted mode with 'set +r' or 'set +o restricted'. + + These restrictions are enforced after any startup files are read. + + When a command that is found to be a shell script is executed (*note +Shell Scripts::), 'rbash' turns off any restrictions in the shell +spawned to execute the script. + + +File: bash.info, Node: Bash POSIX Mode, Prev: The Restricted Shell, Up: Bash Features + +6.11 Bash POSIX Mode +==================== + +Starting Bash with the '--posix' command-line option or executing 'set +-o posix' while Bash is running will cause Bash to conform more closely +to the POSIX standard by changing the behavior to match that specified +by POSIX in areas where the Bash default differs. + + When invoked as 'sh', Bash enters POSIX mode after reading the +startup files. + + The following list is what's changed when 'POSIX mode' is in effect: + + 1. Bash ensures that the 'POSIXLY_CORRECT' variable is set. + + 2. When a command in the hash table no longer exists, Bash will + re-search '$PATH' to find the new location. This is also available + with 'shopt -s checkhash'. + + 3. The message printed by the job control code and builtins when a job + exits with a non-zero status is 'Done(status)'. + + 4. The message printed by the job control code and builtins when a job + is stopped is 'Stopped(SIGNAME)', where SIGNAME is, for example, + 'SIGTSTP'. + + 5. Alias expansion is always enabled, even in non-interactive shells. + + 6. Reserved words appearing in a context where reserved words are + recognized do not undergo alias expansion. + + 7. The POSIX 'PS1' and 'PS2' expansions of '!' to the history number + and '!!' to '!' are enabled, and parameter expansion is performed + on the values of 'PS1' and 'PS2' regardless of the setting of the + 'promptvars' option. + + 8. The POSIX startup files are executed ('$ENV') rather than the + normal Bash files. + + 9. Tilde expansion is only performed on assignments preceding a + command name, rather than on all assignment statements on the line. + + 10. The default history file is '~/.sh_history' (this is the default + value of '$HISTFILE'). + + 11. Redirection operators do not perform filename expansion on the + word in the redirection unless the shell is interactive. + + 12. Redirection operators do not perform word splitting on the word in + the redirection. + + 13. Function names must be valid shell 'name's. That is, they may not + contain characters other than letters, digits, and underscores, and + may not start with a digit. Declaring a function with an invalid + name causes a fatal syntax error in non-interactive shells. + + 14. Function names may not be the same as one of the POSIX special + builtins. + + 15. POSIX special builtins are found before shell functions during + command lookup. + + 16. When printing shell function definitions (e.g., by 'type'), Bash + does not print the 'function' keyword. + + 17. Literal tildes that appear as the first character in elements of + the 'PATH' variable are not expanded as described above under *note + Tilde Expansion::. + + 18. The 'time' reserved word may be used by itself as a command. When + used in this way, it displays timing statistics for the shell and + its completed children. The 'TIMEFORMAT' variable controls the + format of the timing information. + + 19. When parsing and expanding a ${...} expansion that appears within + double quotes, single quotes are no longer special and cannot be + used to quote a closing brace or other special character, unless + the operator is one of those defined to perform pattern removal. + In this case, they do not have to appear as matched pairs. + + 20. The parser does not recognize 'time' as a reserved word if the + next token begins with a '-'. + + 21. The '!' character does not introduce history expansion within a + double-quoted string, even if the 'histexpand' option is enabled. + + 22. If a POSIX special builtin returns an error status, a + non-interactive shell exits. The fatal errors are those listed in + the POSIX standard, and include things like passing incorrect + options, redirection errors, variable assignment errors for + assignments preceding the command name, and so on. + + 23. A non-interactive shell exits with an error status if a variable + assignment error occurs when no command name follows the assignment + statements. A variable assignment error occurs, for example, when + trying to assign a value to a readonly variable. + + 24. A non-interactive shell exits with an error status if a variable + assignment error occurs in an assignment statement preceding a + special builtin, but not with any other simple command. + + 25. A non-interactive shell exits with an error status if the + iteration variable in a 'for' statement or the selection variable + in a 'select' statement is a readonly variable. + + 26. Non-interactive shells exit if FILENAME in '.' FILENAME is not + found. + + 27. Non-interactive shells exit if a syntax error in an arithmetic + expansion results in an invalid expression. + + 28. Non-interactive shells exit if a parameter expansion error occurs. + + 29. Non-interactive shells exit if there is a syntax error in a script + read with the '.' or 'source' builtins, or in a string processed by + the 'eval' builtin. + + 30. Process substitution is not available. + + 31. While variable indirection is available, it may not be applied to + the '#' and '?' special parameters. + + 32. When expanding the '*' special parameter in a pattern context + where the expansion is double-quoted does not treat the '$*' as if + it were double-quoted. + + 33. Assignment statements preceding POSIX special builtins persist in + the shell environment after the builtin completes. + + 34. Assignment statements preceding shell function calls persist in + the shell environment after the function returns, as if a POSIX + special builtin command had been executed. + + 35. The 'command' builtin does not prevent builtins that take + assignment statements as arguments from expanding them as + assignment statements; when not in POSIX mode, assignment builtins + lose their assignment statement expansion properties when preceded + by 'command'. + + 36. The 'bg' builtin uses the required format to describe each job + placed in the background, which does not include an indication of + whether the job is the current or previous job. + + 37. The output of 'kill -l' prints all the signal names on a single + line, separated by spaces, without the 'SIG' prefix. + + 38. The 'kill' builtin does not accept signal names with a 'SIG' + prefix. + + 39. The 'export' and 'readonly' builtin commands display their output + in the format required by POSIX. + + 40. The 'trap' builtin displays signal names without the leading + 'SIG'. + + 41. The 'trap' builtin doesn't check the first argument for a possible + signal specification and revert the signal handling to the original + disposition if it is, unless that argument consists solely of + digits and is a valid signal number. If users want to reset the + handler for a given signal to the original disposition, they should + use '-' as the first argument. + + 42. The '.' and 'source' builtins do not search the current directory + for the filename argument if it is not found by searching 'PATH'. + + 43. Enabling POSIX mode has the effect of setting the + 'inherit_errexit' option, so subshells spawned to execute command + substitutions inherit the value of the '-e' option from the parent + shell. When the 'inherit_errexit' option is not enabled, Bash + clears the '-e' option in such subshells. + + 44. Enabling POSIX mode has the effect of setting the 'shift_verbose' + option, so numeric arguments to 'shift' that exceed the number of + positional parameters will result in an error message. + + 45. When the 'alias' builtin displays alias definitions, it does not + display them with a leading 'alias ' unless the '-p' option is + supplied. + + 46. When the 'set' builtin is invoked without options, it does not + display shell function names and definitions. + + 47. When the 'set' builtin is invoked without options, it displays + variable values without quotes, unless they contain shell + metacharacters, even if the result contains nonprinting characters. + + 48. When the 'cd' builtin is invoked in LOGICAL mode, and the pathname + constructed from '$PWD' and the directory name supplied as an + argument does not refer to an existing directory, 'cd' will fail + instead of falling back to PHYSICAL mode. + + 49. When the 'cd' builtin cannot change a directory because the length + of the pathname constructed from '$PWD' and the directory name + supplied as an argument exceeds PATH_MAX when all symbolic links + are expanded, 'cd' will fail instead of attempting to use only the + supplied directory name. + + 50. The 'pwd' builtin verifies that the value it prints is the same as + the current directory, even if it is not asked to check the file + system with the '-P' option. + + 51. When listing the history, the 'fc' builtin does not include an + indication of whether or not a history entry has been modified. + + 52. The default editor used by 'fc' is 'ed'. + + 53. The 'type' and 'command' builtins will not report a non-executable + file as having been found, though the shell will attempt to execute + such a file if it is the only so-named file found in '$PATH'. + + 54. The 'vi' editing mode will invoke the 'vi' editor directly when + the 'v' command is run, instead of checking '$VISUAL' and + '$EDITOR'. + + 55. When the 'xpg_echo' option is enabled, Bash does not attempt to + interpret any arguments to 'echo' as options. Each argument is + displayed, after escape characters are converted. + + 56. The 'ulimit' builtin uses a block size of 512 bytes for the '-c' + and '-f' options. + + 57. The arrival of 'SIGCHLD' when a trap is set on 'SIGCHLD' does not + interrupt the 'wait' builtin and cause it to return immediately. + The trap command is run once for each child that exits. + + 58. The 'read' builtin may be interrupted by a signal for which a trap + has been set. If Bash receives a trapped signal while executing + 'read', the trap handler executes and 'read' returns an exit status + greater than 128. + + 59. Bash removes an exited background process's status from the list + of such statuses after the 'wait' builtin is used to obtain it. + + There is other POSIX behavior that Bash does not implement by default +even when in POSIX mode. Specifically: + + 1. The 'fc' builtin checks '$EDITOR' as a program to edit history + entries if 'FCEDIT' is unset, rather than defaulting directly to + 'ed'. 'fc' uses 'ed' if 'EDITOR' is unset. + + 2. As noted above, Bash requires the 'xpg_echo' option to be enabled + for the 'echo' builtin to be fully conformant. + + Bash can be configured to be POSIX-conformant by default, by +specifying the '--enable-strict-posix-default' to 'configure' when +building (*note Optional Features::). + + +File: bash.info, Node: Job Control, Next: Command Line Editing, Prev: Bash Features, Up: Top + +7 Job Control +************* + +This chapter discusses what job control is, how it works, and how Bash +allows you to access its facilities. + +* Menu: + +* Job Control Basics:: How job control works. +* Job Control Builtins:: Bash builtin commands used to interact + with job control. +* Job Control Variables:: Variables Bash uses to customize job + control. + + +File: bash.info, Node: Job Control Basics, Next: Job Control Builtins, Up: Job Control + +7.1 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 operating system kernel'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, 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 operating 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, if the user so specifies with 'stty tostop', write to the +terminal. Background processes which attempt to read from (write to +when 'stty tostop' is in effect) the terminal are sent a 'SIGTTIN' +('SIGTTOU') signal by the kernel's terminal driver, which, unless +caught, suspends the process. + + If the operating system on which Bash is running supports job +control, Bash contains facilities to use it. Typing the SUSPEND +character (typically '^Z', Control-Z) while a process is running causes +that process to be stopped and returns control to Bash. Typing the +DELAYED SUSPEND character (typically '^Y', Control-Y) causes the process +to be stopped when it attempts to read input from the terminal, and +control to be returned to Bash. The user then manipulates 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 specification (JOBSPEC). + + Job number 'n' may be referred to as '%n'. The symbols '%%' and '%+' +refer to the shell's notion of the current job, which is the last job +stopped while it was in the foreground or started in the background. A +single '%' (with no accompanying job specification) also refers to the +current job. The previous job may be referenced using '%-'. If there +is only a single job, '%+' and '%-' can both be used to refer to that +job. 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 '-'. + + 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. + + 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 '-b' +option to the 'set' builtin is enabled, Bash reports such changes +immediately (*note The Set Builtin::). Any trap on 'SIGCHLD' is +executed for each child process that exits. + + If an attempt to exit Bash is made while jobs are stopped, (or +running, if the 'checkjobs' option is enabled - see *note The Shopt +Builtin::), the shell prints a warning message, and if the 'checkjobs' +option is enabled, lists the jobs and their statuses. The 'jobs' +command may then be used to inspect their status. If a second attempt +to exit is made without an intervening command, Bash does not print +another warning, and any stopped jobs are terminated. + + When the shell is waiting for a job or process using the 'wait' +builtin, and job control is enabled, 'wait' will return when the job +changes state. The '-f' option will force 'wait' to wait until the job +or process terminates before returning. + + +File: bash.info, Node: Job Control Builtins, Next: Job Control Variables, Prev: Job Control Basics, Up: Job Control + +7.2 Job Control Builtins +======================== + +'bg' + bg [JOBSPEC ...] + + Resume each suspended job JOBSPEC in the background, as if it had + been started with '&'. If JOBSPEC is not supplied, the current job + is used. The return status is zero unless it is run when job + control is not enabled, or, when run with job control enabled, any + JOBSPEC was not found or specifies a job that was started without + job control. + +'fg' + fg [JOBSPEC] + + Resume the job JOBSPEC in the foreground and make it the current + job. If JOBSPEC is not supplied, the current job is used. The + return status is that of the command placed into the foreground, or + non-zero if run when job control is disabled or, when run with job + control enabled, JOBSPEC does not specify a valid job or JOBSPEC + specifies a job that was started without job control. + +'jobs' + jobs [-lnprs] [JOBSPEC] + jobs -x COMMAND [ARGUMENTS] + + The first form lists the active jobs. The options have the + following meanings: + + '-l' + List process IDs in addition to the normal information. + + '-n' + Display information only about jobs that have changed status + since the user was last notified of their status. + + '-p' + List only the process ID of the job's process group leader. + + '-r' + Display only running jobs. + + '-s' + Display only stopped jobs. + + 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. + +'kill' + kill [-s SIGSPEC] [-n SIGNUM] [-SIGSPEC] JOBSPEC or PID + kill -l|-L [EXIT_STATUS] + + Send a signal specified by SIGSPEC or SIGNUM to the process named + by job specification JOBSPEC or process ID PID. SIGSPEC is either + a case-insensitive signal name such as 'SIGINT' (with or without + the 'SIG' prefix) or a signal number; SIGNUM is a signal number. + If SIGSPEC and SIGNUM are not present, 'SIGTERM' is used. The '-l' + option lists the signal names. If any arguments are supplied when + '-l' is given, the names of the signals corresponding to the + arguments are listed, and the return status is zero. EXIT_STATUS + is a number specifying a signal number or the exit status of a + process terminated by a signal. The '-L' option is equivalent to + '-l'. The return status is zero if at least one signal was + successfully sent, or non-zero if an error occurs or an invalid + option is encountered. + +'wait' + wait [-fn] [JOBSPEC or PID ...] + + Wait until the child process specified by each process ID PID or + job specification JOBSPEC exits and return the exit status of the + last command waited for. If a job spec is given, all processes in + the job are waited for. If no arguments are given, all currently + active child processes are waited for, and the return status is + zero. If the '-n' option is supplied, 'wait' waits for any job to + terminate and returns its exit status. If the '-f' option is + supplied, and job control is enabled, 'wait' forces each PID or + JOBSPEC to terminate before returning its status, intead of + returning when it changes status. If neither JOBSPEC nor PID + specifies an active child process of the shell, the return status + is 127. + +'disown' + disown [-ar] [-h] [JOBSPEC ... | PID ... ] + + Without options, remove each JOBSPEC from the table of active jobs. + If the '-h' option is given, the job is not removed from the table, + but is marked so that 'SIGHUP' is not sent to the job if the shell + receives a 'SIGHUP'. If JOBSPEC is not present, and neither the + '-a' nor the '-r' option is supplied, the current job is used. If + no JOBSPEC is supplied, the '-a' option means to remove or mark all + jobs; the '-r' option without a JOBSPEC argument restricts + operation to running jobs. + +'suspend' + suspend [-f] + + Suspend the execution of this shell until it receives a 'SIGCONT' + signal. A login shell cannot be suspended; the '-f' option can be + used to override this and force the suspension. + + When job control is not active, the 'kill' and 'wait' builtins do not +accept JOBSPEC arguments. They must be supplied process IDs. + + +File: bash.info, Node: Job Control Variables, Prev: Job Control Builtins, Up: Job Control + +7.3 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 redirections are treated as candidates for + resumption of an existing job. There is no ambiguity allowed; if + there is more than one job beginning with the string 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 (*note 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. + + +File: bash.info, Node: Command Line Editing, Next: Using History Interactively, Prev: Job Control, Up: Top + +8 Command Line Editing +********************** + +This chapter describes the basic features of the GNU command line +editing interface. Command line editing is provided by the Readline +library, which is used by several different programs, including Bash. +Command line editing is enabled by default when using an interactive +shell, unless the '--noediting' option is supplied at shell invocation. +Line editing is also used when using the '-e' option to the 'read' +builtin command (*note Bash Builtins::). By default, the line editing +commands are similar to those of Emacs. A vi-style line editing +interface is also available. Line editing can be enabled at any time +using the '-o emacs' or '-o vi' options to the 'set' builtin command +(*note The Set Builtin::), or disabled using the '+o emacs' or '+o vi' +options to 'set'. + +* Menu: + +* Introduction and Notation:: Notation used in this text. +* Readline Interaction:: The minimum set of commands for editing a line. +* Readline Init File:: Customizing Readline from a user's view. +* Bindable Readline Commands:: A description of most of the Readline commands + available for binding +* Readline vi Mode:: A short description of how to make Readline + behave like the vi editor. +* Programmable Completion:: How to specify the possible completions for + a specific command. +* Programmable Completion Builtins:: Builtin commands to specify how to + complete arguments for a particular command. +* A Programmable Completion Example:: An example shell function for + generating possible completions. + + +File: bash.info, Node: Introduction and Notation, Next: Readline Interaction, Up: Command Line Editing + +8.1 Introduction to Line Editing +================================ + +The following paragraphs describe the notation used to represent +keystrokes. + + The text 'C-k' is read as 'Control-K' and describes the character +produced when the <k> key is pressed while the Control key is depressed. + + The text 'M-k' is read as 'Meta-K' and describes the character +produced when the Meta key (if you have one) is depressed, and the <k> +key is pressed. The Meta key is labeled <ALT> on many keyboards. On +keyboards with two keys labeled <ALT> (usually to either side of the +space bar), the <ALT> on the left side is generally set to work as a +Meta key. The <ALT> key on the right may also be configured to work as +a Meta key or may be configured as some other modifier, such as a +Compose key for typing accented characters. + + If you do not have a Meta or <ALT> key, or another key working as a +Meta key, the identical keystroke can be generated by typing <ESC> +_first_, and then typing <k>. Either process is known as "metafying" +the <k> key. + + The text 'M-C-k' is read as 'Meta-Control-k' and describes the +character produced by "metafying" 'C-k'. + + In addition, several keys have their own names. Specifically, <DEL>, +<ESC>, <LFD>, <SPC>, <RET>, and <TAB> all stand for themselves when seen +in this text, or in an init file (*note Readline Init File::). If your +keyboard lacks a <LFD> key, typing <C-j> will produce the desired +character. The <RET> key may be labeled <Return> or <Enter> on some +keyboards. + + +File: bash.info, Node: Readline Interaction, Next: Readline Init File, Prev: Introduction and Notation, Up: Command Line Editing + +8.2 Readline Interaction +======================== + +Often during an interactive session you type in a long line of text, +only to notice that the first word on the line is misspelled. The +Readline library gives you a set of commands for manipulating the text +as you type it in, allowing you to just fix your typo, and not forcing +you to retype the majority of the line. Using these editing commands, +you move the cursor to the place that needs correction, and delete or +insert the text of the corrections. Then, when you are satisfied with +the line, you simply press <RET>. You do not have to be at the end of +the line to press <RET>; the entire line is accepted regardless of the +location of the cursor within the line. + +* Menu: + +* Readline Bare Essentials:: The least you need to know about Readline. +* Readline Movement Commands:: Moving about the input line. +* Readline Killing Commands:: How to delete text, and how to get it back! +* Readline Arguments:: Giving numeric arguments to commands. +* Searching:: Searching through previous lines. + + +File: bash.info, Node: Readline Bare Essentials, Next: Readline Movement Commands, Up: Readline Interaction + +8.2.1 Readline Bare Essentials +------------------------------ + +In order to enter characters into the line, simply type them. The typed +character appears where the cursor was, and then the cursor moves one +space to the right. If you mistype a character, you can use your erase +character to back up and delete the mistyped character. + + Sometimes you may mistype a character, and not notice the error until +you have typed several other characters. In that case, you can type +'C-b' to move the cursor to the left, and then correct your mistake. +Afterwards, you can move the cursor to the right with 'C-f'. + + When you add text in the middle of a line, you will notice that +characters to the right of the cursor are 'pushed over' to make room for +the text that you have inserted. Likewise, when you delete text behind +the cursor, characters to the right of the cursor are 'pulled back' to +fill in the blank space created by the removal of the text. A list of +the bare essentials for editing the text of an input line follows. + +'C-b' + Move back one character. +'C-f' + Move forward one character. +<DEL> or <Backspace> + Delete the character to the left of the cursor. +'C-d' + Delete the character underneath the cursor. +Printing characters + Insert the character into the line at the cursor. +'C-_' or 'C-x C-u' + Undo the last editing command. You can undo all the way back to an + empty line. + +(Depending on your configuration, the <Backspace> key be set to delete +the character to the left of the cursor and the <DEL> key set to delete +the character underneath the cursor, like 'C-d', rather than the +character to the left of the cursor.) + + +File: bash.info, Node: Readline Movement Commands, Next: Readline Killing Commands, Prev: Readline Bare Essentials, Up: Readline Interaction + +8.2.2 Readline Movement Commands +-------------------------------- + +The above table describes the most basic keystrokes that you need in +order to do editing of the input line. For your convenience, many other +commands have been added in addition to 'C-b', 'C-f', 'C-d', and <DEL>. +Here are some commands for moving more rapidly about the line. + +'C-a' + Move to the start of the line. +'C-e' + Move to the end of the line. +'M-f' + Move forward a word, where a word is composed of letters and + digits. +'M-b' + Move backward a word. +'C-l' + Clear the screen, reprinting the current line at the top. + + Notice how 'C-f' moves forward a character, while 'M-f' moves forward +a word. It is a loose convention that control keystrokes operate on +characters while meta keystrokes operate on words. + + +File: bash.info, Node: Readline Killing Commands, Next: Readline Arguments, Prev: Readline Movement Commands, Up: Readline Interaction + +8.2.3 Readline Killing Commands +------------------------------- + +"Killing" text means to delete the text from the line, but to save it +away for later use, usually by "yanking" (re-inserting) it back into the +line. ('Cut' and 'paste' are more recent jargon for 'kill' and 'yank'.) + + If the description for a command says that it 'kills' text, then you +can be sure that you can get the text back in a different (or the same) +place later. + + When you use a kill command, the text is saved in a "kill-ring". Any +number of consecutive kills save all of the killed text together, so +that when you yank it back, you get it all. The kill ring is not line +specific; the text that you killed on a previously typed line is +available to be yanked back later, when you are typing another line. + + Here is the list of commands for killing text. + +'C-k' + Kill the text from the current cursor position to the end of the + line. + +'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 'M-f'. + +'M-<DEL>' + Kill from the cursor the start of the current word, or, if between + words, to the start of the previous word. Word boundaries are the + same as those used by 'M-b'. + +'C-w' + Kill from the cursor to the previous whitespace. This is different + than 'M-<DEL>' because the word boundaries differ. + + Here is how to "yank" the text back into the line. Yanking means to +copy the most-recently-killed text from the kill buffer. + +'C-y' + Yank the most recently killed text back into the buffer at the + cursor. + +'M-y' + Rotate the kill-ring, and yank the new top. You can only do this + if the prior command is 'C-y' or 'M-y'. + + +File: bash.info, Node: Readline Arguments, Next: Searching, Prev: Readline Killing Commands, Up: Readline Interaction + +8.2.4 Readline Arguments +------------------------ + +You can pass numeric arguments to Readline commands. Sometimes the +argument acts as a repeat count, other times it is the sign of the +argument that is significant. If you pass a negative argument to a +command which normally acts in a forward direction, that command will +act in a backward direction. For example, to kill text back to the +start of the line, you might type 'M-- C-k'. + + The general way to pass numeric arguments to a command is to type +meta digits before the command. If the first 'digit' typed is a minus +sign ('-'), then the sign of the argument will be negative. Once you +have typed one meta digit to get the argument started, you can type the +remainder of the digits, and then the command. For example, to give the +'C-d' command an argument of 10, you could type 'M-1 0 C-d', which will +delete the next ten characters on the input line. + + +File: bash.info, Node: Searching, Prev: Readline Arguments, Up: Readline Interaction + +8.2.5 Searching for Commands in the History +------------------------------------------- + +Readline provides commands for searching through the command history +(*note Bash History Facilities::) for lines containing a specified +string. There are two search modes: "incremental" and +"non-incremental". + + Incremental searches begin before the user has finished typing the +search string. As each character of the search string is typed, +Readline displays the next entry from the history matching the string +typed so far. An incremental search requires only as many characters as +needed to find the desired history entry. To search backward in the +history for a particular string, type 'C-r'. Typing 'C-s' searches +forward through the history. The characters present in the value of the +'isearch-terminators' variable are used to terminate an incremental +search. If that variable has not been assigned a value, the <ESC> and +'C-J' characters will terminate an incremental search. 'C-g' will abort +an incremental search and restore the original line. When the search is +terminated, the history entry containing the search string becomes the +current line. + + To find other matching entries in the history list, type 'C-r' or +'C-s' as appropriate. This will search backward or forward in the +history for the next entry matching the search string typed so far. Any +other key sequence bound to a Readline command will terminate the search +and execute that command. For instance, a <RET> will terminate the +search and accept the line, thereby executing the command from the +history list. A movement command will terminate the search, make the +last line found the current line, and begin editing. + + Readline remembers the last incremental search string. If two 'C-r's +are typed without any intervening characters defining a new search +string, any remembered search string is used. + + Non-incremental searches read the entire search string before +starting to search for matching history lines. The search string may be +typed by the user or be part of the contents of the current line. + + +File: bash.info, Node: Readline Init File, Next: Bindable Readline Commands, Prev: Readline Interaction, Up: Command Line Editing + +8.3 Readline Init File +====================== + +Although the Readline library comes with a set of Emacs-like keybindings +installed by default, it is possible to use a different set of +keybindings. Any user can customize programs that use Readline by +putting commands in an "inputrc" file, conventionally in his home +directory. The name of this file is taken from the value of the shell +variable 'INPUTRC'. If that variable is unset, the default is +'~/.inputrc'. If that file does not exist or cannot be read, the +ultimate default is '/etc/inputrc'. + + When a program which uses the Readline library starts up, the init +file is read, and the key bindings are set. + + In addition, the 'C-x C-r' command re-reads this init file, thus +incorporating any changes that you might have made to it. + +* Menu: + +* Readline Init File Syntax:: Syntax for the commands in the inputrc file. + +* Conditional Init Constructs:: Conditional key bindings in the inputrc file. + +* Sample Init File:: An example inputrc file. + + +File: bash.info, Node: Readline Init File Syntax, Next: Conditional Init Constructs, Up: Readline Init File + +8.3.1 Readline Init File Syntax +------------------------------- + +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 (*note +Conditional Init Constructs::). Other lines denote variable settings +and key bindings. + +Variable Settings + You can modify the run-time behavior of Readline by altering the + values of variables in Readline using the 'set' command within the + init file. The syntax is simple: + + set VARIABLE VALUE + + Here, for example, is how to change from the default Emacs-like key + binding to use 'vi' line editing commands: + + set editing-mode vi + + Variable names and values, where appropriate, are recognized + without regard to case. Unrecognized variable names are ignored. + + Boolean variables (those that can be set to on or off) are set to + on if the value is null or empty, ON (case-insensitive), or 1. Any + other value results in the variable being set to off. + + The 'bind -V' command lists the current Readline variable names and + values. *Note Bash Builtins::. + + A great deal of run-time behavior is changeable with the following + variables. + + 'bell-style' + Controls what happens when Readline wants to ring the terminal + bell. If set to 'none', Readline never rings the bell. If + set to 'visible', Readline uses a visible bell if one is + available. If set to 'audible' (the default), Readline + attempts to ring the terminal's bell. + + 'bind-tty-special-chars' + If set to 'on' (the default), Readline attempts to bind the + control characters treated specially by the kernel's terminal + driver to their Readline equivalents. + + 'blink-matching-paren' + If set to 'on', Readline attempts to briefly move the cursor + to an opening parenthesis when a closing parenthesis is + inserted. The default is 'off'. + + 'colored-completion-prefix' + If set to 'on', when listing completions, Readline displays + the common prefix of the set of possible completions using a + different color. The color definitions are taken from the + value of the 'LS_COLORS' environment variable. The default is + 'off'. + + 'colored-stats' + If set to 'on', Readline displays possible completions using + different colors to indicate their file type. The color + definitions are taken from the value of the 'LS_COLORS' + environment variable. The default is 'off'. + + 'comment-begin' + The string to insert at the beginning of the line when the + 'insert-comment' command is executed. The default value is + '"#"'. + + 'completion-display-width' + The number of screen columns used to display possible matches + when performing completion. The value is ignored if it is + less than 0 or greater than the terminal screen width. A + value of 0 will cause matches to be displayed one per line. + The default value is -1. + + 'completion-ignore-case' + If set to 'on', Readline performs filename matching and + completion in a case-insensitive fashion. The default value + is 'off'. + + 'completion-map-case' + If set to 'on', and COMPLETION-IGNORE-CASE is enabled, + Readline treats hyphens ('-') and underscores ('_') as + equivalent when performing case-insensitive filename matching + and completion. The default value is 'off'. + + 'completion-prefix-display-length' + The length in characters of the common prefix of a list of + possible completions that is displayed without modification. + When set to a value greater than zero, common prefixes longer + than this value are replaced with an ellipsis when displaying + possible completions. + + 'completion-query-items' + The number of possible completions that determines when the + user is asked whether the list of possibilities should be + displayed. If the number of possible completions is greater + than this value, Readline will ask the user whether or not he + wishes to view them; otherwise, they are simply listed. This + variable must be set to an integer value greater than or equal + to 0. A negative value means Readline should never ask. The + default limit is '100'. + + 'convert-meta' + If set to 'on', Readline will convert characters with the + eighth bit set to an ASCII key sequence by stripping the + eighth bit and prefixing an <ESC> character, converting them + to a meta-prefixed key sequence. The default value is 'on', + but will be set to 'off' if the locale is one that contains + eight-bit characters. + + 'disable-completion' + If set to 'On', Readline will inhibit word completion. + Completion characters will be inserted into the line as if + they had been mapped to 'self-insert'. The default is 'off'. + + 'echo-control-characters' + When set to 'on', on operating systems that indicate they + support it, readline echoes a character corresponding to a + signal generated from the keyboard. The default is 'on'. + + 'editing-mode' + The 'editing-mode' variable controls which default set of key + bindings is used. By default, Readline starts up in Emacs + editing mode, where the keystrokes are most similar to Emacs. + This variable can be set to either 'emacs' or 'vi'. + + 'emacs-mode-string' + If the SHOW-MODE-IN-PROMPT variable is enabled, this string is + displayed immediately before the last line of the primary + prompt when emacs editing mode is active. The value is + expanded like a key binding, so the standard set of meta- and + control prefixes and backslash escape sequences is available. + Use the '\1' and '\2' escapes to begin and end sequences of + non-printing characters, which can be used to embed a terminal + control sequence into the mode string. The default is '@'. + + 'enable-bracketed-paste' + When set to 'On', Readline will configure the terminal in a + way that will enable it to insert each paste into the editing + buffer as a single string of characters, instead of treating + each character as if it had been read from the keyboard. This + can prevent pasted characters from being interpreted as + editing commands. The default is 'off'. + + 'enable-keypad' + When set to 'on', Readline will try to enable the application + keypad when it is called. Some systems need this to enable + the arrow keys. The default is 'off'. + + 'enable-meta-key' + When set to 'on', Readline will try to enable any meta + modifier key the terminal claims to support when it is called. + On many terminals, the meta key is used to send eight-bit + characters. The default is 'on'. + + 'expand-tilde' + If set to 'on', tilde expansion is performed when Readline + attempts word completion. The default is 'off'. + + 'history-preserve-point' + If set to 'on', the history code attempts to place the point + (the current cursor position) at the same location on each + history line retrieved with 'previous-history' or + 'next-history'. The default is 'off'. + + 'history-size' + Set the maximum number of history entries saved in the history + list. If set to zero, any existing history entries are + deleted and no new entries are saved. If set to a value less + than zero, the number of history entries is not limited. By + default, the number of history entries is not limited. If an + attempt is made to set HISTORY-SIZE to a non-numeric value, + the maximum number of history entries will be set to 500. + + 'horizontal-scroll-mode' + This variable can be set to either 'on' or 'off'. Setting it + to 'on' means that the text of the lines being edited will + scroll horizontally on a single screen line when they are + longer than the width of the screen, instead of wrapping onto + a new screen line. By default, this variable is set to 'off'. + + 'input-meta' + If set to 'on', Readline will enable eight-bit input (it will + not clear the eighth bit in the characters it reads), + regardless of what the terminal claims it can support. The + default value is 'off', but Readline will set it to 'on' if + the locale contains eight-bit characters. The name + 'meta-flag' is a synonym for this variable. + + 'isearch-terminators' + The string of characters that should terminate an incremental + search without subsequently executing the character as a + command (*note Searching::). If this variable has not been + given a value, the characters <ESC> and 'C-J' will terminate + an incremental search. + + 'keymap' + Sets Readline's idea of the current keymap for key binding + commands. Built-in 'keymap' names are 'emacs', + 'emacs-standard', 'emacs-meta', 'emacs-ctlx', 'vi', 'vi-move', + 'vi-command', and 'vi-insert'. 'vi' is equivalent to + 'vi-command' ('vi-move' is also a synonym); 'emacs' is + equivalent to 'emacs-standard'. Applications may add + additional names. The default value is 'emacs'. The value of + the 'editing-mode' variable also affects the default keymap. + + 'keyseq-timeout' + Specifies the duration Readline will wait for a character when + reading an ambiguous key sequence (one that can form a + complete key sequence using the input read so far, or can take + additional input to complete a longer key sequence). If no + input is received within the timeout, Readline will use the + shorter but complete key sequence. Readline uses this value + to determine whether or not input is available on the current + input source ('rl_instream' by default). The value is + specified in milliseconds, so a value of 1000 means that + Readline will wait one second for additional input. If this + variable is set to a value less than or equal to zero, or to a + non-numeric value, Readline will wait until another key is + pressed to decide which key sequence to complete. The default + value is '500'. + + 'mark-directories' + If set to 'on', completed directory names have a slash + appended. The default is 'on'. + + 'mark-modified-lines' + This variable, when set to 'on', causes Readline to display an + asterisk ('*') at the start of history lines which have been + modified. This variable is 'off' by default. + + 'mark-symlinked-directories' + If set to 'on', completed names which are symbolic links to + directories have a slash appended (subject to the value of + 'mark-directories'). The default is 'off'. + + 'match-hidden-files' + This variable, when set to 'on', causes Readline to match + files whose names begin with a '.' (hidden files) when + performing filename completion. If set to 'off', the leading + '.' must be supplied by the user in the filename to be + completed. This variable is 'on' by default. + + 'menu-complete-display-prefix' + If set to 'on', menu completion displays the common prefix of + the list of possible completions (which may be empty) before + cycling through the list. The default is 'off'. + + 'output-meta' + If set to 'on', Readline will display characters with the + eighth bit set directly rather than as a meta-prefixed escape + sequence. The default is 'off', but Readline will set it to + 'on' if the locale contains eight-bit characters. + + 'page-completions' + If set to 'on', Readline uses an internal 'more'-like pager to + display a screenful of possible completions at a time. This + variable is 'on' by default. + + 'print-completions-horizontally' + If set to 'on', Readline will display completions with matches + sorted horizontally in alphabetical order, rather than down + the screen. The default is 'off'. + + 'revert-all-at-newline' + If set to 'on', Readline will undo all changes to history + lines before returning when 'accept-line' is executed. By + default, history lines may be modified and retain individual + undo lists across calls to 'readline'. The default is 'off'. + + 'show-all-if-ambiguous' + 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. The default value is 'off'. + + 'show-all-if-unmodified' + This alters the default behavior of the completion functions + in a fashion similar to SHOW-ALL-IF-AMBIGUOUS. If set to + 'on', words which have more than one possible completion + without any possible partial completion (the possible + completions don't share a common prefix) cause the matches to + be listed immediately instead of ringing the bell. The + default value is 'off'. + + 'show-mode-in-prompt' + If set to 'on', add a string to the beginning of the prompt + indicating the editing mode: emacs, vi command, or vi + insertion. The mode strings are user-settable (e.g., + EMACS-MODE-STRING). The default value is 'off'. + + 'skip-completed-text' + If set to 'on', this alters the default completion behavior + when inserting a single match into the line. It's only active + when performing completion in the middle of a word. If + enabled, readline does not insert characters from the + completion that match characters after point in the word being + completed, so portions of the word following the cursor are + not duplicated. For instance, if this is enabled, attempting + completion when the cursor is after the 'e' in 'Makefile' will + result in 'Makefile' rather than 'Makefilefile', assuming + there is a single possible completion. The default value is + 'off'. + + 'vi-cmd-mode-string' + If the SHOW-MODE-IN-PROMPT variable is enabled, this string is + displayed immediately before the last line of the primary + prompt when vi editing mode is active and in command mode. + The value is expanded like a key binding, so the standard set + of meta- and control prefixes and backslash escape sequences + is available. Use the '\1' and '\2' escapes to begin and end + sequences of non-printing characters, which can be used to + embed a terminal control sequence into the mode string. The + default is '(cmd)'. + + 'vi-ins-mode-string' + If the SHOW-MODE-IN-PROMPT variable is enabled, this string is + displayed immediately before the last line of the primary + prompt when vi editing mode is active and in insertion mode. + The value is expanded like a key binding, so the standard set + of meta- and control prefixes and backslash escape sequences + is available. Use the '\1' and '\2' escapes to begin and end + sequences of non-printing characters, which can be used to + embed a terminal control sequence into the mode string. The + default is '(ins)'. + + 'visible-stats' + If set to 'on', a character denoting a file's type is appended + to the filename when listing possible completions. The + default is 'off'. + +Key Bindings + The syntax for controlling key bindings in the init file is simple. + First you need to find the name of the command that you want to + change. The following sections contain tables of the command name, + the default keybinding, if any, and a short description of what the + command does. + + Once you know the name of the command, simply place on a line in + the init file the name of the key you wish to bind the command to, + a colon, and then the name of the command. There can be no space + between the key name and the colon - that will be interpreted as + part of the key name. The name of the key can be expressed in + different ways, depending on what you find most comfortable. + + In addition to command names, readline allows keys to be bound to a + string that is inserted when the key is pressed (a MACRO). + + The 'bind -p' command displays Readline function names and bindings + in a format that can put directly into an initialization file. + *Note Bash Builtins::. + + 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 example above, 'C-u' is bound to the function + 'universal-argument', 'M-DEL' is bound to the function + 'backward-kill-word', and 'C-o' is bound to run the macro + expressed on the right hand side (that is, to insert the text + '> output' into the line). + + A number of symbolic character names are recognized while + processing this key binding syntax: DEL, ESC, ESCAPE, LFD, + NEWLINE, RET, RETURN, RUBOUT, SPACE, SPC, and TAB. + + "KEYSEQ": FUNCTION-NAME or MACRO + KEYSEQ differs from KEYNAME above in that strings denoting an + entire key sequence can be specified, by placing the key + sequence in double quotes. Some GNU Emacs style key escapes + can be used, as in the following example, but the special + character names are not recognized. + + "\C-u": universal-argument + "\C-x\C-r": re-read-init-file + "\e[11~": "Function Key 1" + + In the above example, 'C-u' is again bound to the function + 'universal-argument' (just as it was in the first example), + ''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 following GNU Emacs style escape sequences are available when + specifying key sequences: + + '\C-' + control prefix + '\M-' + meta prefix + '\e' + an escape character + '\\' + backslash + '\"' + <">, a double quotation mark + '\'' + <'>, a single quote or apostrophe + + In addition to the GNU Emacs style escape sequences, a second set + of backslash escapes is available: + + '\a' + alert (bell) + '\b' + backspace + '\d' + delete + '\f' + form feed + '\n' + newline + '\r' + carriage return + '\t' + horizontal tab + '\v' + vertical tab + '\NNN' + the eight-bit character whose value is the octal value NNN + (one to three digits) + '\xHH' + the eight-bit character whose value is the hexadecimal value + HH (one or two hex digits) + + When entering the text of a macro, single or double quotes must be + used to indicate a macro definition. Unquoted text is assumed to + be a function name. In the macro body, the backslash escapes + described above are expanded. Backslash will quote any other + character in the macro text, including '"' and '''. For example, + the following binding will make ''C-x' \' insert a single '\' into + the line: + "\C-x\\": "\\" + + +File: bash.info, Node: Conditional Init Constructs, Next: Sample Init File, Prev: Readline Init File Syntax, Up: Readline Init File + +8.3.2 Conditional Init Constructs +--------------------------------- + +Readline implements a facility similar in spirit to the conditional +compilation features of the C preprocessor which allows key bindings and +variable settings to be performed as the result of tests. There are +four parser directives used. + +'$if' + The '$if' construct allows bindings to be made based on the editing + mode, the terminal being used, or the application using Readline. + The text of the test, after any comparison operator, extends to the + end of the line; unless otherwise noted, 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 terminal-specific key + bindings, perhaps to bind the key sequences output by the + terminal's function keys. The word on the right side of the + '=' is tested against both 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. + + 'version' + The 'version' test may be used to perform comparisons against + specific Readline versions. The 'version' expands to the + current Readline version. The set of comparison operators + includes '=' (and '=='), '!=', '<=', '>=', '<', and '>'. The + version number supplied on the right side of the operator + consists of a major version number, an optional decimal point, + and an optional minor version (e.g., '7.1'). If the minor + version is omitted, it is assumed to be '0'. The operator may + be separated from the string 'version' and from the version + number argument by whitespace. The following example sets a + variable if the Readline version being used is 7.0 or newer: + $if version >= 7.0 + set show-mode-in-prompt on + $endif + + 'application' + The APPLICATION construct is used to include + application-specific settings. Each program using the + Readline library sets the APPLICATION NAME, and you can test + for a particular value. This could be used to bind key + sequences to functions useful 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 + + 'variable' + The VARIABLE construct provides simple equality tests for + Readline variables and values. The permitted comparison + operators are '=', '==', and '!='. The variable name must be + separated from the comparison operator by whitespace; the + operator may be separated from the value on the right hand + side by whitespace. Both string and boolean variables may be + tested. Boolean variables must be tested against the values + ON and OFF. The following example is equivalent to the + 'mode=emacs' test described above: + $if editing-mode == emacs + set show-mode-in-prompt on + $endif + +'$endif' + This command, as seen in the previous example, terminates an '$if' + command. + +'$else' + Commands in this branch of the '$if' directive are executed if the + test fails. + +'$include' + This directive takes a single filename as an argument and reads + commands and bindings from that file. For example, the following + directive reads from '/etc/inputrc': + $include /etc/inputrc + + +File: bash.info, Node: Sample Init File, Prev: Conditional Init Constructs, Up: Readline Init File + +8.3.3 Sample Init File +---------------------- + +Here is an example of an INPUTRC file. This illustrates key binding, +variable assignment, and conditional syntax. + + # This file controls the behaviour of line input editing for + # programs that use the GNU Readline library. Existing + # programs include FTP, Bash, and GDB. + # + # You can re-read the inputrc file with C-x C-r. + # Lines beginning with '#' are comments. + # + # First, include any system-wide bindings and variable + # assignments from /etc/Inputrc + $include /etc/Inputrc + + # + # Set various bindings for emacs mode. + + set editing-mode emacs + + $if mode=emacs + + Meta-Control-h: backward-kill-word Text after the function name is ignored + + # + # Arrow keys in keypad mode + # + #"\M-OD": backward-char + #"\M-OC": forward-char + #"\M-OA": previous-history + #"\M-OB": next-history + # + # Arrow keys in ANSI mode + # + "\M-[D": backward-char + "\M-[C": forward-char + "\M-[A": previous-history + "\M-[B": next-history + # + # Arrow keys in 8 bit keypad mode + # + #"\M-\C-OD": backward-char + #"\M-\C-OC": forward-char + #"\M-\C-OA": previous-history + #"\M-\C-OB": next-history + # + # Arrow keys in 8 bit ANSI mode + # + #"\M-\C-[D": backward-char + #"\M-\C-[C": forward-char + #"\M-\C-[A": previous-history + #"\M-\C-[B": next-history + + C-q: quoted-insert + + $endif + + # An old-style binding. This happens to be the default. + TAB: complete + + # Macros that are convenient for shell interaction + $if Bash + # edit the path + "\C-xp": "PATH=${PATH}\e\C-e\C-a\ef\C-f" + # prepare to type a quoted word -- + # insert open and close double quotes + # and move to just after the open quote + "\C-x\"": "\"\"\C-b" + # insert a backslash (testing backslash escapes + # in sequences and macros) + "\C-x\\": "\\" + # Quote the current or previous word + "\C-xq": "\eb\"\ef\"" + # Add a binding to refresh the line, which is unbound + "\C-xr": redraw-current-line + # Edit variable on current line. + "\M-\C-v": "\C-a\C-k$\C-y\M-\C-e\C-a\C-y=" + $endif + + # use a visible bell if one is available + set bell-style visible + + # don't strip characters to 7 bits when reading + set input-meta on + + # allow iso-latin1 characters to be inserted rather + # than converted to prefix-meta sequences + set convert-meta off + + # display characters with the eighth bit set directly + # rather than as meta-prefixed characters + set output-meta on + + # if there are more than 150 possible completions for + # a word, ask the user if he wants to see all of them + set completion-query-items 150 + + # For FTP + $if Ftp + "\C-xg": "get \M-?" + "\C-xt": "put \M-?" + "\M-.": yank-last-arg + $endif + + +File: bash.info, Node: Bindable Readline Commands, Next: Readline vi Mode, Prev: Readline Init File, Up: Command Line Editing + +8.4 Bindable Readline Commands +============================== + +* Menu: + +* Commands For Moving:: Moving about the line. +* Commands For History:: Getting at previous lines. +* Commands For Text:: Commands for changing text. +* Commands For Killing:: Commands for killing and yanking. +* Numeric Arguments:: Specifying numeric arguments, repeat counts. +* Commands For Completion:: Getting Readline to do the typing for you. +* Keyboard Macros:: Saving and re-executing typed characters +* Miscellaneous Commands:: Other miscellaneous commands. + +This section describes Readline commands that may be bound to key +sequences. You can list your key bindings by executing 'bind -P' or, +for a more terse format, suitable for an INPUTRC file, 'bind -p'. +(*Note Bash Builtins::.) Command names without an accompanying key +sequence are unbound by default. + + In the following descriptions, "point" refers to the current cursor +position, and "mark" refers to a cursor position saved by the 'set-mark' +command. The text between the point and mark is referred to as the +"region". + + +File: bash.info, Node: Commands For Moving, Next: Commands For History, Up: Bindable Readline Commands + +8.4.1 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 + letters and digits. + +'backward-word (M-b)' + Move back to the start of the current or previous word. Words are + composed of letters and digits. + +'shell-forward-word ()' + Move forward to the end of the next word. Words are delimited by + non-quoted shell metacharacters. + +'shell-backward-word ()' + Move back to the start of the current or previous word. Words are + delimited by non-quoted shell metacharacters. + +'previous-screen-line ()' + Attempt to move point to the same physical screen column on the + previous physical screen line. This will not have the desired + effect if the current Readline line does not take up more than one + physical line or if point is not greater than the length of the + prompt plus the screen width. + +'next-screen-line ()' + Attempt to move point to the same physical screen column on the + next physical screen line. This will not have the desired effect + if the current Readline line does not take up more than one + physical line or if the length of the current Readline line is not + greater than the length of the prompt plus the screen width. + +'clear-screen (C-l)' + Clear the screen and redraw the current line, leaving the current + line at the top of the screen. + +'redraw-current-line ()' + Refresh the current line. By default, this is unbound. + + +File: bash.info, Node: Commands For History, Next: Commands For Text, Prev: Commands For Moving, Up: Bindable Readline Commands + +8.4.2 Commands For Manipulating The History +------------------------------------------- + +'accept-line (Newline or 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 setting of + the 'HISTCONTROL' and 'HISTIGNORE' variables. If this line is a + modified history line, then restore the history line to its + original state. + +'previous-history (C-p)' + Move 'back' through the history list, fetching the previous + command. + +'next-history (C-n)' + Move 'forward' through the history list, fetching the next command. + +'beginning-of-history (M-<)' + Move to the first line in the history. + +'end-of-history (M->)' + Move to the end of the input history, i.e., the line currently + being entered. + +'reverse-search-history (C-r)' + Search backward starting at the current line and moving 'up' + through the history as necessary. This is an incremental search. + +'forward-search-history (C-s)' + Search forward starting at the current line and moving 'down' + through the history as necessary. This is an incremental search. + +'non-incremental-reverse-search-history (M-p)' + Search backward starting at the current line and moving 'up' + through the history as necessary using a non-incremental search for + a string supplied by the user. The search string may match + anywhere in a history line. + +'non-incremental-forward-search-history (M-n)' + Search forward starting at the current line and moving 'down' + through the history as necessary using a non-incremental search for + a string supplied by the user. The search string may match + anywhere in a history line. + +'history-search-forward ()' + Search forward through the history for the string of characters + between the start of the current line and the point. The search + string must match at the beginning of a history line. 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 point. The search + string must match at the beginning of a history line. This is a + non-incremental search. By default, this command is unbound. + +'history-substring-search-forward ()' + Search forward through the history for the string of characters + between the start of the current line and the point. The search + string may match anywhere in a history line. This is a + non-incremental search. By default, this command is unbound. + +'history-substring-search-backward ()' + Search backward through the history for the string of characters + between the start of the current line and the point. The search + string may match anywhere in a history line. 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. With an argument N, + insert the Nth word from the previous command (the words in the + previous command begin with word 0). A negative argument inserts + the Nth word from the end of the previous command. Once the + argument N is computed, the argument is extracted as if the '!N' + history expansion had been specified. + +'yank-last-arg (M-. or M-_)' + Insert last argument to the previous command (the last word of the + previous history entry). With a numeric argument, behave exactly + like 'yank-nth-arg'. Successive calls to 'yank-last-arg' move back + through the history list, inserting the last word (or the word + specified by the argument to the first call) of each line in turn. + Any numeric argument supplied to these successive calls determines + the direction to move through the history. A negative argument + switches the direction through the history (back or forward). The + history expansion facilities are used to extract the last argument, + as if the '!$' history expansion had been specified. + + +File: bash.info, Node: Commands For Text, Next: Commands For Killing, Prev: Commands For History, Up: Bindable Readline Commands + +8.4.3 Commands For Changing Text +-------------------------------- + +'end-of-file (usually C-d)' + The character indicating end-of-file as set, for example, by + 'stty'. If this character is read when there are no characters on + the line, and point is at the beginning of the line, Readline + interprets it as the end of input and returns EOF. + +'delete-char (C-d)' + Delete the character at point. If this function is bound to the + same character as the tty EOF character, as 'C-d' commonly is, see + above for the effects. + +'backward-delete-char (Rubout)' + Delete the character behind the cursor. A numeric argument means + to kill the characters instead of deleting them. + +'forward-backward-delete-char ()' + Delete the character under the cursor, unless the cursor is at the + end of the line, in which case the character behind the cursor is + deleted. By default, this is not bound to a key. + +'quoted-insert (C-q or C-v)' + Add the next character typed to the line verbatim. This is how to + insert key sequences like 'C-q', for example. + +'self-insert (a, b, A, 1, !, ...)' + Insert yourself. + +'bracketed-paste-begin ()' + This function is intended to be bound to the "bracketed paste" + escape sequence sent by some terminals, and such a binding is + assigned by default. It allows Readline to insert the pasted text + as a single unit without treating each character as if it had been + read from the keyboard. The characters are inserted as if each one + was bound to 'self-insert' instead of executing any editing + commands. + +'transpose-chars (C-t)' + Drag the character before the cursor forward over the character at + the cursor, moving the cursor forward as well. If the insertion + point is at the end of the line, then this transposes the last two + characters of the line. Negative arguments have no effect. + +'transpose-words (M-t)' + Drag the word before point past the word after point, moving point + past that word as well. If the insertion point is at the end of + the line, this transposes the last two words on the line. + +'upcase-word (M-u)' + Uppercase the current (or following) word. With a negative + argument, uppercase the previous word, but do not move the cursor. + +'downcase-word (M-l)' + Lowercase the current (or following) word. With a negative + argument, lowercase the previous word, but do not move the cursor. + +'capitalize-word (M-c)' + Capitalize the current (or following) word. With a negative + argument, capitalize the previous word, but do not move the cursor. + +'overwrite-mode ()' + Toggle overwrite mode. With an explicit positive numeric argument, + switches to overwrite mode. With an explicit non-positive numeric + argument, switches to insert mode. This command affects only + 'emacs' mode; 'vi' mode does overwrite differently. Each call to + 'readline()' starts in insert mode. + + In overwrite mode, characters bound to 'self-insert' replace the + text at point rather than pushing the text to the right. + Characters bound to 'backward-delete-char' replace the character + before point with a space. + + By default, this command is unbound. + + +File: bash.info, Node: Commands For Killing, Next: Numeric Arguments, Prev: Commands For Text, Up: Bindable Readline Commands + +8.4.4 Killing And Yanking +------------------------- + +'kill-line (C-k)' + Kill the text from point to the end of the line. + +'backward-kill-line (C-x Rubout)' + Kill backward from the cursor to the beginning of the current line. + +'unix-line-discard (C-u)' + Kill backward from the cursor to the beginning of the current line. + +'kill-whole-line ()' + Kill all characters on the current line, no matter where point is. + By default, this is unbound. + +'kill-word (M-d)' + Kill from point to the end of the current word, or if between + words, to the end of the next word. Word boundaries are the same + as 'forward-word'. + +'backward-kill-word (M-<DEL>)' + Kill the word behind point. Word boundaries are the same as + 'backward-word'. + +'shell-kill-word ()' + Kill from point to the end of the current word, or if between + words, to the end of the next word. Word boundaries are the same + as 'shell-forward-word'. + +'shell-backward-kill-word ()' + Kill the word behind point. Word boundaries are the same as + 'shell-backward-word'. + +'unix-word-rubout (C-w)' + Kill the word behind point, using white space as a word boundary. + The killed text is saved on the kill-ring. + +'unix-filename-rubout ()' + Kill the word behind point, using white space and the slash + character as the word boundaries. The killed text is saved on the + kill-ring. + +'delete-horizontal-space ()' + Delete all spaces and tabs around point. By default, this is + unbound. + +'kill-region ()' + Kill the text in the current region. By default, this command is + unbound. + +'copy-region-as-kill ()' + Copy the text in the region to the kill buffer, so it can be yanked + right away. By default, this command is unbound. + +'copy-backward-word ()' + Copy the word before point to the kill buffer. The word boundaries + are the same as 'backward-word'. By default, this command is + unbound. + +'copy-forward-word ()' + Copy the word following point to the kill buffer. The word + boundaries are the same as 'forward-word'. By default, this + command is unbound. + +'yank (C-y)' + Yank the top of the kill ring into the buffer at point. + +'yank-pop (M-y)' + Rotate the kill-ring, and yank the new top. You can only do this + if the prior command is 'yank' or 'yank-pop'. + + +File: bash.info, Node: Numeric Arguments, Next: Commands For Completion, Prev: Commands For Killing, Up: Bindable Readline Commands + +8.4.5 Specifying Numeric Arguments +---------------------------------- + +'digit-argument (M-0, M-1, ... M--)' + Add this digit to the argument already accumulating, or start a new + argument. 'M--' starts a negative argument. + +'universal-argument ()' + This is another way to specify an argument. If this command is + followed by one or more digits, optionally with a leading minus + sign, those digits define the argument. If the command is followed + by digits, executing 'universal-argument' again ends the numeric + argument, but is otherwise ignored. As a special case, if this + command is immediately followed by a character that is neither a + digit nor minus sign, the argument count for the next command is + multiplied by four. The argument count is initially one, so + executing this function the first time makes the argument count + four, a second time makes the argument count sixteen, and so on. + By default, this is not bound to a key. + + +File: bash.info, Node: Commands For Completion, Next: Keyboard Macros, Prev: Numeric Arguments, Up: Bindable Readline Commands + +8.4.6 Letting Readline Type For You +----------------------------------- + +'complete (<TAB>)' + Attempt to perform completion on the text before point. The actual + completion performed is application-specific. 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. When + displaying completions, Readline sets the number of columns used + for display to the value of 'completion-display-width', the value + of the environment variable 'COLUMNS', or the screen width, in that + order. + +'insert-completions (M-*)' + Insert all completions of the text before point that would have + been generated by 'possible-completions'. + +'menu-complete ()' + Similar to 'complete', but replaces the word to be completed with a + single match from the list of possible completions. Repeated + execution of 'menu-complete' steps through the list of possible + completions, inserting each match in turn. At the end of the list + of completions, the bell is rung (subject to the setting of + 'bell-style') and the original text is restored. An argument of N + moves N positions forward in the list of matches; a negative + argument may be used to move backward through the list. This + command is intended to be bound to <TAB>, but is unbound by + default. + +'menu-complete-backward ()' + Identical to 'menu-complete', but moves backward through the list + of possible completions, as if 'menu-complete' had been given a + negative argument. + +'delete-char-or-list ()' + Deletes the character under the cursor if not at the beginning or + end of the line (like 'delete-char'). If at the end of the line, + behaves identically to 'possible-completions'. This command is + unbound by default. + +'complete-filename (M-/)' + Attempt filename completion on the text before point. + +'possible-filename-completions (C-x /)' + List the possible completions of the text before point, treating it + as a filename. + +'complete-username (M-~)' + Attempt completion on the text before point, treating it as a + username. + +'possible-username-completions (C-x ~)' + List the possible completions of the text before point, treating it + as a username. + +'complete-variable (M-$)' + Attempt completion on the text before point, treating it as a shell + variable. + +'possible-variable-completions (C-x $)' + List the possible completions of the text before point, treating it + as a shell variable. + +'complete-hostname (M-@)' + Attempt completion on the text before point, treating it as a + hostname. + +'possible-hostname-completions (C-x @)' + List the possible completions of the text before point, treating it + as a hostname. + +'complete-command (M-!)' + Attempt completion on the text before point, treating it as a + command name. Command completion attempts to match the text + against aliases, reserved words, shell functions, shell builtins, + and finally executable filenames, in that order. + +'possible-command-completions (C-x !)' + List the possible completions of the text before point, treating it + as a command name. + +'dynamic-complete-history (M-<TAB>)' + Attempt completion on the text before point, comparing the text + against lines from the history list for possible completion + matches. + +'dabbrev-expand ()' + Attempt menu completion on the text before point, comparing the + text against lines from the history list for possible completion + matches. + +'complete-into-braces (M-{)' + Perform filename completion and insert the list of possible + completions enclosed within braces so the list is available to the + shell (*note Brace Expansion::). + + +File: bash.info, Node: Keyboard Macros, Next: Miscellaneous Commands, Prev: Commands For Completion, Up: Bindable Readline Commands + +8.4.7 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 making the + characters in the macro appear as if typed at the keyboard. + +'print-last-kbd-macro ()' + Print the last keboard macro defined in a format suitable for the + INPUTRC file. + + +File: bash.info, Node: Miscellaneous Commands, Prev: Keyboard Macros, Up: Bindable Readline Commands + +8.4.8 Some Miscellaneous Commands +--------------------------------- + +'re-read-init-file (C-x C-r)' + Read in the contents of the INPUTRC file, and incorporate any + bindings or variable assignments found there. + +'abort (C-g)' + Abort the current editing command and ring the terminal's bell + (subject to the setting of 'bell-style'). + +'do-lowercase-version (M-A, M-B, M-X, ...)' + If the metafied character X is upper case, run the command that is + bound to the corresponding metafied lower case character. The + behavior is undefined if X is already lower case. + +'prefix-meta (<ESC>)' + Metafy the next character typed. This is for keyboards without a + meta key. Typing '<ESC> f' is equivalent to typing 'M-f'. + +'undo (C-_ or 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 executing the + 'undo' command enough times to get back to the beginning. + +'tilde-expand (M-&)' + Perform tilde expansion on the current word. + +'set-mark (C-@)' + Set the mark to the point. If a numeric argument is supplied, the + mark is set to that position. + +'exchange-point-and-mark (C-x C-x)' + Swap the point with the mark. The current cursor position is set + to the saved position, and the old cursor position is saved as the + mark. + +'character-search (C-])' + A character is read and point is moved to the next occurrence of + that character. A negative count searches for previous + occurrences. + +'character-search-backward (M-C-])' + A character is read and point is moved to the previous occurrence + of that character. A negative count searches for subsequent + occurrences. + +'skip-csi-sequence ()' + Read enough characters to consume a multi-key sequence such as + those defined for keys like Home and End. Such sequences begin + with a Control Sequence Indicator (CSI), usually ESC-[. If this + sequence is bound to "\e[", keys producing such sequences will have + no effect unless explicitly bound to a readline command, instead of + inserting stray characters into the editing buffer. This is + unbound by default, but usually bound to ESC-[. + +'insert-comment (M-#)' + Without a numeric argument, the value of the 'comment-begin' + variable is inserted at the beginning of the current line. If a + numeric argument is supplied, this command acts as a toggle: if the + characters at the beginning of the line do not match the value of + 'comment-begin', the value is inserted, otherwise the characters in + 'comment-begin' are deleted from the beginning of the line. In + either case, the line is accepted as if a newline had been typed. + The default value of 'comment-begin' causes this command to make + the current line a shell comment. If a numeric argument causes the + comment character to be removed, the line will be executed by the + shell. + +'dump-functions ()' + Print all of the functions and their key bindings to the Readline + output stream. If a numeric argument is supplied, the output is + formatted in such a way that it can be made part of an INPUTRC + file. This command is unbound by default. + +'dump-variables ()' + Print all of the settable variables and their values to the + Readline output stream. If a numeric argument is supplied, the + output is formatted in such a way that it can be made part of an + INPUTRC file. This command is unbound by default. + +'dump-macros ()' + Print all of the Readline key sequences bound to macros and the + strings they output. If a numeric argument is supplied, the output + is formatted in such a way that it can be made part of an INPUTRC + file. This command is unbound by default. + +'glob-complete-word (M-g)' + The word before point is treated as a pattern for pathname + expansion, with an asterisk implicitly appended. This pattern is + used to generate a list of matching file names for possible + completions. + +'glob-expand-word (C-x *)' + The word before point is treated as a pattern for pathname + expansion, and the list of matching file names is inserted, + replacing the word. If a numeric argument is supplied, a '*' is + appended before pathname expansion. + +'glob-list-expansions (C-x g)' + The list of expansions that would have been generated by + 'glob-expand-word' is displayed, and the line is redrawn. If a + numeric argument is supplied, a '*' is appended before pathname + expansion. + +'display-shell-version (C-x C-v)' + Display version information about the current instance of Bash. + +'shell-expand-line (M-C-e)' + Expand the line as the shell does. This performs alias and history + expansion as well as all of the shell word expansions (*note Shell + Expansions::). + +'history-expand-line (M-^)' + Perform history expansion on the current line. + +'magic-space ()' + Perform history expansion on the current line and insert a space + (*note History Interaction::). + +'alias-expand-line ()' + Perform alias expansion on the current line (*note Aliases::). + +'history-and-alias-expand-line ()' + Perform history and alias expansion on the current line. + +'insert-last-argument (M-. or M-_)' + A synonym for 'yank-last-arg'. + +'operate-and-get-next (C-o)' + Accept the current line for execution and fetch the next line + relative to the current line from the history for editing. A + numeric argument, if supplied, specifies the history entry to use + instead of the current line. + +'edit-and-execute-command (C-x C-e)' + Invoke an editor on the current command line, and execute the + result as shell commands. Bash attempts to invoke '$VISUAL', + '$EDITOR', and 'emacs' as the editor, in that order. + + +File: bash.info, Node: Readline vi Mode, Next: Programmable Completion, Prev: Bindable Readline Commands, Up: Command Line Editing + +8.5 Readline vi Mode +==================== + +While the Readline library does not have a full set of 'vi' editing +functions, it does contain enough to allow simple editing of the line. +The Readline 'vi' mode behaves as specified in the POSIX standard. + + In order to switch interactively between 'emacs' and 'vi' editing +modes, use the 'set -o emacs' and 'set -o vi' commands (*note The Set +Builtin::). The Readline default is 'emacs' mode. + + When you enter a line in 'vi' mode, you are already placed in +'insertion' mode, as if you had typed an 'i'. Pressing <ESC> switches +you into 'command' mode, where you can edit the text of the line with +the standard 'vi' movement keys, move to previous history lines with 'k' +and subsequent lines with 'j', and so forth. + + +File: bash.info, Node: Programmable Completion, Next: Programmable Completion Builtins, Prev: Readline vi Mode, Up: Command Line Editing + +8.6 Programmable Completion +=========================== + +When word completion is attempted for an argument to a command for which +a completion specification (a COMPSPEC) has been defined using the +'complete' builtin (*note Programmable Completion Builtins::), the +programmable completion facilities are invoked. + + First, the command name is identified. If a compspec has been +defined for that command, the compspec is used to generate the list of +possible completions for the word. If the command word is the empty +string (completion attempted at the beginning of an empty line), any +compspec defined with the '-E' option to 'complete' is used. If the +command word is a full pathname, a compspec for the full pathname is +searched for first. If no compspec is found for the full pathname, an +attempt is made to find a compspec for the portion following the final +slash. If those searches do not result in a compspec, any compspec +defined with the '-D' option to 'complete' is used as the default. If +there is no default compspec, Bash attempts alias expansion on the +command word as a final resort, and attempts to find a compspec for the +command word from any successful expansion + + Once a compspec has been found, it is used to generate the list of +matching words. If a compspec is not found, the default Bash completion +described above (*note Commands For Completion::) is performed. + + First, the actions specified by the compspec are used. Only matches +which are prefixed by the word being completed are returned. When the +'-f' or '-d' option is used for filename or directory name completion, +the shell variable 'FIGNORE' is used to filter the matches. *Note Bash +Variables::, for a description of 'FIGNORE'. + + Any completions specified by a filename expansion pattern to the '-G' +option are generated next. The words generated by the pattern need not +match the word being completed. The 'GLOBIGNORE' shell variable is not +used to filter the matches, but the 'FIGNORE' shell variable is used. + + Next, the string specified as the argument to the '-W' option is +considered. The string is first split using the characters in the 'IFS' +special variable as delimiters. Shell quoting is honored within the +string, in order to provide a mechanism for the words to contain shell +metacharacters or characters in the value of 'IFS'. Each word is then +expanded using brace expansion, tilde expansion, parameter and variable +expansion, command substitution, and arithmetic expansion, as described +above (*note Shell Expansions::). The results are split using the rules +described above (*note Word Splitting::). The results of the expansion +are prefix-matched against the word being completed, and the matching +words become the possible completions. + + After these matches have been generated, any shell function or +command specified with the '-F' and '-C' options is invoked. When the +command or function is invoked, the 'COMP_LINE', 'COMP_POINT', +'COMP_KEY', and 'COMP_TYPE' variables are assigned values as described +above (*note Bash Variables::). If a shell function is being invoked, +the 'COMP_WORDS' and 'COMP_CWORD' variables are also set. When the +function or command is invoked, the first argument ($1) is the name of +the command whose arguments are being completed, the second argument +($2) is the word being completed, and the third argument ($3) is the +word preceding the word being completed on the current command line. No +filtering of the generated completions against the word being completed +is performed; the function or command has complete freedom in generating +the matches. + + Any function specified with '-F' is invoked first. The function may +use any of the shell facilities, including the 'compgen' and 'compopt' +builtins described below (*note Programmable Completion Builtins::), to +generate the matches. It must put the possible completions in the +'COMPREPLY' array variable, one per array element. + + Next, any command specified with the '-C' option is invoked in an +environment equivalent to command substitution. It should print a list +of completions, one per line, to the standard output. Backslash may be +used to escape a newline, if necessary. + + After all of the possible completions are generated, any filter +specified with the '-X' option is applied to the list. The filter is a +pattern as used for pathname expansion; a '&' in the pattern is replaced +with the text of the word being completed. A literal '&' may be escaped +with a backslash; the backslash is removed before attempting a match. +Any completion that matches the pattern will be removed from the list. +A leading '!' negates the pattern; in this case any completion not +matching the pattern will be removed. If the 'nocasematch' shell option +(see the description of 'shopt' in *note The Shopt Builtin::) is +enabled, the match is performed without regard to the case of alphabetic +characters. + + Finally, any prefix and suffix specified with the '-P' and '-S' +options are added to each member of the completion list, and the result +is returned to the Readline completion code as the list of possible +completions. + + If the previously-applied actions do not generate any matches, and +the '-o dirnames' option was supplied to 'complete' when the compspec +was defined, directory name completion is attempted. + + If the '-o plusdirs' option was supplied to 'complete' when the +compspec was defined, directory name completion is attempted and any +matches are added to the results of the other actions. + + By default, if a compspec is found, whatever it generates is returned +to the completion code as the full set of possible completions. The +default Bash completions are not attempted, and the Readline default of +filename completion is disabled. If the '-o bashdefault' option was +supplied to 'complete' when the compspec was defined, the default Bash +completions are attempted if the compspec generates no matches. If the +'-o default' option was supplied to 'complete' when the compspec was +defined, Readline's default completion will be performed if the compspec +(and, if attempted, the default Bash completions) generate no matches. + + When a compspec indicates that directory name completion is desired, +the programmable completion functions force Readline to append a slash +to completed names which are symbolic links to directories, subject to +the value of the MARK-DIRECTORIES Readline variable, regardless of the +setting of the MARK-SYMLINKED-DIRECTORIES Readline variable. + + There is some support for dynamically modifying completions. This is +most useful when used in combination with a default completion specified +with '-D'. It's possible for shell functions executed as completion +handlers to indicate that completion should be retried by returning an +exit status of 124. If a shell function returns 124, and changes the +compspec associated with the command on which completion is being +attempted (supplied as the first argument when the function is +executed), programmable completion restarts from the beginning, with an +attempt to find a new compspec for that command. This allows a set of +completions to be built dynamically as completion is attempted, rather +than being loaded all at once. + + For instance, assuming that there is a library of compspecs, each +kept in a file corresponding to the name of the command, the following +default completion function would load completions dynamically: + + _completion_loader() + { + . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124 + } + complete -D -F _completion_loader -o bashdefault -o default + + +File: bash.info, Node: Programmable Completion Builtins, Next: A Programmable Completion Example, Prev: Programmable Completion, Up: Command Line Editing + +8.7 Programmable Completion Builtins +==================================== + +Three builtin commands are available to manipulate the programmable +completion facilities: one to specify how the arguments to a particular +command are to be completed, and two to modify the completion as it is +happening. + +'compgen' + compgen [OPTION] [WORD] + + Generate possible completion matches for WORD according to the + OPTIONs, which may be any option accepted by the 'complete' builtin + with the exception of '-p' and '-r', and write the matches to the + standard output. When using the '-F' or '-C' options, the various + shell variables set by the programmable completion facilities, + while available, will not have useful values. + + The matches will be generated in the same way as if the + programmable completion code had generated them directly from a + completion specification with the same flags. If WORD is + specified, only those completions matching WORD will be displayed. + + The return value is true unless an invalid option is supplied, or + no matches were generated. + +'complete' + complete [-abcdefgjksuv] [-o COMP-OPTION] [-DEI] [-A ACTION] [-G GLOBPAT] + [-W WORDLIST] [-F FUNCTION] [-C COMMAND] [-X FILTERPAT] + [-P PREFIX] [-S SUFFIX] NAME [NAME ...] + complete -pr [-DEI] [NAME ...] + + Specify how arguments to each NAME should be completed. If the + '-p' option is supplied, or if no options are supplied, existing + completion specifications are printed in a way that allows them to + be reused as input. The '-r' option removes a completion + specification for each NAME, or, if no NAMEs are supplied, all + completion specifications. The '-D' option indicates that other + supplied options and actions should apply to the "default" command + completion; that is, completion attempted on a command for which no + completion has previously been defined. The '-E' option indicates + that other supplied options and actions should apply to "empty" + command completion; that is, completion attempted on a blank line. + The '-I' option indicates that other supplied options and actions + should apply to completion on the inital non-assignment word on the + line, or after a command delimiter such as ';' or '|', which is + usually command name completion. If multiple options are supplied, + the '-D' option takes precedence over '-E', and both take + precedence over '-I'. If any of '-D', '-E', or '-I' are supplied, + any other NAME arguments are ignored; these completions only apply + to the case specified by the option. + + The process of applying these completion specifications when word + completion is attempted is described above (*note Programmable + Completion::). + + Other options, if specified, have the following meanings. The + arguments to the '-G', '-W', and '-X' options (and, if necessary, + the '-P' and '-S' options) should be quoted to protect them from + expansion before the 'complete' builtin is invoked. + + '-o COMP-OPTION' + The COMP-OPTION controls several aspects of the compspec's + behavior beyond the simple generation of completions. + COMP-OPTION may be one of: + + 'bashdefault' + Perform the rest of the default Bash completions if the + compspec generates no matches. + + 'default' + Use Readline's default filename completion if the + compspec generates no matches. + + 'dirnames' + Perform directory name completion if the compspec + generates no matches. + + 'filenames' + Tell Readline that the compspec generates filenames, so + it can perform any filename-specific processing (like + adding a slash to directory names, quoting special + characters, or suppressing trailing spaces). This option + is intended to be used with shell functions specified + with '-F'. + + 'noquote' + Tell Readline not to quote the completed words if they + are filenames (quoting filenames is the default). + + 'nosort' + Tell Readline not to sort the list of possible + completions alphabetically. + + 'nospace' + Tell Readline not to append a space (the default) to + words completed at the end of the line. + + 'plusdirs' + After any matches defined by the compspec are generated, + directory name completion is attempted and any matches + are added to the results of the other actions. + + '-A ACTION' + The ACTION may be one of the following to generate a list of + possible completions: + + 'alias' + Alias names. May also be specified as '-a'. + + 'arrayvar' + Array variable names. + + 'binding' + Readline key binding names (*note Bindable Readline + Commands::). + + 'builtin' + Names of shell builtin commands. May also be specified + as '-b'. + + 'command' + Command names. May also be specified as '-c'. + + 'directory' + Directory names. May also be specified as '-d'. + + 'disabled' + Names of disabled shell builtins. + + 'enabled' + Names of enabled shell builtins. + + 'export' + Names of exported shell variables. May also be specified + as '-e'. + + 'file' + File names. May also be specified as '-f'. + + 'function' + Names of shell functions. + + 'group' + Group names. May also be specified as '-g'. + + 'helptopic' + Help topics as accepted by the 'help' builtin (*note Bash + Builtins::). + + 'hostname' + Hostnames, as taken from the file specified by the + 'HOSTFILE' shell variable (*note Bash Variables::). + + 'job' + Job names, if job control is active. May also be + specified as '-j'. + + 'keyword' + Shell reserved words. May also be specified as '-k'. + + 'running' + Names of running jobs, if job control is active. + + 'service' + Service names. May also be specified as '-s'. + + 'setopt' + Valid arguments for the '-o' option to the 'set' builtin + (*note The Set Builtin::). + + 'shopt' + Shell option names as accepted by the 'shopt' builtin + (*note Bash Builtins::). + + 'signal' + Signal names. + + 'stopped' + Names of stopped jobs, if job control is active. + + 'user' + User names. May also be specified as '-u'. + + 'variable' + Names of all shell variables. May also be specified as + '-v'. + + '-C COMMAND' + COMMAND is executed in a subshell environment, and its output + is used as the possible completions. + + '-F FUNCTION' + The shell function FUNCTION is executed in the current shell + environment. When it is executed, $1 is the name of the + command whose arguments are being completed, $2 is the word + being completed, and $3 is the word preceding the word being + completed, as described above (*note Programmable + Completion::). When it finishes, the possible completions are + retrieved from the value of the 'COMPREPLY' array variable. + + '-G GLOBPAT' + The filename expansion pattern GLOBPAT is expanded to generate + the possible completions. + + '-P PREFIX' + PREFIX is added at the beginning of each possible completion + after all other options have been applied. + + '-S SUFFIX' + SUFFIX is appended to each possible completion after all other + options have been applied. + + '-W WORDLIST' + The WORDLIST is split using the characters in the 'IFS' + special variable as delimiters, and each resultant word is + expanded. The possible completions are the members of the + resultant list which match the word being completed. + + '-X FILTERPAT' + FILTERPAT is a pattern as used for filename expansion. It is + applied to the list of possible completions generated by the + preceding options and arguments, and each completion matching + FILTERPAT is removed from the list. A leading '!' in + FILTERPAT negates the pattern; in this case, any completion + not matching FILTERPAT is removed. + + The return value is true unless an invalid option is supplied, an + option other than '-p' or '-r' is supplied without a NAME argument, + an attempt is made to remove a completion specification for a NAME + for which no specification exists, or an error occurs adding a + completion specification. + +'compopt' + compopt [-o OPTION] [-DEI] [+o OPTION] [NAME] + Modify completion options for each NAME according to the OPTIONs, + or for the currently-executing completion if no NAMEs are supplied. + If no OPTIONs are given, display the completion options for each + NAME or the current completion. The possible values of OPTION are + those valid for the 'complete' builtin described above. The '-D' + option indicates that other supplied options should apply to the + "default" command completion; that is, completion attempted on a + command for which no completion has previously been defined. The + '-E' option indicates that other supplied options should apply to + "empty" command completion; that is, completion attempted on a + blank line. The '-I' option indicates that other supplied options + should apply to completion on the inital non-assignment word on the + line, or after a command delimiter such as ';' or '|', which is + usually command name completion. + + If multiple options are supplied, the '-D' option takes precedence + over '-E', and both take precedence over '-I' + + The return value is true unless an invalid option is supplied, an + attempt is made to modify the options for a NAME for which no + completion specification exists, or an output error occurs. + + +File: bash.info, Node: A Programmable Completion Example, Prev: Programmable Completion Builtins, Up: Command Line Editing + +8.8 A Programmable Completion Example +===================================== + +The most common way to obtain additional completion functionality beyond +the default actions 'complete' and 'compgen' provide is to use a shell +function and bind it to a particular command using 'complete -F'. + + The following function provides completions for the 'cd' builtin. It +is a reasonably good example of what shell functions must do when used +for completion. This function uses the word passed as '$2' to determine +the directory name to complete. You can also use the 'COMP_WORDS' array +variable; the current word is indexed by the 'COMP_CWORD' variable. + + The function relies on the 'complete' and 'compgen' builtins to do +much of the work, adding only the things that the Bash 'cd' does beyond +accepting basic directory names: tilde expansion (*note Tilde +Expansion::), searching directories in $CDPATH, which is described above +(*note Bourne Shell Builtins::), and basic support for the 'cdable_vars' +shell option (*note The Shopt Builtin::). '_comp_cd' modifies the value +of IFS so that it contains only a newline to accommodate file names +containing spaces and tabs - 'compgen' prints the possible completions +it generates one per line. + + Possible completions go into the COMPREPLY array variable, one +completion per array element. The programmable completion system +retrieves the completions from there when the function returns. + + # A completion function for the cd builtin + # based on the cd completion function from the bash_completion package + _comp_cd() + { + local IFS=$' \t\n' # normalize IFS + local cur _skipdot _cdpath + local i j k + + # Tilde expansion, which also expands tilde to full pathname + case "$2" in + \~*) eval cur="$2" ;; + *) cur=$2 ;; + esac + + # no cdpath or absolute pathname -- straight directory completion + if [[ -z "${CDPATH:-}" ]] || [[ "$cur" == @(./*|../*|/*) ]]; then + # compgen prints paths one per line; could also use while loop + IFS=$'\n' + COMPREPLY=( $(compgen -d -- "$cur") ) + IFS=$' \t\n' + # CDPATH+directories in the current directory if not in CDPATH + else + IFS=$'\n' + _skipdot=false + # preprocess CDPATH to convert null directory names to . + _cdpath=${CDPATH/#:/.:} + _cdpath=${_cdpath//::/:.:} + _cdpath=${_cdpath/%:/:.} + for i in ${_cdpath//:/$'\n'}; do + if [[ $i -ef . ]]; then _skipdot=true; fi + k="${#COMPREPLY[@]}" + for j in $( compgen -d -- "$i/$cur" ); do + COMPREPLY[k++]=${j#$i/} # cut off directory + done + done + $_skipdot || COMPREPLY+=( $(compgen -d -- "$cur") ) + IFS=$' \t\n' + fi + + # variable names if appropriate shell option set and no completions + if shopt -q cdable_vars && [[ ${#COMPREPLY[@]} -eq 0 ]]; then + COMPREPLY=( $(compgen -v -- "$cur") ) + fi + + return 0 + } + + We install the completion function using the '-F' option to +'complete': + + # Tell readline to quote appropriate and append slashes to directories; + # use the bash default completion for other arguments + complete -o filenames -o nospace -o bashdefault -F _comp_cd cd + +Since we'd like Bash and Readline to take care of some of the other +details for us, we use several other options to tell Bash and Readline +what to do. The '-o filenames' option tells Readline that the possible +completions should be treated as filenames, and quoted appropriately. +That option will also cause Readline to append a slash to filenames it +can determine are directories (which is why we might want to extend +'_comp_cd' to append a slash if we're using directories found via +CDPATH: Readline can't tell those completions are directories). The '-o +nospace' option tells Readline to not append a space character to the +directory name, in case we want to append to it. The '-o bashdefault' +option brings in the rest of the "Bash default" completions - possible +completion that Bash adds to the default Readline set. These include +things like command name completion, variable completion for words +beginning with '{', completions containing pathname expansion patterns +(*note Filename Expansion::), and so on. + + Once installed using 'complete', '_comp_cd' will be called every time +we attempt word completion for a 'cd' command. + + Many more examples - an extensive collection of completions for most +of the common GNU, Unix, and Linux commands - are available as part of +the bash_completion project. This is installed by default on many +GNU/Linux distributions. Originally written by Ian Macdonald, the +project now lives at <http://bash-completion.alioth.debian.org/>. There +are ports for other systems such as Solaris and Mac OS X. + + An older version of the bash_completion package is distributed with +bash in the 'examples/complete' subdirectory. + + +File: bash.info, Node: Using History Interactively, Next: Installing Bash, Prev: Command Line Editing, Up: Top + +9 Using History Interactively +***************************** + +This chapter describes how to use the GNU History Library interactively, +from a user's standpoint. It should be considered a user's guide. For +information on using the GNU History Library in other programs, see the +GNU Readline Library Manual. + +* Menu: + +* Bash History Facilities:: How Bash lets you manipulate your command + history. +* Bash History Builtins:: The Bash builtin commands that manipulate + the command history. +* History Interaction:: What it feels like using History as a user. + + +File: bash.info, Node: Bash History Facilities, Next: Bash History Builtins, Up: Using History Interactively + +9.1 Bash History Facilities +=========================== + +When the '-o history' option to the 'set' builtin is enabled (*note The +Set Builtin::), the shell provides access to the "command history", the +list of commands previously typed. The value of the 'HISTSIZE' shell +variable is used as the number of commands to save in a history list. +The text of the last '$HISTSIZE' commands (default 500) is saved. The +shell stores each command in the history list prior to parameter and +variable expansion but after history expansion is performed, subject to +the values of the shell variables 'HISTIGNORE' and 'HISTCONTROL'. + + When the shell starts up, the history is initialized from the file +named by the 'HISTFILE' variable (default '~/.bash_history'). The file +named by the value of 'HISTFILE' is truncated, if necessary, to contain +no more than the number of lines specified by the value of the +'HISTFILESIZE' variable. When a shell with history enabled exits, the +last '$HISTSIZE' lines are copied from the history list to the file +named by '$HISTFILE'. If the 'histappend' shell option is set (*note +Bash Builtins::), the lines are appended to the history file, otherwise +the history file is overwritten. If 'HISTFILE' is unset, or if the +history file is unwritable, the history is not saved. After saving the +history, the history file is truncated to contain no more than +'$HISTFILESIZE' lines. If 'HISTFILESIZE' is unset, or set to null, a +non-numeric value, or a numeric value less than zero, the history file +is not truncated. + + If the 'HISTTIMEFORMAT' is set, the time stamp information associated +with each history entry is written to the history file, marked with the +history comment character. When the history file is read, lines +beginning with the history comment character followed immediately by a +digit are interpreted as timestamps for the following history entry. + + The builtin command 'fc' may be used to list or edit and re-execute a +portion of the history list. The 'history' builtin may be used to +display or modify the history list and manipulate the history file. +When using command-line editing, search commands are available in each +editing mode that provide access to the history list (*note Commands For +History::). + + The shell allows control over which commands are saved on the history +list. The 'HISTCONTROL' and 'HISTIGNORE' variables may be set to cause +the shell to save only a subset of the commands entered. The 'cmdhist' +shell option, if enabled, causes the shell to attempt to save each line +of a multi-line command in the same history entry, adding semicolons +where necessary to preserve syntactic correctness. The 'lithist' shell +option causes the shell to save the command with embedded newlines +instead of semicolons. The 'shopt' builtin is used to set these +options. *Note The Shopt Builtin::, for a description of 'shopt'. + + +File: bash.info, Node: Bash History Builtins, Next: History Interaction, Prev: Bash History Facilities, Up: Using History Interactively + +9.2 Bash History Builtins +========================= + +Bash provides two builtin commands which manipulate the history list and +history file. + +'fc' + fc [-e ENAME] [-lnr] [FIRST] [LAST] + fc -s [PAT=REP] [COMMAND] + + The first form selects a range of commands from FIRST to LAST from + the history list and displays or edits and re-executes them. 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. COMMAND is + intepreted the same as FIRST above. + + 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 (*note Aliases::). + +'history' + history [N] + history -c + history -d OFFSET + history -d START-END + history [-anrw] [FILENAME] + history -ps ARG + + With no options, display the history list with line numbers. Lines + prefixed with a '*' have been modified. An argument of N lists + only the last N lines. If the shell variable 'HISTTIMEFORMAT' is + set and not null, it is used as a format string for STRFTIME to + display the time stamp associated with each displayed history + entry. No intervening blank is printed between the formatted time + stamp and the history line. + + Options, if supplied, have the following meanings: + + '-c' + Clear the history list. This may be combined with the other + options to replace the history list completely. + + '-d OFFSET' + Delete the history entry at position OFFSET. If OFFSET is + positive, it should be specified as it appears when the + history is displayed. If OFFSET is negative, it is + interpreted as relative to one greater than the last history + position, so negative indices count back from the end of the + history, and an index of '-1' refers to the current 'history + -d' command. + + '-d START-END' + Delete the history entries between positions START and END, + inclusive. Positive and negative values for START and END are + interpreted as described above. + + '-a' + Append the new history lines to the history file. These are + history lines entered since the beginning of the current Bash + session, but not already appended to the history file. + + '-n' + Append the history lines not already read from the history + file to the current history list. These are lines appended to + the history file since the beginning of the current Bash + session. + + '-r' + Read the history file and append its contents to the history + list. + + '-w' + Write out the current history list to the history file. + + '-p' + Perform history substitution on the ARGs and display the + result on the standard output, without storing the results in + the history list. + + '-s' + The ARGs are added to the end of the history list as a single + entry. + + When any of the '-w', '-r', '-a', or '-n' options is used, if + FILENAME is given, then it is used as the history file. If not, + then the value of the 'HISTFILE' variable is used. + + +File: bash.info, Node: History Interaction, Prev: Bash History Builtins, Up: Using History Interactively + +9.3 History Expansion +===================== + +The History library provides a history expansion feature that is similar +to the history expansion provided by 'csh'. This section describes the +syntax used to manipulate the history information. + + History expansions introduce words from the history list into the +input stream, making it easy to repeat commands, insert the arguments to +a previous command into the current input line, or fix errors in +previous commands quickly. + + History expansion is performed immediately after a complete line is +read, before the shell breaks it into words, and is performed on each +line individually. Bash attempts to inform the history expansion +functions about quoting still in effect from previous lines. + + History expansion takes place in two parts. The first is to +determine which line from the history list should be used during +substitution. The second is to select portions of that line for +inclusion into the current one. The line selected from the history is +called the "event", and the portions of that line that are acted upon +are called "words". Various "modifiers" are available to manipulate the +selected words. The line is broken into words in the same fashion that +Bash does, so that several words surrounded by quotes are considered one +word. History expansions are introduced by the appearance of the +history expansion character, which is '!' by default. + + History expansion implements shell-like quoting conventions: a +backslash can be used to remove the special handling for the next +character; single quotes enclose verbatim sequences of characters, and +can be used to inhibit history expansion; and characters enclosed within +double quotes may be subject to history expansion, since backslash can +escape the history expansion character, but single quotes may not, since +they are not treated specially within double quotes. + + When using the shell, only '\' and ''' may be used to escape the +history expansion character, but the history expansion character is also +treated as quoted if it immediately precedes the closing double quote in +a double-quoted string. + + Several shell options settable with the 'shopt' builtin (*note The +Shopt Builtin::) may be used to tailor the behavior of history +expansion. If the 'histverify' shell option is enabled, and Readline is +being used, history substitutions are not immediately passed to the +shell parser. Instead, the expanded line is reloaded into the Readline +editing buffer for further modification. If Readline is being used, and +the 'histreedit' shell option is enabled, a failed history expansion +will be reloaded into the Readline editing buffer for correction. The +'-p' option to the 'history' builtin command may be used to see what a +history expansion will do before using it. The '-s' option to the +'history' builtin may be used to add commands to the end of the history +list without actually executing them, so that they are available for +subsequent recall. This is most useful in conjunction with Readline. + + The shell allows control of the various characters used by the +history expansion mechanism with the 'histchars' variable, as explained +above (*note Bash Variables::). The shell uses the history comment +character to mark history timestamps when writing the history file. + +* Menu: + +* Event Designators:: How to specify which history line to use. +* Word Designators:: Specifying which words are of interest. +* Modifiers:: Modifying the results of substitution. + + +File: bash.info, Node: Event Designators, Next: Word Designators, Up: History Interaction + +9.3.1 Event Designators +----------------------- + +An event designator is a reference to a command line entry in the +history list. Unless the reference is absolute, events are relative to +the current position in the history list. + +'!' + Start a history substitution, except when followed by a space, tab, + the end of the line, '=' or '(' (when the 'extglob' shell option is + enabled using the 'shopt' builtin). + +'!N' + Refer to command line N. + +'!-N' + Refer to the command N lines back. + +'!!' + Refer to the previous command. This is a synonym for '!-1'. + +'!STRING' + Refer to the most recent command preceding the current position in + the history list starting with STRING. + +'!?STRING[?]' + Refer to the most recent command preceding the current position in + the history list containing STRING. The trailing '?' may be + omitted if the STRING is followed immediately by a newline. + +'^STRING1^STRING2^' + Quick Substitution. Repeat the last command, replacing STRING1 + with STRING2. Equivalent to '!!:s/STRING1/STRING2/'. + +'!#' + The entire command line typed so far. + + +File: bash.info, Node: Word Designators, Next: Modifiers, Prev: Event Designators, Up: History Interaction + +9.3.2 Word Designators +---------------------- + +Word designators are used to select desired words from the event. A ':' +separates the event specification from the word designator. It may be +omitted if the word designator begins with a '^', '$', '*', '-', or '%'. +Words are numbered from the beginning of the line, with the first word +being denoted by 0 (zero). Words are inserted into the current line +separated by single spaces. + + For example, + +'!!' + designates the preceding command. When you type this, the + preceding command is repeated in toto. + +'!!:$' + designates the last argument of the preceding command. This may be + shortened to '!$'. + +'!fi:2' + designates the second argument of the most recent command starting + with the letters 'fi'. + + Here are the word designators: + +'0 (zero)' + The '0'th word. For many applications, this is the command word. + +'N' + The Nth word. + +'^' + The first argument; that is, word 1. + +'$' + The last argument. + +'%' + The word matched by the most recent '?STRING?' search. + +'X-Y' + A range of words; '-Y' abbreviates '0-Y'. + +'*' + All of the words, except the '0'th. This is a synonym for '1-$'. + It is not an error to use '*' if there is just one word in the + event; the empty string is returned in that case. + +'X*' + Abbreviates 'X-$' + +'X-' + Abbreviates 'X-$' like 'X*', but omits the last word. + + If a word designator is supplied without an event specification, the +previous command is used as the event. + + +File: bash.info, Node: Modifiers, Prev: Word Designators, Up: History Interaction + +9.3.3 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. + +'t' + Remove all leading pathname components, leaving the tail. + +'r' + Remove a trailing suffix of the form '.SUFFIX', leaving the + basename. + +'e' + Remove all but the trailing suffix. + +'p' + Print the new command but do not execute it. + +'q' + Quote the substituted words, escaping further substitutions. + +'x' + Quote the substituted words as with 'q', but break into words at + spaces, tabs, and newlines. + +'s/OLD/NEW/' + Substitute NEW for the first occurrence of OLD in the event line. + Any delimiter may be used in place of '/'. The delimiter may be + quoted in OLD and NEW with a single backslash. If '&' appears in + NEW, it is replaced by OLD. A single backslash will quote the '&'. + The final delimiter is optional if it is the last character on the + input line. + +'&' + Repeat the previous substitution. + +'g' +'a' + Cause changes to be applied over the entire event line. Used in + conjunction with 's', as in 'gs/OLD/NEW/', or with '&'. + +'G' + Apply the following 's' modifier once to each word in the event. + + +File: bash.info, Node: Installing Bash, Next: Reporting Bugs, Prev: Using History Interactively, Up: Top + +10 Installing Bash +****************** + +This chapter provides basic instructions for installing Bash on the +various supported platforms. The distribution supports the GNU +operating systems, nearly every version of Unix, and several non-Unix +systems such as BeOS and Interix. Other independent ports exist for +MS-DOS, OS/2, and Windows platforms. + +* Menu: + +* Basic Installation:: Installation instructions. +* Compilers and Options:: How to set special options for various + systems. +* Compiling For Multiple Architectures:: How to compile Bash for more + than one kind of system from + the same source tree. +* Installation Names:: How to set the various paths used by the installation. +* Specifying the System Type:: How to configure Bash for a particular system. +* Sharing Defaults:: How to share default configuration values among GNU + programs. +* Operation Controls:: Options recognized by the configuration program. +* Optional Features:: How to enable and disable optional features when + building Bash. + + +File: bash.info, Node: Basic Installation, Next: Compilers and Options, Up: Installing Bash + +10.1 Basic Installation +======================= + +These are installation instructions for Bash. + + The simplest way to compile Bash is: + + 1. 'cd' to the directory containing the source code and type + './configure' to configure Bash for your system. If you're using + 'csh' on an old version of System V, you might need to type 'sh + ./configure' instead to prevent 'csh' from trying to execute + 'configure' itself. + + Running 'configure' takes some time. While running, it prints + messages telling which features it is checking for. + + 2. Type 'make' to compile Bash and build the 'bashbug' bug reporting + script. + + 3. Optionally, type 'make tests' to run the Bash test suite. + + 4. Type 'make install' to install 'bash' and 'bashbug'. This will + also install the manual pages and Info file. + + The 'configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a 'Makefile' in each directory of the package +(the top directory, the 'builtins', 'doc', and 'support' directories, +each directory under 'lib', and several others). It also creates a +'config.h' file containing system-dependent definitions. Finally, it +creates a shell script named 'config.status' that you can run in the +future to recreate the current configuration, a file 'config.cache' that +saves the results of its tests to speed up reconfiguring, and a file +'config.log' containing compiler output (useful mainly for debugging +'configure'). If at some point 'config.cache' contains results you +don't want to keep, you may remove or edit it. + + To find out more about the options and arguments that the 'configure' +script understands, type + + bash-4.2$ ./configure --help + +at the Bash prompt in your Bash source directory. + + If you want to build Bash in a directory separate from the source +directory - to build for multiple architectures, for example - just use +the full path to the configure script. The following commands will +build bash in a directory under '/usr/local/build' from the source code +in '/usr/local/src/bash-4.4': + + mkdir /usr/local/build/bash-4.4 + cd /usr/local/build/bash-4.4 + bash /usr/local/src/bash-4.4/configure + make + + See *note Compiling For Multiple Architectures:: for more information +about building in a directory separate from the source. + + If you need to do unusual things to compile Bash, please try to +figure out how 'configure' could check whether or not to do them, and +mail diffs or instructions to <bash-maintainers@gnu.org> so they can be +considered for the next release. + + The file 'configure.ac' is used to create 'configure' by a program +called Autoconf. You only need 'configure.ac' if you want to change it +or regenerate 'configure' using a newer version of Autoconf. If you do +this, make sure you are using Autoconf version 2.50 or newer. + + You can remove the program binaries and object files from the source +code directory by typing 'make clean'. To also remove the files that +'configure' created (so you can compile Bash for a different kind of +computer), type 'make distclean'. + + +File: bash.info, Node: Compilers and Options, Next: Compiling For Multiple Architectures, Prev: Basic Installation, Up: Installing Bash + +10.2 Compilers and Options +========================== + +Some systems require unusual options for compilation or linking that the +'configure' script does not know about. You can give 'configure' +initial values for variables by setting them in the environment. Using +a Bourne-compatible shell, you can do that on the command line like +this: + + CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure + + On systems that have the 'env' program, you can do it like this: + + env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure + + The configuration process uses GCC to build Bash if it is available. + + +File: bash.info, Node: Compiling For Multiple Architectures, Next: Installation Names, Prev: Compilers and Options, Up: Installing Bash + +10.3 Compiling For Multiple Architectures +========================================= + +You can compile Bash for more than one kind of computer at the same +time, by placing the object files for each architecture in their own +directory. To do this, you must use a version of 'make' that supports +the 'VPATH' variable, such as GNU 'make'. 'cd' to the directory where +you want the object files and executables to go and run the 'configure' +script from the source directory (*note Basic Installation::). You may +need to supply the '--srcdir=PATH' argument to tell 'configure' where +the source files are. 'configure' automatically checks for the source +code in the directory that 'configure' is in and in '..'. + + If you have to use a 'make' that does not supports the 'VPATH' +variable, you can compile Bash for one architecture at a time in the +source code directory. After you have installed Bash for one +architecture, use 'make distclean' before reconfiguring for another +architecture. + + Alternatively, if your system supports symbolic links, you can use +the 'support/mkclone' script to create a build tree which has symbolic +links back to each file in the source directory. Here's an example that +creates a build directory in the current directory from a source +directory '/usr/gnu/src/bash-2.0': + + bash /usr/gnu/src/bash-2.0/support/mkclone -s /usr/gnu/src/bash-2.0 . + +The 'mkclone' script requires Bash, so you must have already built Bash +for at least one architecture before you can create build directories +for other architectures. + + +File: bash.info, Node: Installation Names, Next: Specifying the System Type, Prev: Compiling For Multiple Architectures, Up: Installing Bash + +10.4 Installation Names +======================= + +By default, 'make install' will install into '/usr/local/bin', +'/usr/local/man', etc. You can specify an installation prefix other +than '/usr/local' by giving 'configure' the option '--prefix=PATH', or +by specifying a value for the 'DESTDIR' 'make' variable when running +'make install'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +give 'configure' the option '--exec-prefix=PATH', 'make install' will +use PATH as the prefix for installing programs and libraries. +Documentation and other data files will still use the regular prefix. + + +File: bash.info, Node: Specifying the System Type, Next: Sharing Defaults, Prev: Installation Names, Up: Installing Bash + +10.5 Specifying the System Type +=============================== + +There may be some features 'configure' can not figure out automatically, +but need to determine by the type of host Bash will run on. Usually +'configure' can figure that out, but if it prints a message saying it +can not guess the host type, give it the '--host=TYPE' option. 'TYPE' +can either be a short name for the system type, such as 'sun4', or a +canonical name with three fields: 'CPU-COMPANY-SYSTEM' (e.g., +'i386-unknown-freebsd4.2'). + + See the file 'support/config.sub' for the possible values of each +field. + + +File: bash.info, Node: Sharing Defaults, Next: Operation Controls, Prev: Specifying the System Type, Up: Installing Bash + +10.6 Sharing Defaults +===================== + +If you want to set default values for 'configure' scripts to share, you +can create a site shell script called 'config.site' that gives default +values for variables like 'CC', 'cache_file', and 'prefix'. 'configure' +looks for 'PREFIX/share/config.site' if it exists, then +'PREFIX/etc/config.site' if it exists. Or, you can set the +'CONFIG_SITE' environment variable to the location of the site script. +A warning: the Bash 'configure' looks for a site script, but not all +'configure' scripts do. + + +File: bash.info, Node: Operation Controls, Next: Optional Features, Prev: Sharing Defaults, Up: Installing Bash + +10.7 Operation Controls +======================= + +'configure' recognizes the following options to control how it operates. + +'--cache-file=FILE' + Use and save the results of the tests in FILE instead of + './config.cache'. Set FILE to '/dev/null' to disable caching, for + debugging 'configure'. + +'--help' + Print a summary of the options to 'configure', and exit. + +'--quiet' +'--silent' +'-q' + Do not print messages saying which checks are being made. + +'--srcdir=DIR' + Look for the Bash source code in directory DIR. Usually + 'configure' can determine that directory automatically. + +'--version' + Print the version of Autoconf used to generate the 'configure' + script, and exit. + + 'configure' also accepts some other, not widely used, boilerplate +options. 'configure --help' prints the complete list. + + +File: bash.info, Node: Optional Features, Prev: Operation Controls, Up: Installing Bash + +10.8 Optional Features +====================== + +The Bash 'configure' has a number of '--enable-FEATURE' options, where +FEATURE indicates an optional part of Bash. There are also several +'--with-PACKAGE' options, where PACKAGE is something like 'bash-malloc' +or 'purify'. To turn off the default use of a package, use +'--without-PACKAGE'. To configure Bash without a feature that is +enabled by default, use '--disable-FEATURE'. + + Here is a complete list of the '--enable-' and '--with-' options that +the Bash 'configure' recognizes. + +'--with-afs' + Define if you are using the Andrew File System from Transarc. + +'--with-bash-malloc' + Use the Bash version of 'malloc' in the directory 'lib/malloc'. + This is not the same 'malloc' that appears in GNU libc, but an + older version originally derived from the 4.2 BSD 'malloc'. This + 'malloc' is very fast, but wastes some space on each allocation. + This option is enabled by default. The 'NOTES' file contains a + list of systems for which this should be turned off, and + 'configure' disables this option automatically for a number of + systems. + +'--with-curses' + Use the curses library instead of the termcap library. This should + be supplied if your system has an inadequate or incomplete termcap + database. + +'--with-gnu-malloc' + A synonym for '--with-bash-malloc'. + +'--with-installed-readline[=PREFIX]' + Define this to make Bash link with a locally-installed version of + Readline rather than the version in 'lib/readline'. This works + only with Readline 5.0 and later versions. If PREFIX is 'yes' or + not supplied, 'configure' uses the values of the make variables + 'includedir' and 'libdir', which are subdirectories of 'prefix' by + default, to find the installed version of Readline if it is not in + the standard system include and library directories. If PREFIX is + 'no', Bash links with the version in 'lib/readline'. If PREFIX is + set to any other value, 'configure' treats it as a directory + pathname and looks for the installed version of Readline in + subdirectories of that directory (include files in PREFIX/'include' + and the library in PREFIX/'lib'). + +'--with-purify' + Define this to use the Purify memory allocation checker from + Rational Software. + +'--enable-minimal-config' + This produces a shell with minimal features, close to the + historical Bourne shell. + + There are several '--enable-' options that alter how Bash is compiled +and linked, rather than changing run-time features. + +'--enable-largefile' + Enable support for large files + (http://www.unix.org/version2/whatsnew/lfs20mar.html) if the + operating system requires special compiler options to build + programs which can access large files. This is enabled by default, + if the operating system provides large file support. + +'--enable-profiling' + This builds a Bash binary that produces profiling information to be + processed by 'gprof' each time it is executed. + +'--enable-static-link' + This causes Bash to be linked statically, if 'gcc' is being used. + This could be used to build a version to use as root's shell. + + The 'minimal-config' option can be used to disable all of the +following options, but it is processed first, so individual options may +be enabled using 'enable-FEATURE'. + + All of the following options except for 'disabled-builtins', +'direxpand-default', and 'xpg-echo-default' are enabled by default, +unless the operating system does not provide the necessary support. + +'--enable-alias' + Allow alias expansion and include the 'alias' and 'unalias' + builtins (*note Aliases::). + +'--enable-arith-for-command' + Include support for the alternate form of the 'for' command that + behaves like the C language 'for' statement (*note Looping + Constructs::). + +'--enable-array-variables' + Include support for one-dimensional array shell variables (*note + Arrays::). + +'--enable-bang-history' + Include support for 'csh'-like history substitution (*note History + Interaction::). + +'--enable-brace-expansion' + Include 'csh'-like brace expansion ( 'b{a,b}c' ==> 'bac bbc' ). + See *note Brace Expansion::, for a complete description. + +'--enable-casemod-attributes' + Include support for case-modifying attributes in the 'declare' + builtin and assignment statements. Variables with the UPPERCASE + attribute, for example, will have their values converted to + uppercase upon assignment. + +'--enable-casemod-expansion' + Include support for case-modifying word expansions. + +'--enable-command-timing' + Include support for recognizing 'time' as a reserved word and for + displaying timing statistics for the pipeline following 'time' + (*note Pipelines::). This allows pipelines as well as shell + builtins and functions to be timed. + +'--enable-cond-command' + Include support for the '[[' conditional command. (*note + Conditional Constructs::). + +'--enable-cond-regexp' + Include support for matching POSIX regular expressions using the + '=~' binary operator in the '[[' conditional command. (*note + Conditional Constructs::). + +'--enable-coprocesses' + Include support for coprocesses and the 'coproc' reserved word + (*note Pipelines::). + +'--enable-debugger' + Include support for the bash debugger (distributed separately). + +'--enable-dev-fd-stat-broken' + If calling 'stat' on /dev/fd/N returns different results than + calling 'fstat' on file descriptor N, supply this option to enable + a workaround. This has implications for conditional commands that + test file attributes. + +'--enable-direxpand-default' + Cause the 'direxpand' shell option (*note The Shopt Builtin::) to + be enabled by default when the shell starts. It is normally + disabled by default. + +'--enable-directory-stack' + Include support for a 'csh'-like directory stack and the 'pushd', + 'popd', and 'dirs' builtins (*note The Directory Stack::). + +'--enable-disabled-builtins' + Allow builtin commands to be invoked via 'builtin xxx' even after + 'xxx' has been disabled using 'enable -n xxx'. See *note Bash + Builtins::, for details of the 'builtin' and 'enable' builtin + commands. + +'--enable-dparen-arithmetic' + Include support for the '((...))' command (*note Conditional + Constructs::). + +'--enable-extended-glob' + Include support for the extended pattern matching features + described above under *note Pattern Matching::. + +'--enable-extended-glob-default' + Set the default value of the EXTGLOB shell option described above + under *note The Shopt Builtin:: to be enabled. + +'--enable-function-import' + Include support for importing function definitions exported by + another instance of the shell from the environment. This option is + enabled by default. + +'--enable-glob-asciirange-default' + Set the default value of the GLOBASCIIRANGES shell option described + above under *note The Shopt Builtin:: to be enabled. This controls + the behavior of character ranges when used in pattern matching + bracket expressions. + +'--enable-help-builtin' + Include the 'help' builtin, which displays help on shell builtins + and variables (*note Bash Builtins::). + +'--enable-history' + Include command history and the 'fc' and 'history' builtin commands + (*note Bash History Facilities::). + +'--enable-job-control' + This enables the job control features (*note Job Control::), if the + operating system supports them. + +'--enable-multibyte' + This enables support for multibyte characters if the operating + system provides the necessary support. + +'--enable-net-redirections' + This enables the special handling of filenames of the form + '/dev/tcp/HOST/PORT' and '/dev/udp/HOST/PORT' when used in + redirections (*note Redirections::). + +'--enable-process-substitution' + This enables process substitution (*note Process Substitution::) if + the operating system provides the necessary support. + +'--enable-progcomp' + Enable the programmable completion facilities (*note Programmable + Completion::). If Readline is not enabled, this option has no + effect. + +'--enable-prompt-string-decoding' + Turn on the interpretation of a number of backslash-escaped + characters in the '$PS0', '$PS1', '$PS2', and '$PS4' prompt + strings. See *note Controlling the Prompt::, for a complete list + of prompt string escape sequences. + +'--enable-readline' + Include support for command-line editing and history with the Bash + version of the Readline library (*note Command Line Editing::). + +'--enable-restricted' + Include support for a "restricted shell". If this is enabled, + Bash, when called as 'rbash', enters a restricted mode. See *note + The Restricted Shell::, for a description of restricted mode. + +'--enable-select' + Include the 'select' compound command, which allows the generation + of simple menus (*note Conditional Constructs::). + +'--enable-separate-helpfiles' + Use external files for the documentation displayed by the 'help' + builtin instead of storing the text internally. + +'--enable-single-help-strings' + Store the text displayed by the 'help' builtin as a single string + for each help topic. This aids in translating the text to + different languages. You may need to disable this if your compiler + cannot handle very long string literals. + +'--enable-strict-posix-default' + Make Bash POSIX-conformant by default (*note Bash POSIX Mode::). + +'--enable-usg-echo-default' + A synonym for '--enable-xpg-echo-default'. + +'--enable-xpg-echo-default' + Make the 'echo' builtin expand backslash-escaped characters by + default, without requiring the '-e' option. This sets the default + value of the 'xpg_echo' shell option to 'on', which makes the Bash + 'echo' behave more like the version specified in the Single Unix + Specification, version 3. *Note Bash Builtins::, for a description + of the escape sequences that 'echo' recognizes. + + The file 'config-top.h' contains C Preprocessor '#define' statements +for options which are not settable from 'configure'. Some of these are +not meant to be changed; beware of the consequences if you do. Read the +comments associated with each definition for more information about its +effect. + + +File: bash.info, Node: Reporting Bugs, Next: Major Differences From The Bourne Shell, Prev: Installing Bash, Up: Top + +Appendix A Reporting Bugs +************************* + +Please report all bugs you find in Bash. But first, you should make +sure that it really is a bug, and that it appears in the latest version +of Bash. The latest version of Bash is always available for FTP from +<ftp://ftp.gnu.org/pub/gnu/bash/>. + + Once you have determined that a bug actually exists, use the +'bashbug' command to submit a bug report. If you have a fix, you are +encouraged to mail that as well! Suggestions and 'philosophical' bug +reports may be mailed to <bug-bash@gnu.org> or posted to the Usenet +newsgroup 'gnu.bash.bug'. + + All bug reports should include: + * The version number of Bash. + * The hardware and operating system. + * The compiler used to compile Bash. + * A description of the bug behaviour. + * A short script or 'recipe' which exercises the bug and may be used + to reproduce it. + +'bashbug' inserts the first three items automatically into the template +it provides for filing a bug report. + + Please send all reports concerning this manual to <bug-bash@gnu.org>. + + +File: bash.info, Node: Major Differences From The Bourne Shell, Next: GNU Free Documentation License, Prev: Reporting Bugs, Up: Top + +Appendix B Major Differences From The Bourne Shell +************************************************** + +Bash implements essentially the same grammar, parameter and variable +expansion, redirection, and quoting as the Bourne Shell. Bash uses the +POSIX standard as the specification of how these features are to be +implemented. There are some differences between the traditional Bourne +shell and Bash; this section quickly details the differences of +significance. A number of these differences are explained in greater +depth in previous sections. This section uses the version of 'sh' +included in SVR4.2 (the last version of the historical Bourne shell) as +the baseline reference. + + * Bash is POSIX-conformant, even where the POSIX specification + differs from traditional 'sh' behavior (*note Bash POSIX Mode::). + + * Bash has multi-character invocation options (*note Invoking + Bash::). + + * Bash has command-line editing (*note Command Line Editing::) and + the 'bind' builtin. + + * Bash provides a programmable word completion mechanism (*note + Programmable Completion::), and builtin commands 'complete', + 'compgen', and 'compopt', to manipulate it. + + * Bash has command history (*note Bash History Facilities::) and the + 'history' and 'fc' builtins to manipulate it. The Bash history + list maintains timestamp information and uses the value of the + 'HISTTIMEFORMAT' variable to display it. + + * Bash implements 'csh'-like history expansion (*note History + Interaction::). + + * Bash has one-dimensional array variables (*note Arrays::), and the + appropriate variable expansions and assignment syntax to use them. + Several of the Bash builtins take options to act on arrays. Bash + provides a number of built-in array variables. + + * The '$'...'' quoting syntax, which expands ANSI-C backslash-escaped + characters in the text between the single quotes, is supported + (*note ANSI-C Quoting::). + + * Bash supports the '$"..."' quoting syntax to do locale-specific + translation of the characters between the double quotes. The '-D', + '--dump-strings', and '--dump-po-strings' invocation options list + the translatable strings found in a script (*note Locale + Translation::). + + * Bash implements the '!' keyword to negate the return value of a + pipeline (*note Pipelines::). Very useful when an 'if' statement + needs to act only if a test fails. The Bash '-o pipefail' option + to 'set' will cause a pipeline to return a failure status if any + command fails. + + * Bash has the 'time' reserved word and command timing (*note + Pipelines::). The display of the timing statistics may be + controlled with the 'TIMEFORMAT' variable. + + * Bash implements the 'for (( EXPR1 ; EXPR2 ; EXPR3 ))' arithmetic + for command, similar to the C language (*note Looping + Constructs::). + + * Bash includes the 'select' compound command, which allows the + generation of simple menus (*note Conditional Constructs::). + + * Bash includes the '[[' compound command, which makes conditional + testing part of the shell grammar (*note Conditional Constructs::), + including optional regular expression matching. + + * Bash provides optional case-insensitive matching for the 'case' and + '[[' constructs. + + * Bash includes brace expansion (*note Brace Expansion::) and tilde + expansion (*note Tilde Expansion::). + + * Bash implements command aliases and the 'alias' and 'unalias' + builtins (*note Aliases::). + + * Bash provides shell arithmetic, the '((' compound command (*note + Conditional Constructs::), and arithmetic expansion (*note Shell + Arithmetic::). + + * 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. + + * Bash supports the '+=' assignment operator, which appends to the + value of the variable named on the left hand side. + + * Bash includes the POSIX pattern removal '%', '#', '%%' and '##' + expansions to remove leading or trailing substrings from variable + values (*note Shell Parameter Expansion::). + + * The expansion '${#xx}', which returns the length of '${xx}', is + supported (*note Shell Parameter Expansion::). + + * The expansion '${var:'OFFSET'[:'LENGTH']}', which expands to the + substring of 'var''s value of length LENGTH, beginning at OFFSET, + is present (*note Shell Parameter Expansion::). + + * The expansion '${var/[/]'PATTERN'[/'REPLACEMENT']}', which matches + PATTERN and replaces it with REPLACEMENT in the value of 'var', is + available (*note Shell Parameter Expansion::). + + * The expansion '${!PREFIX*}' expansion, which expands to the names + of all shell variables whose names begin with PREFIX, is available + (*note Shell Parameter Expansion::). + + * Bash has INDIRECT variable expansion using '${!word}' (*note Shell + Parameter Expansion::). + + * Bash can expand positional parameters beyond '$9' using '${NUM}'. + + * The POSIX '$()' form of command substitution is implemented (*note + Command Substitution::), and preferred to the Bourne shell's '``' + (which is also implemented for backwards compatibility). + + * Bash has process substitution (*note Process Substitution::). + + * Bash automatically assigns variables that provide information about + the current user ('UID', 'EUID', and 'GROUPS'), the current host + ('HOSTTYPE', 'OSTYPE', 'MACHTYPE', and 'HOSTNAME'), and the + instance of Bash that is running ('BASH', 'BASH_VERSION', and + 'BASH_VERSINFO'). *Note Bash Variables::, for details. + + * The 'IFS' variable is used to split only the results of expansion, + not all words (*note Word Splitting::). This closes a longstanding + shell security hole. + + * The filename expansion bracket expression code uses '!' and '^' to + negate the set of characters between the brackets. The Bourne + shell uses only '!'. + + * Bash implements the full set of POSIX filename expansion operators, + including CHARACTER CLASSES, EQUIVALENCE CLASSES, and COLLATING + SYMBOLS (*note Filename Expansion::). + + * Bash implements extended pattern matching features when the + 'extglob' shell option is enabled (*note Pattern Matching::). + + * 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 using the + 'local' builtin, and thus useful recursive functions may be written + (*note Bash Builtins::). + + * Variable assignments preceding commands affect only that command, + even builtins and functions (*note Environment::). In 'sh', all + variable assignments preceding commands are global unless the + command is executed from the file system. + + * Bash performs filename expansion on filenames specified as operands + to input and output redirection operators (*note Redirections::). + + * Bash contains the '<>' redirection operator, allowing a file to be + opened for both reading and writing, and the '&>' redirection + operator, for directing standard output and standard error to the + same file (*note Redirections::). + + * Bash includes the '<<<' redirection operator, allowing a string to + be used as the standard input to a command. + + * Bash implements the '[n]<&WORD' and '[n]>&WORD' redirection + operators, which move one file descriptor to another. + + * Bash treats a number of filenames specially when they are used in + redirection operators (*note Redirections::). + + * Bash can open network connections to arbitrary machines and + services with the redirection operators (*note Redirections::). + + * The 'noclobber' option is available to avoid overwriting existing + files with output redirection (*note The Set Builtin::). The '>|' + redirection operator may be used to override 'noclobber'. + + * The Bash 'cd' and 'pwd' builtins (*note Bourne Shell Builtins::) + each take '-L' and '-P' options to switch between logical and + physical modes. + + * Bash allows a function to override a builtin with the same name, + and provides access to that builtin's functionality within the + function via the 'builtin' and 'command' builtins (*note Bash + Builtins::). + + * The 'command' builtin allows selective disabling of functions when + command lookup is performed (*note Bash Builtins::). + + * Individual builtins may be enabled or disabled using the 'enable' + builtin (*note Bash Builtins::). + + * The Bash 'exec' builtin takes additional options that allow users + to control the contents of the environment passed to the executed + command, and what the zeroth argument to the command is to be + (*note Bourne Shell Builtins::). + + * Shell functions may be exported to children via the environment + using 'export -f' (*note Shell Functions::). + + * The Bash 'export', 'readonly', and 'declare' builtins can take a + '-f' option to act on shell functions, a '-p' option to display + variables with various attributes set in a format that can be used + as shell input, a '-n' option to remove various variable + attributes, and 'name=value' arguments to set variable attributes + and values simultaneously. + + * The Bash 'hash' builtin allows a name to be associated with an + arbitrary filename, even when that filename cannot be found by + searching the '$PATH', using 'hash -p' (*note Bourne Shell + Builtins::). + + * Bash includes a 'help' builtin for quick reference to shell + facilities (*note Bash Builtins::). + + * The 'printf' builtin is available to display formatted output + (*note Bash Builtins::). + + * The Bash 'read' builtin (*note Bash Builtins::) will read a line + ending in '\' with the '-r' option, and will use the 'REPLY' + variable as a default if no non-option arguments are supplied. The + Bash 'read' builtin also accepts a prompt string with the '-p' + option and will use Readline to obtain the line when given the '-e' + option. The 'read' builtin also has additional options to control + input: the '-s' option will turn off echoing of input characters as + they are read, the '-t' option will allow 'read' to time out if + input does not arrive within a specified number of seconds, the + '-n' option will allow reading only a specified number of + characters rather than a full line, and the '-d' option will read + until a particular character rather than newline. + + * The 'return' builtin may be used to abort execution of scripts + executed with the '.' or 'source' builtins (*note Bourne Shell + Builtins::). + + * Bash includes the 'shopt' builtin, for finer control of shell + optional capabilities (*note The Shopt Builtin::), and allows these + options to be set and unset at shell invocation (*note Invoking + Bash::). + + * Bash has much more optional behavior controllable with the 'set' + builtin (*note The Set Builtin::). + + * The '-x' ('xtrace') option displays commands other than simple + commands when performing an execution trace (*note The Set + Builtin::). + + * The 'test' builtin (*note Bourne Shell Builtins::) is slightly + different, as it implements the POSIX algorithm, which specifies + the behavior based on the number of arguments. + + * Bash includes the 'caller' builtin, which displays the context of + any active subroutine call (a shell function or a script executed + with the '.' or 'source' builtins). This supports the bash + debugger. + + * The 'trap' builtin (*note Bourne Shell Builtins::) allows a 'DEBUG' + pseudo-signal specification, similar to 'EXIT'. Commands specified + with a 'DEBUG' trap are executed before every simple command, 'for' + command, 'case' command, 'select' command, every arithmetic 'for' + command, and before the first command executes in a shell function. + The 'DEBUG' trap is not inherited by shell functions unless the + function has been given the 'trace' attribute or the 'functrace' + option has been enabled using the 'shopt' builtin. The 'extdebug' + shell option has additional effects on the 'DEBUG' trap. + + The 'trap' builtin (*note Bourne Shell Builtins::) allows an 'ERR' + pseudo-signal specification, similar to 'EXIT' and 'DEBUG'. + Commands specified with an 'ERR' trap are executed after a simple + command fails, with a few exceptions. The 'ERR' trap is not + inherited by shell functions unless the '-o errtrace' option to the + 'set' builtin is enabled. + + The 'trap' builtin (*note Bourne Shell Builtins::) allows a + 'RETURN' pseudo-signal specification, similar to 'EXIT' and + 'DEBUG'. Commands specified with an 'RETURN' trap are executed + before execution resumes after a shell function or a shell script + executed with '.' or 'source' returns. The 'RETURN' trap is not + inherited by shell functions unless the function has been given the + 'trace' attribute or the 'functrace' option has been enabled using + the 'shopt' builtin. + + * The Bash 'type' builtin is more extensive and gives more + information about the names it finds (*note Bash Builtins::). + + * The Bash 'umask' builtin permits a '-p' option to cause the output + to be displayed in the form of a 'umask' command that may be reused + as input (*note Bourne Shell Builtins::). + + * Bash implements a 'csh'-like directory stack, and provides the + 'pushd', 'popd', and 'dirs' builtins to manipulate it (*note The + Directory Stack::). Bash also makes the directory stack visible as + the value of the 'DIRSTACK' shell variable. + + * Bash interprets special backslash-escaped characters in the prompt + strings when interactive (*note Controlling the Prompt::). + + * The Bash restricted mode is more useful (*note The Restricted + Shell::); the SVR4.2 shell restricted mode is too limited. + + * The 'disown' builtin can remove a job from the internal shell job + table (*note Job Control Builtins::) or suppress the sending of + 'SIGHUP' to a job when the shell exits as the result of a 'SIGHUP'. + + * Bash includes a number of features to support a separate debugger + for shell scripts. + + * The SVR4.2 shell has two privilege-related builtins ('mldmode' and + 'priv') not present in Bash. + + * Bash does not have the 'stop' or 'newgrp' builtins. + + * Bash does not use the 'SHACCT' variable or perform shell + accounting. + + * The SVR4.2 'sh' uses a 'TIMEOUT' variable like Bash uses 'TMOUT'. + +More features unique to Bash may be found in *note Bash Features::. + +B.1 Implementation Differences From The SVR4.2 Shell +==================================================== + +Since Bash is a completely new implementation, it does not suffer from +many of the limitations of the SVR4.2 shell. For instance: + + * Bash does not fork a subshell when redirecting into or out of a + shell control structure such as an 'if' or 'while' statement. + + * Bash does not allow unbalanced quotes. The SVR4.2 shell will + silently insert a needed closing quote at 'EOF' under certain + circumstances. This can be the cause of some hard-to-find errors. + + * The SVR4.2 shell uses a baroque memory management scheme based on + trapping 'SIGSEGV'. If the shell is started from a process with + 'SIGSEGV' blocked (e.g., by using the 'system()' C library function + call), it misbehaves badly. + + * In a questionable attempt at security, the SVR4.2 shell, when + invoked without the '-p' option, will alter its real and effective + UID and GID if they are less than some magic threshold value, + commonly 100. This can lead to unexpected results. + + * The SVR4.2 shell does not allow users to trap 'SIGSEGV', 'SIGALRM', + or 'SIGCHLD'. + + * The SVR4.2 shell does not allow the 'IFS', 'MAILCHECK', 'PATH', + 'PS1', or 'PS2' variables to be unset. + + * The SVR4.2 shell treats '^' as the undocumented equivalent of '|'. + + * Bash allows multiple option arguments when it is invoked ('-x -v'); + the SVR4.2 shell allows only one option argument ('-xv'). In fact, + some versions of the shell dump core if the second argument begins + with a '-'. + + * The SVR4.2 shell exits a script if any builtin fails; Bash exits a + script only if one of the POSIX special builtins fails, and only + for certain failures, as enumerated in the POSIX standard. + + * The SVR4.2 shell behaves differently when invoked as 'jsh' (it + turns on job control). + + +File: bash.info, Node: GNU Free Documentation License, Next: Indexes, Prev: Major Differences From The Bourne Shell, Up: Top + +Appendix C GNU Free Documentation License +***************************************** + + Version 1.3, 3 November 2008 + + Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. + <http://fsf.org/> + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + 0. PREAMBLE + + The purpose of this License is to make a manual, textbook, or other + functional and useful document "free" in the sense of freedom: to + assure everyone the effective freedom to copy and redistribute it, + with or without modifying it, either commercially or + noncommercially. Secondarily, this License preserves for the + author and publisher a way to get credit for their work, while not + being considered responsible for modifications made by others. + + This License is a kind of "copyleft", which means that derivative + works of the document must themselves be free in the same sense. + It complements the GNU General Public License, which is a copyleft + license designed for free software. + + We have designed this License in order to use it for manuals for + free software, because free software needs free documentation: a + free program should come with manuals providing the same freedoms + that the software does. But this License is not limited to + software manuals; it can be used for any textual work, regardless + of subject matter or whether it is published as a printed book. We + recommend this License principally for works whose purpose is + instruction or reference. + + 1. APPLICABILITY AND DEFINITIONS + + This License applies to any manual or other work, in any medium, + that contains a notice placed by the copyright holder saying it can + be distributed under the terms of this License. Such a notice + grants a world-wide, royalty-free license, unlimited in duration, + to use that work under the conditions stated herein. The + "Document", below, refers to any such manual or work. Any member + of the public is a licensee, and is addressed as "you". You accept + the license if you copy, modify or distribute the work in a way + requiring permission under copyright law. + + A "Modified Version" of the Document means any work containing the + Document or a portion of it, either copied verbatim, or with + modifications and/or translated into another language. + + A "Secondary Section" is a named appendix or a front-matter section + of the Document that deals exclusively with the relationship of the + publishers or authors of the Document to the Document's overall + subject (or to related matters) and contains nothing that could + fall directly within that overall subject. (Thus, if the Document + is in part a textbook of mathematics, a Secondary Section may not + explain any mathematics.) The relationship could be a matter of + historical connection with the subject or with related matters, or + of legal, commercial, philosophical, ethical or political position + regarding them. + + The "Invariant Sections" are certain Secondary Sections whose + titles are designated, as being those of Invariant Sections, in the + notice that says that the Document is released under this License. + If a section does not fit the above definition of Secondary then it + is not allowed to be designated as Invariant. The Document may + contain zero Invariant Sections. If the Document does not identify + any Invariant Sections then there are none. + + The "Cover Texts" are certain short passages of text that are + listed, as Front-Cover Texts or Back-Cover Texts, in the notice + that says that the Document is released under this License. A + Front-Cover Text may be at most 5 words, and a Back-Cover Text may + be at most 25 words. + + A "Transparent" copy of the Document means a machine-readable copy, + represented in a format whose specification is available to the + general public, that is suitable for revising the document + straightforwardly with generic text editors or (for images composed + of pixels) generic paint programs or (for drawings) some widely + available drawing editor, and that is suitable for input to text + formatters or for automatic translation to a variety of formats + suitable for input to text formatters. A copy made in an otherwise + Transparent file format whose markup, or absence of markup, has + been arranged to thwart or discourage subsequent modification by + readers is not Transparent. An image format is not Transparent if + used for any substantial amount of text. A copy that is not + "Transparent" is called "Opaque". + + Examples of suitable formats for Transparent copies include plain + ASCII without markup, Texinfo input format, LaTeX input format, + SGML or XML using a publicly available DTD, and standard-conforming + simple HTML, PostScript or PDF designed for human modification. + Examples of transparent image formats include PNG, XCF and JPG. + Opaque formats include proprietary formats that can be read and + edited only by proprietary word processors, SGML or XML for which + the DTD and/or processing tools are not generally available, and + the machine-generated HTML, PostScript or PDF produced by some word + processors for output purposes only. + + The "Title Page" means, for a printed book, the title page itself, + plus such following pages as are needed to hold, legibly, the + material this License requires to appear in the title page. For + works in formats which do not have any title page as such, "Title + Page" means the text near the most prominent appearance of the + work's title, preceding the beginning of the body of the text. + + The "publisher" means any person or entity that distributes copies + of the Document to the public. + + A section "Entitled XYZ" means a named subunit of the Document + whose title either is precisely XYZ or contains XYZ in parentheses + following text that translates XYZ in another language. (Here XYZ + stands for a specific section name mentioned below, such as + "Acknowledgements", "Dedications", "Endorsements", or "History".) + To "Preserve the Title" of such a section when you modify the + Document means that it remains a section "Entitled XYZ" according + to this definition. + + The Document may include Warranty Disclaimers next to the notice + which states that this License applies to the Document. These + Warranty Disclaimers are considered to be included by reference in + this License, but only as regards disclaiming warranties: any other + implication that these Warranty Disclaimers may have is void and + has no effect on the meaning of this License. + + 2. VERBATIM COPYING + + You may copy and distribute the Document in any medium, either + commercially or noncommercially, provided that this License, the + copyright notices, and the license notice saying this License + applies to the Document are reproduced in all copies, and that you + add no other conditions whatsoever to those of this License. You + may not use technical measures to obstruct or control the reading + or further copying of the copies you make or distribute. However, + you may accept compensation in exchange for copies. If you + distribute a large enough number of copies you must also follow the + conditions in section 3. + + You may also lend copies, under the same conditions stated above, + and you may publicly display copies. + + 3. COPYING IN QUANTITY + + If you publish printed copies (or copies in media that commonly + have printed covers) of the Document, numbering more than 100, and + the Document's license notice requires Cover Texts, you must + enclose the copies in covers that carry, clearly and legibly, all + these Cover Texts: Front-Cover Texts on the front cover, and + Back-Cover Texts on the back cover. Both covers must also clearly + and legibly identify you as the publisher of these copies. The + front cover must present the full title with all words of the title + equally prominent and visible. You may add other material on the + covers in addition. Copying with changes limited to the covers, as + long as they preserve the title of the Document and satisfy these + conditions, can be treated as verbatim copying in other respects. + + If the required texts for either cover are too voluminous to fit + legibly, you should put the first ones listed (as many as fit + reasonably) on the actual cover, and continue the rest onto + adjacent pages. + + If you publish or distribute Opaque copies of the Document + numbering more than 100, you must either include a machine-readable + Transparent copy along with each Opaque copy, or state in or with + each Opaque copy a computer-network location from which the general + network-using public has access to download using public-standard + network protocols a complete Transparent copy of the Document, free + of added material. If you use the latter option, you must take + reasonably prudent steps, when you begin distribution of Opaque + copies in quantity, to ensure that this Transparent copy will + remain thus accessible at the stated location until at least one + year after the last time you distribute an Opaque copy (directly or + through your agents or retailers) of that edition to the public. + + It is requested, but not required, that you contact the authors of + the Document well before redistributing any large number of copies, + to give them a chance to provide you with an updated version of the + Document. + + 4. MODIFICATIONS + + You may copy and distribute a Modified Version of the Document + under the conditions of sections 2 and 3 above, provided that you + release the Modified Version under precisely this License, with the + Modified Version filling the role of the Document, thus licensing + distribution and modification of the Modified Version to whoever + possesses a copy of it. In addition, you must do these things in + the Modified Version: + + A. Use in the Title Page (and on the covers, if any) a title + distinct from that of the Document, and from those of previous + versions (which should, if there were any, be listed in the + History section of the Document). You may use the same title + as a previous version if the original publisher of that + version gives permission. + + B. List on the Title Page, as authors, one or more persons or + entities responsible for authorship of the modifications in + the Modified Version, together with at least five of the + principal authors of the Document (all of its principal + authors, if it has fewer than five), unless they release you + from this requirement. + + C. State on the Title page the name of the publisher of the + Modified Version, as the publisher. + + D. Preserve all the copyright notices of the Document. + + E. Add an appropriate copyright notice for your modifications + adjacent to the other copyright notices. + + F. Include, immediately after the copyright notices, a license + notice giving the public permission to use the Modified + Version under the terms of this License, in the form shown in + the Addendum below. + + G. Preserve in that license notice the full lists of Invariant + Sections and required Cover Texts given in the Document's + license notice. + + H. Include an unaltered copy of this License. + + I. Preserve the section Entitled "History", Preserve its Title, + and add to it an item stating at least the title, year, new + authors, and publisher of the Modified Version as given on the + Title Page. If there is no section Entitled "History" in the + Document, create one stating the title, year, authors, and + publisher of the Document as given on its Title Page, then add + an item describing the Modified Version as stated in the + previous sentence. + + J. Preserve the network location, if any, given in the Document + for public access to a Transparent copy of the Document, and + likewise the network locations given in the Document for + previous versions it was based on. These may be placed in the + "History" section. You may omit a network location for a work + that was published at least four years before the Document + itself, or if the original publisher of the version it refers + to gives permission. + + K. For any section Entitled "Acknowledgements" or "Dedications", + Preserve the Title of the section, and preserve in the section + all the substance and tone of each of the contributor + acknowledgements and/or dedications given therein. + + L. Preserve all the Invariant Sections of the Document, unaltered + in their text and in their titles. Section numbers or the + equivalent are not considered part of the section titles. + + M. Delete any section Entitled "Endorsements". Such a section + may not be included in the Modified Version. + + N. Do not retitle any existing section to be Entitled + "Endorsements" or to conflict in title with any Invariant + Section. + + O. Preserve any Warranty Disclaimers. + + If the Modified Version includes new front-matter sections or + appendices that qualify as Secondary Sections and contain no + material copied from the Document, you may at your option designate + some or all of these sections as invariant. To do this, add their + titles to the list of Invariant Sections in the Modified Version's + license notice. These titles must be distinct from any other + section titles. + + You may add a section Entitled "Endorsements", provided it contains + nothing but endorsements of your Modified Version by various + parties--for example, statements of peer review or that the text + has been approved by an organization as the authoritative + definition of a standard. + + You may add a passage of up to five words as a Front-Cover Text, + and a passage of up to 25 words as a Back-Cover Text, to the end of + the list of Cover Texts in the Modified Version. Only one passage + of Front-Cover Text and one of Back-Cover Text may be added by (or + through arrangements made by) any one entity. If the Document + already includes a cover text for the same cover, previously added + by you or by arrangement made by the same entity you are acting on + behalf of, you may not add another; but you may replace the old + one, on explicit permission from the previous publisher that added + the old one. + + The author(s) and publisher(s) of the Document do not by this + License give permission to use their names for publicity for or to + assert or imply endorsement of any Modified Version. + + 5. COMBINING DOCUMENTS + + You may combine the Document with other documents released under + this License, under the terms defined in section 4 above for + modified versions, provided that you include in the combination all + of the Invariant Sections of all of the original documents, + unmodified, and list them all as Invariant Sections of your + combined work in its license notice, and that you preserve all + their Warranty Disclaimers. + + The combined work need only contain one copy of this License, and + multiple identical Invariant Sections may be replaced with a single + copy. If there are multiple Invariant Sections with the same name + but different contents, make the title of each such section unique + by adding at the end of it, in parentheses, the name of the + original author or publisher of that section if known, or else a + unique number. Make the same adjustment to the section titles in + the list of Invariant Sections in the license notice of the + combined work. + + In the combination, you must combine any sections Entitled + "History" in the various original documents, forming one section + Entitled "History"; likewise combine any sections Entitled + "Acknowledgements", and any sections Entitled "Dedications". You + must delete all sections Entitled "Endorsements." + + 6. COLLECTIONS OF DOCUMENTS + + You may make a collection consisting of the Document and other + documents released under this License, and replace the individual + copies of this License in the various documents with a single copy + that is included in the collection, provided that you follow the + rules of this License for verbatim copying of each of the documents + in all other respects. + + You may extract a single document from such a collection, and + distribute it individually under this License, provided you insert + a copy of this License into the extracted document, and follow this + License in all other respects regarding verbatim copying of that + document. + + 7. AGGREGATION WITH INDEPENDENT WORKS + + A compilation of the Document or its derivatives with other + separate and independent documents or works, in or on a volume of a + storage or distribution medium, is called an "aggregate" if the + copyright resulting from the compilation is not used to limit the + legal rights of the compilation's users beyond what the individual + works permit. When the Document is included in an aggregate, this + License does not apply to the other works in the aggregate which + are not themselves derivative works of the Document. + + If the Cover Text requirement of section 3 is applicable to these + copies of the Document, then if the Document is less than one half + of the entire aggregate, the Document's Cover Texts may be placed + on covers that bracket the Document within the aggregate, or the + electronic equivalent of covers if the Document is in electronic + form. Otherwise they must appear on printed covers that bracket + the whole aggregate. + + 8. TRANSLATION + + Translation is considered a kind of modification, so you may + distribute translations of the Document under the terms of section + 4. Replacing Invariant Sections with translations requires special + permission from their copyright holders, but you may include + translations of some or all Invariant Sections in addition to the + original versions of these Invariant Sections. You may include a + translation of this License, and all the license notices in the + Document, and any Warranty Disclaimers, provided that you also + include the original English version of this License and the + original versions of those notices and disclaimers. In case of a + disagreement between the translation and the original version of + this License or a notice or disclaimer, the original version will + prevail. + + If a section in the Document is Entitled "Acknowledgements", + "Dedications", or "History", the requirement (section 4) to + Preserve its Title (section 1) will typically require changing the + actual title. + + 9. TERMINATION + + You may not copy, modify, sublicense, or distribute the Document + except as expressly provided under this License. Any attempt + otherwise to copy, modify, sublicense, or distribute it is void, + and will automatically terminate your rights under this License. + + However, if you cease all violation of this License, then your + license from a particular copyright holder is reinstated (a) + provisionally, unless and until the copyright holder explicitly and + finally terminates your license, and (b) permanently, if the + copyright holder fails to notify you of the violation by some + reasonable means prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is + reinstated permanently if the copyright holder notifies you of the + violation by some reasonable means, this is the first time you have + received notice of violation of this License (for any work) from + that copyright holder, and you cure the violation prior to 30 days + after your receipt of the notice. + + Termination of your rights under this section does not terminate + the licenses of parties who have received copies or rights from you + under this License. If your rights have been terminated and not + permanently reinstated, receipt of a copy of some or all of the + same material does not give you any rights to use it. + + 10. FUTURE REVISIONS OF THIS LICENSE + + The Free Software Foundation may publish new, revised versions of + the GNU Free Documentation License from time to time. Such new + versions will be similar in spirit to the present version, but may + differ in detail to address new problems or concerns. See + <http://www.gnu.org/copyleft/>. + + Each version of the License is given a distinguishing version + number. If the Document specifies that a particular numbered + version of this License "or any later version" applies to it, you + have the option of following the terms and conditions either of + that specified version or of any later version that has been + published (not as a draft) by the Free Software Foundation. If the + Document does not specify a version number of this License, you may + choose any version ever published (not as a draft) by the Free + Software Foundation. If the Document specifies that a proxy can + decide which future versions of this License can be used, that + proxy's public statement of acceptance of a version permanently + authorizes you to choose that version for the Document. + + 11. RELICENSING + + "Massive Multiauthor Collaboration Site" (or "MMC Site") means any + World Wide Web server that publishes copyrightable works and also + provides prominent facilities for anybody to edit those works. A + public wiki that anybody can edit is an example of such a server. + A "Massive Multiauthor Collaboration" (or "MMC") contained in the + site means any set of copyrightable works thus published on the MMC + site. + + "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 + license published by Creative Commons Corporation, a not-for-profit + corporation with a principal place of business in San Francisco, + California, as well as future copyleft versions of that license + published by that same organization. + + "Incorporate" means to publish or republish a Document, in whole or + in part, as part of another Document. + + An MMC is "eligible for relicensing" if it is licensed under this + License, and if all works that were first published under this + License somewhere other than this MMC, and subsequently + incorporated in whole or in part into the MMC, (1) had no cover + texts or invariant sections, and (2) were thus incorporated prior + to November 1, 2008. + + The operator of an MMC Site may republish an MMC contained in the + site under CC-BY-SA on the same site at any time before August 1, + 2009, provided the MMC is eligible for relicensing. + +ADDENDUM: How to use this License for your documents +==================================================== + +To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and license +notices just after the title page: + + Copyright (C) YEAR YOUR NAME. + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.3 + or any later version published by the Free Software Foundation; + with no Invariant Sections, no Front-Cover Texts, and no Back-Cover + Texts. A copy of the license is included in the section entitled ``GNU + Free Documentation License''. + + If you have Invariant Sections, Front-Cover Texts and Back-Cover +Texts, replace the "with...Texts." line with this: + + with the Invariant Sections being LIST THEIR TITLES, with + the Front-Cover Texts being LIST, and with the Back-Cover Texts + being LIST. + + If you have Invariant Sections without Cover Texts, or some other +combination of the three, merge those two alternatives to suit the +situation. + + If your document contains nontrivial examples of program code, we +recommend releasing these examples in parallel under your choice of free +software license, such as the GNU General Public License, to permit +their use in free software. + + +File: bash.info, Node: Indexes, Prev: GNU Free Documentation License, Up: Top + +Appendix D Indexes +****************** + +* Menu: + +* Builtin Index:: Index of Bash builtin commands. +* Reserved Word Index:: Index of Bash reserved words. +* Variable Index:: Quick reference helps you find the + variable you want. +* Function Index:: Index of bindable Readline functions. +* Concept Index:: General index for concepts described in + this manual. + + +File: bash.info, Node: Builtin Index, Next: Reserved Word Index, Up: Indexes + +D.1 Index of Shell Builtin Commands +=================================== + + +* Menu: + +* .: Bourne Shell Builtins. + (line 17) +* :: Bourne Shell Builtins. + (line 11) +* [: Bourne Shell Builtins. + (line 269) +* alias: Bash Builtins. (line 11) +* bg: Job Control Builtins. + (line 7) +* bind: Bash Builtins. (line 21) +* break: Bourne Shell Builtins. + (line 36) +* builtin: Bash Builtins. (line 102) +* caller: Bash Builtins. (line 111) +* cd: Bourne Shell Builtins. + (line 44) +* command: Bash Builtins. (line 128) +* compgen: Programmable Completion Builtins. + (line 12) +* complete: Programmable Completion Builtins. + (line 30) +* compopt: Programmable Completion Builtins. + (line 237) +* continue: Bourne Shell Builtins. + (line 85) +* declare: Bash Builtins. (line 148) +* dirs: Directory Stack Builtins. + (line 7) +* disown: Job Control Builtins. + (line 92) +* echo: Bash Builtins. (line 246) +* enable: Bash Builtins. (line 295) +* eval: Bourne Shell Builtins. + (line 94) +* exec: Bourne Shell Builtins. + (line 102) +* exit: Bourne Shell Builtins. + (line 120) +* export: Bourne Shell Builtins. + (line 127) +* fc: Bash History Builtins. + (line 10) +* fg: Job Control Builtins. + (line 17) +* getopts: Bourne Shell Builtins. + (line 143) +* hash: Bourne Shell Builtins. + (line 186) +* help: Bash Builtins. (line 324) +* history: Bash History Builtins. + (line 40) +* jobs: Job Control Builtins. + (line 27) +* kill: Job Control Builtins. + (line 58) +* let: Bash Builtins. (line 343) +* local: Bash Builtins. (line 351) +* logout: Bash Builtins. (line 365) +* mapfile: Bash Builtins. (line 370) +* popd: Directory Stack Builtins. + (line 35) +* printf: Bash Builtins. (line 416) +* pushd: Directory Stack Builtins. + (line 53) +* pwd: Bourne Shell Builtins. + (line 206) +* read: Bash Builtins. (line 460) +* readarray: Bash Builtins. (line 554) +* readonly: Bourne Shell Builtins. + (line 216) +* return: Bourne Shell Builtins. + (line 235) +* set: The Set Builtin. (line 11) +* shift: Bourne Shell Builtins. + (line 256) +* shopt: The Shopt Builtin. (line 9) +* source: Bash Builtins. (line 563) +* suspend: Job Control Builtins. + (line 104) +* test: Bourne Shell Builtins. + (line 269) +* times: Bourne Shell Builtins. + (line 348) +* trap: Bourne Shell Builtins. + (line 354) +* type: Bash Builtins. (line 568) +* typeset: Bash Builtins. (line 600) +* ulimit: Bash Builtins. (line 606) +* umask: Bourne Shell Builtins. + (line 403) +* unalias: Bash Builtins. (line 705) +* unset: Bourne Shell Builtins. + (line 421) +* wait: Job Control Builtins. + (line 76) + + +File: bash.info, Node: Reserved Word Index, Next: Variable Index, Prev: Builtin Index, Up: Indexes + +D.2 Index of Shell Reserved Words +================================= + + +* Menu: + +* !: Pipelines. (line 9) +* [[: Conditional Constructs. + (line 124) +* ]]: Conditional Constructs. + (line 124) +* {: Command Grouping. (line 21) +* }: Command Grouping. (line 21) +* case: Conditional Constructs. + (line 28) +* do: Looping Constructs. (line 12) +* done: Looping Constructs. (line 12) +* elif: Conditional Constructs. + (line 7) +* else: Conditional Constructs. + (line 7) +* esac: Conditional Constructs. + (line 28) +* fi: Conditional Constructs. + (line 7) +* for: Looping Constructs. (line 32) +* function: Shell Functions. (line 13) +* if: Conditional Constructs. + (line 7) +* in: Conditional Constructs. + (line 28) +* select: Conditional Constructs. + (line 82) +* then: Conditional Constructs. + (line 7) +* time: Pipelines. (line 9) +* until: Looping Constructs. (line 12) +* while: Looping Constructs. (line 22) + + +File: bash.info, Node: Variable Index, Next: Function Index, Prev: Reserved Word Index, Up: Indexes + +D.3 Parameter and Variable Index +================================ + + +* Menu: + +* !: Special Parameters. (line 56) +* #: Special Parameters. (line 39) +* $: Special Parameters. (line 51) +* $!: Special Parameters. (line 57) +* $#: Special Parameters. (line 40) +* $$: Special Parameters. (line 52) +* $*: Special Parameters. (line 10) +* $-: Special Parameters. (line 47) +* $0: Special Parameters. (line 62) +* $?: Special Parameters. (line 43) +* $@: Special Parameters. (line 23) +* $_: Special Parameters. (line 71) +* *: Special Parameters. (line 9) +* -: Special Parameters. (line 46) +* 0: Special Parameters. (line 61) +* ?: Special Parameters. (line 42) +* @: Special Parameters. (line 22) +* _: Special Parameters. (line 70) +* auto_resume: Job Control Variables. + (line 6) +* BASH: Bash Variables. (line 13) +* BASHOPTS: Bash Variables. (line 16) +* BASHPID: Bash Variables. (line 25) +* BASH_ALIASES: Bash Variables. (line 32) +* BASH_ARGC: Bash Variables. (line 41) +* BASH_ARGV: Bash Variables. (line 54) +* BASH_ARGV0: Bash Variables. (line 66) +* BASH_CMDS: Bash Variables. (line 74) +* BASH_COMMAND: Bash Variables. (line 83) +* BASH_COMPAT: Bash Variables. (line 88) +* BASH_ENV: Bash Variables. (line 103) +* BASH_EXECUTION_STRING: Bash Variables. (line 109) +* BASH_LINENO: Bash Variables. (line 112) +* BASH_LOADABLES_PATH: Bash Variables. (line 120) +* BASH_REMATCH: Bash Variables. (line 124) +* BASH_SOURCE: Bash Variables. (line 132) +* BASH_SUBSHELL: Bash Variables. (line 139) +* BASH_VERSINFO: Bash Variables. (line 144) +* BASH_VERSION: Bash Variables. (line 167) +* BASH_XTRACEFD: Bash Variables. (line 170) +* bell-style: Readline Init File Syntax. + (line 38) +* bind-tty-special-chars: Readline Init File Syntax. + (line 45) +* blink-matching-paren: Readline Init File Syntax. + (line 50) +* CDPATH: Bourne Shell Variables. + (line 9) +* CHILD_MAX: Bash Variables. (line 181) +* colored-completion-prefix: Readline Init File Syntax. + (line 55) +* colored-stats: Readline Init File Syntax. + (line 62) +* COLUMNS: Bash Variables. (line 188) +* comment-begin: Readline Init File Syntax. + (line 68) +* completion-display-width: Readline Init File Syntax. + (line 73) +* completion-ignore-case: Readline Init File Syntax. + (line 80) +* completion-map-case: Readline Init File Syntax. + (line 85) +* completion-prefix-display-length: Readline Init File Syntax. + (line 91) +* completion-query-items: Readline Init File Syntax. + (line 98) +* COMPREPLY: Bash Variables. (line 240) +* COMP_CWORD: Bash Variables. (line 194) +* COMP_KEY: Bash Variables. (line 223) +* COMP_LINE: Bash Variables. (line 200) +* COMP_POINT: Bash Variables. (line 205) +* COMP_TYPE: Bash Variables. (line 213) +* COMP_WORDBREAKS: Bash Variables. (line 227) +* COMP_WORDS: Bash Variables. (line 233) +* convert-meta: Readline Init File Syntax. + (line 108) +* COPROC: Bash Variables. (line 246) +* DIRSTACK: Bash Variables. (line 250) +* disable-completion: Readline Init File Syntax. + (line 116) +* echo-control-characters: Readline Init File Syntax. + (line 121) +* editing-mode: Readline Init File Syntax. + (line 126) +* EMACS: Bash Variables. (line 260) +* emacs-mode-string: Readline Init File Syntax. + (line 132) +* enable-bracketed-paste: Readline Init File Syntax. + (line 142) +* enable-keypad: Readline Init File Syntax. + (line 150) +* ENV: Bash Variables. (line 265) +* EPOCHREALTIME: Bash Variables. (line 269) +* EPOCHSECONDS: Bash Variables. (line 277) +* EUID: Bash Variables. (line 284) +* EXECIGNORE: Bash Variables. (line 288) +* expand-tilde: Readline Init File Syntax. + (line 161) +* FCEDIT: Bash Variables. (line 301) +* FIGNORE: Bash Variables. (line 305) +* FUNCNAME: Bash Variables. (line 311) +* FUNCNEST: Bash Variables. (line 328) +* GLOBIGNORE: Bash Variables. (line 333) +* GROUPS: Bash Variables. (line 340) +* histchars: Bash Variables. (line 346) +* HISTCMD: Bash Variables. (line 361) +* HISTCONTROL: Bash Variables. (line 366) +* HISTFILE: Bash Variables. (line 382) +* HISTFILESIZE: Bash Variables. (line 386) +* HISTIGNORE: Bash Variables. (line 397) +* history-preserve-point: Readline Init File Syntax. + (line 165) +* history-size: Readline Init File Syntax. + (line 171) +* HISTSIZE: Bash Variables. (line 417) +* HISTTIMEFORMAT: Bash Variables. (line 424) +* HOME: Bourne Shell Variables. + (line 13) +* horizontal-scroll-mode: Readline Init File Syntax. + (line 180) +* HOSTFILE: Bash Variables. (line 432) +* HOSTNAME: Bash Variables. (line 443) +* HOSTTYPE: Bash Variables. (line 446) +* IFS: Bourne Shell Variables. + (line 18) +* IGNOREEOF: Bash Variables. (line 449) +* input-meta: Readline Init File Syntax. + (line 187) +* INPUTRC: Bash Variables. (line 459) +* INSIDE_EMACS: Bash Variables. (line 463) +* isearch-terminators: Readline Init File Syntax. + (line 195) +* keymap: Readline Init File Syntax. + (line 202) +* LANG: Bash Variables. (line 469) +* LC_ALL: Bash Variables. (line 473) +* LC_COLLATE: Bash Variables. (line 477) +* LC_CTYPE: Bash Variables. (line 484) +* LC_MESSAGES: Locale Translation. (line 11) +* LC_MESSAGES <1>: Bash Variables. (line 489) +* LC_NUMERIC: Bash Variables. (line 493) +* LC_TIME: Bash Variables. (line 497) +* LINENO: Bash Variables. (line 501) +* LINES: Bash Variables. (line 505) +* MACHTYPE: Bash Variables. (line 511) +* MAIL: Bourne Shell Variables. + (line 22) +* MAILCHECK: Bash Variables. (line 515) +* MAILPATH: Bourne Shell Variables. + (line 27) +* MAPFILE: Bash Variables. (line 523) +* mark-modified-lines: Readline Init File Syntax. + (line 232) +* mark-symlinked-directories: Readline Init File Syntax. + (line 237) +* match-hidden-files: Readline Init File Syntax. + (line 242) +* menu-complete-display-prefix: Readline Init File Syntax. + (line 249) +* meta-flag: Readline Init File Syntax. + (line 187) +* OLDPWD: Bash Variables. (line 527) +* OPTARG: Bourne Shell Variables. + (line 34) +* OPTERR: Bash Variables. (line 530) +* OPTIND: Bourne Shell Variables. + (line 38) +* OSTYPE: Bash Variables. (line 534) +* output-meta: Readline Init File Syntax. + (line 254) +* page-completions: Readline Init File Syntax. + (line 260) +* PATH: Bourne Shell Variables. + (line 42) +* PIPESTATUS: Bash Variables. (line 537) +* POSIXLY_CORRECT: Bash Variables. (line 542) +* PPID: Bash Variables. (line 552) +* PROMPT_COMMAND: Bash Variables. (line 556) +* PROMPT_DIRTRIM: Bash Variables. (line 560) +* PS0: Bash Variables. (line 566) +* PS1: Bourne Shell Variables. + (line 48) +* PS2: Bourne Shell Variables. + (line 53) +* PS3: Bash Variables. (line 571) +* PS4: Bash Variables. (line 576) +* PWD: Bash Variables. (line 584) +* RANDOM: Bash Variables. (line 587) +* READLINE_LINE: Bash Variables. (line 592) +* READLINE_POINT: Bash Variables. (line 596) +* REPLY: Bash Variables. (line 600) +* revert-all-at-newline: Readline Init File Syntax. + (line 270) +* SECONDS: Bash Variables. (line 603) +* SHELL: Bash Variables. (line 609) +* SHELLOPTS: Bash Variables. (line 614) +* SHLVL: Bash Variables. (line 623) +* show-all-if-ambiguous: Readline Init File Syntax. + (line 276) +* show-all-if-unmodified: Readline Init File Syntax. + (line 282) +* show-mode-in-prompt: Readline Init File Syntax. + (line 291) +* skip-completed-text: Readline Init File Syntax. + (line 297) +* TEXTDOMAIN: Locale Translation. (line 11) +* TEXTDOMAINDIR: Locale Translation. (line 11) +* TIMEFORMAT: Bash Variables. (line 628) +* TMOUT: Bash Variables. (line 666) +* TMPDIR: Bash Variables. (line 678) +* UID: Bash Variables. (line 682) +* vi-cmd-mode-string: Readline Init File Syntax. + (line 310) +* vi-ins-mode-string: Readline Init File Syntax. + (line 321) +* visible-stats: Readline Init File Syntax. + (line 332) + + +File: bash.info, Node: Function Index, Next: Concept Index, Prev: Variable Index, Up: Indexes + +D.4 Function Index +================== + + +* Menu: + +* abort (C-g): Miscellaneous Commands. + (line 10) +* accept-line (Newline or Return): Commands For History. + (line 6) +* alias-expand-line (): Miscellaneous Commands. + (line 125) +* backward-char (C-b): Commands For Moving. (line 15) +* backward-delete-char (Rubout): Commands For Text. (line 17) +* backward-kill-line (C-x Rubout): Commands For Killing. + (line 9) +* backward-kill-word (M-<DEL>): Commands For Killing. + (line 24) +* backward-word (M-b): Commands For Moving. (line 22) +* beginning-of-history (M-<): Commands For History. + (line 20) +* beginning-of-line (C-a): Commands For Moving. (line 6) +* bracketed-paste-begin (): Commands For Text. (line 33) +* call-last-kbd-macro (C-x e): Keyboard Macros. (line 13) +* capitalize-word (M-c): Commands For Text. (line 61) +* character-search (C-]): Miscellaneous Commands. + (line 42) +* character-search-backward (M-C-]): Miscellaneous Commands. + (line 47) +* clear-screen (C-l): Commands For Moving. (line 48) +* complete (<TAB>): Commands For Completion. + (line 6) +* complete-command (M-!): Commands For Completion. + (line 80) +* complete-filename (M-/): Commands For Completion. + (line 49) +* complete-hostname (M-@): Commands For Completion. + (line 72) +* complete-into-braces (M-{): Commands For Completion. + (line 100) +* complete-username (M-~): Commands For Completion. + (line 56) +* complete-variable (M-$): Commands For Completion. + (line 64) +* copy-backward-word (): Commands For Killing. + (line 58) +* copy-forward-word (): Commands For Killing. + (line 63) +* copy-region-as-kill (): Commands For Killing. + (line 54) +* dabbrev-expand (): Commands For Completion. + (line 95) +* delete-char (C-d): Commands For Text. (line 12) +* delete-char-or-list (): Commands For Completion. + (line 43) +* delete-horizontal-space (): Commands For Killing. + (line 46) +* digit-argument (M-0, M-1, ... M--): Numeric Arguments. (line 6) +* display-shell-version (C-x C-v): Miscellaneous Commands. + (line 110) +* do-lowercase-version (M-A, M-B, M-X, ...): Miscellaneous Commands. + (line 14) +* downcase-word (M-l): Commands For Text. (line 57) +* dump-functions (): Miscellaneous Commands. + (line 74) +* dump-macros (): Miscellaneous Commands. + (line 86) +* dump-variables (): Miscellaneous Commands. + (line 80) +* dynamic-complete-history (M-<TAB>): Commands For Completion. + (line 90) +* edit-and-execute-command (C-x C-e): Miscellaneous Commands. + (line 140) +* end-kbd-macro (C-x )): Keyboard Macros. (line 9) +* end-of-file (usually C-d): Commands For Text. (line 6) +* end-of-history (M->): Commands For History. + (line 23) +* end-of-line (C-e): Commands For Moving. (line 9) +* exchange-point-and-mark (C-x C-x): Miscellaneous Commands. + (line 37) +* forward-backward-delete-char (): Commands For Text. (line 21) +* forward-char (C-f): Commands For Moving. (line 12) +* forward-search-history (C-s): Commands For History. + (line 31) +* forward-word (M-f): Commands For Moving. (line 18) +* glob-complete-word (M-g): Miscellaneous Commands. + (line 92) +* glob-expand-word (C-x *): Miscellaneous Commands. + (line 98) +* glob-list-expansions (C-x g): Miscellaneous Commands. + (line 104) +* history-and-alias-expand-line (): Miscellaneous Commands. + (line 128) +* history-expand-line (M-^): Miscellaneous Commands. + (line 118) +* history-search-backward (): Commands For History. + (line 53) +* history-search-forward (): Commands For History. + (line 47) +* history-substring-search-backward (): Commands For History. + (line 65) +* history-substring-search-forward (): Commands For History. + (line 59) +* insert-comment (M-#): Miscellaneous Commands. + (line 61) +* insert-completions (M-*): Commands For Completion. + (line 22) +* insert-last-argument (M-. or M-_): Miscellaneous Commands. + (line 131) +* kill-line (C-k): Commands For Killing. + (line 6) +* kill-region (): Commands For Killing. + (line 50) +* kill-whole-line (): Commands For Killing. + (line 15) +* kill-word (M-d): Commands For Killing. + (line 19) +* magic-space (): Miscellaneous Commands. + (line 121) +* menu-complete (): Commands For Completion. + (line 26) +* menu-complete-backward (): Commands For Completion. + (line 38) +* next-history (C-n): Commands For History. + (line 17) +* next-screen-line (): Commands For Moving. (line 41) +* non-incremental-forward-search-history (M-n): Commands For History. + (line 41) +* non-incremental-reverse-search-history (M-p): Commands For History. + (line 35) +* operate-and-get-next (C-o): Miscellaneous Commands. + (line 134) +* overwrite-mode (): Commands For Text. (line 65) +* possible-command-completions (C-x !): Commands For Completion. + (line 86) +* possible-completions (M-?): Commands For Completion. + (line 15) +* possible-filename-completions (C-x /): Commands For Completion. + (line 52) +* possible-hostname-completions (C-x @): Commands For Completion. + (line 76) +* possible-username-completions (C-x ~): Commands For Completion. + (line 60) +* possible-variable-completions (C-x $): Commands For Completion. + (line 68) +* prefix-meta (<ESC>): Miscellaneous Commands. + (line 19) +* previous-history (C-p): Commands For History. + (line 13) +* previous-screen-line (): Commands For Moving. (line 34) +* print-last-kbd-macro (): Keyboard Macros. (line 17) +* quoted-insert (C-q or C-v): Commands For Text. (line 26) +* re-read-init-file (C-x C-r): Miscellaneous Commands. + (line 6) +* redraw-current-line (): Commands For Moving. (line 52) +* reverse-search-history (C-r): Commands For History. + (line 27) +* revert-line (M-r): Miscellaneous Commands. + (line 26) +* self-insert (a, b, A, 1, !, ...): Commands For Text. (line 30) +* set-mark (C-@): Miscellaneous Commands. + (line 33) +* shell-backward-kill-word (): Commands For Killing. + (line 33) +* shell-backward-word (): Commands For Moving. (line 30) +* shell-expand-line (M-C-e): Miscellaneous Commands. + (line 113) +* shell-forward-word (): Commands For Moving. (line 26) +* shell-kill-word (): Commands For Killing. + (line 28) +* skip-csi-sequence (): Miscellaneous Commands. + (line 52) +* start-kbd-macro (C-x (): Keyboard Macros. (line 6) +* tilde-expand (M-&): Miscellaneous Commands. + (line 30) +* transpose-chars (C-t): Commands For Text. (line 42) +* transpose-words (M-t): Commands For Text. (line 48) +* undo (C-_ or C-x C-u): Miscellaneous Commands. + (line 23) +* universal-argument (): Numeric Arguments. (line 10) +* unix-filename-rubout (): Commands For Killing. + (line 41) +* unix-line-discard (C-u): Commands For Killing. + (line 12) +* unix-word-rubout (C-w): Commands For Killing. + (line 37) +* upcase-word (M-u): Commands For Text. (line 53) +* yank (C-y): Commands For Killing. + (line 68) +* yank-last-arg (M-. or M-_): Commands For History. + (line 80) +* yank-nth-arg (M-C-y): Commands For History. + (line 71) +* yank-pop (M-y): Commands For Killing. + (line 71) + + +File: bash.info, Node: Concept Index, Prev: Function Index, Up: Indexes + +D.5 Concept Index +================= + + +* Menu: + +* alias expansion: Aliases. (line 6) +* arithmetic evaluation: Shell Arithmetic. (line 6) +* arithmetic expansion: Arithmetic Expansion. + (line 6) +* arithmetic, shell: Shell Arithmetic. (line 6) +* arrays: Arrays. (line 6) +* background: Job Control Basics. (line 6) +* Bash configuration: Basic Installation. (line 6) +* Bash installation: Basic Installation. (line 6) +* Bourne shell: Basic Shell Features. + (line 6) +* brace expansion: Brace Expansion. (line 6) +* builtin: Definitions. (line 17) +* command editing: Readline Bare Essentials. + (line 6) +* command execution: Command Search and Execution. + (line 6) +* command expansion: Simple Command Expansion. + (line 6) +* command history: Bash History Facilities. + (line 6) +* command search: Command Search and Execution. + (line 6) +* command substitution: Command Substitution. + (line 6) +* command timing: Pipelines. (line 9) +* commands, compound: Compound Commands. (line 6) +* commands, conditional: Conditional Constructs. + (line 6) +* commands, grouping: Command Grouping. (line 6) +* commands, lists: Lists. (line 6) +* commands, looping: Looping Constructs. (line 6) +* commands, pipelines: Pipelines. (line 6) +* commands, shell: Shell Commands. (line 6) +* commands, simple: Simple Commands. (line 6) +* comments, shell: Comments. (line 6) +* completion builtins: Programmable Completion Builtins. + (line 6) +* configuration: Basic Installation. (line 6) +* control operator: Definitions. (line 21) +* coprocess: Coprocesses. (line 6) +* directory stack: The Directory Stack. (line 6) +* editing command lines: Readline Bare Essentials. + (line 6) +* environment: Environment. (line 6) +* evaluation, arithmetic: Shell Arithmetic. (line 6) +* event designators: Event Designators. (line 6) +* execution environment: Command Execution Environment. + (line 6) +* exit status: Definitions. (line 26) +* exit status <1>: Exit Status. (line 6) +* expansion: Shell Expansions. (line 6) +* expansion, arithmetic: Arithmetic Expansion. + (line 6) +* expansion, brace: Brace Expansion. (line 6) +* expansion, filename: Filename Expansion. (line 9) +* expansion, parameter: Shell Parameter Expansion. + (line 6) +* expansion, pathname: Filename Expansion. (line 9) +* expansion, tilde: Tilde Expansion. (line 6) +* expressions, arithmetic: Shell Arithmetic. (line 6) +* expressions, conditional: Bash Conditional Expressions. + (line 6) +* field: Definitions. (line 30) +* filename: Definitions. (line 35) +* filename expansion: Filename Expansion. (line 9) +* foreground: Job Control Basics. (line 6) +* functions, shell: Shell Functions. (line 6) +* history builtins: Bash History Builtins. + (line 6) +* history events: Event Designators. (line 8) +* history expansion: History Interaction. (line 6) +* history list: Bash History Facilities. + (line 6) +* History, how to use: A Programmable Completion Example. + (line 113) +* identifier: Definitions. (line 51) +* initialization file, readline: Readline Init File. (line 6) +* installation: Basic Installation. (line 6) +* interaction, readline: Readline Interaction. + (line 6) +* interactive shell: Invoking Bash. (line 131) +* interactive shell <1>: Interactive Shells. (line 6) +* internationalization: Locale Translation. (line 6) +* job: Definitions. (line 38) +* job control: Definitions. (line 42) +* job control <1>: Job Control Basics. (line 6) +* kill ring: Readline Killing Commands. + (line 18) +* killing text: Readline Killing Commands. + (line 6) +* localization: Locale Translation. (line 6) +* login shell: Invoking Bash. (line 128) +* matching, pattern: Pattern Matching. (line 6) +* metacharacter: Definitions. (line 46) +* name: Definitions. (line 51) +* native languages: Locale Translation. (line 6) +* notation, readline: Readline Bare Essentials. + (line 6) +* operator, shell: Definitions. (line 57) +* parameter expansion: Shell Parameter Expansion. + (line 6) +* parameters: Shell Parameters. (line 6) +* parameters, positional: Positional Parameters. + (line 6) +* parameters, special: Special Parameters. (line 6) +* pathname expansion: Filename Expansion. (line 9) +* pattern matching: Pattern Matching. (line 6) +* pipeline: Pipelines. (line 6) +* POSIX: Definitions. (line 9) +* POSIX Mode: Bash POSIX Mode. (line 6) +* process group: Definitions. (line 62) +* process group ID: Definitions. (line 66) +* process substitution: Process Substitution. + (line 6) +* programmable completion: Programmable Completion. + (line 6) +* prompting: Controlling the Prompt. + (line 6) +* quoting: Quoting. (line 6) +* quoting, ANSI: ANSI-C Quoting. (line 6) +* Readline, how to use: Job Control Variables. + (line 23) +* redirection: Redirections. (line 6) +* reserved word: Definitions. (line 70) +* restricted shell: The Restricted Shell. + (line 6) +* return status: Definitions. (line 75) +* shell arithmetic: Shell Arithmetic. (line 6) +* shell function: Shell Functions. (line 6) +* shell script: Shell Scripts. (line 6) +* shell variable: Shell Parameters. (line 6) +* shell, interactive: Interactive Shells. (line 6) +* signal: Definitions. (line 78) +* signal handling: Signals. (line 6) +* special builtin: Definitions. (line 82) +* special builtin <1>: Special Builtins. (line 6) +* startup files: Bash Startup Files. (line 6) +* suspending jobs: Job Control Basics. (line 6) +* tilde expansion: Tilde Expansion. (line 6) +* token: Definitions. (line 86) +* translation, native languages: Locale Translation. (line 6) +* variable, shell: Shell Parameters. (line 6) +* variables, readline: Readline Init File Syntax. + (line 37) +* word: Definitions. (line 90) +* word splitting: Word Splitting. (line 6) +* yanking text: Readline Killing Commands. + (line 6) + + + +Tag Table: +Node: Top895 +Node: Introduction2813 +Node: What is Bash?3029 +Node: What is a shell?4143 +Node: Definitions6681 +Node: Basic Shell Features9632 +Node: Shell Syntax10851 +Node: Shell Operation11877 +Node: Quoting13170 +Node: Escape Character14470 +Node: Single Quotes14955 +Node: Double Quotes15303 +Node: ANSI-C Quoting16581 +Node: Locale Translation17840 +Node: Comments18736 +Node: Shell Commands19354 +Node: Simple Commands20226 +Node: Pipelines20857 +Node: Lists23789 +Node: Compound Commands25580 +Node: Looping Constructs26592 +Node: Conditional Constructs29087 +Node: Command Grouping40170 +Node: Coprocesses41649 +Node: GNU Parallel43552 +Node: Shell Functions47610 +Node: Shell Parameters54693 +Node: Positional Parameters59106 +Node: Special Parameters60006 +Node: Shell Expansions63760 +Node: Brace Expansion65883 +Node: Tilde Expansion68607 +Node: Shell Parameter Expansion71224 +Node: Command Substitution85680 +Node: Arithmetic Expansion87035 +Node: Process Substitution87967 +Node: Word Splitting89087 +Node: Filename Expansion91031 +Node: Pattern Matching93561 +Node: Quote Removal97547 +Node: Redirections97842 +Node: Executing Commands107400 +Node: Simple Command Expansion108070 +Node: Command Search and Execution110000 +Node: Command Execution Environment112376 +Node: Environment115360 +Node: Exit Status117019 +Node: Signals118689 +Node: Shell Scripts120656 +Node: Shell Builtin Commands123171 +Node: Bourne Shell Builtins125209 +Node: Bash Builtins145959 +Node: Modifying Shell Behavior174884 +Node: The Set Builtin175229 +Node: The Shopt Builtin185642 +Node: Special Builtins203284 +Node: Shell Variables204263 +Node: Bourne Shell Variables204700 +Node: Bash Variables206804 +Node: Bash Features237264 +Node: Invoking Bash238163 +Node: Bash Startup Files244176 +Node: Interactive Shells249279 +Node: What is an Interactive Shell?249689 +Node: Is this Shell Interactive?250338 +Node: Interactive Shell Behavior251153 +Node: Bash Conditional Expressions254640 +Node: Shell Arithmetic259217 +Node: Aliases262034 +Node: Arrays264654 +Node: The Directory Stack270020 +Node: Directory Stack Builtins270804 +Node: Controlling the Prompt273772 +Node: The Restricted Shell276538 +Node: Bash POSIX Mode278363 +Node: Job Control289296 +Node: Job Control Basics289756 +Node: Job Control Builtins294724 +Node: Job Control Variables299451 +Node: Command Line Editing300607 +Node: Introduction and Notation302278 +Node: Readline Interaction303901 +Node: Readline Bare Essentials305092 +Node: Readline Movement Commands306875 +Node: Readline Killing Commands307835 +Node: Readline Arguments309753 +Node: Searching310797 +Node: Readline Init File312983 +Node: Readline Init File Syntax314130 +Node: Conditional Init Constructs334569 +Node: Sample Init File338765 +Node: Bindable Readline Commands341882 +Node: Commands For Moving343086 +Node: Commands For History344935 +Node: Commands For Text349230 +Node: Commands For Killing352618 +Node: Numeric Arguments355099 +Node: Commands For Completion356238 +Node: Keyboard Macros360429 +Node: Miscellaneous Commands361116 +Node: Readline vi Mode367069 +Node: Programmable Completion367976 +Node: Programmable Completion Builtins375756 +Node: A Programmable Completion Example386449 +Node: Using History Interactively391689 +Node: Bash History Facilities392373 +Node: Bash History Builtins395378 +Node: History Interaction399909 +Node: Event Designators403529 +Node: Word Designators404748 +Node: Modifiers406385 +Node: Installing Bash407787 +Node: Basic Installation408924 +Node: Compilers and Options412182 +Node: Compiling For Multiple Architectures412923 +Node: Installation Names414616 +Node: Specifying the System Type415434 +Node: Sharing Defaults416150 +Node: Operation Controls416823 +Node: Optional Features417781 +Node: Reporting Bugs428299 +Node: Major Differences From The Bourne Shell429493 +Node: GNU Free Documentation License446345 +Node: Indexes471522 +Node: Builtin Index471976 +Node: Reserved Word Index478803 +Node: Variable Index481251 +Node: Function Index497002 +Node: Concept Index510305 + +End Tag Table |