10348 lines
432 KiB
Text
10348 lines
432 KiB
Text
This is bashref.info, produced by makeinfo version 4.13 from
|
||
/Users/chet/src/bash/src/doc/bashref.texi.
|
||
|
||
This text is a brief description of the features that are present in
|
||
the Bash shell (version 4.1, 23 December 2009).
|
||
|
||
This is Edition 4.1, last updated 23 December 2009, of `The GNU Bash
|
||
Reference Manual', for `Bash', Version 4.1.
|
||
|
||
Copyright (C) 1988-2009 Free Software Foundation, Inc.
|
||
|
||
Permission is granted to make and distribute verbatim copies of this
|
||
manual provided the copyright notice and this permission notice are
|
||
preserved on all copies.
|
||
|
||
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, with the Front-Cover texts
|
||
being "A GNU Manual", and with the Back-Cover Texts as in (a)
|
||
below. A copy of the license is included in the section entitled
|
||
"GNU Free Documentation License".
|
||
|
||
(a) The FSF's Back-Cover Text is: You are free to copy and modify
|
||
this GNU manual. Buying copies from GNU Press supports the FSF in
|
||
developing GNU and promoting software freedom."
|
||
|
||
|
||
INFO-DIR-SECTION Basics
|
||
START-INFO-DIR-ENTRY
|
||
* Bash: (bash). The GNU Bourne-Again SHell.
|
||
END-INFO-DIR-ENTRY
|
||
|
||
|
||
File: bashref.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 4.1, 23 December 2009).
|
||
|
||
This is Edition 4.1, last updated 23 December 2009, of `The GNU Bash
|
||
Reference Manual', for `Bash', Version 4.1.
|
||
|
||
Bash contains features that appear in other popular shells, and some
|
||
features that only appear in Bash. Some of the shells that Bash has
|
||
borrowed concepts from are the Bourne Shell (`sh'), the Korn Shell
|
||
(`ksh'), and the C-shell (`csh' and its successor, `tcsh'). The
|
||
following menu breaks the features up into categories based upon which
|
||
one of these other shells inspired the feature.
|
||
|
||
This manual is meant as a brief introduction to features found in
|
||
Bash. The Bash manual page should be used as the definitive reference
|
||
on shell behavior.
|
||
|
||
* 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: bashref.info, Node: Introduction, Next: Definitions, Prev: Top, Up: Top
|
||
|
||
1 Introduction
|
||
**************
|
||
|
||
* Menu:
|
||
|
||
* What is Bash?:: A short description of Bash.
|
||
* What is a shell?:: A brief introduction to shells.
|
||
|
||
|
||
File: bashref.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: bashref.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: bashref.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 `blank' 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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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, `!'. 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: bashref.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
|
||
|
||
`\NNN'
|
||
the eight-bit character whose value is the octal value NNN (one to
|
||
three digits)
|
||
|
||
`\xHH'
|
||
the eight-bit character whose value is the hexadecimal value HH
|
||
(one or two hex digits)
|
||
|
||
`\cX'
|
||
a control-X character
|
||
|
||
The expanded result is single-quoted, as if the dollar sign had not
|
||
been present.
|
||
|
||
|
||
File: bashref.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: bashref.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: bashref.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.
|
||
|
||
|
||
File: bashref.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: bashref.info, Node: Pipelines, Next: Lists, Prev: Simple Commands, Up: Shell Commands
|
||
|
||
3.2.2 Pipelines
|
||
---------------
|
||
|
||
A `pipeline' is a sequence of simple 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, the standard error of COMMAND1 is connected to
|
||
COMMAND2's standard input through the pipe; it is shorthand for `2>&1
|
||
|'. This implicit redirection of the standard error 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. 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.
|
||
|
||
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 (*note
|
||
Command Execution Environment::). 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: bashref.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. 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.
|
||
|
||
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: bashref.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 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.
|
||
|
||
Bash provides looping constructs, conditional commands, and
|
||
mechanisms to group commands and execute them as a unit.
|
||
|
||
|
||
File: bashref.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, 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 LIST 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: bashref.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. If the shell option
|
||
`nocasematch' (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 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.
|
||
|
||
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::. If the
|
||
shell option `nocasematch' (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 it to be matched as a string.
|
||
|
||
An additional binary operator, `=~', is available, with the same
|
||
precedence as `==' and `!='. When it is used, the string to the
|
||
right of the operator is considered an 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 shell option `nocasematch'
|
||
(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 it 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.
|
||
|
||
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: bashref.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: bashref.info, Node: Coprocesses, 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 coproc 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.
|
||
|
||
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.
|
||
|
||
The return status of a coprocess is the exit status of COMMAND.
|
||
|
||
|
||
File: bashref.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:
|
||
[ `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. COMPOUND-COMMAND is executed whenever NAME is
|
||
specified as the name of a command. 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.
|
||
|
||
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.
|
||
|
||
Function names and definitions may be listed with the `-f' option to
|
||
the `declare' or `typeset' builtin commands (*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::). Note that shell functions and
|
||
variables with the same name may result in multiple identically-named
|
||
entries in the environment passed to the shell's children. Care should
|
||
be taken in cases where this may cause a problem.
|
||
|
||
Functions may be recursive. No limit is placed on the number of
|
||
recursive calls.
|
||
|
||
|
||
File: bashref.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.
|
||
|
||
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. 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.
|
||
|
||
|
||
File: bashref.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: bashref.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 occurs within double quotes, it expands to a single word
|
||
with the value of each parameter separated by the first character
|
||
of the `IFS' special variable. That is, `"$*"' is equivalent to
|
||
`"$1C$2C..."', where C is the first character of the value of the
|
||
`IFS' variable. If `IFS' is unset, the parameters are separated
|
||
by spaces. If `IFS' is null, the parameters are joined without
|
||
intervening separators.
|
||
|
||
`@'
|
||
Expands to the positional parameters, starting from one. When the
|
||
expansion occurs within double quotes, each parameter expands to a
|
||
separate word. That is, `"$@"' is equivalent to `"$1" "$2" ...'.
|
||
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 most recently executed background
|
||
(asynchronous) command.
|
||
|
||
`0'
|
||
Expands to the name of the shell or shell script. This is set at
|
||
shell initialization. If Bash is invoked with a file of commands
|
||
(*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 command, 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: bashref.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, variable, and 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
|
||
parameter, variable, and arithmetic expansion and command substitution.
|
||
|
||
Only brace expansion, word splitting, and filename expansion can
|
||
change the number of words of the expansion; other expansions expand a
|
||
single word to a single word. The only exceptions to this are the
|
||
expansions of `"$@"' (*note Special Parameters::) and `"${NAME[@]}"'
|
||
(*note Arrays::).
|
||
|
||
After all expansions, `quote removal' (*note Quote Removal::) is
|
||
performed.
|
||
|
||
|
||
File: bashref.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 file names generated need not exist.
|
||
Patterns to be brace expanded take the form of an optional PREAMBLE,
|
||
followed by either a series of comma-separated strings or a seqeunce
|
||
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. 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. To
|
||
avoid conflicts with parameter expansion, the string `${' is not
|
||
considered eligible for brace expansion.
|
||
|
||
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.
|
||
|
||
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: bashref.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 file names 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'
|
||
|
||
|
||
|
||
File: bashref.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 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 (!), a
|
||
level of variable indirection is introduced. Bash uses the value of
|
||
the variable formed from the rest of PARAMETER as the name of the
|
||
variable; this variable is then expanded and that value is used in the
|
||
rest of the substitution, rather than the value of PARAMETER itself.
|
||
This is known as `indirect expansion'. The 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, 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}'
|
||
Expands to up to LENGTH characters of PARAMETER starting at the
|
||
character specified by OFFSET. If LENGTH is omitted, expands to
|
||
the substring of PARAMETER starting at the character specified by
|
||
OFFSET. LENGTH and OFFSET are arithmetic expressions (*note Shell
|
||
Arithmetic::). This is referred to as Substring Expansion.
|
||
|
||
LENGTH must evaluate to a number greater than or equal to zero.
|
||
If OFFSET evaluates to a number less than zero, the value is used
|
||
as an offset from the end of the value of PARAMETER. If PARAMETER
|
||
is `@', the result is LENGTH positional parameters beginning at
|
||
OFFSET. If PARAMETER is an 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.
|
||
Substring expansion applied to an associative array produces
|
||
undefined results.
|
||
|
||
Note that a negative offset must be separated from the colon by at
|
||
least one space to avoid being confused with the `:-' expansion.
|
||
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.
|
||
|
||
`${PARAMETER#WORD}'
|
||
`${PARAMETER##WORD}'
|
||
The WORD is expanded to produce a pattern just as in filename
|
||
expansion (*note Filename Expansion::). 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 just as in filename
|
||
expansion. 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. 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 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. 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.
|
||
|
||
|
||
|
||
File: bashref.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 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: bashref.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 expansion, command
|
||
substitution, and quote removal. 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: bashref.info, Node: Process Substitution, Next: Word Splitting, Prev: Arithmetic Expansion, Up: Shell Expansions
|
||
|
||
3.5.6 Process Substitution
|
||
--------------------------
|
||
|
||
Process substitution is supported on systems that support named pipes
|
||
(FIFOs) or the `/dev/fd' method of naming open files. It takes the
|
||
form of
|
||
<(LIST)
|
||
or
|
||
>(LIST)
|
||
The process LIST is run with its input or output connected to a FIFO
|
||
or some file in `/dev/fd'. The name of this file is passed as an
|
||
argument to the current command as the result of the expansion. If the
|
||
`>(LIST)' form is used, writing to the file will provide input for
|
||
LIST. If the `<(LIST)' form is used, the file passed as an argument
|
||
should be read to obtain the output of LIST. Note that no space may
|
||
appear between the `<' or `>' and the left parenthesis, otherwise the
|
||
construct would be interpreted as a redirection.
|
||
|
||
When available, process substitution is performed simultaneously with
|
||
parameter and variable expansion, command substitution, and arithmetic
|
||
expansion.
|
||
|
||
|
||
File: bashref.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 on these characters. 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' and `tab'
|
||
are ignored at the beginning and end of the word, as long as the
|
||
whitespace character is in the value of `IFS' (an `IFS' whitespace
|
||
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. Unquoted
|
||
implicit null arguments, resulting from the expansion of parameters
|
||
that have no values, are removed. If a parameter with no value is
|
||
expanded within double quotes, a null argument results and is retained.
|
||
|
||
Note that if no expansion occurs, no splitting is performed.
|
||
|
||
|
||
File: bashref.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 file
|
||
names matching the pattern. If no matching file names are found, and
|
||
the shell option `nullglob' is disabled, the word is left unchanged.
|
||
If the `nullglob' option is set, and no matches are found, the word is
|
||
removed. If the `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. When
|
||
matching a file name, the slash character must always be matched
|
||
explicitly. In other cases, the `.' character is not treated specially.
|
||
|
||
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
|
||
filenames matching a pattern. If `GLOBIGNORE' is set, each matching
|
||
filename that also matches one of the patterns in `GLOBIGNORE' is
|
||
removed from the list of matches. 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: bashref.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 sorts between those two characters, inclusive, using the
|
||
current locale's collating sequence and character set, is matched.
|
||
If the first character following the `[' is a `!' or a `^' then
|
||
any character not enclosed is matched. 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 value of the `LC_COLLATE' shell
|
||
variable, 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'.
|
||
|
||
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.
|
||
|
||
|
||
File: bashref.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: bashref.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 may
|
||
also be used to open and close files for the current shell execution
|
||
environment. The following redirection operators may precede or appear
|
||
anywhere within a simple command or may follow a command. Redirections
|
||
are processed in 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.
|
||
|
||
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:
|
||
|
||
`/dev/fd/FD'
|
||
If FD is a valid integer, file descriptor FD is duplicated.
|
||
|
||
`/dev/stdin'
|
||
File descriptor 0 is duplicated.
|
||
|
||
`/dev/stdout'
|
||
File descriptor 1 is duplicated.
|
||
|
||
`/dev/stderr'
|
||
File descriptor 2 is duplicated.
|
||
|
||
`/dev/tcp/HOST/PORT'
|
||
If HOST is a valid hostname or Internet address, and PORT is an
|
||
integer port number or service name, Bash attempts to open a TCP
|
||
connection to the corresponding socket.
|
||
|
||
`/dev/udp/HOST/PORT'
|
||
If HOST is a valid hostname or Internet address, and PORT is an
|
||
integer port number or service name, Bash attempts to open a UDP
|
||
connection to the corresponding 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
|
||
|
||
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
|
||
|
||
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 for a command.
|
||
|
||
The format of here-documents is:
|
||
<<[-]WORD
|
||
HERE-DOCUMENT
|
||
DELIMITER
|
||
|
||
No parameter expansion, command substitution, arithmetic expansion,
|
||
or filename expansion is performed on WORD. If any characters in WORD
|
||
are quoted, the DELIMITER is the result of quote removal on WORD, and
|
||
the lines in the here-document are not expanded. If WORD is unquoted,
|
||
all lines of the here-document are subjected to parameter expansion,
|
||
command substitution, and arithmetic expansion. In the latter case,
|
||
the character sequence `\newline' is ignored, and `\' must be used to
|
||
quote the characters `\', `$', and ``'.
|
||
|
||
If the redirection operator is `<<-', then all leading tab
|
||
characters are stripped from input lines and the line 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:
|
||
<<< WORD
|
||
|
||
The WORD is expanded and supplied to the command on its standard
|
||
input.
|
||
|
||
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. As a special case, if N is omitted, and WORD
|
||
does not expand to one or more digits, the standard output and standard
|
||
error are redirected as described previously.
|
||
|
||
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: bashref.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: bashref.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: bashref.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 with the original command and
|
||
the original command's arguments as its arguments, and the
|
||
function's exit status becomes the exit status of the shell. 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: bashref.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: bashref.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 path name of the command and passed to that command in its
|
||
environment.
|
||
|
||
|
||
File: bashref.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.
|
||
|
||
|
||
File: bashref.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: bashref.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: bashref.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', `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: bashref.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. 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] [DIRECTORY]
|
||
Change the current working directory to DIRECTORY. If DIRECTORY
|
||
is not given, the value of the `HOME' shell variable is used. If
|
||
the shell variable `CDPATH' exists, it is used as a search path.
|
||
If DIRECTORY begins with a slash, `CDPATH' is not used.
|
||
|
||
The `-P' option means to not follow symbolic links; symbolic links
|
||
are followed by default or with the `-L' option. If DIRECTORY is
|
||
`-', it is equivalent to `$OLDPWD'.
|
||
|
||
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 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 exported
|
||
names 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 white space. 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]
|
||
Remember the full pathnames of 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'. 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 [-aApf] [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 no NAME
|
||
arguments are given, or if the `-p' option is supplied, a list of
|
||
all readonly names is printed. The `-p' option causes output to
|
||
be 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 exit with the return value N. If N is
|
||
not supplied, the return value is the exit status of the last
|
||
command executed in the function. This may also be used to
|
||
terminate execution of a script being executed with the `.' (or
|
||
`source') builtin, returning either N or the exit status of the
|
||
last command executed within the script as the exit status of the
|
||
script. 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 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'
|
||
`['
|
||
Evaluate a conditional expression EXPR. 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.
|
||
|
||
`! 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
|
||
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. If the first argument is `!', the value is
|
||
the negation of the two-argument test using the second and
|
||
third arguments. If the first argument is exactly `(' and
|
||
the third argument is exactly `)', the result is the
|
||
one-argument test of the second argument. 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.
|
||
|
||
`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
|
||
simple command has 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, or if the command's return status is being inverted
|
||
using `!'. These are the same conditions obeyed by the `errexit'
|
||
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 [-fv] [NAME]
|
||
Each variable or function NAME is removed. If no options are
|
||
supplied, or the `-v' option is given, each NAME refers to a shell
|
||
variable. If the `-f' option is given, the NAMEs refer to shell
|
||
functions, and the function definition is removed. Readonly
|
||
variables and functions may not be unset. The return status is
|
||
zero unless a NAME is readonly.
|
||
|
||
|
||
File: bashref.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] [-lpsvPSV]
|
||
bind [-m KEYMAP] [-q FUNCTION] [-u FUNCTION] [-r KEYSEQ]
|
||
bind [-m KEYMAP] -f FILENAME
|
||
bind [-m KEYMAP] -x KEYSEQ:SHELL-COMMAND
|
||
bind [-m KEYMAP] KEYSEQ:FUNCTION-NAME
|
||
bind READLINE-COMMAND
|
||
|
||
Display current Readline (*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'; `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.
|
||
|
||
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 [-aAfFilrtux] [-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
|
||
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 the function is defined
|
||
are displayed as well. `-F' implies `-f'. 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.
|
||
|
||
`-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' may not be used to destroy an array variable
|
||
and `+r' will not remove the readonly attribute. When used in a
|
||
function, `declare' makes each NAME local, as with the `local'
|
||
command. 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 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 always 0. 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'
|
||
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)
|
||
|
||
`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. 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 [-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:
|
||
`-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 newline from each line read.
|
||
|
||
`-u'
|
||
Read lines from file descriptor FD instead of the standard
|
||
input.
|
||
|
||
`-C'
|
||
Evaluate CALLBACK each time QUANTUMP 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 as an additional argument. 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 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, `%b' causes `printf' to expand backslash escape sequences
|
||
in the corresponding ARGUMENT, (except that `\c' terminates
|
||
output, backslashes in `\'', `\"', and `\?' are not removed, and
|
||
octal escapes beginning with `\0' may contain up to four digits),
|
||
and `%q' causes `printf' to output the corresponding ARGUMENT in a
|
||
format that can be reused as shell input.
|
||
|
||
The `-v' option causes the output to be assigned to the variable
|
||
VAR rather than being printed to the standard output.
|
||
|
||
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, and the
|
||
first word is assigned to the first NAME, the second word to the
|
||
second NAME, and so on, with leftover words and their intervening
|
||
separators 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. 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
|
||
return code is zero, unless end-of-file is encountered, `read'
|
||
times out (in which case the return code is greater than 128), 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.
|
||
|
||
`-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.
|
||
|
||
`-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 honor 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.
|
||
|
||
`-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 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 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
|
||
TIMEOUT is 0, `read' returns success if input is available on
|
||
the specified file descriptor, failure otherwise. The exit
|
||
status is greater than 128 if the timeout is exceeded.
|
||
|
||
`-u FD'
|
||
Read input from file descriptor FD.
|
||
|
||
|
||
`readarray'
|
||
readarray [-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, 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 [-afFrxi] [-p] [NAME[=VALUE] ...]
|
||
The `typeset' command is supplied for compatibility with the Korn
|
||
shell; however, it has been deprecated in favor of the `declare'
|
||
builtin command.
|
||
|
||
`ulimit'
|
||
ulimit [-abcdefilmnpqrstuvxHST] [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.
|
||
|
||
`-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 process.
|
||
|
||
`-x'
|
||
The maximum number of file locks.
|
||
|
||
`-T'
|
||
The maximum number of threads.
|
||
|
||
|
||
If LIMIT is given, it 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, and `-n' and `-u', which are unscaled values.
|
||
|
||
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: bashref.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: bashref.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] [ARGUMENT ...]
|
||
set [+abefhkmnptuvxBCEHPT] [+o OPTION] [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'
|
||
Mark variables and function which are modified or created 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 subshell command enclosed in parentheses (*note Command
|
||
Grouping::), or one of the commands executed as part of a
|
||
command list enclosed by braces (*note Command Grouping::)
|
||
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 `!'. 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.
|
||
|
||
`-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::).
|
||
|
||
`-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 follow 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: bashref.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 variables controlling optional shell behavior.
|
||
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. 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, the
|
||
display is limited to 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:
|
||
`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 command and,
|
||
if necessary, updates the values of `LINES' and `COLUMNS'.
|
||
|
||
`cmdhist'
|
||
If set, Bash attempts to save all lines of a multiple-line
|
||
command in the same history entry. This allows easy
|
||
re-editing of multi-line commands.
|
||
|
||
`compat31'
|
||
If set, Bash changes its behavior to that of version 3.1 with
|
||
respect to quoted arguments to the conditional command's =~
|
||
operator.
|
||
|
||
`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.
|
||
|
||
`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, 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), a call to `return' is simulated.
|
||
|
||
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 `ERROR' 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.
|
||
|
||
`globstar'
|
||
If set, the pattern `**' used in a filename expansion context
|
||
will match a 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::).
|
||
|
||
`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.
|
||
|
||
`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.
|
||
|
||
`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.
|
||
|
||
`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.
|
||
|
||
`promptvars'
|
||
If set, prompt strings undergo parameter expansion, command
|
||
substitution, arithmetic expansion, and quote removal after
|
||
being expanded as described below (*note Printing a 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: bashref.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: bashref.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: bashref.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 and the `MAILPATH' variable
|
||
is not set, Bash informs the user of the arrival of mail in the
|
||
specified file.
|
||
|
||
`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 file name 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 Printing a Prompt::, for the complete list of escape
|
||
sequences that are expanded before `PS1' is displayed.
|
||
|
||
`PS2'
|
||
The secondary prompt string. The default value is `> '.
|
||
|
||
|
||
|
||
File: bashref.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.
|
||
|
||
`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; unsetting array elements cause aliases
|
||
to be removed from the alias list.
|
||
|
||
`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).
|
||
|
||
`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).
|
||
|
||
`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; unsetting array elements cause commands
|
||
to be removed from the hash table.
|
||
|
||
`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_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 corresponding to each member of FUNCNAME.
|
||
`${BASH_LINENO[$i]}' is the line number in the source file where
|
||
`${FUNCNAME[$i]}' was called (or `${BASH_LINENO[$i-1]}' if
|
||
referenced within another shell function). The corresponding
|
||
source file name is `${BASH_SOURCE[$i]}'. Use `LINENO' to obtain
|
||
the current line number.
|
||
|
||
`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
|
||
corresponding to the elements in the `FUNCNAME' array variable.
|
||
|
||
`BASH_SUBSHELL'
|
||
Incremented by one each time a subshell or subshell environment is
|
||
spawned. 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.
|
||
|
||
`COLUMNS'
|
||
Used by the `select' builtin command to determine the terminal
|
||
width when printing selection lists. Automatically set 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::).
|
||
|
||
`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.
|
||
|
||
`EUID'
|
||
The numeric effective user id of the current user. This variable
|
||
is readonly.
|
||
|
||
`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 file name whose suffix matches one of the
|
||
entries in `FIGNORE' is excluded from the list of matched file
|
||
names. A sample value is `.o:~'
|
||
|
||
`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 is `"main"'. This variable exists only when a
|
||
shell function is executing. Assignments to `FUNCNAME' have no
|
||
effect and return an error status. If `FUNCNAME' is unset, it
|
||
loses its special properties, even if it is subsequently reset.
|
||
|
||
`GLOBIGNORE'
|
||
A colon-separated list of patterns defining the set of filenames to
|
||
be ignored by filename expansion. If a filename matched by a
|
||
filename expansion pattern also matches one of the patterns in
|
||
`GLOBIGNORE', it is removed from the list of matches.
|
||
|
||
`GROUPS'
|
||
An array variable containing the list of groups of which the
|
||
current user is a member. Assignments to `GROUPS' have no effect
|
||
and return an error status. If `GROUPS' is unset, it loses its
|
||
special 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, by removing the oldest entries, to contain no more
|
||
than that number of lines. The history file is also truncated to
|
||
this size after writing it when an interactive shell exits. The
|
||
default value is 500.
|
||
|
||
`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'.
|
||
|
||
`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.
|
||
The default value is 500.
|
||
|
||
`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'.
|
||
|
||
`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.
|
||
|
||
`LINENO'
|
||
The line number in the script or shell function currently
|
||
executing.
|
||
|
||
`LINES'
|
||
Used by the `select' builtin command to determine the column length
|
||
for printing selection lists. Automatically set 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.
|
||
|
||
`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.
|
||
|
||
`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 Printing a
|
||
Prompt::). Characters removed are replaced with an ellipsis.
|
||
|
||
`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 is the prompt printed before the command line is echoed
|
||
when the `-x' option is set (*note The Set Builtin::). The first
|
||
character of `PS4' 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.
|
||
|
||
`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 input after issuing the primary prompt when
|
||
the shell is interactive. Bash terminates after that number of
|
||
seconds if 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: bashref.info, Node: Bash Features, Next: Job Control, Prev: Shell Variables, Up: Top
|
||
|
||
6 Bash Features
|
||
***************
|
||
|
||
This section 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.
|
||
* Printing a Prompt:: Controlling the PS1 string.
|
||
* 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: bashref.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 ...]
|
||
|
||
In addition to the single-character shell command-line options
|
||
(*note The Set Builtin::), there are several multi-character options
|
||
that you can use. These options must appear on the command line before
|
||
the single-character options to be recognized.
|
||
|
||
`--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) and shell function tracing (see *note The Set Builtin::
|
||
for a description of the `-o functrace' option).
|
||
|
||
`--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 STRING'
|
||
Read and execute commands from STRING after processing the
|
||
options, then exit. Any remaining arguments are assigned to the
|
||
positional parameters, starting with `$0'.
|
||
|
||
`-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.
|
||
|
||
`-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: bashref.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 file names 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 a login shell exits, 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
|
||
file name.
|
||
|
||
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 a network connection, as if 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 `rshd' does not 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: bashref.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: bashref.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: bashref.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: bashref.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.
|
||
|
||
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 an interactive shell 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: bashref.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.
|
||
|
||
Expressions may be unary or binary. Unary expressions are often
|
||
used to examine the status of a file. There are string operators and
|
||
numeric comparison operators as well. 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.
|
||
|
||
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.
|
||
|
||
`-O FILE'
|
||
True if FILE exists and is owned by the effective user id.
|
||
|
||
`-G FILE'
|
||
True if FILE exists and is owned by the effective group id.
|
||
|
||
`-L FILE'
|
||
True if FILE exists and is a symbolic link.
|
||
|
||
`-S FILE'
|
||
True if FILE exists and is a socket.
|
||
|
||
`-N FILE'
|
||
True if FILE exists and has been modified since it was last read.
|
||
|
||
`FILE1 -nt FILE2'
|
||
True if FILE1 is newer (according to modification date) than
|
||
FILE2, or if FILE1 exists and FILE2 does not.
|
||
|
||
`FILE1 -ot FILE2'
|
||
True if FILE1 is older than FILE2, or if FILE2 exists and FILE1
|
||
does not.
|
||
|
||
`FILE1 -ef FILE2'
|
||
True if FILE1 and FILE2 refer to the same device and inode numbers.
|
||
|
||
`-o OPTNAME'
|
||
True if shell option OPTNAME is enabled. The list of options
|
||
appears in the description of the `-o' option to the `set' builtin
|
||
(*note The Set Builtin::).
|
||
|
||
`-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. `=' 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.
|
||
|
||
|
||
|
||
File: bashref.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 the `let' and the `-i' option to the `declare'
|
||
builtins.
|
||
|
||
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 BASE is a decimal number between 2 and 64
|
||
representing the arithmetic base, and N is a number in that base. If
|
||
BASE`#' is omitted, then base 10 is used. The digits greater than 9
|
||
are 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: bashref.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 space or tab character, then the next command word following the
|
||
alias is also checked for alias expansion.
|
||
|
||
Aliases are created and listed with the `alias' command, and removed
|
||
with the `unalias' command.
|
||
|
||
There is no mechanism for using arguments in the replacement text,
|
||
as in `csh'. If arguments are needed, a shell function should be used
|
||
(*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
|
||
before executing any of the commands on that line. Aliases are
|
||
expanded when a command is read, not when it is executed. Therefore, an
|
||
alias definition appearing on the same line as another command does not
|
||
take effect until the next line of input is read. 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
|
||
compound command. As a consequence, aliases defined in a function are
|
||
not available until after that function is executed. To be safe,
|
||
always put alias definitions on a separate line, and do not use `alias'
|
||
in compound commands.
|
||
|
||
For almost every purpose, shell functions are preferred over aliases.
|
||
|
||
|
||
File: bashref.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.
|
||
|
||
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 greater than or equal to zero. 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 ... valueN)
|
||
where each VALUE is of the form `[SUBSCRIPT]='STRING. Indexed array
|
||
assignments do not require the bracket and subscript. 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.
|
||
|
||
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. Referencing an array variable without a subscript is
|
||
equivalent to referencing with a subscript of 0.
|
||
|
||
An array variable is considered set if a subscript has been assigned
|
||
a value. The null string is a valid value.
|
||
|
||
The `unset' builtin is used to destroy arrays. `unset'
|
||
NAME[SUBSCRIPT] destroys the array element at index SUBSCRIPT. Care
|
||
must be taken to avoid unwanted side effects caused by filename
|
||
expansion. `unset' NAME, where NAME is an array, removes the entire
|
||
array. A subscript of `*' or `@' also removes the entire array.
|
||
|
||
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. 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: bashref.info, Node: The Directory Stack, Next: Printing a 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 contents of the directory stack are also visible as the value of
|
||
the `DIRSTACK' shell variable.
|
||
|
||
|
||
File: bashref.info, Node: Directory Stack Builtins, Up: The Directory Stack
|
||
|
||
6.8.1 Directory Stack Builtins
|
||
------------------------------
|
||
|
||
`dirs'
|
||
dirs [+N | -N] [-clpv]
|
||
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.
|
||
`+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.
|
||
|
||
`-c'
|
||
Clears the directory stack by deleting all of the elements.
|
||
|
||
`-l'
|
||
Produces a longer listing; 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.
|
||
|
||
`popd'
|
||
popd [+N | -N] [-n]
|
||
|
||
Remove the top entry from the directory stack, and `cd' to the new
|
||
top directory. 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'; i.e., `popd' is equivalent to `popd
|
||
+0'.
|
||
`+N'
|
||
Removes the Nth directory (counting from the left of the list
|
||
printed by `dirs'), starting with zero.
|
||
|
||
`-N'
|
||
Removes the Nth directory (counting from the right of the
|
||
list printed by `dirs'), starting with zero.
|
||
|
||
`-n'
|
||
Suppresses the normal change of directory when removing
|
||
directories from the stack, so that only the stack is
|
||
manipulated.
|
||
|
||
`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.
|
||
|
||
`-n'
|
||
Suppresses the normal change of directory when 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 the current working directory be the top of the stack,
|
||
and then executes the equivalent of ``cd' DIR'. `cd's to DIR.
|
||
|
||
|
||
|
||
File: bashref.info, Node: Printing a 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:
|
||
|
||
`\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 Bash Builtins::).
|
||
|
||
|
||
File: bashref.info, Node: The Restricted Shell, Next: Bash POSIX Mode, Prev: Printing a 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: bashref.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. 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'.
|
||
|
||
2. The message printed by the job control code and builtins when a job
|
||
exits with a non-zero status is `Done(status)'.
|
||
|
||
3. The message printed by the job control code and builtins when a job
|
||
is stopped is `Stopped(SIGNAME)', where SIGNAME is, for example,
|
||
`SIGTSTP'.
|
||
|
||
4. 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.
|
||
|
||
5. Reserved words appearing in a context where reserved words are
|
||
recognized do not undergo alias expansion.
|
||
|
||
6. 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.
|
||
|
||
7. The POSIX startup files are executed (`$ENV') rather than the
|
||
normal Bash files.
|
||
|
||
8. Tilde expansion is only performed on assignments preceding a
|
||
command name, rather than on all assignment statements on the line.
|
||
|
||
9. The default history file is `~/.sh_history' (this is the default
|
||
value of `$HISTFILE').
|
||
|
||
10. The output of `kill -l' prints all the signal names on a single
|
||
line, separated by spaces, without the `SIG' prefix.
|
||
|
||
11. The `kill' builtin does not accept signal names with a `SIG'
|
||
prefix.
|
||
|
||
12. Non-interactive shells exit if FILENAME in `.' FILENAME is not
|
||
found.
|
||
|
||
13. Non-interactive shells exit if a syntax error in an arithmetic
|
||
expansion results in an invalid expression.
|
||
|
||
14. Redirection operators do not perform filename expansion on the word
|
||
in the redirection unless the shell is interactive.
|
||
|
||
15. Redirection operators do not perform word splitting on the word in
|
||
the redirection.
|
||
|
||
16. 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.
|
||
|
||
17. POSIX special builtins are found before shell functions during
|
||
command lookup.
|
||
|
||
18. 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.
|
||
|
||
19. If `CDPATH' is set, the `cd' builtin will not implicitly append
|
||
the current directory to it. This means that `cd' will fail if no
|
||
valid directory name can be constructed from any of the entries in
|
||
`$CDPATH', even if the a directory with the same name as the name
|
||
given as an argument to `cd' exists in the current directory.
|
||
|
||
20. 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.
|
||
|
||
21. 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.
|
||
|
||
22. Process substitution is not available.
|
||
|
||
23. Assignment statements preceding POSIX special builtins persist in
|
||
the shell environment after the builtin completes.
|
||
|
||
24. 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.
|
||
|
||
25. The `export' and `readonly' builtin commands display their output
|
||
in the format required by POSIX.
|
||
|
||
26. The `trap' builtin displays signal names without the leading `SIG'.
|
||
|
||
27. 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.
|
||
|
||
28. The `.' and `source' builtins do not search the current directory
|
||
for the filename argument if it is not found by searching `PATH'.
|
||
|
||
29. 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.
|
||
|
||
30. Alias expansion is always enabled, even in non-interactive shells.
|
||
|
||
31. When the `alias' builtin displays alias definitions, it does not
|
||
display them with a leading `alias ' unless the `-p' option is
|
||
supplied.
|
||
|
||
32. When the `set' builtin is invoked without options, it does not
|
||
display shell function names and definitions.
|
||
|
||
33. 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.
|
||
|
||
34. 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.
|
||
|
||
35. When the `pwd' builtin is supplied the `-P' option, it resets
|
||
`$PWD' to a pathname containing no symlinks.
|
||
|
||
36. 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.
|
||
|
||
37. When listing the history, the `fc' builtin does not include an
|
||
indication of whether or not a history entry has been modified.
|
||
|
||
38. The default editor used by `fc' is `ed'.
|
||
|
||
39. 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'.
|
||
|
||
40. The `vi' editing mode will invoke the `vi' editor directly when
|
||
the `v' command is run, instead of checking `$VISUAL' and
|
||
`$EDITOR'.
|
||
|
||
41. 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.
|
||
|
||
42. The `ulimit' builtin uses a block size of 512 bytes for the `-c'
|
||
and `-f' options.
|
||
|
||
43. 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.
|
||
|
||
|
||
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: bashref.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: bashref.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.
|
||
|
||
|
||
File: bashref.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'
|
||
Restrict output to running jobs.
|
||
|
||
`-s'
|
||
Restrict output to 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 [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 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 [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 neither JOBSPEC nor PID specifies an active child process
|
||
of the shell, the return status is 127.
|
||
|
||
`disown'
|
||
disown [-ar] [-h] [JOBSPEC ...]
|
||
Without options, each JOBSPEC is removed 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 `-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: bashref.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: bashref.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.
|
||
|
||
|
||
File: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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', Readline attempts to bind the control
|
||
characters treated specially by the kernel's terminal driver
|
||
to their Readline equivalents.
|
||
|
||
`comment-begin'
|
||
The string to insert at the beginning of the line when the
|
||
`insert-comment' command is executed. The default value is
|
||
`"#"'.
|
||
|
||
`completion-ignore-case'
|
||
If set to `on', Readline performs filename matching and
|
||
completion in a case-insensitive fashion. 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'.
|
||
|
||
`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'.
|
||
|
||
`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'.
|
||
|
||
`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'.
|
||
|
||
`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, the number of entries in the
|
||
history list is not limited.
|
||
|
||
`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'. 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. Acceptable `keymap' names are `emacs',
|
||
`emacs-standard', `emacs-meta', `emacs-ctlx', `vi', `vi-move',
|
||
`vi-command', and `vi-insert'. `vi' is equivalent to
|
||
`vi-command'; `emacs' is equivalent to `emacs-standard'. The
|
||
default value is `emacs'. The value of the `editing-mode'
|
||
variable also affects the default keymap.
|
||
|
||
`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, unless the leading `.' is
|
||
supplied by the user in the filename to be completed. This
|
||
variable is `on' by default.
|
||
|
||
`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'.
|
||
|
||
`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'.
|
||
|
||
`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'.
|
||
|
||
`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 above example, `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: bashref.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 extends to the end of the line; no
|
||
characters are required to isolate it.
|
||
|
||
`mode'
|
||
The `mode=' form of the `$if' directive is used to test
|
||
whether Readline is in `emacs' or `vi' mode. This may be
|
||
used in conjunction with the `set keymap' command, for
|
||
instance, to set bindings in the `emacs-standard' and
|
||
`emacs-ctlx' keymaps only if Readline is starting out in
|
||
`emacs' mode.
|
||
|
||
`term'
|
||
The `term=' form may be used to include 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.
|
||
|
||
`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
|
||
|
||
`$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: bashref.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 systemwide 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: bashref.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: bashref.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.
|
||
|
||
`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: bashref.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 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.
|
||
|
||
`non-incremental-forward-search-history (M-n)'
|
||
Search forward starting at the current line and moving `down'
|
||
through the the history as necessary using a non-incremental search
|
||
for a string supplied by the user.
|
||
|
||
`history-search-forward ()'
|
||
Search forward through the history for the string of characters
|
||
between the start of the current line and the point. This is a
|
||
non-incremental search. 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. 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 an argument, behave exactly like
|
||
`yank-nth-arg'. Successive calls to `yank-last-arg' move back
|
||
through the history list, inserting the last argument of each line
|
||
in turn. The history expansion facilities are used to extract the
|
||
last argument, as if the `!$' history expansion had been specified.
|
||
|
||
|
||
|
||
File: bashref.info, Node: Commands For Text, Next: Commands For Killing, Prev: Commands For History, Up: Bindable Readline Commands
|
||
|
||
8.4.3 Commands For Changing Text
|
||
--------------------------------
|
||
|
||
`delete-char (C-d)'
|
||
Delete the character at point. If point is at the beginning of
|
||
the line, there are no characters in the line, and the last
|
||
character typed was not bound to `delete-char', then return EOF.
|
||
|
||
`backward-delete-char (Rubout)'
|
||
Delete the character behind the cursor. 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.
|
||
|
||
`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: bashref.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 to the beginning of the 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'.
|
||
|
||
`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: bashref.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 or 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: bashref.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.
|
||
|
||
`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: bashref.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.
|
||
|
||
|
||
|
||
File: bashref.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-uppercase-version (M-a, M-b, M-X, ...)'
|
||
If the metafied character X is lowercase, run the command that is
|
||
bound to the corresponding uppercase character.
|
||
|
||
`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. Any
|
||
argument is ignored.
|
||
|
||
`edit-and-execute-command (C-xC-e)'
|
||
Invoke an editor on the current command line, and execute the
|
||
result as shell commands. Bash attempts to invoke `$VISUAL',
|
||
`$EDITOR', and `emacs' as the editor, in that order.
|
||
|
||
|
||
|
||
File: bashref.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 1003.2
|
||
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: bashref.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.
|
||
|
||
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. 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 is the name of the
|
||
command whose arguments are being completed, the second argument is the
|
||
word being completed, and the third argument 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.
|
||
|
||
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.
|
||
|
||
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 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
|
||
|
||
|
||
File: bashref.info, Node: Programmable Completion Builtins, Prev: Programmable Completion, Up: Command Line Editing
|
||
|
||
8.7 Programmable Completion Builtins
|
||
====================================
|
||
|
||
Two builtin commands are available to manipulate the programmable
|
||
completion facilities.
|
||
|
||
`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] [-DE] [-A ACTION] [-G GLOBPAT] [-W WORDLIST]
|
||
[-F FUNCTION] [-C COMMAND] [-X FILTERPAT]
|
||
[-P PREFIX] [-S SUFFIX] NAME [NAME ...]'
|
||
`complete -pr [-DE] [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 the
|
||
remaining 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 the remaining options and actions should apply to
|
||
"empty" command completion; that is, completion attempted on a
|
||
blank line.
|
||
|
||
The process of applying these completion specifications when word
|
||
completion is attempted is described above (*note Programmable
|
||
Completion::). The `-D' option takes precedence over `-E'.
|
||
|
||
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'.
|
||
|
||
`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'.
|
||
|
||
`-G GLOBPAT'
|
||
The filename expansion pattern GLOBPAT is expanded to generate
|
||
the possible completions.
|
||
|
||
`-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.
|
||
|
||
`-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 finishes, the possible completions are
|
||
retrieved from the value of the `COMPREPLY' array variable.
|
||
|
||
`-X FILTERPAT'
|
||
FILTERPAT is a pattern as used for filename expansion. It is
|
||
applied to the list of possible completions generated by the
|
||
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.
|
||
|
||
`-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.
|
||
|
||
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] [-DE] [+o OPTION] [NAME]
|
||
Modify completion options for each NAME according to the OPTIONs,
|
||
or for the currently-execution 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 the remaining 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 the remaining options should apply to
|
||
"empty" command completion; that is, completion attempted on a
|
||
blank line.
|
||
|
||
The `-D' option takes precedence over `-E'.
|
||
|
||
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: bashref.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: bashref.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 an interactive shell 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 not set, no truncation is
|
||
performed.
|
||
|
||
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 previous
|
||
history line.
|
||
|
||
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 Bash Builtins::, for a description of `shopt'.
|
||
|
||
|
||
File: bashref.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]'
|
||
|
||
Fix Command. In the first form, a range of commands from FIRST to
|
||
LAST is selected from the history list. Both FIRST and LAST may
|
||
be specified as a string (to locate the most recent command
|
||
beginning with that string) or as a number (an index into the
|
||
history list, where a negative number is used as an offset from the
|
||
current command number). If LAST is not specified it is set to
|
||
FIRST. If FIRST is not specified it is set to the previous
|
||
command for editing and -16 for listing. If the `-l' flag is
|
||
given, the commands are listed on standard output. The `-n' flag
|
||
suppresses the command numbers when listing. The `-r' flag
|
||
reverses the order of the listing. Otherwise, the editor given by
|
||
ENAME is invoked on a file containing those commands. If ENAME is
|
||
not given, the value of the following variable expansion is used:
|
||
`${FCEDIT:-${EDITOR:-vi}}'. This says to use the value of the
|
||
`FCEDIT' variable if set, or the value of the `EDITOR' variable if
|
||
that is set, or `vi' if neither is set. When editing is complete,
|
||
the edited commands are echoed and executed.
|
||
|
||
In the second form, COMMAND is re-executed after each instance of
|
||
PAT in the selected command is replaced by REP.
|
||
|
||
A useful alias to use with the `fc' command is `r='fc -s'', so
|
||
that typing `r cc' runs the last command beginning with `cc' and
|
||
typing `r' re-executes the last command (*note Aliases::).
|
||
|
||
`history'
|
||
history [N]
|
||
history -c
|
||
history -d OFFSET
|
||
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. OFFSET should
|
||
be specified as it appears when the history is displayed.
|
||
|
||
`-a'
|
||
Append the new history lines (history lines entered since the
|
||
beginning of the current Bash session) 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 current history file and append its contents to the
|
||
history list.
|
||
|
||
`-w'
|
||
Write out the current history 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: bashref.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 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.
|
||
Only `\' and `'' may be used to escape the history expansion character.
|
||
|
||
Several shell options settable with the `shopt' builtin (*note Bash
|
||
Builtins::) 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: bashref.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.
|
||
|
||
`!'
|
||
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 starting with STRING.
|
||
|
||
`!?STRING[?]'
|
||
Refer to the most recent command 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: bashref.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: bashref.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: bashref.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: bashref.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-2.04$ ./configure --help
|
||
|
||
at the Bash prompt in your Bash source directory.
|
||
|
||
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.in' is used to create `configure' by a program
|
||
called Autoconf. You only need `configure.in' 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: bashref.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: bashref.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. 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: bashref.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: bashref.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: bashref.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: bashref.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: bashref.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.sas.com/standards/large_file/x_open.20Mar96.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' 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-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-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 `$PS1', `$PS2', `$PS3', and `$PS4' prompt
|
||
strings. See *note Printing a 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' builtin, 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: bashref.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
|
||
<chet.ramey@case.edu>.
|
||
|
||
|
||
File: bashref.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.
|
||
|
||
* 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 Printing a 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: bashref.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: bashref.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: bashref.info, Node: Builtin Index, Next: Reserved Word Index, Up: Indexes
|
||
|
||
D.1 Index of Shell Builtin Commands
|
||
===================================
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* .: Bourne Shell Builtins.
|
||
(line 16)
|
||
* :: Bourne Shell Builtins.
|
||
(line 11)
|
||
* [: Bourne Shell Builtins.
|
||
(line 213)
|
||
* alias: Bash Builtins. (line 11)
|
||
* bg: Job Control Builtins.
|
||
(line 7)
|
||
* bind: Bash Builtins. (line 21)
|
||
* break: Bourne Shell Builtins.
|
||
(line 29)
|
||
* builtin: Bash Builtins. (line 98)
|
||
* caller: Bash Builtins. (line 106)
|
||
* cd: Bourne Shell Builtins.
|
||
(line 36)
|
||
* command: Bash Builtins. (line 123)
|
||
* compgen: Programmable Completion Builtins.
|
||
(line 10)
|
||
* complete: Programmable Completion Builtins.
|
||
(line 28)
|
||
* compopt: Programmable Completion Builtins.
|
||
(line 217)
|
||
* continue: Bourne Shell Builtins.
|
||
(line 55)
|
||
* declare: Bash Builtins. (line 142)
|
||
* dirs: Directory Stack Builtins.
|
||
(line 7)
|
||
* disown: Job Control Builtins.
|
||
(line 83)
|
||
* echo: Bash Builtins. (line 221)
|
||
* enable: Bash Builtins. (line 273)
|
||
* eval: Bourne Shell Builtins.
|
||
(line 63)
|
||
* exec: Bourne Shell Builtins.
|
||
(line 70)
|
||
* exit: Bourne Shell Builtins.
|
||
(line 82)
|
||
* export: Bourne Shell Builtins.
|
||
(line 88)
|
||
* fc: Bash History Builtins.
|
||
(line 10)
|
||
* fg: Job Control Builtins.
|
||
(line 16)
|
||
* getopts: Bourne Shell Builtins.
|
||
(line 103)
|
||
* hash: Bourne Shell Builtins.
|
||
(line 145)
|
||
* help: Bash Builtins. (line 301)
|
||
* history: Bash History Builtins.
|
||
(line 39)
|
||
* jobs: Job Control Builtins.
|
||
(line 25)
|
||
* kill: Job Control Builtins.
|
||
(line 57)
|
||
* let: Bash Builtins. (line 321)
|
||
* local: Bash Builtins. (line 328)
|
||
* logout: Bash Builtins. (line 338)
|
||
* mapfile: Bash Builtins. (line 342)
|
||
* popd: Directory Stack Builtins.
|
||
(line 37)
|
||
* printf: Bash Builtins. (line 388)
|
||
* pushd: Directory Stack Builtins.
|
||
(line 58)
|
||
* pwd: Bourne Shell Builtins.
|
||
(line 163)
|
||
* read: Bash Builtins. (line 413)
|
||
* readarray: Bash Builtins. (line 493)
|
||
* readonly: Bourne Shell Builtins.
|
||
(line 172)
|
||
* return: Bourne Shell Builtins.
|
||
(line 188)
|
||
* set: The Set Builtin. (line 11)
|
||
* shift: Bourne Shell Builtins.
|
||
(line 201)
|
||
* shopt: The Shopt Builtin. (line 9)
|
||
* source: Bash Builtins. (line 501)
|
||
* suspend: Job Control Builtins.
|
||
(line 94)
|
||
* test: Bourne Shell Builtins.
|
||
(line 213)
|
||
* times: Bourne Shell Builtins.
|
||
(line 281)
|
||
* trap: Bourne Shell Builtins.
|
||
(line 286)
|
||
* type: Bash Builtins. (line 505)
|
||
* typeset: Bash Builtins. (line 536)
|
||
* ulimit: Bash Builtins. (line 542)
|
||
* umask: Bourne Shell Builtins.
|
||
(line 332)
|
||
* unalias: Bash Builtins. (line 630)
|
||
* unset: Bourne Shell Builtins.
|
||
(line 349)
|
||
* wait: Job Control Builtins.
|
||
(line 73)
|
||
|
||
|
||
File: bashref.info, Node: Reserved Word Index, Next: Variable Index, Prev: Builtin Index, Up: Indexes
|
||
|
||
D.2 Index of Shell Reserved Words
|
||
=================================
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* !: Pipelines. (line 9)
|
||
* [[: Conditional Constructs.
|
||
(line 117)
|
||
* ]]: Conditional Constructs.
|
||
(line 117)
|
||
* 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 29)
|
||
* function: Shell Functions. (line 13)
|
||
* if: Conditional Constructs.
|
||
(line 7)
|
||
* in: Conditional Constructs.
|
||
(line 28)
|
||
* select: Conditional Constructs.
|
||
(line 76)
|
||
* then: Conditional Constructs.
|
||
(line 7)
|
||
* time: Pipelines. (line 9)
|
||
* until: Looping Constructs. (line 12)
|
||
* while: Looping Constructs. (line 20)
|
||
* {: Command Grouping. (line 21)
|
||
* }: Command Grouping. (line 21)
|
||
|
||
|
||
File: bashref.info, Node: Variable Index, Next: Function Index, Prev: Reserved Word Index, Up: Indexes
|
||
|
||
D.3 Parameter and Variable Index
|
||
================================
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* !: Special Parameters. (line 46)
|
||
* #: Special Parameters. (line 30)
|
||
* $: Special Parameters. (line 42)
|
||
* *: Special Parameters. (line 9)
|
||
* -: Special Parameters. (line 37)
|
||
* 0: Special Parameters. (line 50)
|
||
* ?: Special Parameters. (line 33)
|
||
* @: Special Parameters. (line 19)
|
||
* _: Special Parameters. (line 59)
|
||
* auto_resume: Job Control Variables.
|
||
(line 6)
|
||
* BASH: Bash Variables. (line 13)
|
||
* BASH_ALIASES: Bash Variables. (line 30)
|
||
* BASH_ARGC: Bash Variables. (line 37)
|
||
* BASH_ARGV: Bash Variables. (line 47)
|
||
* BASH_CMDS: Bash Variables. (line 57)
|
||
* BASH_COMMAND: Bash Variables. (line 64)
|
||
* BASH_ENV: Bash Variables. (line 69)
|
||
* BASH_EXECUTION_STRING: Bash Variables. (line 75)
|
||
* BASH_LINENO: Bash Variables. (line 78)
|
||
* BASH_REMATCH: Bash Variables. (line 87)
|
||
* BASH_SOURCE: Bash Variables. (line 95)
|
||
* BASH_SUBSHELL: Bash Variables. (line 99)
|
||
* BASH_VERSINFO: Bash Variables. (line 103)
|
||
* BASH_VERSION: Bash Variables. (line 127)
|
||
* BASH_XTRACEFD: Bash Variables. (line 130)
|
||
* BASHOPTS: Bash Variables. (line 16)
|
||
* BASHPID: Bash Variables. (line 25)
|
||
* bell-style: Readline Init File Syntax.
|
||
(line 38)
|
||
* bind-tty-special-chars: Readline Init File Syntax.
|
||
(line 45)
|
||
* CDPATH: Bourne Shell Variables.
|
||
(line 9)
|
||
* COLUMNS: Bash Variables. (line 141)
|
||
* comment-begin: Readline Init File Syntax.
|
||
(line 50)
|
||
* COMP_CWORD: Bash Variables. (line 146)
|
||
* COMP_KEY: Bash Variables. (line 175)
|
||
* COMP_LINE: Bash Variables. (line 152)
|
||
* COMP_POINT: Bash Variables. (line 157)
|
||
* COMP_TYPE: Bash Variables. (line 165)
|
||
* COMP_WORDBREAKS: Bash Variables. (line 179)
|
||
* COMP_WORDS: Bash Variables. (line 185)
|
||
* completion-prefix-display-length: Readline Init File Syntax.
|
||
(line 60)
|
||
* completion-query-items: Readline Init File Syntax.
|
||
(line 67)
|
||
* COMPREPLY: Bash Variables. (line 193)
|
||
* convert-meta: Readline Init File Syntax.
|
||
(line 77)
|
||
* DIRSTACK: Bash Variables. (line 198)
|
||
* disable-completion: Readline Init File Syntax.
|
||
(line 83)
|
||
* editing-mode: Readline Init File Syntax.
|
||
(line 88)
|
||
* EMACS: Bash Variables. (line 208)
|
||
* enable-keypad: Readline Init File Syntax.
|
||
(line 99)
|
||
* EUID: Bash Variables. (line 213)
|
||
* expand-tilde: Readline Init File Syntax.
|
||
(line 110)
|
||
* FCEDIT: Bash Variables. (line 217)
|
||
* FIGNORE: Bash Variables. (line 221)
|
||
* FUNCNAME: Bash Variables. (line 227)
|
||
* GLOBIGNORE: Bash Variables. (line 236)
|
||
* GROUPS: Bash Variables. (line 242)
|
||
* histchars: Bash Variables. (line 248)
|
||
* HISTCMD: Bash Variables. (line 263)
|
||
* HISTCONTROL: Bash Variables. (line 268)
|
||
* HISTFILE: Bash Variables. (line 284)
|
||
* HISTFILESIZE: Bash Variables. (line 288)
|
||
* HISTIGNORE: Bash Variables. (line 296)
|
||
* history-preserve-point: Readline Init File Syntax.
|
||
(line 114)
|
||
* history-size: Readline Init File Syntax.
|
||
(line 120)
|
||
* HISTSIZE: Bash Variables. (line 315)
|
||
* HISTTIMEFORMAT: Bash Variables. (line 319)
|
||
* HOME: Bourne Shell Variables.
|
||
(line 13)
|
||
* horizontal-scroll-mode: Readline Init File Syntax.
|
||
(line 125)
|
||
* HOSTFILE: Bash Variables. (line 328)
|
||
* HOSTNAME: Bash Variables. (line 339)
|
||
* HOSTTYPE: Bash Variables. (line 342)
|
||
* IFS: Bourne Shell Variables.
|
||
(line 18)
|
||
* IGNOREEOF: Bash Variables. (line 345)
|
||
* input-meta: Readline Init File Syntax.
|
||
(line 132)
|
||
* INPUTRC: Bash Variables. (line 355)
|
||
* isearch-terminators: Readline Init File Syntax.
|
||
(line 139)
|
||
* keymap: Readline Init File Syntax.
|
||
(line 146)
|
||
* LANG: Bash Variables. (line 359)
|
||
* LC_ALL: Bash Variables. (line 363)
|
||
* LC_COLLATE: Bash Variables. (line 367)
|
||
* LC_CTYPE: Bash Variables. (line 374)
|
||
* LC_MESSAGES <1>: Locale Translation. (line 11)
|
||
* LC_MESSAGES: Bash Variables. (line 379)
|
||
* LC_NUMERIC: Bash Variables. (line 383)
|
||
* LINENO: Bash Variables. (line 387)
|
||
* LINES: Bash Variables. (line 391)
|
||
* MACHTYPE: Bash Variables. (line 396)
|
||
* MAIL: Bourne Shell Variables.
|
||
(line 22)
|
||
* MAILCHECK: Bash Variables. (line 400)
|
||
* MAILPATH: Bourne Shell Variables.
|
||
(line 27)
|
||
* mark-modified-lines: Readline Init File Syntax.
|
||
(line 159)
|
||
* mark-symlinked-directories: Readline Init File Syntax.
|
||
(line 164)
|
||
* match-hidden-files: Readline Init File Syntax.
|
||
(line 169)
|
||
* meta-flag: Readline Init File Syntax.
|
||
(line 132)
|
||
* OLDPWD: Bash Variables. (line 408)
|
||
* OPTARG: Bourne Shell Variables.
|
||
(line 34)
|
||
* OPTERR: Bash Variables. (line 411)
|
||
* OPTIND: Bourne Shell Variables.
|
||
(line 38)
|
||
* OSTYPE: Bash Variables. (line 415)
|
||
* output-meta: Readline Init File Syntax.
|
||
(line 176)
|
||
* page-completions: Readline Init File Syntax.
|
||
(line 181)
|
||
* PATH: Bourne Shell Variables.
|
||
(line 42)
|
||
* PIPESTATUS: Bash Variables. (line 418)
|
||
* POSIXLY_CORRECT: Bash Variables. (line 423)
|
||
* PPID: Bash Variables. (line 432)
|
||
* PROMPT_COMMAND: Bash Variables. (line 436)
|
||
* PROMPT_DIRTRIM: Bash Variables. (line 440)
|
||
* PS1: Bourne Shell Variables.
|
||
(line 48)
|
||
* PS2: Bourne Shell Variables.
|
||
(line 53)
|
||
* PS3: Bash Variables. (line 446)
|
||
* PS4: Bash Variables. (line 451)
|
||
* PWD: Bash Variables. (line 457)
|
||
* RANDOM: Bash Variables. (line 460)
|
||
* REPLY: Bash Variables. (line 465)
|
||
* revert-all-at-newline: Readline Init File Syntax.
|
||
(line 191)
|
||
* SECONDS: Bash Variables. (line 468)
|
||
* SHELL: Bash Variables. (line 474)
|
||
* SHELLOPTS: Bash Variables. (line 479)
|
||
* SHLVL: Bash Variables. (line 488)
|
||
* show-all-if-ambiguous: Readline Init File Syntax.
|
||
(line 197)
|
||
* show-all-if-unmodified: Readline Init File Syntax.
|
||
(line 203)
|
||
* skip-completed-text: Readline Init File Syntax.
|
||
(line 212)
|
||
* TEXTDOMAIN: Locale Translation. (line 11)
|
||
* TEXTDOMAINDIR: Locale Translation. (line 11)
|
||
* TIMEFORMAT: Bash Variables. (line 493)
|
||
* TMOUT: Bash Variables. (line 531)
|
||
* TMPDIR: Bash Variables. (line 543)
|
||
* UID: Bash Variables. (line 547)
|
||
* visible-stats: Readline Init File Syntax.
|
||
(line 225)
|
||
|
||
|
||
File: bashref.info, Node: Function Index, Next: Concept Index, Prev: Variable Index, Up: Indexes
|
||
|
||
D.4 Function Index
|
||
==================
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* abort (C-g): Miscellaneous Commands.
|
||
(line 10)
|
||
* accept-line (Newline or Return): Commands For History. (line 6)
|
||
* backward-char (C-b): Commands For Moving. (line 15)
|
||
* backward-delete-char (Rubout): Commands For Text. (line 11)
|
||
* 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)
|
||
* call-last-kbd-macro (C-x e): Keyboard Macros. (line 13)
|
||
* capitalize-word (M-c): Commands For Text. (line 46)
|
||
* character-search (C-]): Miscellaneous Commands.
|
||
(line 41)
|
||
* character-search-backward (M-C-]): Miscellaneous Commands.
|
||
(line 46)
|
||
* clear-screen (C-l): Commands For Moving. (line 34)
|
||
* complete (<TAB>): Commands For Completion.
|
||
(line 6)
|
||
* 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)
|
||
* delete-char (C-d): Commands For Text. (line 6)
|
||
* delete-char-or-list (): Commands For Completion.
|
||
(line 39)
|
||
* delete-horizontal-space (): Commands For Killing. (line 46)
|
||
* digit-argument (M-0, M-1, ... M--): Numeric Arguments. (line 6)
|
||
* do-uppercase-version (M-a, M-b, M-X, ...): Miscellaneous Commands.
|
||
(line 14)
|
||
* downcase-word (M-l): Commands For Text. (line 42)
|
||
* dump-functions (): Miscellaneous Commands.
|
||
(line 73)
|
||
* dump-macros (): Miscellaneous Commands.
|
||
(line 85)
|
||
* dump-variables (): Miscellaneous Commands.
|
||
(line 79)
|
||
* end-kbd-macro (C-x )): Keyboard Macros. (line 9)
|
||
* 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 36)
|
||
* forward-backward-delete-char (): Commands For Text. (line 15)
|
||
* 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)
|
||
* history-search-backward (): Commands For History. (line 51)
|
||
* history-search-forward (): Commands For History. (line 46)
|
||
* insert-comment (M-#): Miscellaneous Commands.
|
||
(line 60)
|
||
* insert-completions (M-*): Commands For Completion.
|
||
(line 18)
|
||
* 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)
|
||
* menu-complete (): Commands For Completion.
|
||
(line 22)
|
||
* menu-complete-backward (): Commands For Completion.
|
||
(line 34)
|
||
* next-history (C-n): Commands For History. (line 17)
|
||
* non-incremental-forward-search-history (M-n): Commands For History.
|
||
(line 41)
|
||
* non-incremental-reverse-search-history (M-p): Commands For History.
|
||
(line 36)
|
||
* overwrite-mode (): Commands For Text. (line 50)
|
||
* possible-completions (M-?): Commands For Completion.
|
||
(line 15)
|
||
* prefix-meta (<ESC>): Miscellaneous Commands.
|
||
(line 18)
|
||
* previous-history (C-p): Commands For History. (line 13)
|
||
* quoted-insert (C-q or C-v): Commands For Text. (line 20)
|
||
* re-read-init-file (C-x C-r): Miscellaneous Commands.
|
||
(line 6)
|
||
* redraw-current-line (): Commands For Moving. (line 38)
|
||
* reverse-search-history (C-r): Commands For History. (line 27)
|
||
* revert-line (M-r): Miscellaneous Commands.
|
||
(line 25)
|
||
* self-insert (a, b, A, 1, !, ...): Commands For Text. (line 24)
|
||
* set-mark (C-@): Miscellaneous Commands.
|
||
(line 32)
|
||
* skip-csi-sequence (): Miscellaneous Commands.
|
||
(line 51)
|
||
* start-kbd-macro (C-x (): Keyboard Macros. (line 6)
|
||
* transpose-chars (C-t): Commands For Text. (line 27)
|
||
* transpose-words (M-t): Commands For Text. (line 33)
|
||
* undo (C-_ or C-x C-u): Miscellaneous Commands.
|
||
(line 22)
|
||
* 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 38)
|
||
* yank (C-y): Commands For Killing. (line 68)
|
||
* yank-last-arg (M-. or M-_): Commands For History. (line 65)
|
||
* yank-nth-arg (M-C-y): Commands For History. (line 56)
|
||
* yank-pop (M-y): Commands For Killing. (line 71)
|
||
|
||
|
||
File: bashref.info, Node: Concept Index, Prev: Function Index, Up: Indexes
|
||
|
||
D.5 Concept Index
|
||
=================
|
||
|
||
[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 <1>: Exit Status. (line 6)
|
||
* exit status: Definitions. (line 26)
|
||
* 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 7)
|
||
* history expansion: History Interaction. (line 6)
|
||
* history list: Bash History Facilities.
|
||
(line 6)
|
||
* History, how to use: Programmable Completion Builtins.
|
||
(line 237)
|
||
* 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 <1>: Interactive Shells. (line 6)
|
||
* interactive shell: Invoking Bash. (line 127)
|
||
* internationalization: Locale Translation. (line 6)
|
||
* job: Definitions. (line 38)
|
||
* job control <1>: Job Control Basics. (line 6)
|
||
* job control: Definitions. (line 42)
|
||
* kill ring: Readline Killing Commands.
|
||
(line 19)
|
||
* killing text: Readline Killing Commands.
|
||
(line 6)
|
||
* localization: Locale Translation. (line 6)
|
||
* login shell: Invoking Bash. (line 124)
|
||
* 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: Printing a Prompt. (line 6)
|
||
* quoting: Quoting. (line 6)
|
||
* quoting, ANSI: ANSI-C Quoting. (line 6)
|
||
* Readline, how to use: Job Control Variables.
|
||
(line 24)
|
||
* 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 <1>: Special Builtins. (line 6)
|
||
* special builtin: Definitions. (line 82)
|
||
* 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: Top1346
|
||
Node: Introduction3185
|
||
Node: What is Bash?3413
|
||
Node: What is a shell?4526
|
||
Node: Definitions7066
|
||
Node: Basic Shell Features9984
|
||
Node: Shell Syntax11203
|
||
Node: Shell Operation12233
|
||
Node: Quoting13527
|
||
Node: Escape Character14830
|
||
Node: Single Quotes15315
|
||
Node: Double Quotes15663
|
||
Node: ANSI-C Quoting16788
|
||
Node: Locale Translation17773
|
||
Node: Comments18669
|
||
Node: Shell Commands19287
|
||
Node: Simple Commands20111
|
||
Node: Pipelines20742
|
||
Node: Lists22998
|
||
Node: Compound Commands24727
|
||
Node: Looping Constructs25531
|
||
Node: Conditional Constructs27986
|
||
Node: Command Grouping36099
|
||
Node: Coprocesses37578
|
||
Node: Shell Functions39222
|
||
Node: Shell Parameters43776
|
||
Node: Positional Parameters46192
|
||
Node: Special Parameters47092
|
||
Node: Shell Expansions50056
|
||
Node: Brace Expansion51981
|
||
Node: Tilde Expansion54736
|
||
Node: Shell Parameter Expansion57087
|
||
Node: Command Substitution65988
|
||
Node: Arithmetic Expansion67321
|
||
Node: Process Substitution68171
|
||
Node: Word Splitting69221
|
||
Node: Filename Expansion70844
|
||
Node: Pattern Matching72983
|
||
Node: Quote Removal76622
|
||
Node: Redirections76917
|
||
Node: Executing Commands85442
|
||
Node: Simple Command Expansion86112
|
||
Node: Command Search and Execution88042
|
||
Node: Command Execution Environment90379
|
||
Node: Environment93365
|
||
Node: Exit Status95025
|
||
Node: Signals96646
|
||
Node: Shell Scripts98614
|
||
Node: Shell Builtin Commands101132
|
||
Node: Bourne Shell Builtins103160
|
||
Node: Bash Builtins120536
|
||
Node: Modifying Shell Behavior145364
|
||
Node: The Set Builtin145709
|
||
Node: The Shopt Builtin155233
|
||
Node: Special Builtins166095
|
||
Node: Shell Variables167074
|
||
Node: Bourne Shell Variables167514
|
||
Node: Bash Variables169495
|
||
Node: Bash Features192981
|
||
Node: Invoking Bash193864
|
||
Node: Bash Startup Files199673
|
||
Node: Interactive Shells204685
|
||
Node: What is an Interactive Shell?205095
|
||
Node: Is this Shell Interactive?205744
|
||
Node: Interactive Shell Behavior206559
|
||
Node: Bash Conditional Expressions209839
|
||
Node: Shell Arithmetic213488
|
||
Node: Aliases216234
|
||
Node: Arrays218806
|
||
Node: The Directory Stack222764
|
||
Node: Directory Stack Builtins223478
|
||
Node: Printing a Prompt226370
|
||
Node: The Restricted Shell229122
|
||
Node: Bash POSIX Mode230954
|
||
Node: Job Control239011
|
||
Node: Job Control Basics239471
|
||
Node: Job Control Builtins244188
|
||
Node: Job Control Variables248552
|
||
Node: Command Line Editing249710
|
||
Node: Introduction and Notation251277
|
||
Node: Readline Interaction252899
|
||
Node: Readline Bare Essentials254090
|
||
Node: Readline Movement Commands255879
|
||
Node: Readline Killing Commands256844
|
||
Node: Readline Arguments258764
|
||
Node: Searching259808
|
||
Node: Readline Init File261994
|
||
Node: Readline Init File Syntax263141
|
||
Node: Conditional Init Constructs277628
|
||
Node: Sample Init File280161
|
||
Node: Bindable Readline Commands283278
|
||
Node: Commands For Moving284485
|
||
Node: Commands For History285629
|
||
Node: Commands For Text288784
|
||
Node: Commands For Killing291457
|
||
Node: Numeric Arguments293908
|
||
Node: Commands For Completion295047
|
||
Node: Keyboard Macros299007
|
||
Node: Miscellaneous Commands299578
|
||
Node: Readline vi Mode305384
|
||
Node: Programmable Completion306298
|
||
Node: Programmable Completion Builtins313504
|
||
Node: Using History Interactively322640
|
||
Node: Bash History Facilities323324
|
||
Node: Bash History Builtins326238
|
||
Node: History Interaction330095
|
||
Node: Event Designators332800
|
||
Node: Word Designators333815
|
||
Node: Modifiers335454
|
||
Node: Installing Bash336858
|
||
Node: Basic Installation337995
|
||
Node: Compilers and Options340687
|
||
Node: Compiling For Multiple Architectures341428
|
||
Node: Installation Names343092
|
||
Node: Specifying the System Type343910
|
||
Node: Sharing Defaults344626
|
||
Node: Operation Controls345299
|
||
Node: Optional Features346257
|
||
Node: Reporting Bugs355816
|
||
Node: Major Differences From The Bourne Shell357017
|
||
Node: GNU Free Documentation License373704
|
||
Node: Indexes398900
|
||
Node: Builtin Index399354
|
||
Node: Reserved Word Index406181
|
||
Node: Variable Index408629
|
||
Node: Function Index420722
|
||
Node: Concept Index427731
|
||
|
||
End Tag Table
|