readline/doc/history.info

   1 This is Info file history.info, produced by Makeinfo version 1.68 from
   2 the input file /usr/homes/chet/src/bash/readline-src/doc/hist.texinfo.
   3
   4 INFO-DIR-SECTION Libraries
   5 START-INFO-DIR-ENTRY
   6 * History: (history).       The GNU history library API
   7 END-INFO-DIR-ENTRY
   8
   9    This document describes the GNU History library, a programming tool
  10 that provides a consistent user interface for recalling lines of
  11 previously typed input.
  12
  13    Copyright (C) 1988-1999 Free Software Foundation, Inc.
  14
  15    Permission is granted to make and distribute verbatim copies of this
  16 manual provided the copyright notice and this permission notice pare
  17 preserved on all copies.
  18
  19    Permission is granted to copy and distribute modified versions of
  20 this manual under the conditions for verbatim copying, provided that
  21 the entire resulting derived work is distributed under the terms of a
  22 permission notice identical to this one.
  23
  24    Permission is granted to copy and distribute translations of this
  25 manual into another language, under the above conditions for modified
  26 versions, except that this permission notice may be stated in a
  27 translation approved by the Free Software Foundation.
  28
  29 \1f
  30 File: history.info,  Node: Top,  Next: Using History Interactively,  Up: (dir)
  31
  32 GNU History Library
  33 *******************
  34
  35    This document describes the GNU History library, a programming tool
  36 that provides a consistent user interface for recalling lines of
  37 previously typed input.
  38
  39 * Menu:
  40
  41 * Using History Interactively::   GNU History User's Manual.
  42 * Programming with GNU History::  GNU History Programmer's Manual.
  43 * Concept Index::                 Index of concepts described in this manual.
  44 * Function and Variable Index::   Index of externally visible functions
  45                                   and variables.
  46
  47 \1f
  48 File: history.info,  Node: Using History Interactively,  Next: Programming with GNU History,  Prev: Top,  Up: Top
  49
  50 Using History Interactively
  51 ***************************
  52
  53    This chapter describes how to use the GNU History Library
  54 interactively, from a user's standpoint.  It should be considered a
  55 user's guide.  For information on using the GNU History Library in your
  56 own programs, *note Programming with GNU History::..
  57
  58 * Menu:
  59
  60 * History Interaction::         What it feels like using History as a user.
  61
  62 \1f
  63 File: history.info,  Node: History Interaction,  Up: Using History Interactively
  64
  65 History Expansion
  66 =================
  67
  68    The History library provides a history expansion feature that is
  69 similar to the history expansion provided by `csh'.  This section
  70 describes the syntax used to manipulate the history information.
  71
  72    History expansions introduce words from the history list into the
  73 input stream, making it easy to repeat commands, insert the arguments
  74 to a previous command into the current input line, or fix errors in
  75 previous commands quickly.
  76
  77    History expansion takes place in two parts.  The first is to
  78 determine which line from the history list should be used during
  79 substitution.  The second is to select portions of that line for
  80 inclusion into the current one.  The line selected from the history is
  81 called the "event", and the portions of that line that are acted upon
  82 are called "words".  Various "modifiers" are available to manipulate
  83 the selected words.  The line is broken into words in the same fashion
  84 that Bash does, so that several words surrounded by quotes are
  85 considered one word.  History expansions are introduced by the
  86 appearance of the history expansion character, which is `!' by default.
  87
  88 * Menu:
  89
  90 * Event Designators::   How to specify which history line to use.
  91 * Word Designators::    Specifying which words are of interest.
  92 * Modifiers::           Modifying the results of substitution.
  93
  94 \1f
  95 File: history.info,  Node: Event Designators,  Next: Word Designators,  Up: History Interaction
  96
  97 Event Designators
  98 -----------------
  99
 100    An event designator is a reference to a command line entry in the
 101 history list.
 102
 103 `!'
 104      Start a history substitution, except when followed by a space, tab,
 105      the end of the line, `=' or `('.
 106
 107 `!N'
 108      Refer to command line N.
 109
 110 `!-N'
 111      Refer to the command N lines back.
 112
 113 `!!'
 114      Refer to the previous command.  This is a synonym for `!-1'.
 115
 116 `!STRING'
 117      Refer to the most recent command starting with STRING.
 118
 119 `!?STRING[?]'
 120      Refer to the most recent command containing STRING.  The trailing
 121      `?' may be omitted if the STRING is followed immediately by a
 122      newline.
 123
 124 `^STRING1^STRING2^'
 125      Quick Substitution.  Repeat the last command, replacing STRING1
 126      with STRING2.  Equivalent to `!!:s/STRING1/STRING2/'.
 127
 128 `!#'
 129      The entire command line typed so far.
 130
 131 \1f
 132 File: history.info,  Node: Word Designators,  Next: Modifiers,  Prev: Event Designators,  Up: History Interaction
 133
 134 Word Designators
 135 ----------------
 136
 137    Word designators are used to select desired words from the event.  A
 138 `:' separates the event specification from the word designator.  It may
 139 be omitted if the word designator begins with a `^', `$', `*', `-', or
 140 `%'.  Words are numbered from the beginning of the line, with the first
 141 word being denoted by 0 (zero).  Words are inserted into the current
 142 line separated by single spaces.
 143
 144    For example,
 145
 146 `!!'
 147      designates the preceding command.  When you type this, the
 148      preceding command is repeated in toto.
 149
 150 `!!:$'
 151      designates the last argument of the preceding command.  This may be
 152      shortened to `!$'.
 153
 154 `!fi:2'
 155      designates the second argument of the most recent command starting
 156      with the letters `fi'.
 157
 158    Here are the word designators:
 159
 160 `0 (zero)'
 161      The `0'th word.  For many applications, this is the command word.
 162
 163 `N'
 164      The Nth word.
 165
 166 `^'
 167      The first argument; that is, word 1.
 168
 169 `$'
 170      The last argument.
 171
 172 `%'
 173      The word matched by the most recent `?STRING?' search.
 174
 175 `X-Y'
 176      A range of words; `-Y' abbreviates `0-Y'.
 177
 178 `*'
 179      All of the words, except the `0'th.  This is a synonym for `1-$'.
 180      It is not an error to use `*' if there is just one word in the
 181      event; the empty string is returned in that case.
 182
 183 `X*'
 184      Abbreviates `X-$'
 185
 186 `X-'
 187      Abbreviates `X-$' like `X*', but omits the last word.
 188
 189    If a word designator is supplied without an event specification, the
 190 previous command is used as the event.
 191
 192 \1f
 193 File: history.info,  Node: Modifiers,  Prev: Word Designators,  Up: History Interaction
 194
 195 Modifiers
 196 ---------
 197
 198    After the optional word designator, you can add a sequence of one or
 199 more of the following modifiers, each preceded by a `:'.
 200
 201 `h'
 202      Remove a trailing pathname component, leaving only the head.
 203
 204 `t'
 205      Remove all leading  pathname  components, leaving the tail.
 206
 207 `r'
 208      Remove a trailing suffix of the form `.SUFFIX', leaving the
 209      basename.
 210
 211 `e'
 212      Remove all but the trailing suffix.
 213
 214 `p'
 215      Print the new command but do not execute it.
 216
 217 `s/OLD/NEW/'
 218      Substitute NEW for the first occurrence of OLD in the event line.
 219      Any delimiter may be used in place of `/'.  The delimiter may be
 220      quoted in OLD and NEW with a single backslash.  If `&' appears in
 221      NEW, it is replaced by OLD.  A single backslash will quote the
 222      `&'.  The final delimiter is optional if it is the last character
 223      on the input line.
 224
 225 `&'
 226      Repeat the previous substitution.
 227
 228 `g'
 229      Cause changes to be applied over the entire event line.  Used in
 230      conjunction with `s', as in `gs/OLD/NEW/', or with `&'.
 231
 232 \1f
 233 File: history.info,  Node: Programming with GNU History,  Next: Concept Index,  Prev: Using History Interactively,  Up: Top
 234
 235 Programming with GNU History
 236 ****************************
 237
 238    This chapter describes how to interface programs that you write with
 239 the GNU History Library.  It should be considered a technical guide.
 240 For information on the interactive use of GNU History, *note Using
 241 History Interactively::..
 242
 243 * Menu:
 244
 245 * Introduction to History::     What is the GNU History library for?
 246 * History Storage::             How information is stored.
 247 * History Functions::           Functions that you can use.
 248 * History Variables::           Variables that control behaviour.
 249 * History Programming Example:: Example of using the GNU History Library.
 250
 251 \1f
 252 File: history.info,  Node: Introduction to History,  Next: History Storage,  Up: Programming with GNU History
 253
 254 Introduction to History
 255 =======================
 256
 257    Many programs read input from the user a line at a time.  The GNU
 258 History library is able to keep track of those lines, associate
 259 arbitrary data with each line, and utilize information from previous
 260 lines in composing new ones.
 261
 262    The programmer using the History library has available functions for
 263 remembering lines on a history list, associating arbitrary data with a
 264 line, removing lines from the list, searching through the list for a
 265 line containing an arbitrary text string, and referencing any line in
 266 the list directly.  In addition, a history "expansion" function is
 267 available which provides for a consistent user interface across
 268 different programs.
 269
 270    The user using programs written with the History library has the
 271 benefit of a consistent user interface with a set of well-known
 272 commands for manipulating the text of previous lines and using that text
 273 in new commands.  The basic history manipulation commands are similar to
 274 the history substitution provided by `csh'.
 275
 276    If the programmer desires, he can use the Readline library, which
 277 includes some history manipulation by default, and has the added
 278 advantage of command line editing.
 279
 280    Before declaring any functions using any functionality the History
 281 library provides in other code, an application writer should include
 282 the file `<readline/history.h>' in any file that uses the History
 283 library's features.  It supplies extern declarations for all of the
 284 library's public functions and variables, and declares all of the
 285 public data structures.
 286
 287 \1f
 288 File: history.info,  Node: History Storage,  Next: History Functions,  Prev: Introduction to History,  Up: Programming with GNU History
 289
 290 History Storage
 291 ===============
 292
 293    The history list is an array of history entries.  A history entry is
 294 declared as follows:
 295
 296      typedef struct _hist_entry {
 297        char *line;
 298        char *data;
 299      } HIST_ENTRY;
 300
 301    The history list itself might therefore be declared as
 302
 303      HIST_ENTRY **the_history_list;
 304
 305    The state of the History library is encapsulated into a single
 306 structure:
 307
 308      /* A structure used to pass the current state of the history stuff around. */
 309      typedef struct _hist_state {
 310        HIST_ENTRY **entries;         /* Pointer to the entries themselves. */
 311        int offset;                   /* The location pointer within this array. */
 312        int length;                   /* Number of elements within this array. */
 313        int size;                     /* Number of slots allocated to this array. */
 314        int flags;
 315      } HISTORY_STATE;
 316
 317    If the flags member includes `HS_STIFLED', the history has been
 318 stifled.
 319
 320 \1f
 321 File: history.info,  Node: History Functions,  Next: History Variables,  Prev: History Storage,  Up: Programming with GNU History
 322
 323 History Functions
 324 =================
 325
 326    This section describes the calling sequence for the various functions
 327 present in GNU History.
 328
 329 * Menu:
 330
 331 * Initializing History and State Management::   Functions to call when you
 332                                                 want to use history in a
 333                                                 program.
 334 * History List Management::             Functions used to manage the list
 335                                         of history entries.
 336 * Information About the History List::  Functions returning information about
 337                                         the history list.
 338 * Moving Around the History List::      Functions used to change the position
 339                                         in the history list.
 340 * Searching the History List::          Functions to search the history list
 341                                         for entries containing a string.
 342 * Managing the History File::           Functions that read and write a file
 343                                         containing the history list.
 344 * History Expansion::                   Functions to perform csh-like history
 345                                         expansion.
 346
 347 \1f
 348 File: history.info,  Node: Initializing History and State Management,  Next: History List Management,  Up: History Functions
 349
 350 Initializing History and State Management
 351 -----------------------------------------
 352
 353    This section describes functions used to initialize and manage the
 354 state of the History library when you want to use the history functions
 355 in your program.
 356
 357  - Function: void using_history ()
 358      Begin a session in which the history functions might be used.  This
 359      initializes the interactive variables.
 360
 361  - Function: HISTORY_STATE * history_get_history_state ()
 362      Return a structure describing the current state of the input
 363      history.
 364
 365  - Function: void history_set_history_state (HISTORY_STATE *state)
 366      Set the state of the history list according to STATE.
 367
 368 \1f
 369 File: history.info,  Node: History List Management,  Next: Information About the History List,  Prev: Initializing History and State Management,  Up: History Functions
 370
 371 History List Management
 372 -----------------------
 373
 374    These functions manage individual entries on the history list, or set
 375 parameters managing the list itself.
 376
 377  - Function: void add_history (char *string)
 378      Place STRING at the end of the history list.  The associated data
 379      field (if any) is set to `NULL'.
 380
 381  - Function: HIST_ENTRY * remove_history (int which)
 382      Remove history entry at offset WHICH from the history.  The
 383      removed element is returned so you can free the line, data, and
 384      containing structure.
 385
 386  - Function: HIST_ENTRY * replace_history_entry (int which, char *line,
 387           char *data)
 388      Make the history entry at offset WHICH have LINE and DATA.  This
 389      returns the old entry so you can dispose of the data.  In the case
 390      of an invalid WHICH, a `NULL' pointer is returned.
 391
 392  - Function: void clear_history ()
 393      Clear the history list by deleting all the entries.
 394
 395  - Function: void stifle_history (int max)
 396      Stifle the history list, remembering only the last MAX entries.
 397
 398  - Function: int unstifle_history ()
 399      Stop stifling the history.  This returns the previous amount the
 400      history was stifled.  The value is positive if the history was
 401      stifled, negative if it wasn't.
 402
 403  - Function: int history_is_stifled ()
 404      Returns non-zero if the history is stifled, zero if it is not.
 405
 406 \1f
 407 File: history.info,  Node: Information About the History List,  Next: Moving Around the History List,  Prev: History List Management,  Up: History Functions
 408
 409 Information About the History List
 410 ----------------------------------
 411
 412    These functions return information about the entire history list or
 413 individual list entries.
 414
 415  - Function: HIST_ENTRY ** history_list ()
 416      Return a `NULL' terminated array of `HIST_ENTRY' which is the
 417      current input history.  Element 0 of this list is the beginning of
 418      time.  If there is no history, return `NULL'.
 419
 420  - Function: int where_history ()
 421      Returns the offset of the current history element.
 422
 423  - Function: HIST_ENTRY * current_history ()
 424      Return the history entry at the current position, as determined by
 425      `where_history ()'.  If there is no entry there, return a `NULL'
 426      pointer.
 427
 428  - Function: HIST_ENTRY * history_get (int offset)
 429      Return the history entry at position OFFSET, starting from
 430      `history_base'.  If there is no entry there, or if OFFSET is
 431      greater than the history length, return a `NULL' pointer.
 432
 433  - Function: int history_total_bytes ()
 434      Return the number of bytes that the primary history entries are
 435      using.  This function returns the sum of the lengths of all the
 436      lines in the history.
 437
 438 \1f
 439 File: history.info,  Node: Moving Around the History List,  Next: Searching the History List,  Prev: Information About the History List,  Up: History Functions
 440
 441 Moving Around the History List
 442 ------------------------------
 443
 444    These functions allow the current index into the history list to be
 445 set or changed.
 446
 447  - Function: int history_set_pos (int pos)
 448      Set the position in the history list to POS, an absolute index
 449      into the list.
 450
 451  - Function: HIST_ENTRY * previous_history ()
 452      Back up the current history offset to the previous history entry,
 453      and return a pointer to that entry.  If there is no previous
 454      entry, return a `NULL' pointer.
 455
 456  - Function: HIST_ENTRY * next_history ()
 457      Move the current history offset forward to the next history entry,
 458      and return the a pointer to that entry.  If there is no next
 459      entry, return a `NULL' pointer.
 460
 461 \1f
 462 File: history.info,  Node: Searching the History List,  Next: Managing the History File,  Prev: Moving Around the History List,  Up: History Functions
 463
 464 Searching the History List
 465 --------------------------
 466
 467    These functions allow searching of the history list for entries
 468 containing a specific string.  Searching may be performed both forward
 469 and backward from the current history position.  The search may be
 470 "anchored", meaning that the string must match at the beginning of the
 471 history entry.
 472
 473  - Function: int history_search (char *string, int direction)
 474      Search the history for STRING, starting at the current history
 475      offset.  If DIRECTION < 0, then the search is through previous
 476      entries, else through subsequent.  If STRING is found, then the
 477      current history index is set to that history entry, and the value
 478      returned is the offset in the line of the entry where STRING was
 479      found.  Otherwise, nothing is changed, and a -1 is returned.
 480
 481  - Function: int history_search_prefix (char *string, int direction)
 482      Search the history for STRING, starting at the current history
 483      offset.  The search is anchored: matching lines must begin with
 484      STRING.  If DIRECTION < 0, then the search is through previous
 485      entries, else through subsequent.  If STRING is found, then the
 486      current history index is set to that entry, and the return value
 487      is 0.  Otherwise, nothing is changed, and a -1 is returned.
 488
 489  - Function: int history_search_pos (char *string, int direction, int
 490           pos)
 491      Search for STRING in the history list, starting at POS, an
 492      absolute index into the list.  If DIRECTION is negative, the search
 493      proceeds backward from POS, otherwise forward.  Returns the
 494      absolute index of the history element where STRING was found, or
 495      -1 otherwise.
 496
 497 \1f
 498 File: history.info,  Node: Managing the History File,  Next: History Expansion,  Prev: Searching the History List,  Up: History Functions
 499
 500 Managing the History File
 501 -------------------------
 502
 503    The History library can read the history from and write it to a file.
 504 This section documents the functions for managing a history file.
 505
 506  - Function: int read_history (char *filename)
 507      Add the contents of FILENAME to the history list, a line at a
 508      time.  If FILENAME is `NULL', then read from `~/.history'.
 509      Returns 0 if successful, or errno if not.
 510
 511  - Function: int read_history_range (char *filename, int from, int to)
 512      Read a range of lines from FILENAME, adding them to the history
 513      list.  Start reading at line FROM and end at TO.  If FROM is zero,
 514      start at the beginning.  If TO is less than FROM, then read until
 515      the end of the file.  If FILENAME is `NULL', then read from
 516      `~/.history'.  Returns 0 if successful, or `errno' if not.
 517
 518  - Function: int write_history (char *filename)
 519      Write the current history to FILENAME, overwriting FILENAME if
 520      necessary.  If FILENAME is `NULL', then write the history list to
 521      `~/.history'.  Values returned are as in `read_history ()'.
 522
 523  - Function: int append_history (int nelements, char *filename)
 524      Append the last NELEMENTS of the history list to FILENAME.
 525
 526  - Function: int history_truncate_file (char *filename, int nlines)
 527      Truncate the history file FILENAME, leaving only the last NLINES
 528      lines.
 529
 530 \1f
 531 File: history.info,  Node: History Expansion,  Prev: Managing the History File,  Up: History Functions
 532
 533 History Expansion
 534 -----------------
 535
 536    These functions implement `csh'-like history expansion.
 537
 538  - Function: int history_expand (char *string, char **output)
 539      Expand STRING, placing the result into OUTPUT, a pointer to a
 540      string (*note History Interaction::.).  Returns:
 541     `0'
 542           If no expansions took place (or, if the only change in the
 543           text was the de-slashifying of the history expansion
 544           character);
 545
 546     `1'
 547           if expansions did take place;
 548
 549     `-1'
 550           if there was an error in expansion;
 551
 552     `2'
 553           if the returned line should be displayed, but not executed,
 554           as with the `:p' modifier (*note Modifiers::.).
 555
 556      If an error ocurred in expansion, then OUTPUT contains a
 557      descriptive error message.
 558
 559  - Function: char * history_arg_extract (int first, int last, char
 560           *string)
 561      Extract a string segment consisting of the FIRST through LAST
 562      arguments present in STRING.  Arguments are broken up as in Bash.
 563
 564  - Function: char * get_history_event (char *string, int *cindex, int
 565           qchar)
 566      Returns the text of the history event beginning at STRING +
 567      *CINDEX.  *CINDEX is modified to point to after the event
 568      specifier.  At function entry, CINDEX points to the index into
 569      STRING where the history event specification begins.  QCHAR is a
 570      character that is allowed to end the event specification in
 571      addition to the "normal" terminating characters.
 572
 573  - Function: char ** history_tokenize (char *string)
 574      Return an array of tokens parsed out of STRING, much as the shell
 575      might.  The tokens are split on white space and on the characters
 576      `()<>;&|$', and shell quoting conventions are obeyed.
 577
 578 \1f
 579 File: history.info,  Node: History Variables,  Next: History Programming Example,  Prev: History Functions,  Up: Programming with GNU History
 580
 581 History Variables
 582 =================
 583
 584    This section describes the externally visible variables exported by
 585 the GNU History Library.
 586
 587  - Variable: int history_base
 588      The logical offset of the first entry in the history list.
 589
 590  - Variable: int history_length
 591      The number of entries currently stored in the history list.
 592
 593  - Variable: int max_input_history
 594      The maximum number of history entries.  This must be changed using
 595      `stifle_history ()'.
 596
 597  - Variable: char history_expansion_char
 598      The character that starts a history event.  The default is `!'.
 599
 600  - Variable: char history_subst_char
 601      The character that invokes word substitution if found at the start
 602      of a line.  The default is `^'.
 603
 604  - Variable: char history_comment_char
 605      During tokenization, if this character is seen as the first
 606      character of a word, then it and all subsequent characters up to a
 607      newline are ignored, suppressing history expansion for the
 608      remainder of the line.  This is disabled by default.
 609
 610  - Variable: char * history_no_expand_chars
 611      The list of characters which inhibit history expansion if found
 612      immediately following HISTORY_EXPANSION_CHAR.  The default is
 613      whitespace and `='.
 614
 615  - Variable: char * history_search_delimiter_chars
 616      The list of additional characters which can delimit a history
 617      search string, in addition to whitespace, `:' and `?' in the case
 618      of a substring search.  The default is empty.
 619
 620  - Variable: int history_quotes_inhibit_expansion
 621      If non-zero, single-quoted words are not scanned for the history
 622      expansion character.  The default value is 0.
 623
 624  - Variable: Function * history_inhibit_expansion_function
 625      This should be set to the address of a function that takes two
 626      arguments: a `char *' (STRING) and an integer index into that
 627      string (I).  It should return a non-zero value if the history
 628      expansion starting at STRING[I] should not be performed; zero if
 629      the expansion should be done.  It is intended for use by
 630      applications like Bash that use the history expansion character
 631      for additional purposes.  By default, this variable is set to NULL.
 632
 633 \1f
 634 File: history.info,  Node: History Programming Example,  Prev: History Variables,  Up: Programming with GNU History
 635
 636 History Programming Example
 637 ===========================
 638
 639    The following program demonstrates simple use of the GNU History
 640 Library.
 641
 642      main ()
 643      {
 644        char line[1024], *t;
 645        int len, done = 0;
 646
 647        line[0] = 0;
 648
 649        using_history ();
 650        while (!done)
 651          {
 652            printf ("history$ ");
 653            fflush (stdout);
 654            t = fgets (line, sizeof (line) - 1, stdin);
 655            if (t && *t)
 656              {
 657                len = strlen (t);
 658                if (t[len - 1] == '\n')
 659                  t[len - 1] = '\0';
 660              }
 661
 662            if (!t)
 663              strcpy (line, "quit");
 664
 665            if (line[0])
 666              {
 667                char *expansion;
 668                int result;
 669
 670                result = history_expand (line, &expansion);
 671                if (result)
 672                  fprintf (stderr, "%s\n", expansion);
 673
 674                if (result < 0 || result == 2)
 675                  {
 676                    free (expansion);
 677                    continue;
 678                  }
 679
 680                add_history (expansion);
 681                strncpy (line, expansion, sizeof (line) - 1);
 682                free (expansion);
 683              }
 684
 685            if (strcmp (line, "quit") == 0)
 686              done = 1;
 687            else if (strcmp (line, "save") == 0)
 688              write_history ("history_file");
 689            else if (strcmp (line, "read") == 0)
 690              read_history ("history_file");
 691            else if (strcmp (line, "list") == 0)
 692              {
 693                register HIST_ENTRY **the_list;
 694                register int i;
 695
 696                the_list = history_list ();
 697                if (the_list)
 698                  for (i = 0; the_list[i]; i++)
 699                    printf ("%d: %s\n", i + history_base, the_list[i]->line);
 700              }
 701            else if (strncmp (line, "delete", 6) == 0)
 702              {
 703                int which;
 704                if ((sscanf (line + 6, "%d", &which)) == 1)
 705                  {
 706                    HIST_ENTRY *entry = remove_history (which);
 707                    if (!entry)
 708                      fprintf (stderr, "No such entry %d\n", which);
 709                    else
 710                      {
 711                        free (entry->line);
 712                        free (entry);
 713                      }
 714                  }
 715                else
 716                  {
 717                    fprintf (stderr, "non-numeric arg given to `delete'\n");
 718                  }
 719              }
 720          }
 721      }
 722
 723 \1f
 724 File: history.info,  Node: Concept Index,  Next: Function and Variable Index,  Prev: Programming with GNU History,  Up: Top
 725
 726 Concept Index
 727 *************
 728
 729 * Menu:
 730
 731 * anchored search:                       Searching the History List.
 732 * event designators:                     Event Designators.
 733 * history events:                        Event Designators.
 734 * history expansion:                     History Interaction.
 735 * History Searching:                     Searching the History List.
 736
 737 \1f
 738 File: history.info,  Node: Function and Variable Index,  Prev: Concept Index,  Up: Top
 739
 740 Function and Variable Index
 741 ***************************
 742
 743 * Menu:
 744
 745 * add_history:                           History List Management.
 746 * append_history:                        Managing the History File.
 747 * clear_history:                         History List Management.
 748 * current_history:                       Information About the History List.
 749 * get_history_event:                     History Expansion.
 750 * history_arg_extract:                   History Expansion.
 751 * history_base:                          History Variables.
 752 * history_comment_char:                  History Variables.
 753 * history_expand:                        History Expansion.
 754 * history_expansion_char:                History Variables.
 755 * history_get:                           Information About the History List.
 756 * history_get_history_state:             Initializing History and State Management.
 757 * history_inhibit_expansion_function:    History Variables.
 758 * history_is_stifled:                    History List Management.
 759 * history_length:                        History Variables.
 760 * history_list:                          Information About the History List.
 761 * history_no_expand_chars:               History Variables.
 762 * history_quotes_inhibit_expansion:      History Variables.
 763 * history_search:                        Searching the History List.
 764 * history_search_delimiter_chars:        History Variables.
 765 * history_search_pos:                    Searching the History List.
 766 * history_search_prefix:                 Searching the History List.
 767 * history_set_history_state:             Initializing History and State Management.
 768 * history_set_pos:                       Moving Around the History List.
 769 * history_subst_char:                    History Variables.
 770 * history_tokenize:                      History Expansion.
 771 * history_total_bytes:                   Information About the History List.
 772 * history_truncate_file:                 Managing the History File.
 773 * max_input_history:                     History Variables.
 774 * next_history:                          Moving Around the History List.
 775 * previous_history:                      Moving Around the History List.
 776 * read_history:                          Managing the History File.
 777 * read_history_range:                    Managing the History File.
 778 * remove_history:                        History List Management.
 779 * replace_history_entry:                 History List Management.
 780 * stifle_history:                        History List Management.
 781 * unstifle_history:                      History List Management.
 782 * using_history:                         Initializing History and State Management.
 783 * where_history:                         Information About the History List.
 784 * write_history:                         Managing the History File.
 785
 786
 787 \1f
 788 Tag Table:
 789 Node: Top\7f1162
 790 Node: Using History Interactively\7f1742
 791 Node: History Interaction\7f2250
 792 Node: Event Designators\7f3669
 793 Node: Word Designators\7f4596
 794 Node: Modifiers\7f6225
 795 Node: Programming with GNU History\7f7363
 796 Node: Introduction to History\7f8089
 797 Node: History Storage\7f9774
 798 Node: History Functions\7f10867
 799 Node: Initializing History and State Management\7f11838
 800 Node: History List Management\7f12630
 801 Node: Information About the History List\7f14151
 802 Node: Moving Around the History List\7f15457
 803 Node: Searching the History List\7f16342
 804 Node: Managing the History File\7f18174
 805 Node: History Expansion\7f19680
 806 Node: History Variables\7f21519
 807 Node: History Programming Example\7f23837
 808 Node: Concept Index\7f26441
 809 Node: Function and Variable Index\7f26927
 810 \1f
 811 End Tag Table