Return to readline.h CVS log

Up to [Apple XNU] / GNUtools / debug / gdb / readline

Annotation of GNUtools/debug/gdb/readline/readline.h, revision 1.1

1.1     ! root        1: /* Readline.h -- the names of functions callable from within readline. */
        !             2: 
        !             3: #if !defined (_READLINE_H_)
        !             4: #define _READLINE_H_
        !             5: 
        !             6: #include "keymaps.h"
        !             7: 
        !             8: #if !defined (__FUNCTION_DEF)
        !             9: typedef int Function ();
        !            10: #define __FUNCTION_DEF
        !            11: #endif /* __FUNCTION_DEF */
        !            12: 
        !            13: /* The functions for manipulating the text of the line within readline.
        !            14: Most of these functions are bound to keys by default. */
        !            15: extern int
        !            16:   rl_beg_of_line (), rl_backward (), rl_delete (), rl_end_of_line (),
        !            17:   rl_forward (), ding (), rl_backward (), rl_newline (), rl_kill_line (),
        !            18:   rl_clear_screen (), rl_get_next_history (), rl_get_previous_history (),
        !            19:   rl_quoted_insert (), rl_reverse_search_history (), rl_transpose_chars (),
        !            20:   rl_unix_line_discard (), rl_quoted_insert (), rl_unix_word_rubout (),
        !            21:   rl_yank (), rl_rubout (), rl_backward_word (), rl_kill_word (),
        !            22:   rl_forward_word (), rl_tab_insert (), rl_yank_pop (), rl_yank_nth_arg (),
        !            23:   rl_backward_kill_word (), rl_backward_kill_line (), rl_transpose_words (),
        !            24:   rl_complete (), rl_possible_completions (), rl_do_lowercase_version (),
        !            25:   rl_digit_argument (), rl_universal_argument (), rl_abort (),
        !            26:   rl_undo_command (), rl_revert_line (), rl_beginning_of_history (),
        !            27:   rl_end_of_history (), rl_forward_search_history (), rl_insert (),
        !            28:   rl_upcase_word (), rl_downcase_word (), rl_capitalize_word (),
        !            29:   rl_restart_output (), rl_re_read_init_file (), rl_dump_functions ();
        !            30: 
        !            31: /* These are *both* defined even when VI_MODE is not. */
        !            32: extern int rl_vi_editing_mode (), rl_emacs_editing_mode ();
        !            33: 
        !            34: #if defined (VI_MODE)
        !            35: /* Things for vi mode. */
        !            36: extern int
        !            37:   rl_vi_movement_mode (), rl_vi_insertion_mode (), rl_vi_arg_digit (),
        !            38:   rl_vi_prev_word (), rl_vi_next_word (), rl_vi_char_search (),
        !            39:   rl_vi_eof_maybe (), rl_vi_append_mode (), rl_vi_put (),
        !            40:   rl_vi_append_eol (), rl_vi_insert_beg (), rl_vi_delete (), rl_vi_comment (),
        !            41:   rl_vi_first_print (), rl_vi_fword (), rl_vi_fWord (), rl_vi_bword (),
        !            42:   rl_vi_bWord (), rl_vi_eword (), rl_vi_eWord (), rl_vi_end_word (),
        !            43:   rl_vi_change_case (), rl_vi_match (), rl_vi_bracktype (),
        !            44:   rl_vi_change_char (), rl_vi_yank_arg (), rl_vi_search (),
        !            45:   rl_vi_search_again (), rl_vi_dosearch (), rl_vi_subst (),
        !            46:   rl_vi_overstrike (), rl_vi_overstrike_delete (), rl_vi_replace(),
        !            47:   rl_vi_column (), rl_vi_delete_to (), rl_vi_change_to (), rl_vi_yank_to (),
        !            48:   rl_vi_complete (), rl_vi_fetch_history ();
        !            49: #endif /* VI_MODE */
        !            50: 
        !            51: /* Keyboard macro commands. */
        !            52: extern int
        !            53: rl_start_kbd_macro (), rl_end_kbd_macro (), rl_call_last_kbd_macro ();
        !            54: 
        !            55: extern int rl_arrow_keys(), rl_refresh_line ();
        !            56: 
        !            57: /* Maintaining the state of undo.  We remember individual deletes and inserts
        !            58:    on a chain of things to do. */
        !            59: 
        !            60: /* The actions that undo knows how to undo.  Notice that UNDO_DELETE means
        !            61:    to insert some text, and UNDO_INSERT means to delete some text.   I.e.,
        !            62:    the code tells undo what to undo, not how to undo it. */
        !            63: enum undo_code { UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END };
        !            64: 
        !            65: /* What an element of THE_UNDO_LIST looks like. */
        !            66: typedef struct undo_list {
        !            67:   struct undo_list *next;
        !            68:   int start, end;              /* Where the change took place. */
        !            69:   char *text;                  /* The text to insert, if undoing a delete. */
        !            70:   enum undo_code what;         /* Delete, Insert, Begin, End. */
        !            71: } UNDO_LIST;
        !            72: 
        !            73: /* The current undo list for RL_LINE_BUFFER. */
        !            74: extern UNDO_LIST *rl_undo_list;
        !            75: 
        !            76: /* The data structure for mapping textual names to code addresses. */
        !            77: typedef struct {
        !            78:   char *name;
        !            79:   Function *function;
        !            80: } FUNMAP;
        !            81: 
        !            82: extern FUNMAP **funmap;
        !            83: 
        !            84: /* **************************************************************** */
        !            85: /*                                                                 */
        !            86: /*                     Well Published Variables                    */
        !            87: /*                                                                 */
        !            88: /* **************************************************************** */
        !            89: 
        !            90: /* The name of the calling program.  You should initialize this to
        !            91:    whatever was in argv[0].  It is used when parsing conditionals. */
        !            92: extern char *rl_readline_name;
        !            93: 
        !            94: /* The line buffer that is in use. */
        !            95: extern char *rl_line_buffer;
        !            96: 
        !            97: /* The location of point, and end. */
        !            98: extern int rl_point, rl_end;
        !            99: 
        !           100: /* The name of the terminal to use. */
        !           101: extern char *rl_terminal_name;
        !           102: 
        !           103: /* The input and output streams. */
        !           104: extern FILE *rl_instream, *rl_outstream;
        !           105: 
        !           106: /* The basic list of characters that signal a break between words for the
        !           107:    completer routine.  The initial contents of this variable is what
        !           108:    breaks words in the shell, i.e. "n\"\\'`@$>". */
        !           109: extern char *rl_basic_word_break_characters;
        !           110: 
        !           111: /* The list of characters that signal a break between words for
        !           112:    rl_complete_internal.  The default list is the contents of
        !           113:    rl_basic_word_break_characters.  */
        !           114: extern char *rl_completer_word_break_characters;
        !           115: 
        !           116: /* List of characters which are used to quote a substring of the command
        !           117:    line, upon which completion is to be performed for the entire substring.
        !           118:    Within quoted substrings, rl_completer_word_break_characters are treated
        !           119:    as normal characters, unless they also appear in this list. */
        !           120: extern char *rl_completer_quote_characters;
        !           121: 
        !           122: /* List of characters that are word break characters, but should be left
        !           123:    in TEXT when it is passed to the completion function.  The shell uses
        !           124:    this to help determine what kind of completing to do. */
        !           125: extern char *rl_special_prefixes;
        !           126: 
        !           127: /* Pointer to the generator function for completion_matches ().
        !           128:    NULL means to use filename_entry_function (), the default filename
        !           129:    completer. */
        !           130: extern Function *rl_completion_entry_function;
        !           131: 
        !           132: /* If rl_ignore_some_completions_function is non-NULL it is the address
        !           133:    of a function to call after all of the possible matches have been
        !           134:    generated, but before the actual completion is done to the input line.
        !           135:    The function is called with one argument; a NULL terminated array
        !           136:    of (char *).  If your function removes any of the elements, they
        !           137:    must be free()'ed. */
        !           138: extern Function *rl_ignore_some_completions_function;
        !           139: 
        !           140: /* Pointer to alternative function to create matches.
        !           141:    Function is called with TEXT, START, and END.
        !           142:    START and END are indices in RL_LINE_BUFFER saying what the boundaries
        !           143:    of TEXT are.
        !           144:    If this function exists and returns NULL then call the value of
        !           145:    rl_completion_entry_function to try to match, otherwise use the
        !           146:    array of strings returned. */
        !           147: extern Function *rl_attempted_completion_function;
        !           148: 
        !           149: /* If non-zero, then this is the address of a function to call just
        !           150:    before readline_internal () prints the first prompt. */
        !           151: extern Function *rl_startup_hook;
        !           152: 
        !           153: /* If non-zero, then this is the address of a function to call when
        !           154:    completing on a directory name.  The function is called with
        !           155:    the address of a string (the current directory name) as an arg. */
        !           156: extern Function *rl_symbolic_link_hook;
        !           157: 
        !           158: /* If non-zero then this is the address of a function you want called
        !           159:    while Readline is waiting for character input.     */
        !           160: extern Function *rl_event_hook;
        !           161: 
        !           162: /* Non-zero means that modified history lines are preceded
        !           163:    with an asterisk. */
        !           164: extern int rl_show_star;
        !           165: 
        !           166: 
        !           167: /* **************************************************************** */
        !           168: /*                                                                  */
        !           169: /*             Tilde Variables That Can be Externally Set           */
        !           170: /*                                                                  */
        !           171: /* **************************************************************** */
        !           172: 
        !           173: /* If non-null, this contains the address of a function to call if the
        !           174:    standard meaning for expanding a tilde fails.  The function is called
        !           175:    with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
        !           176:    which is the expansion, or a NULL pointer if there is no expansion. */
        !           177: extern Function *tilde_expansion_failure_hook;
        !           178: 
        !           179: /* When non-null, this is a NULL terminated array of strings which
        !           180:    are duplicates for a tilde prefix.  Bash uses this to expand
        !           181:    `=~' and `:~'. */
        !           182: extern char **tilde_additional_prefixes;
        !           183: 
        !           184: /* When non-null, this is a NULL terminated array of strings which match
        !           185:    the end of a username, instead of just "/".  Bash sets this to
        !           186:    `/' and `:'. */
        !           187: extern char **tilde_additional_suffixes;
        !           188: 
        !           189: /* **************************************************************** */
        !           190: /*                                                                 */
        !           191: /*                     Well Published Functions                    */
        !           192: /*                                                                 */
        !           193: /* **************************************************************** */
        !           194: 
        !           195: /* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means none. */
        !           196: extern char *readline ();
        !           197: 
        !           198: /* Return an array of strings which are the result of repeatadly calling
        !           199:    FUNC with TEXT. */
        !           200: extern char **completion_matches ();
        !           201: 
        !           202: /* rl_add_defun (char *name, Function *function, int key)
        !           203:    Add NAME to the list of named functions.  Make FUNCTION
        !           204:    be the function that gets called.
        !           205:    If KEY is not -1, then bind it. */
        !           206: extern int rl_add_defun ();
        !           207: 
        !           208: #endif /* _READLINE_H_ */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.