diff options
Diffstat (limited to 'gnu/lib/libreadline/doc/readline.info-2')
| -rw-r--r-- | gnu/lib/libreadline/doc/readline.info-2 | 978 |
1 files changed, 978 insertions, 0 deletions
diff --git a/gnu/lib/libreadline/doc/readline.info-2 b/gnu/lib/libreadline/doc/readline.info-2 new file mode 100644 index 0000000..35681aa --- /dev/null +++ b/gnu/lib/libreadline/doc/readline.info-2 @@ -0,0 +1,978 @@ +This is Info file readline.info, produced by Makeinfo-1.55 from the +input file rlman.texinfo. + + This document describes the GNU Readline Library, a utility which +aids in the consistency of user interface across discrete programs that +need to provide a command line interface. + + Copyright (C) 1988, 1991 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice pare +preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided that +the entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that this permission notice may be stated in a +translation approved by the Foundation. + + +File: readline.info, Node: Modifying Text, Next: Utility Functions, Prev: Redisplay, Up: Readline Convenience Functions + +Modifying Text +-------------- + + - Function: int rl_insert_text (char *text) + Insert TEXT into the line at the current cursor position. + + - Function: int rl_delete_text (int start, int end) + Delete the text between START and END in the current line. + + - Function: char * rl_copy_text (int start, int end) + Return a copy of the text between START and END in the current + line. + + - Function: int rl_kill_text (int start, int end) + Copy the text between START and END in the current line to the + kill ring, appending or prepending to the last kill if the last + command was a kill command. The text is deleted. If START is + less than END, the text is appended, otherwise prepended. If the + last command was not a kill, a new kill ring slot is used. + + +File: readline.info, Node: Utility Functions, Prev: Modifying Text, Up: Readline Convenience Functions + +Utility Functions +----------------- + + - Function: int rl_reset_terminal (char *terminal_name) + Reinitialize Readline's idea of the terminal settings using + TERMINAL_NAME as the terminal type (e.g., `vt100'). + + - Function: int alphabetic (int c) + Return 1 if C is an alphabetic character. + + - Function: int numeric (int c) + Return 1 if C is a numeric character. + + - Function: int ding () + Ring the terminal bell, obeying the setting of `bell-style'. + + The following are implemented as macros, defined in `chartypes.h'. + + - Function: int uppercase_p (int c) + Return 1 if C is an uppercase alphabetic character. + + - Function: int lowercase_p (int c) + Return 1 if C is a lowercase alphabetic character. + + - Function: int digit_p (int c) + Return 1 if C is a numeric character. + + - Function: int to_upper (int c) + If C is a lowercase alphabetic character, return the corresponding + uppercase character. + + - Function: int to_lower (int c) + If C is an uppercase alphabetic character, return the corresponding + lowercase character. + + - Function: int digit_value (int c) + If C is a number, return the value it represents. + +An Example +---------- + + Here is a function which changes lowercase characters to their +uppercase equivalents, and uppercase characters to lowercase. If this +function was bound to `M-c', then typing `M-c' would change the case of +the character under point. Typing `M-1 0 M-c' would change the case of +the following 10 characters, leaving the cursor on the last character +changed. + + /* Invert the case of the COUNT following characters. */ + int + invert_case_line (count, key) + int count, key; + { + register int start, end, i; + + start = rl_point; + + if (rl_point >= rl_end) + return (0); + + if (count < 0) + { + direction = -1; + count = -count; + } + else + direction = 1; + + /* Find the end of the range to modify. */ + end = start + (count * direction); + + /* Force it to be within range. */ + if (end > rl_end) + end = rl_end; + else if (end < 0) + end = 0; + + if (start == end) + return (0); + + if (start > end) + { + int temp = start; + start = end; + end = temp; + } + + /* Tell readline that we are modifying the line, so it will save + the undo information. */ + rl_modifying (start, end); + + for (i = start; i != end; i++) + { + if (uppercase_p (rl_line_buffer[i])) + rl_line_buffer[i] = to_lower (rl_line_buffer[i]); + else if (lowercase_p (rl_line_buffer[i])) + rl_line_buffer[i] = to_upper (rl_line_buffer[i]); + } + /* Move point to on top of the last character changed. */ + rl_point = (direction == 1) ? end - 1 : start; + return (0); + } + + +File: readline.info, Node: Custom Completers, Prev: Readline Convenience Functions, Up: Programming with GNU Readline + +Custom Completers +================= + + Typically, a program that reads commands from the user has a way of +disambiguating commands and data. If your program is one of these, then +it can provide completion for commands, data, or both. The following +sections describe how your program and Readline cooperate to provide +this service. + +* Menu: + +* How Completing Works:: The logic used to do completion. +* Completion Functions:: Functions provided by Readline. +* Completion Variables:: Variables which control completion. +* A Short Completion Example:: An example of writing completer subroutines. + + +File: readline.info, Node: How Completing Works, Next: Completion Functions, Up: Custom Completers + +How Completing Works +-------------------- + + In order to complete some text, the full list of possible completions +must be available. That is, it is not possible to accurately expand a +partial word without knowing all of the possible words which make sense +in that context. The Readline library provides the user interface to +completion, and two of the most common completion functions: filename +and username. For completing other types of text, you must write your +own completion function. This section describes exactly what such +functions must do, and provides an example. + + There are three major functions used to perform completion: + + 1. The user-interface function `rl_complete ()'. This function is + called with the same arguments as other Readline functions + intended for interactive use: COUNT and INVOKING_KEY. It + isolates the word to be completed and calls `completion_matches + ()' to generate a list of possible completions. It then either + lists the possible completions, inserts the possible completions, + or actually performs the completion, depending on which behavior + is desired. + + 2. The internal function `completion_matches ()' uses your + "generator" function to generate the list of possible matches, and + then returns the array of these matches. You should place the + address of your generator function in + `rl_completion_entry_function'. + + 3. The generator function is called repeatedly from + `completion_matches ()', returning a string each time. The + arguments to the generator function are TEXT and STATE. TEXT is + the partial word to be completed. STATE is zero the first time + the function is called, allowing the generator to perform any + necessary initialization, and a positive non-zero integer for each + subsequent call. When the generator function returns `(char + *)NULL' this signals `completion_matches ()' that there are no + more possibilities left. Usually the generator function computes + the list of possible completions when STATE is zero, and returns + them one at a time on subsequent calls. Each string the generator + function returns as a match must be allocated with `malloc()'; + Readline frees the strings when it has finished with them. + + + - Function: int rl_complete (int ignore, int invoking_key) + Complete the word at or before point. You have supplied the + function that does the initial simple matching selection algorithm + (see `completion_matches ()'). The default is to do filename + completion. + + - Variable: Function * rl_completion_entry_function + This is a pointer to the generator function for `completion_matches + ()'. If the value of `rl_completion_entry_function' is `(Function + *)NULL' then the default filename generator function, + `filename_entry_function ()', is used. + + +File: readline.info, Node: Completion Functions, Next: Completion Variables, Prev: How Completing Works, Up: Custom Completers + +Completion Functions +-------------------- + + Here is the complete list of callable completion functions present in +Readline. + + - Function: int rl_complete_internal (int what_to_do) + Complete the word at or before point. WHAT_TO_DO says what to do + with the completion. A value of `?' means list the possible + completions. `TAB' means do standard completion. `*' means + insert all of the possible completions. `!' means to display all + of the possible completions, if there is more than one, as well as + performing partial completion. + + - Function: int rl_complete (int ignore, int invoking_key) + Complete the word at or before point. You have supplied the + function that does the initial simple matching selection algorithm + (see `completion_matches ()' and `rl_completion_entry_function'). + The default is to do filename completion. This calls + `rl_complete_internal ()' with an argument depending on + INVOKING_KEY. + + - Function: int rl_possible_completions (int count, int invoking_key)) + List the possible completions. See description of `rl_complete + ()'. This calls `rl_complete_internal ()' with an argument of `?'. + + - Function: int rl_insert_completions (int count, int invoking_key)) + Insert the list of possible completions into the line, deleting the + partially-completed word. See description of `rl_complete ()'. + This calls `rl_complete_internal ()' with an argument of `*'. + + - Function: char ** completion_matches (char *text, CPFunction + *entry_func) + Returns an array of `(char *)' which is a list of completions for + TEXT. If there are no completions, returns `(char **)NULL'. The + first entry in the returned array is the substitution for TEXT. + The remaining entries are the possible completions. The array is + terminated with a `NULL' pointer. + + ENTRY_FUNC is a function of two args, and returns a `(char *)'. + The first argument is TEXT. The second is a state argument; it is + zero on the first call, and non-zero on subsequent calls. + eNTRY_FUNC returns a `NULL' pointer to the caller when there are + no more matches. + + - Function: char * filename_completion_function (char *text, int state) + A generator function for filename completion in the general case. + Note that completion in Bash is a little different because of all + the pathnames that must be followed when looking up completions + for a command. The Bash source is a useful reference for writing + custom completion functions. + + - Function: char * username_completion_function (char *text, int state) + A completion generator for usernames. TEXT contains a partial + username preceded by a random character (usually `~'). As with all + completion generators, STATE is zero on the first call and non-zero + for subsequent calls. + + +File: readline.info, Node: Completion Variables, Next: A Short Completion Example, Prev: Completion Functions, Up: Custom Completers + +Completion Variables +-------------------- + + - Variable: Function * rl_completion_entry_function + A pointer to the generator function for `completion_matches ()'. + `NULL' means to use `filename_entry_function ()', the default + filename completer. + + - Variable: CPPFunction * rl_attempted_completion_function + A pointer to an alternative function to create matches. The + function is called with TEXT, START, and END. START and END are + indices in `rl_line_buffer' saying what the boundaries of TEXT + are. If this function exists and returns `NULL', or if this + variable is set to `NULL', then `rl_complete ()' will call the + value of `rl_completion_entry_function' to generate matches, + otherwise the array of strings returned will be used. + + - Variable: int rl_completion_query_items + Up to this many items will be displayed in response to a + possible-completions call. After that, we ask the user if she is + sure she wants to see them all. The default value is 100. + + - Variable: char * rl_basic_word_break_characters + The basic list of characters that signal a break between words for + the completer routine. The default value of this variable is the + characters which break words for completion in Bash, i.e., `" + \t\n\"\\'`@$><=;|&{("'. + + - Variable: char * rl_completer_word_break_characters + The list of characters that signal a break between words for + `rl_complete_internal ()'. The default list is the value of + `rl_basic_word_break_characters'. + + - Variable: char * rl_special_prefixes + The list of characters that are word break characters, but should + be left in TEXT when it is passed to the completion function. + Programs can use this to help determine what kind of completing to + do. For instance, Bash sets this variable to "$@" so that it can + complete shell variables and hostnames. + + - Variable: int rl_ignore_completion_duplicates + If non-zero, then disallow duplicates in the matches. Default is + 1. + + - Variable: int rl_filename_completion_desired + Non-zero means that the results of the matches are to be treated as + filenames. This is *always* zero on entry, and can only be changed + within a completion entry generator function. If it is set to a + non-zero value, directory names have a slash appended and Readline + attempts to quote completed filenames if they contain any embedded + word break characters. + + - Variable: int rl_filename_quoting_desired + Non-zero means that the results of the matches are to be quoted + using double quotes (or an application-specific quoting mechanism) + if the completed filename contains any characters in + `rl_completer_word_break_chars'. This is *always* non-zero on + entry, and can only be changed within a completion entry generator + function. + + - Variable: Function * rl_ignore_some_completions_function + This function, if defined, is called by the completer when real + filename completion is done, after all the matching names have + been generated. It is passed a `NULL' terminated array of matches. + The first element (`matches[0]') is the maximal substring common + to all matches. This function can re-arrange the list of matches + as required, but each element deleted from the array must be freed. + + - Variable: char * rl_completer_quote_characters + List of characters which can be used to quote a substring of the + line. Completion occurs on the entire substring, and within the + substring `rl_completer_word_break_characters' are treated as any + other character, unless they also appear within this list. + + +File: readline.info, Node: A Short Completion Example, Prev: Completion Variables, Up: Custom Completers + +A Short Completion Example +-------------------------- + + Here is a small application demonstrating the use of the GNU Readline +library. It is called `fileman', and the source code resides in +`examples/fileman.c'. This sample application provides completion of +command names, line editing features, and access to the history list. + + /* fileman.c -- A tiny application which demonstrates how to use the + GNU Readline library. This application interactively allows users + to manipulate files and their modes. */ + + #include <stdio.h> + #include <sys/types.h> + #include <sys/file.h> + #include <sys/stat.h> + #include <sys/errno.h> + + #include <readline/readline.h> + #include <readline/history.h> + + extern char *getwd (); + extern char *xmalloc (); + + /* The names of functions that actually do the manipulation. */ + int com_list (), com_view (), com_rename (), com_stat (), com_pwd (); + int com_delete (), com_help (), com_cd (), com_quit (); + + /* A structure which contains information on the commands this program + can understand. */ + + typedef struct { + char *name; /* User printable name of the function. */ + Function *func; /* Function to call to do the job. */ + char *doc; /* Documentation for this function. */ + } COMMAND; + + COMMAND commands[] = { + { "cd", com_cd, "Change to directory DIR" }, + { "delete", com_delete, "Delete FILE" }, + { "help", com_help, "Display this text" }, + { "?", com_help, "Synonym for `help'" }, + { "list", com_list, "List files in DIR" }, + { "ls", com_list, "Synonym for `list'" }, + { "pwd", com_pwd, "Print the current working directory" }, + { "quit", com_quit, "Quit using Fileman" }, + { "rename", com_rename, "Rename FILE to NEWNAME" }, + { "stat", com_stat, "Print out statistics on FILE" }, + { "view", com_view, "View the contents of FILE" }, + { (char *)NULL, (Function *)NULL, (char *)NULL } + }; + + /* Forward declarations. */ + char *stripwhite (); + COMMAND *find_command (); + + /* The name of this program, as taken from argv[0]. */ + char *progname; + + /* When non-zero, this global means the user is done using this program. */ + int done; + + char * + dupstr (s) + int s; + { + char *r; + + r = xmalloc (strlen (s) + 1); + strcpy (r, s); + return (r); + } + + main (argc, argv) + int argc; + char **argv; + { + char *line, *s; + + progname = argv[0]; + + initialize_readline (); /* Bind our completer. */ + + /* Loop reading and executing lines until the user quits. */ + for ( ; done == 0; ) + { + line = readline ("FileMan: "); + + if (!line) + break; + + /* Remove leading and trailing whitespace from the line. + Then, if there is anything left, add it to the history list + and execute it. */ + s = stripwhite (line); + + if (*s) + { + add_history (s); + execute_line (s); + } + + free (line); + } + exit (0); + } + + /* Execute a command line. */ + int + execute_line (line) + char *line; + { + register int i; + COMMAND *command; + char *word; + + /* Isolate the command word. */ + i = 0; + while (line[i] && whitespace (line[i])) + i++; + word = line + i; + + while (line[i] && !whitespace (line[i])) + i++; + + if (line[i]) + line[i++] = '\0'; + + command = find_command (word); + + if (!command) + { + fprintf (stderr, "%s: No such command for FileMan.\n", word); + return (-1); + } + + /* Get argument to command, if any. */ + while (whitespace (line[i])) + i++; + + word = line + i; + + /* Call the function. */ + return ((*(command->func)) (word)); + } + + /* Look up NAME as the name of a command, and return a pointer to that + command. Return a NULL pointer if NAME isn't a command name. */ + COMMAND * + find_command (name) + char *name; + { + register int i; + + for (i = 0; commands[i].name; i++) + if (strcmp (name, commands[i].name) == 0) + return (&commands[i]); + + return ((COMMAND *)NULL); + } + + /* Strip whitespace from the start and end of STRING. Return a pointer + into STRING. */ + char * + stripwhite (string) + char *string; + { + register char *s, *t; + + for (s = string; whitespace (*s); s++) + ; + + if (*s == 0) + return (s); + + t = s + strlen (s) - 1; + while (t > s && whitespace (*t)) + t--; + *++t = '\0'; + + return s; + } + + /* **************************************************************** */ + /* */ + /* Interface to Readline Completion */ + /* */ + /* **************************************************************** */ + + char *command_generator (); + char **fileman_completion (); + + /* Tell the GNU Readline library how to complete. We want to try to complete + on command names if this is the first word in the line, or on filenames + if not. */ + initialize_readline () + { + /* Allow conditional parsing of the ~/.inputrc file. */ + rl_readline_name = "FileMan"; + + /* Tell the completer that we want a crack first. */ + rl_attempted_completion_function = (CPPFunction *)fileman_completion; + } + + /* Attempt to complete on the contents of TEXT. START and END show the + region of TEXT that contains the word to complete. We can use the + entire line in case we want to do some simple parsing. Return the + array of matches, or NULL if there aren't any. */ + char ** + fileman_completion (text, start, end) + char *text; + int start, end; + { + char **matches; + + matches = (char **)NULL; + + /* If this word is at the start of the line, then it is a command + to complete. Otherwise it is the name of a file in the current + directory. */ + if (start == 0) + matches = completion_matches (text, command_generator); + + return (matches); + } + + /* Generator function for command completion. STATE lets us know whether + to start from scratch; without any state (i.e. STATE == 0), then we + start at the top of the list. */ + char * + command_generator (text, state) + char *text; + int state; + { + static int list_index, len; + char *name; + + /* If this is a new word to complete, initialize now. This includes + saving the length of TEXT for efficiency, and initializing the index + variable to 0. */ + if (!state) + { + list_index = 0; + len = strlen (text); + } + + /* Return the next name which partially matches from the command list. */ + while (name = commands[list_index].name) + { + list_index++; + + if (strncmp (name, text, len) == 0) + return (dupstr(name)); + } + + /* If no names matched, then return NULL. */ + return ((char *)NULL); + } + + /* **************************************************************** */ + /* */ + /* FileMan Commands */ + /* */ + /* **************************************************************** */ + + /* String to pass to system (). This is for the LIST, VIEW and RENAME + commands. */ + static char syscom[1024]; + + /* List the file(s) named in arg. */ + com_list (arg) + char *arg; + { + if (!arg) + arg = ""; + + sprintf (syscom, "ls -FClg %s", arg); + return (system (syscom)); + } + + com_view (arg) + char *arg; + { + if (!valid_argument ("view", arg)) + return 1; + + sprintf (syscom, "more %s", arg); + return (system (syscom)); + } + + com_rename (arg) + char *arg; + { + too_dangerous ("rename"); + return (1); + } + + com_stat (arg) + char *arg; + { + struct stat finfo; + + if (!valid_argument ("stat", arg)) + return (1); + + if (stat (arg, &finfo) == -1) + { + perror (arg); + return (1); + } + + printf ("Statistics for `%s':\n", arg); + + printf ("%s has %d link%s, and is %d byte%s in length.\n", arg, + finfo.st_nlink, + (finfo.st_nlink == 1) ? "" : "s", + finfo.st_size, + (finfo.st_size == 1) ? "" : "s"); + printf ("Inode Last Change at: %s", ctime (&finfo.st_ctime)); + printf (" Last access at: %s", ctime (&finfo.st_atime)); + printf (" Last modified at: %s", ctime (&finfo.st_mtime)); + return (0); + } + + com_delete (arg) + char *arg; + { + too_dangerous ("delete"); + return (1); + } + + /* Print out help for ARG, or for all of the commands if ARG is + not present. */ + com_help (arg) + char *arg; + { + register int i; + int printed = 0; + + for (i = 0; commands[i].name; i++) + { + if (!*arg || (strcmp (arg, commands[i].name) == 0)) + { + printf ("%s\t\t%s.\n", commands[i].name, commands[i].doc); + printed++; + } + } + + if (!printed) + { + printf ("No commands match `%s'. Possibilties are:\n", arg); + + for (i = 0; commands[i].name; i++) + { + /* Print in six columns. */ + if (printed == 6) + { + printed = 0; + printf ("\n"); + } + + printf ("%s\t", commands[i].name); + printed++; + } + + if (printed) + printf ("\n"); + } + return (0); + } + + /* Change to the directory ARG. */ + com_cd (arg) + char *arg; + { + if (chdir (arg) == -1) + { + perror (arg); + return 1; + } + + com_pwd (""); + return (0); + } + + /* Print out the current working directory. */ + com_pwd (ignore) + char *ignore; + { + char dir[1024], *s; + + s = getwd (dir); + if (s == 0) + { + printf ("Error getting pwd: %s\n", dir); + return 1; + } + + printf ("Current directory is %s\n", dir); + return 0; + } + + /* The user wishes to quit using this program. Just set DONE non-zero. */ + com_quit (arg) + char *arg; + { + done = 1; + return (0); + } + + /* Function which tells you that you can't do this. */ + too_dangerous (caller) + char *caller; + { + fprintf (stderr, + "%s: Too dangerous for me to distribute. Write it yourself.\n", + caller); + } + + /* Return non-zero if ARG is a valid argument for CALLER, else print + an error message and return zero. */ + int + valid_argument (caller, arg) + char *caller, *arg; + { + if (!arg || !*arg) + { + fprintf (stderr, "%s: Argument required.\n", caller); + return (0); + } + + return (1); + } + + +File: readline.info, Node: Concept Index, Next: Function and Variable Index, Prev: Programming with GNU Readline, Up: Top + +Concept Index +************* + +* Menu: + +* interaction, readline: Readline Interaction. +* Kill ring: Readline Killing Commands. +* Killing text: Readline Killing Commands. +* readline, function: Basic Behavior. +* Yanking text: Readline Killing Commands. + + +File: readline.info, Node: Function and Variable Index, Prev: Concept Index, Up: Top + +Function and Variable Index +*************************** + +* Menu: + +* $else: Conditional Init Constructs. +* $endif: Conditional Init Constructs. +* $if: Conditional Init Constructs. +* abort (C-g): Miscellaneous Commands. +* accept-line (Newline, Return): Commands For History. +* alphabetic: Utility Functions. +* backward-char (C-b): Commands For Moving. +* backward-delete-char (Rubout): Commands For Text. +* backward-kill-line (C-x Rubout): Commands For Killing. +* backward-kill-word (M-DEL): Commands For Killing. +* backward-word (M-b): Commands For Moving. +* beginning-of-history (M-<): Commands For History. +* beginning-of-line (C-a): Commands For Moving. +* bell-style: Readline Init Syntax. +* call-last-kbd-macro (C-x e): Keyboard Macros. +* capitalize-word (M-c): Commands For Text. +* clear-screen (C-l): Commands For Moving. +* comment-begin: Readline Init Syntax. +* complete (TAB): Commands For Completion. +* completion-query-items: Readline Init Syntax. +* completion_matches: Completion Functions. +* convert-meta: Readline Init Syntax. +* delete-char (C-d): Commands For Text. +* delete-horizontal-space (): Commands For Killing. +* digit-argument (M-0, M-1, ... M-): Numeric Arguments. +* digit_p: Utility Functions. +* digit_value: Utility Functions. +* ding: Utility Functions. +* do-uppercase-version (M-a, M-b, ...): Miscellaneous Commands. +* downcase-word (M-l): Commands For Text. +* dump-functions (): Miscellaneous Commands. +* editing-mode: Readline Init Syntax. +* end-kbd-macro (C-x )): Keyboard Macros. +* end-of-history (M->): Commands For History. +* end-of-line (C-e): Commands For Moving. +* expand-tilde: Readline Init Syntax. +* filename_completion_function: Completion Functions. +* forward-char (C-f): Commands For Moving. +* forward-search-history (C-s): Commands For History. +* forward-word (M-f): Commands For Moving. +* free_undo_list: Allowing Undoing. +* history-search-backward (): Commands For History. +* history-search-forward (): Commands For History. +* horizontal-scroll-mode: Readline Init Syntax. +* insert-completions (): Commands For Completion. +* keymap: Readline Init Syntax. +* kill-line (C-k): Commands For Killing. +* kill-whole-line (): Commands For Killing. +* kill-word (M-d): Commands For Killing. +* lowercase_p: Utility Functions. +* mark-modified-lines: Readline Init Syntax. +* meta-flag: Readline Init Syntax. +* next-history (C-n): Commands For History. +* non-incremental-forward-search-history (M-n): Commands For History. +* non-incremental-reverse-search-history (M-p): Commands For History. +* numeric: Utility Functions. +* output-meta: Readline Init Syntax. +* possible-completions (M-?): Commands For Completion. +* prefix-meta (ESC): Miscellaneous Commands. +* previous-history (C-p): Commands For History. +* quoted-insert (C-q, C-v): Commands For Text. +* re-read-init-file (C-x C-r): Miscellaneous Commands. +* readline: Basic Behavior. +* redraw-current-line (): Commands For Moving. +* reverse-search-history (C-r): Commands For History. +* revert-line (M-r): Miscellaneous Commands. +* rl_add_defun: Function Naming. +* rl_add_undo: Allowing Undoing. +* rl_attempted_completion_function: Completion Variables. +* rl_basic_word_break_characters: Completion Variables. +* rl_begin_undo_group: Allowing Undoing. +* rl_bind_key: Binding Keys. +* rl_bind_key_in_map: Binding Keys. +* rl_clear_message: Redisplay. +* rl_complete: How Completing Works. +* rl_complete: Completion Functions. +* rl_completer_quote_characters: Completion Variables. +* rl_completer_word_break_characters: Completion Variables. +* rl_complete_internal: Completion Functions. +* rl_completion_entry_function: Completion Variables. +* rl_completion_entry_function: How Completing Works. +* rl_completion_query_items: Completion Variables. +* rl_copy_keymap: Keymaps. +* rl_copy_text: Modifying Text. +* rl_delete_text: Modifying Text. +* rl_discard_keymap: Keymaps. +* rl_done: Function Writing. +* rl_do_undo: Allowing Undoing. +* rl_end: Function Writing. +* rl_end_undo_group: Allowing Undoing. +* rl_filename_completion_desired: Completion Variables. +* rl_filename_quoting_desired: Completion Variables. +* rl_forced_update_display: Redisplay. +* rl_function_of_keyseq: Associating Function Names and Bindings. +* rl_generic_bind: Binding Keys. +* rl_get_keymap: Keymaps. +* rl_get_keymap_by_name: Keymaps. +* rl_ignore_completion_duplicates: Completion Variables. +* rl_ignore_some_completions_function: Completion Variables. +* rl_insert_completions: Completion Functions. +* rl_insert_text: Modifying Text. +* rl_instream: Function Writing. +* rl_invoking_keyseqs: Associating Function Names and Bindings. +* rl_invoking_keyseqs_in_map: Associating Function Names and Bindings. +* rl_kill_text: Modifying Text. +* rl_line_buffer: Function Writing. +* rl_make_bare_keymap: Keymaps. +* rl_make_keymap: Keymaps. +* rl_mark: Function Writing. +* rl_message: Redisplay. +* rl_modifying: Allowing Undoing. +* rl_named_function: Associating Function Names and Bindings. +* rl_on_new_line: Redisplay. +* rl_outstream: Function Writing. +* rl_parse_and_bind: Binding Keys. +* rl_pending_input: Function Writing. +* rl_point: Function Writing. +* rl_possible_completions: Completion Functions. +* rl_prompt: Function Writing. +* rl_readline_name: Function Writing. +* rl_redisplay: Redisplay. +* rl_reset_line_state: Redisplay. +* rl_reset_terminal: Utility Functions. +* rl_set_keymap: Keymaps. +* rl_special_prefixes: Completion Variables. +* rl_startup_hook: Function Writing. +* rl_terminal_name: Function Writing. +* rl_unbind_key: Binding Keys. +* rl_unbind_key_in_map: Binding Keys. +* self-insert (a, b, A, 1, !, ...): Commands For Text. +* show-all-if-ambiguous: Readline Init Syntax. +* start-kbd-macro (C-x (): Keyboard Macros. +* tab-insert (M-TAB): Commands For Text. +* tilde-expand (M-~): Miscellaneous Commands. +* to_lower: Utility Functions. +* to_upper: Utility Functions. +* transpose-chars (C-t): Commands For Text. +* transpose-words (M-t): Commands For Text. +* undo (C-_, C-x C-u): Miscellaneous Commands. +* universal-argument (): Numeric Arguments. +* unix-line-discard (C-u): Commands For Killing. +* unix-word-rubout (C-w): Commands For Killing. +* upcase-word (M-u): Commands For Text. +* uppercase_p: Utility Functions. +* username_completion_function: Completion Functions. +* yank (C-y): Commands For Killing. +* yank-last-arg (M-., M-_): Commands For History. +* yank-nth-arg (M-C-y): Commands For History. +* yank-pop (M-y): Commands For Killing. + + |
