|
.\" |
|
.\" MAN PAGE COMMENTS to |
|
.\" |
|
.\" Chet Ramey |
|
.\" Information Network Services |
|
.\" Case Western Reserve University |
|
.\" chet.ramey@case.edu |
|
.\" |
|
.\" Last Change: Fri Jul 17 09:43:01 EDT 2020 |
|
.\" |
|
.TH HISTORY 3 "2020 July 17" "GNU History 8.1" |
|
.\" |
|
.\" File Name macro. This used to be `.PN', for Path Name, |
|
.\" but Sun doesn't seem to like that very much. |
|
.\" |
|
.de FN |
|
\fI\|\\$1\|\fP |
|
.. |
|
.ds lp \fR\|(\fP |
|
.ds rp \fR\|)\fP |
|
.\" FnN return-value fun-name N arguments |
|
.de Fn1 |
|
\fI\\$1\fP \fB\\$2\fP \\*(lp\fI\\$3\fP\\*(rp |
|
.br |
|
.. |
|
.de Fn2 |
|
.if t \fI\\$1\fP \fB\\$2\fP \\*(lp\fI\\$3,\|\\$4\fP\\*(rp |
|
.if n \fI\\$1\fP \fB\\$2\fP \\*(lp\fI\\$3, \\$4\fP\\*(rp |
|
.br |
|
.. |
|
.de Fn3 |
|
.if t \fI\\$1\fP \fB\\$2\fP \\*(lp\fI\\$3,\|\\$4,\|\\$5\fP\|\\*(rp |
|
.if n \fI\\$1\fP \fB\\$2\fP \\*(lp\fI\\$3, \\$4, \\$5\fP\\*(rp |
|
.br |
|
.. |
|
.de Vb |
|
\fI\\$1\fP \fB\\$2\fP |
|
.br |
|
.. |
|
.SH NAME |
|
history \- GNU History Library |
|
.SH COPYRIGHT |
|
.if t The GNU History Library is Copyright \(co 1989-2020 by the Free Software Foundation, Inc. |
|
.if n The GNU History Library is Copyright (C) 1989-2020 by the Free Software Foundation, Inc. |
|
.SH DESCRIPTION |
|
Many programs read input from the user a line at a time. The GNU |
|
History library is able to keep track of those lines, associate arbitrary |
|
data with each line, and utilize information from previous lines in |
|
composing new ones. |
|
.PP |
|
.SH "HISTORY EXPANSION" |
|
The history library supports a history expansion feature that |
|
is identical to the history expansion in |
|
.BR bash. |
|
This section describes what syntax features are available. |
|
.PP |
|
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. |
|
.PP |
|
History expansion is usually performed immediately after a complete line |
|
is read. |
|
It takes place in two parts. |
|
The first is to determine which line from the history list |
|
to use during substitution. |
|
The second is to select portions of that line for inclusion into |
|
the current one. |
|
The line selected from the history is the \fIevent\fP, |
|
and the portions of that line that are acted upon are \fIwords\fP. |
|
Various \fImodifiers\fP are available to manipulate the selected words. |
|
The line is broken into words in the same fashion as \fBbash\fP |
|
does when reading input, |
|
so that several words that would otherwise be separated |
|
are considered one word when surrounded by quotes (see the |
|
description of \fBhistory_tokenize()\fP below). |
|
History expansions are introduced by the appearance of the |
|
history expansion character, which is \^\fB!\fP\^ by default. |
|
Only backslash (\^\fB\e\fP\^) and single quotes can quote |
|
the history expansion character. |
|
.SS Event Designators |
|
An event designator is a reference to a command line entry in the |
|
history list. |
|
Unless the reference is absolute, events are relative to the current |
|
position in the history list. |
|
.PP |
|
.PD 0 |
|
.TP |
|
.B ! |
|
Start a history substitution, except when followed by a |
|
.BR blank , |
|
newline, = or (. |
|
.TP |
|
.B !\fIn\fR |
|
Refer to command line |
|
.IR n . |
|
.TP |
|
.B !\-\fIn\fR |
|
Refer to the current command minus |
|
.IR n . |
|
.TP |
|
.B !! |
|
Refer to the previous command. This is a synonym for `!\-1'. |
|
.TP |
|
.B !\fIstring\fR |
|
Refer to the most recent command |
|
preceding the current position in the history list |
|
starting with |
|
.IR string . |
|
.TP |
|
.B !?\fIstring\fR\fB[?]\fR |
|
Refer to the most recent command |
|
preceding the current position in the history list |
|
containing |
|
.IR string . |
|
The trailing \fB?\fP may be omitted if |
|
.I string |
|
is followed immediately by a newline. |
|
If \fIstring\fP is missing, the string from the most recent search is used; |
|
it is an error if there is no previous search string. |
|
.TP |
|
.B \d\s+2^\s-2\u\fIstring1\fP\d\s+2^\s-2\u\fIstring2\fP\d\s+2^\s-2\u |
|
Quick substitution. Repeat the last command, replacing |
|
.I string1 |
|
with |
|
.IR string2 . |
|
Equivalent to |
|
``!!:s\d\s+2^\s-2\u\fIstring1\fP\d\s+2^\s-2\u\fIstring2\fP\d\s+2^\s-2\u'' |
|
(see \fBModifiers\fP below). |
|
.TP |
|
.B !# |
|
The entire command line typed so far. |
|
.PD |
|
.SS Word Designators |
|
Word designators are used to select desired words from the event. |
|
A |
|
.B : |
|
separates the event specification from the word designator. |
|
It may be omitted if the word designator begins with a |
|
.BR ^ , |
|
.BR $ , |
|
.BR * , |
|
.BR \- , |
|
or |
|
.BR % . |
|
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. |
|
.PP |
|
.PD 0 |
|
.TP |
|
.B 0 (zero) |
|
The zeroth word. For the shell, this is the command |
|
word. |
|
.TP |
|
.I n |
|
The \fIn\fRth word. |
|
.TP |
|
.B ^ |
|
The first argument. That is, word 1. |
|
.TP |
|
.B $ |
|
The last word. This is usually the last argument, but will expand to the |
|
zeroth word if there is only one word in the line. |
|
.TP |
|
.B % |
|
The first word matched by the most recent `?\fIstring\fR?' search, |
|
if the search string begins with a character that is part of a word. |
|
.TP |
|
.I x\fB\-\fPy |
|
A range of words; `\-\fIy\fR' abbreviates `0\-\fIy\fR'. |
|
.TP |
|
.B * |
|
All of the words but the zeroth. This is a synonym |
|
for `\fI1\-$\fP'. It is not an error to use |
|
.B * |
|
if there is just one |
|
word in the event; the empty string is returned in that case. |
|
.TP |
|
.B x* |
|
Abbreviates \fIx\-$\fP. |
|
.TP |
|
.B x\- |
|
Abbreviates \fIx\-$\fP like \fBx*\fP, but omits the last word. |
|
If \fBx\fP is missing, it defaults to 0. |
|
.PD |
|
.PP |
|
If a word designator is supplied without an event specification, the |
|
previous command is used as the event. |
|
.SS Modifiers |
|
After the optional word designator, there may appear a sequence of |
|
one or more of the following modifiers, each preceded by a `:'. |
|
These modify, or edit, the word or words selected from the history event. |
|
.PP |
|
.PD 0 |
|
.PP |
|
.TP |
|
.B h |
|
Remove a trailing file name component, leaving only the head. |
|
.TP |
|
.B t |
|
Remove all leading file name components, leaving the tail. |
|
.TP |
|
.B r |
|
Remove a trailing suffix of the form \fI.xxx\fP, leaving the |
|
basename. |
|
.TP |
|
.B e |
|
Remove all but the trailing suffix. |
|
.TP |
|
.B p |
|
Print the new command but do not execute it. |
|
.TP |
|
.B q |
|
Quote the substituted words, escaping further substitutions. |
|
.TP |
|
.B x |
|
Quote the substituted words as with |
|
.BR q , |
|
but break into words at |
|
.B blanks |
|
and newlines. |
|
The \fBq\fP and \fBx\fP modifiers are mutually exclusive; the last one |
|
supplied is used. |
|
.TP |
|
.B s/\fIold\fP/\fInew\fP/ |
|
Substitute |
|
.I new |
|
for the first occurrence of |
|
.I old |
|
in the event line. |
|
Any character may be used as the delimiter in place of /. |
|
The final delimiter is optional if it is the last character of the |
|
event line. |
|
The delimiter may be quoted in |
|
.I old |
|
and |
|
.I new |
|
with a single backslash. If & appears in |
|
.IR new , |
|
it is replaced by |
|
.IR old . |
|
A single backslash will quote the &. |
|
If |
|
.I old |
|
is null, it is set to the last |
|
.I old |
|
substituted, or, if no previous history substitutions took place, |
|
the last |
|
.I string |
|
in a |
|
.B !?\fIstring\fR\fB[?]\fR |
|
search. |
|
If |
|
.I new |
|
is null, each matching |
|
.I old |
|
is deleted. |
|
.TP |
|
.B & |
|
Repeat the previous substitution. |
|
.TP |
|
.B g |
|
Cause changes to be applied over the entire event line. This is |
|
used in conjunction with `\fB:s\fP' (e.g., `\fB:gs/\fIold\fP/\fInew\fP/\fR') |
|
or `\fB:&\fP'. If used with |
|
`\fB:s\fP', any delimiter can be used |
|
in place of /, and the final delimiter is optional |
|
if it is the last character of the event line. |
|
An \fBa\fP may be used as a synonym for \fBg\fP. |
|
.TP |
|
.B G |
|
Apply the following `\fBs\fP' or `\fB&\fP' modifier once to each word |
|
in the event line. |
|
.PD |
|
.SH "PROGRAMMING WITH HISTORY FUNCTIONS" |
|
This section describes how to use the History library in other programs. |
|
.SS Introduction to History |
|
A programmer using the History library has available functions |
|
for remembering lines on a history list, associating arbitrary data |
|
with a line, removing lines from the list, searching through the list |
|
for a line containing an arbitrary text string, and referencing any line |
|
in the list directly. In addition, a history \fIexpansion\fP function |
|
is available which provides for a consistent user interface across |
|
different programs. |
|
.PP |
|
The user using programs written with the History library has the |
|
benefit of a consistent user interface with a set of well-known |
|
commands for manipulating the text of previous lines and using that text |
|
in new commands. The basic history manipulation commands are |
|
identical to |
|
the history substitution provided by \fBbash\fP. |
|
.PP |
|
The programmer can also use the readline library, which |
|
includes some history manipulation by default, and has the added |
|
advantage of command line editing. |
|
.PP |
|
Before declaring any functions using any functionality the History |
|
library provides in other code, an application writer should include |
|
the file |
|
.FN <readline/history.h> |
|
in any file that uses the |
|
History library's features. It supplies extern declarations for all |
|
of the library's public functions and variables, and declares all of |
|
the public data structures. |
|
.SS History Storage |
|
The history list is an array of history entries. A history entry is |
|
declared as follows: |
|
.PP |
|
.Vb "typedef void *" histdata_t; |
|
.PP |
|
.nf |
|
typedef struct _hist_entry { |
|
char *line; |
|
char *timestamp; |
|
histdata_t data; |
|
} HIST_ENTRY; |
|
.fi |
|
.PP |
|
The history list itself might therefore be declared as |
|
.PP |
|
.Vb "HIST_ENTRY **" the_history_list; |
|
.PP |
|
The state of the History library is encapsulated into a single structure: |
|
.PP |
|
.nf |
|
/* |
|
* A structure used to pass around the current state of the history. |
|
*/ |
|
typedef struct _hist_state { |
|
HIST_ENTRY **entries; /* Pointer to the entries themselves. */ |
|
int offset; /* The location pointer within this array. */ |
|
int length; /* Number of elements within this array. */ |
|
int size; /* Number of slots allocated to this array. */ |
|
int flags; |
|
} HISTORY_STATE; |
|
.fi |
|
.PP |
|
If the flags member includes \fBHS_STIFLED\fP, the history has been |
|
stifled. |
|
.SH "History Functions" |
|
This section describes the calling sequence for the various functions |
|
exported by the GNU History library. |
|
.SS Initializing History and State Management |
|
This section describes functions used to initialize and manage |
|
the state of the History library when you want to use the history |
|
functions in your program. |
|
|
|
.Fn1 void using_history void |
|
Begin a session in which the history functions might be used. This |
|
initializes the interactive variables. |
|
|
|
.Fn1 "HISTORY_STATE *" history_get_history_state void |
|
Return a structure describing the current state of the input history. |
|
|
|
.Fn1 void history_set_history_state "HISTORY_STATE *state" |
|
Set the state of the history list according to \fIstate\fP. |
|
|
|
.SS History List Management |
|
These functions manage individual entries on the history list, or set |
|
parameters managing the list itself. |
|
|
|
.Fn1 void add_history "const char *string" |
|
Place \fIstring\fP at the end of the history list. The associated data |
|
field (if any) is set to \fBNULL\fP. |
|
If the maximum number of history entries has been set using |
|
\fBstifle_history()\fP, and the new number of history entries would exceed |
|
that maximum, the oldest history entry is removed. |
|
|
|
.Fn1 void add_history_time "const char *string" |
|
Change the time stamp associated with the most recent history entry to |
|
\fIstring\fP. |
|
|
|
.Fn1 "HIST_ENTRY *" remove_history "int which" |
|
Remove history entry at offset \fIwhich\fP from the history. The |
|
removed element is returned so you can free the line, data, |
|
and containing structure. |
|
|
|
.Fn1 "histdata_t" free_history_entry "HIST_ENTRY *histent" |
|
Free the history entry \fIhistent\fP and any history library private |
|
data associated with it. Returns the application-specific data |
|
so the caller can dispose of it. |
|
|
|
.Fn3 "HIST_ENTRY *" replace_history_entry "int which" "const char *line" "histdata_t data" |
|
Make the history entry at offset \fIwhich\fP have \fIline\fP and \fIdata\fP. |
|
This returns the old entry so the caller can dispose of any |
|
application-specific data. In the case |
|
of an invalid \fIwhich\fP, a \fBNULL\fP pointer is returned. |
|
|
|
.Fn1 void clear_history "void" |
|
Clear the history list by deleting all the entries. |
|
|
|
.Fn1 void stifle_history "int max" |
|
Stifle the history list, remembering only the last \fImax\fP entries. |
|
The history list will contain only \fImax\fP entries at a time. |
|
|
|
.Fn1 int unstifle_history "void" |
|
Stop stifling the history. This returns the previously-set |
|
maximum number of history entries (as set by \fBstifle_history()\fP). |
|
history was stifled. The value is positive if the history was |
|
stifled, negative if it wasn't. |
|
|
|
.Fn1 int history_is_stifled "void" |
|
Returns non-zero if the history is stifled, zero if it is not. |
|
|
|
.SS Information About the History List |
|
|
|
These functions return information about the entire history list or |
|
individual list entries. |
|
|
|
.Fn1 "HIST_ENTRY **" history_list "void" |
|
Return a \fBNULL\fP terminated array of \fIHIST_ENTRY *\fP which is the |
|
current input history. Element 0 of this list is the beginning of time. |
|
If there is no history, return \fBNULL\fP. |
|
|
|
.Fn1 int where_history "void" |
|
Returns the offset of the current history element. |
|
|
|
.Fn1 "HIST_ENTRY *" current_history "void" |
|
Return the history entry at the current position, as determined by |
|
\fBwhere_history()\fP. If there is no entry there, return a \fBNULL\fP |
|
pointer. |
|
|
|
.Fn1 "HIST_ENTRY *" history_get "int offset" |
|
Return the history entry at position \fIoffset\fP. |
|
The range of valid values of \fIoffset\fP starts at \fBhistory_base\fP |
|
and ends at \fBhistory_length\fP \- 1. |
|
If there is no entry there, or if \fIoffset\fP is outside the valid |
|
range, return a \fBNULL\fP pointer. |
|
|
|
.Fn1 "time_t" history_get_time "HIST_ENTRY *" |
|
Return the time stamp associated with the history entry passed as the argument. |
|
|
|
.Fn1 int history_total_bytes "void" |
|
Return the number of bytes that the primary history entries are using. |
|
This function returns the sum of the lengths of all the lines in the |
|
history. |
|
|
|
.SS Moving Around the History List |
|
|
|
These functions allow the current index into the history list to be |
|
set or changed. |
|
|
|
.Fn1 int history_set_pos "int pos" |
|
Set the current history offset to \fIpos\fP, an absolute index |
|
into the list. |
|
Returns 1 on success, 0 if \fIpos\fP is less than zero or greater |
|
than the number of history entries. |
|
|
|
.Fn1 "HIST_ENTRY *" previous_history "void" |
|
Back up the current history offset to the previous history entry, and |
|
return a pointer to that entry. If there is no previous entry, return |
|
a \fBNULL\fP pointer. |
|
|
|
.Fn1 "HIST_ENTRY *" next_history "void" |
|
If the current history offset refers to a valid history entry, |
|
increment the current history offset. |
|
If the possibly-incremented history offset refers to a valid history |
|
entry, return a pointer to that entry; |
|
otherwise, return a \fBNULL\fP pointer. |
|
|
|
.SS Searching the History List |
|
|
|
These functions allow searching of the history list for entries containing |
|
a specific string. Searching may be performed both forward and backward |
|
from the current history position. The search may be \fIanchored\fP, |
|
meaning that the string must match at the beginning of the history entry. |
|
|
|
.Fn2 int history_search "const char *string" "int direction" |
|
Search the history for \fIstring\fP, starting at the current history offset. |
|
If \fIdirection\fP is less than 0, then the search is through |
|
previous entries, otherwise through subsequent entries. |
|
If \fIstring\fP is found, then |
|
the current history index is set to that history entry, and the value |
|
returned is the offset in the line of the entry where |
|
\fIstring\fP was found. Otherwise, nothing is changed, and a -1 is |
|
returned. |
|
|
|
.Fn2 int history_search_prefix "const char *string" "int direction" |
|
Search the history for \fIstring\fP, starting at the current history |
|
offset. The search is anchored: matching lines must begin with |
|
\fIstring\fP. If \fIdirection\fP is less than 0, then the search is |
|
through previous entries, otherwise through subsequent entries. |
|
If \fIstring\fP is found, then the |
|
current history index is set to that entry, and the return value is 0. |
|
Otherwise, nothing is changed, and a -1 is returned. |
|
|
|
.Fn3 int history_search_pos "const char *string" "int direction" "int pos" |
|
Search for \fIstring\fP in the history list, starting at \fIpos\fP, an |
|
absolute index into the list. If \fIdirection\fP is negative, the search |
|
proceeds backward from \fIpos\fP, otherwise forward. Returns the absolute |
|
index of the history element where \fIstring\fP was found, or -1 otherwise. |
|
|
|
.SS Managing the History File |
|
The History library can read the history from and write it to a file. |
|
This section documents the functions for managing a history file. |
|
|
|
.Fn1 int read_history "const char *filename" |
|
Add the contents of \fIfilename\fP to the history list, a line at a time. |
|
If \fIfilename\fP is \fBNULL\fP, then read from \fI~/.history\fP. |
|
Returns 0 if successful, or \fBerrno\fP if not. |
|
|
|
.Fn3 int read_history_range "const char *filename" "int from" "int to" |
|
Read a range of lines from \fIfilename\fP, adding them to the history list. |
|
Start reading at line \fIfrom\fP and end at \fIto\fP. |
|
If \fIfrom\fP is zero, start at the beginning. If \fIto\fP is less than |
|
\fIfrom\fP, then read until the end of the file. If \fIfilename\fP is |
|
\fBNULL\fP, then read from \fI~/.history\fP. Returns 0 if successful, |
|
or \fBerrno\fP if not. |
|
|
|
.Fn1 int write_history "const char *filename" |
|
Write the current history to \fIfilename\fP, overwriting \fIfilename\fP |
|
if necessary. |
|
If \fIfilename\fP is \fBNULL\fP, then write the history list to \fI~/.history\fP. |
|
Returns 0 on success, or \fBerrno\fP on a read or write error. |
|
|
|
|
|
.Fn2 int append_history "int nelements" "const char *filename" |
|
Append the last \fInelements\fP of the history list to \fIfilename\fP. |
|
If \fIfilename\fP is \fBNULL\fP, then append to \fI~/.history\fP. |
|
Returns 0 on success, or \fBerrno\fP on a read or write error. |
|
|
|
.Fn2 int history_truncate_file "const char *filename" "int nlines" |
|
Truncate the history file \fIfilename\fP, leaving only the last |
|
\fInlines\fP lines. |
|
If \fIfilename\fP is \fBNULL\fP, then \fI~/.history\fP is truncated. |
|
Returns 0 on success, or \fBerrno\fP on failure. |
|
|
|
.SS History Expansion |
|
|
|
These functions implement history expansion. |
|
|
|
.Fn2 int history_expand "char *string" "char **output" |
|
Expand \fIstring\fP, placing the result into \fIoutput\fP, a pointer |
|
to a string. Returns: |
|
.RS |
|
.PD 0 |
|
.TP |
|
0 |
|
If no expansions took place (or, if the only change in |
|
the text was the removal of escape characters preceding the history expansion |
|
character); |
|
.TP |
|
1 |
|
if expansions did take place; |
|
.TP |
|
-1 |
|
if there was an error in expansion; |
|
.TP |
|
2 |
|
if the returned line should be displayed, but not executed, |
|
as with the \fB:p\fP modifier. |
|
.PD |
|
.RE |
|
If an error occurred in expansion, then \fIoutput\fP contains a descriptive |
|
error message. |
|
|
|
.Fn3 "char *" get_history_event "const char *string" "int *cindex" "int qchar" |
|
Returns the text of the history event beginning at \fIstring\fP + |
|
\fI*cindex\fP. \fI*cindex\fP is modified to point to after the event |
|
specifier. At function entry, \fIcindex\fP points to the index into |
|
\fIstring\fP where the history event specification begins. \fIqchar\fP |
|
is a character that is allowed to end the event specification in addition |
|
to the ``normal'' terminating characters. |
|
|
|
.Fn1 "char **" history_tokenize "const char *string" |
|
Return an array of tokens parsed out of \fIstring\fP, much as the |
|
shell might. |
|
The tokens are split on the characters in the |
|
\fBhistory_word_delimiters\fP variable, |
|
and shell quoting conventions are obeyed. |
|
|
|
.Fn3 "char *" history_arg_extract "int first" "int last" "const char *string" |
|
Extract a string segment consisting of the \fIfirst\fP through \fIlast\fP |
|
arguments present in \fIstring\fP. Arguments are split using |
|
\fBhistory_tokenize()\fP. |
|
|
|
.SS History Variables |
|
|
|
This section describes the externally-visible variables exported by |
|
the GNU History Library. |
|
|
|
.Vb int history_base |
|
The logical offset of the first entry in the history list. |
|
|
|
.Vb int history_length |
|
The number of entries currently stored in the history list. |
|
|
|
.Vb int history_max_entries |
|
The maximum number of history entries. This must be changed using |
|
\fBstifle_history()\fP. |
|
|
|
.Vb int history_write_timestamps |
|
If non-zero, timestamps are written to the history file, so they can be |
|
preserved between sessions. The default value is 0, meaning that |
|
timestamps are not saved. |
|
The current timestamp format uses the value of \fIhistory_comment_char\fP |
|
to delimit timestamp entries in the history file. If that variable does |
|
not have a value (the default), timestamps will not be written. |
|
|
|
.Vb char history_expansion_char |
|
The character that introduces a history event. The default is \fB!\fP. |
|
Setting this to 0 inhibits history expansion. |
|
|
|
.Vb char history_subst_char |
|
The character that invokes word substitution if found at the start of |
|
a line. The default is \fB^\fP. |
|
|
|
.Vb char history_comment_char |
|
During tokenization, if this character is seen as the first character |
|
of a word, then it and all subsequent characters up to a newline are |
|
ignored, suppressing history expansion for the remainder of the line. |
|
This is disabled by default. |
|
|
|
.Vb "char *" history_word_delimiters |
|
The characters that separate tokens for \fBhistory_tokenize()\fP. |
|
The default value is \fB"\ \et\en()<>;&|"\fP. |
|
|
|
.Vb "char *" history_no_expand_chars |
|
The list of characters which inhibit history expansion if found immediately |
|
following \fBhistory_expansion_char\fP. The default is space, tab, newline, |
|
\fB\er\fP, and \fB=\fP. |
|
|
|
.Vb "char *" history_search_delimiter_chars |
|
The list of additional characters which can delimit a history search |
|
string, in addition to space, tab, \fI:\fP and \fI?\fP in the case of |
|
a substring search. The default is empty. |
|
|
|
.Vb int history_quotes_inhibit_expansion |
|
If non-zero, double-quoted words are not scanned for the history expansion |
|
character or the history comment character. The default value is 0. |
|
|
|
.Vb "rl_linebuf_func_t *" history_inhibit_expansion_function |
|
This should be set to the address of a function that takes two arguments: |
|
a \fBchar *\fP (\fIstring\fP) |
|
and an \fBint\fP index into that string (\fIi\fP). |
|
It should return a non-zero value if the history expansion starting at |
|
\fIstring[i]\fP should not be performed; zero if the expansion should |
|
be done. |
|
It is intended for use by applications like \fBbash\fP that use the history |
|
expansion character for additional purposes. |
|
By default, this variable is set to \fBNULL\fP. |
|
.SH FILES |
|
.PD 0 |
|
.TP |
|
.FN ~/.history |
|
Default filename for reading and writing saved history |
|
.PD |
|
.SH "SEE ALSO" |
|
.PD 0 |
|
.TP |
|
\fIThe Gnu Readline Library\fP, Brian Fox and Chet Ramey |
|
.TP |
|
\fIThe Gnu History Library\fP, Brian Fox and Chet Ramey |
|
.TP |
|
\fIbash\fP(1) |
|
.TP |
|
\fIreadline\fP(3) |
|
.PD |
|
.SH AUTHORS |
|
Brian Fox, Free Software Foundation |
|
.br |
|
bfox@gnu.org |
|
.PP |
|
Chet Ramey, Case Western Reserve University |
|
.br |
|
chet.ramey@case.edu |
|
.SH BUG REPORTS |
|
If you find a bug in the |
|
.B history |
|
library, you should report it. But first, you should |
|
make sure that it really is a bug, and that it appears in the latest |
|
version of the |
|
.B history |
|
library that you have. |
|
.PP |
|
Once you have determined that a bug actually exists, mail a |
|
bug report to \fIbug\-readline\fP@\fIgnu.org\fP. |
|
If you have a fix, you are welcome to mail that |
|
as well! Suggestions and `philosophical' bug reports may be mailed |
|
to \fPbug-readline\fP@\fIgnu.org\fP or posted to the Usenet |
|
newsgroup |
|
.BR gnu.bash.bug . |
|
.PP |
|
Comments and bug reports concerning |
|
this manual page should be directed to |
|
.IR chet.ramey@case.edu . |
|
|