1 /* readline.c -- a general facility for reading lines of input
2 with emacs style editing and completion. */
4 /* Copyright (C) 1987-2016 Free Software Foundation, Inc.
6 This file is part of the GNU Readline Library (Readline), a library
7 for reading lines of text with interactive input and history editing.
9 Readline is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 Readline is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with Readline. If not, see <http://www.gnu.org/licenses/>.
23 #define READLINE_LIBRARY
25 #if defined (HAVE_CONFIG_H)
29 #include <sys/types.h>
30 #include "posixstat.h"
32 #if defined (HAVE_SYS_FILE_H)
33 # include <sys/file.h>
34 #endif /* HAVE_SYS_FILE_H */
36 #if defined (HAVE_UNISTD_H)
38 #endif /* HAVE_UNISTD_H */
40 #if defined (HAVE_STDLIB_H)
43 # include "ansi_stdlib.h"
44 #endif /* HAVE_STDLIB_H */
46 #if defined (HAVE_LOCALE_H)
58 /* System-specific feature definitions and include files. */
63 # define INCL_DOSPROCESS
67 /* Some standard library routines. */
71 #include "rlprivate.h"
75 #ifndef RL_LIBRARY_VERSION
76 # define RL_LIBRARY_VERSION "5.1"
79 #ifndef RL_READLINE_VERSION
80 # define RL_READLINE_VERSION 0x0501
83 extern void _rl_free_history_entry
PARAMS((HIST_ENTRY
*));
85 #if defined (COLOR_SUPPORT)
86 extern void _rl_parse_colors
PARAMS((void)); /* XXX */
90 /* Forward declarations used in this file. */
91 static char *readline_internal
PARAMS((void));
92 static void readline_initialize_everything
PARAMS((void));
94 static void bind_arrow_keys_internal
PARAMS((Keymap
));
95 static void bind_arrow_keys
PARAMS((void));
97 static void bind_bracketed_paste_prefix
PARAMS((void));
99 static void readline_default_bindings
PARAMS((void));
100 static void reset_default_bindings
PARAMS((void));
102 static int _rl_subseq_result
PARAMS((int, Keymap
, int, int));
103 static int _rl_subseq_getchar
PARAMS((int));
105 /* **************************************************************** */
107 /* Line editing input utility */
109 /* **************************************************************** */
111 const char *rl_library_version
= RL_LIBRARY_VERSION
;
113 int rl_readline_version
= RL_READLINE_VERSION
;
115 /* True if this is `real' readline as opposed to some stub substitute. */
116 int rl_gnu_readline_p
= 1;
118 /* A pointer to the keymap that is currently in use.
119 By default, it is the standard emacs keymap. */
120 Keymap _rl_keymap
= emacs_standard_keymap
;
122 /* The current style of editing. */
123 int rl_editing_mode
= emacs_mode
;
125 /* The current insert mode: input (the default) or overwrite */
126 int rl_insert_mode
= RL_IM_DEFAULT
;
128 /* Non-zero if we called this function from _rl_dispatch(). It's present
129 so functions can find out whether they were called from a key binding
130 or directly from an application. */
133 /* Non-zero if the previous command was a kill command. */
134 int _rl_last_command_was_kill
= 0;
136 /* The current value of the numeric argument specified by the user. */
137 int rl_numeric_arg
= 1;
139 /* Non-zero if an argument was typed. */
140 int rl_explicit_arg
= 0;
142 /* Temporary value used while generating the argument. */
145 /* Non-zero means we have been called at least once before. */
146 static int rl_initialized
;
149 /* If non-zero, this program is running in an EMACS buffer. */
150 static int running_in_emacs
;
153 /* Flags word encapsulating the current readline state. */
154 unsigned long rl_readline_state
= RL_STATE_NONE
;
156 /* The current offset in the current input line. */
159 /* Mark in the current input line. */
162 /* Length of the current input line. */
165 /* Make this non-zero to return the current input_line. */
168 /* The last function executed by readline. */
169 rl_command_func_t
*rl_last_func
= (rl_command_func_t
*)NULL
;
171 /* Top level environment for readline_internal (). */
172 procenv_t _rl_top_level
;
174 /* The streams we interact with. */
175 FILE *_rl_in_stream
, *_rl_out_stream
;
177 /* The names of the streams that we do input and output to. */
178 FILE *rl_instream
= (FILE *)NULL
;
179 FILE *rl_outstream
= (FILE *)NULL
;
181 /* Non-zero means echo characters as they are read. Defaults to no echo;
182 set to 1 if there is a controlling terminal, we can get its attributes,
183 and the attributes include `echo'. Look at rltty.c:prepare_terminal_settings
184 for the code that sets it. */
185 int _rl_echoing_p
= 0;
187 /* Current prompt. */
188 char *rl_prompt
= (char *)NULL
;
189 int rl_visible_prompt_length
= 0;
191 /* Set to non-zero by calling application if it has already printed rl_prompt
192 and does not want readline to do it the first time. */
193 int rl_already_prompted
= 0;
195 /* The number of characters read in order to type this complete command. */
196 int rl_key_sequence_length
= 0;
198 /* If non-zero, then this is the address of a function to call just
199 before readline_internal_setup () prints the first prompt. */
200 rl_hook_func_t
*rl_startup_hook
= (rl_hook_func_t
*)NULL
;
202 /* If non-zero, this is the address of a function to call just before
203 readline_internal_setup () returns and readline_internal starts
204 reading input characters. */
205 rl_hook_func_t
*rl_pre_input_hook
= (rl_hook_func_t
*)NULL
;
207 /* What we use internally. You should always refer to RL_LINE_BUFFER. */
208 static char *the_line
;
210 /* The character that can generate an EOF. Really read from
211 the terminal driver... just defaulted here. */
212 int _rl_eof_char
= CTRL ('D');
214 /* Non-zero makes this the next keystroke to read. */
215 int rl_pending_input
= 0;
217 /* Pointer to a useful terminal name. */
218 const char *rl_terminal_name
= (const char *)NULL
;
220 /* Non-zero means to always use horizontal scrolling in line display. */
221 int _rl_horizontal_scroll_mode
= 0;
223 /* Non-zero means to display an asterisk at the starts of history lines
224 which have been modified. */
225 int _rl_mark_modified_lines
= 0;
227 /* The style of `bell' notification preferred. This can be set to NO_BELL,
228 AUDIBLE_BELL, or VISIBLE_BELL. */
229 int _rl_bell_preference
= AUDIBLE_BELL
;
231 /* String inserted into the line by rl_insert_comment (). */
232 char *_rl_comment_begin
;
234 /* Keymap holding the function currently being executed. */
235 Keymap rl_executing_keymap
;
237 /* Keymap we're currently using to dispatch. */
238 Keymap _rl_dispatching_keymap
;
240 /* Non-zero means to erase entire line, including prompt, on empty input lines. */
241 int rl_erase_empty_line
= 0;
243 /* Non-zero means to read only this many characters rather than up to a
244 character bound to accept-line. */
245 int rl_num_chars_to_read
;
247 /* Line buffer and maintenance. */
248 char *rl_line_buffer
= (char *)NULL
;
249 int rl_line_buffer_len
= 0;
251 /* Key sequence `contexts' */
252 _rl_keyseq_cxt
*_rl_kscxt
= 0;
254 int rl_executing_key
;
255 char *rl_executing_keyseq
= 0;
256 int _rl_executing_keyseq_size
= 0;
258 /* Timeout (specified in milliseconds) when reading characters making up an
259 ambiguous multiple-key sequence */
260 int _rl_keyseq_timeout
= 500;
262 #define RESIZE_KEYSEQ_BUFFER() \
265 if (rl_key_sequence_length + 2 >= _rl_executing_keyseq_size) \
267 _rl_executing_keyseq_size += 16; \
268 rl_executing_keyseq = xrealloc (rl_executing_keyseq, _rl_executing_keyseq_size); \
273 /* Forward declarations used by the display, termcap, and history code. */
275 /* **************************************************************** */
277 /* `Forward' declarations */
279 /* **************************************************************** */
281 /* Non-zero means do not parse any lines other than comments and
282 parser directives. */
283 unsigned char _rl_parsing_conditionalized_out
= 0;
285 /* Non-zero means to convert characters with the meta bit set to
286 escape-prefixed characters so we can indirect through
287 emacs_meta_keymap or vi_escape_keymap. */
288 int _rl_convert_meta_chars_to_ascii
= 1;
290 /* Non-zero means to output characters with the meta bit set directly
291 rather than as a meta-prefixed escape sequence. */
292 int _rl_output_meta_chars
= 0;
294 /* Non-zero means to look at the termios special characters and bind
295 them to equivalent readline functions at startup. */
296 int _rl_bind_stty_chars
= 1;
298 /* Non-zero means to go through the history list at every newline (or
299 whenever rl_done is set and readline returns) and revert each line to
300 its initial state. */
301 int _rl_revert_all_at_newline
= 0;
303 /* Non-zero means to honor the termios ECHOCTL bit and echo control
304 characters corresponding to keyboard-generated signals. */
305 int _rl_echo_control_chars
= 1;
307 /* Non-zero means to prefix the displayed prompt with a character indicating
308 the editing mode: @ for emacs, : for vi-command, + for vi-insert. */
309 int _rl_show_mode_in_prompt
= 0;
311 /* Non-zero means to attempt to put the terminal in `bracketed paste mode',
312 where it will prefix pasted text with an escape sequence and send
313 another to mark the end of the paste. */
314 int _rl_enable_bracketed_paste
= 0;
316 /* **************************************************************** */
318 /* Top Level Functions */
320 /* **************************************************************** */
322 /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
323 int _rl_meta_flag
= 0; /* Forward declaration */
325 /* Set up the prompt and expand it. Called from readline() and
326 rl_callback_handler_install (). */
328 rl_set_prompt (prompt
)
332 rl_prompt
= prompt
? savestring (prompt
) : (char *)NULL
;
333 rl_display_prompt
= rl_prompt
? rl_prompt
: "";
335 rl_visible_prompt_length
= rl_expand_prompt (rl_prompt
);
339 /* Read a line of input. Prompt with PROMPT. An empty PROMPT means
340 none. A return value of NULL means that EOF was encountered. */
350 /* If we are at EOF return a NULL string. */
351 if (rl_pending_input
== EOF
)
353 rl_clear_pending_input ();
354 return ((char *)NULL
);
358 /* If readline() is called after installing a callback handler, temporarily
359 turn off the callback state to avoid ensuing messiness. Patch supplied
360 by the gdb folks. XXX -- disabled. This can be fooled and readline
361 left in a strange state by a poorly-timed longjmp. */
362 if (in_callback
= RL_ISSTATE (RL_STATE_CALLBACK
))
363 RL_UNSETSTATE (RL_STATE_CALLBACK
);
366 rl_set_prompt (prompt
);
369 if (rl_prep_term_function
)
370 (*rl_prep_term_function
) (_rl_meta_flag
);
372 #if defined (HANDLE_SIGNALS)
376 value
= readline_internal ();
377 if (rl_deprep_term_function
)
378 (*rl_deprep_term_function
) ();
380 #if defined (HANDLE_SIGNALS)
386 RL_SETSTATE (RL_STATE_CALLBACK
);
389 #if HAVE_DECL_AUDIT_USER_TTY && defined (HAVE_LIBAUDIT_H) && defined (ENABLE_TTY_AUDIT_SUPPORT)
391 _rl_audit_tty (value
);
397 #if defined (READLINE_CALLBACKS)
398 # define STATIC_CALLBACK
400 # define STATIC_CALLBACK static
404 readline_internal_setup ()
408 _rl_in_stream
= rl_instream
;
409 _rl_out_stream
= rl_outstream
;
411 /* Enable the meta key only for the duration of readline(), if this
412 terminal has one and the terminal has been initialized */
413 if (_rl_enable_meta
& RL_ISSTATE (RL_STATE_TERMPREPPED
))
414 _rl_enable_meta_key ();
417 (*rl_startup_hook
) ();
419 #if defined (VI_MODE)
420 if (rl_editing_mode
== vi_mode
)
421 rl_vi_insertion_mode (1, 'i'); /* don't want to reset last */
424 /* If we're not echoing, we still want to at least print a prompt, because
425 rl_redisplay will not do it for us. If the calling application has a
426 custom redisplay function, though, let that function handle it. */
427 if (_rl_echoing_p
== 0 && rl_redisplay_function
== rl_redisplay
)
429 if (rl_prompt
&& rl_already_prompted
== 0)
431 nprompt
= _rl_strip_prompt (rl_prompt
);
432 fprintf (_rl_out_stream
, "%s", nprompt
);
433 fflush (_rl_out_stream
);
439 if (rl_prompt
&& rl_already_prompted
)
440 rl_on_new_line_with_prompt ();
443 (*rl_redisplay_function
) ();
446 if (rl_pre_input_hook
)
447 (*rl_pre_input_hook
) ();
452 STATIC_CALLBACK
char *
453 readline_internal_teardown (eof
)
461 /* Restore the original of this history line, iff the line that we
462 are editing was originally in the history, AND the line has changed. */
463 entry
= current_history ();
465 if (entry
&& rl_undo_list
)
467 temp
= savestring (the_line
);
468 rl_revert_line (1, 0);
469 entry
= replace_history_entry (where_history (), the_line
, (histdata_t
)NULL
);
470 _rl_free_history_entry (entry
);
472 strcpy (the_line
, temp
);
476 if (_rl_revert_all_at_newline
)
477 _rl_revert_all_lines ();
479 /* At any rate, it is highly likely that this line has an undo list. Get
482 rl_free_undo_list ();
484 /* Disable the meta key, if this terminal has one and we were told to use it.
485 The check whether or not we sent the enable string is in
486 _rl_disable_meta_key(); the flag is set in _rl_enable_meta_key */
487 _rl_disable_meta_key ();
489 /* Restore normal cursor, if available. */
490 _rl_set_insert_mode (RL_IM_INSERT
, 0);
492 return (eof
? (char *)NULL
: savestring (the_line
));
496 _rl_internal_char_cleanup ()
498 #if defined (VI_MODE)
499 /* In vi mode, when you exit insert mode, the cursor moves back
500 over the previous character. We explicitly check for that here. */
501 if (rl_editing_mode
== vi_mode
&& _rl_keymap
== vi_movement_keymap
)
505 if (rl_num_chars_to_read
&& rl_end
>= rl_num_chars_to_read
)
507 (*rl_redisplay_function
) ();
508 _rl_want_redisplay
= 0;
509 rl_newline (1, '\n');
514 (*rl_redisplay_function
) ();
515 _rl_want_redisplay
= 0;
518 /* If the application writer has told us to erase the entire line if
519 the only character typed was something bound to rl_newline, do so. */
520 if (rl_erase_empty_line
&& rl_done
&& rl_last_func
== rl_newline
&&
521 rl_point
== 0 && rl_end
== 0)
522 _rl_erase_entire_line ();
526 #if defined (READLINE_CALLBACKS)
527 readline_internal_char ()
529 readline_internal_charloop ()
532 static int lastc
, eof_found
;
537 #if !defined (READLINE_CALLBACKS)
542 lk
= _rl_last_command_was_kill
;
544 #if defined (HAVE_POSIX_SIGSETJMP)
545 code
= sigsetjmp (_rl_top_level
, 0);
547 code
= setjmp (_rl_top_level
);
552 (*rl_redisplay_function
) ();
553 _rl_want_redisplay
= 0;
554 /* If we get here, we're not being called from something dispatched
555 from _rl_callback_read_char(), which sets up its own value of
556 _rl_top_level (saving and restoring the old, of course), so
557 we can just return here. */
558 if (RL_ISSTATE (RL_STATE_CALLBACK
))
562 if (rl_pending_input
== 0)
564 /* Then initialize the argument and number of keys read. */
565 _rl_reset_argument ();
566 rl_executing_keyseq
[rl_key_sequence_length
= 0] = '\0';
569 RL_SETSTATE(RL_STATE_READCMD
);
571 RL_UNSETSTATE(RL_STATE_READCMD
);
573 /* look at input.c:rl_getc() for the circumstances under which this will
574 be returned; punt immediately on read error without converting it to
575 a newline; assume that rl_read_key has already called the signal
579 #if defined (READLINE_CALLBACKS)
580 RL_SETSTATE(RL_STATE_DONE
);
581 return (rl_done
= 1);
588 /* EOF typed to a non-blank line is ^D the first time, EOF the second
589 time in a row. This won't return any partial line read from the tty.
590 If we want to change this, to force any existing line to be returned
591 when read(2) reads EOF, for example, this is the place to change. */
592 if (c
== EOF
&& rl_end
)
594 if (RL_SIG_RECEIVED ())
597 if (rl_signal_event_hook
)
598 (*rl_signal_event_hook
) (); /* XXX */
601 /* XXX - reading two consecutive EOFs returns EOF */
602 if (RL_ISSTATE (RL_STATE_TERMPREPPED
))
604 if (lastc
== _rl_eof_char
|| lastc
== EOF
)
613 /* The character _rl_eof_char typed to blank line, and not as the
614 previous character is interpreted as EOF. This doesn't work when
615 READLINE_CALLBACKS is defined, so hitting a series of ^Ds will
616 erase all the chars on the line and then return EOF. */
617 if (((c
== _rl_eof_char
&& lastc
!= c
) || c
== EOF
) && rl_end
== 0)
619 #if defined (READLINE_CALLBACKS)
620 RL_SETSTATE(RL_STATE_DONE
);
621 return (rl_done
= 1);
629 _rl_dispatch ((unsigned char)c
, _rl_keymap
);
632 /* If there was no change in _rl_last_command_was_kill, then no kill
633 has taken place. Note that if input is pending we are reading
634 a prefix command, so nothing has changed yet. */
635 if (rl_pending_input
== 0 && lk
== _rl_last_command_was_kill
)
636 _rl_last_command_was_kill
= 0;
638 _rl_internal_char_cleanup ();
640 #if defined (READLINE_CALLBACKS)
649 #if defined (READLINE_CALLBACKS)
651 readline_internal_charloop ()
656 eof
= readline_internal_char ();
659 #endif /* READLINE_CALLBACKS */
661 /* Read a line of input from the global rl_instream, doing output on
662 the global rl_outstream.
663 If rl_prompt is non-null, then that is our prompt. */
669 readline_internal_setup ();
670 eof
= readline_internal_charloop ();
671 return (readline_internal_teardown (eof
));
675 _rl_init_line_state ()
677 rl_point
= rl_end
= rl_mark
= 0;
678 the_line
= rl_line_buffer
;
685 the_line
= rl_line_buffer
;
688 #if defined (READLINE_CALLBACKS)
690 _rl_keyseq_cxt_alloc ()
694 cxt
= (_rl_keyseq_cxt
*)xmalloc (sizeof (_rl_keyseq_cxt
));
696 cxt
->flags
= cxt
->subseq_arg
= cxt
->subseq_retval
= 0;
699 cxt
->ocxt
= _rl_kscxt
;
700 cxt
->childval
= 42; /* sentinel value */
706 _rl_keyseq_cxt_dispose (cxt
)
713 _rl_keyseq_chain_dispose ()
720 _rl_kscxt
= _rl_kscxt
->ocxt
;
721 _rl_keyseq_cxt_dispose (cxt
);
727 _rl_subseq_getchar (key
)
733 RL_SETSTATE(RL_STATE_METANEXT
);
734 RL_SETSTATE(RL_STATE_MOREINPUT
);
736 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
738 RL_UNSETSTATE(RL_STATE_METANEXT
);
743 #if defined (READLINE_CALLBACKS)
745 _rl_dispatch_callback (cxt
)
751 /* The first time this context is used, we want to read input and dispatch
752 on it. When traversing the chain of contexts back `up', we want to use
753 the value from the next context down. We're simulating recursion using
754 a chain of contexts. */
755 if ((cxt
->flags
& KSEQ_DISPATCHED
) == 0)
757 nkey
= _rl_subseq_getchar (cxt
->okey
);
760 _rl_abort_internal ();
763 r
= _rl_dispatch_subseq (nkey
, cxt
->dmap
, cxt
->subseq_arg
);
764 cxt
->flags
|= KSEQ_DISPATCHED
;
770 if (r
!= -3) /* don't do this if we indicate there will be other matches */
771 r
= _rl_subseq_result (r
, cxt
->oldmap
, cxt
->okey
, (cxt
->flags
& KSEQ_SUBSEQ
));
774 /* We only treat values < 0 specially to simulate recursion. */
775 if (r
>= 0 || (r
== -1 && (cxt
->flags
& KSEQ_SUBSEQ
) == 0)) /* success! or failure! */
777 _rl_keyseq_chain_dispose ();
778 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
782 if (r
!= -3) /* magic value that says we added to the chain */
783 _rl_kscxt
= cxt
->ocxt
;
785 _rl_kscxt
->childval
= r
;
787 _rl_keyseq_cxt_dispose (cxt
);
791 #endif /* READLINE_CALLBACKS */
793 /* Do the command associated with KEY in MAP.
794 If the associated command is really a keymap, then read
795 another key, and dispatch into that map. */
797 _rl_dispatch (key
, map
)
801 _rl_dispatching_keymap
= map
;
802 return _rl_dispatch_subseq (key
, map
, 0);
806 _rl_dispatch_subseq (key
, map
, got_subseq
)
813 rl_command_func_t
*func
;
814 #if defined (READLINE_CALLBACKS)
818 if (META_CHAR (key
) && _rl_convert_meta_chars_to_ascii
)
820 if (map
[ESC
].type
== ISKMAP
)
822 if (RL_ISSTATE (RL_STATE_MACRODEF
))
823 _rl_add_macro_char (ESC
);
824 RESIZE_KEYSEQ_BUFFER ();
825 rl_executing_keyseq
[rl_key_sequence_length
++] = ESC
;
826 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
828 return (_rl_dispatch (key
, map
));
835 if (RL_ISSTATE (RL_STATE_MACRODEF
))
836 _rl_add_macro_char (key
);
839 switch (map
[key
].type
)
842 func
= map
[key
].function
;
845 /* Special case rl_do_lowercase_version (). */
846 if (func
== rl_do_lowercase_version
)
847 /* Should we do anything special if key == ANYOTHERKEY? */
848 return (_rl_dispatch (_rl_to_lower ((unsigned char)key
), map
));
850 rl_executing_keymap
= map
;
851 rl_executing_key
= key
;
853 RESIZE_KEYSEQ_BUFFER();
854 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
855 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
858 RL_SETSTATE(RL_STATE_DISPATCHING
);
859 r
= (*func
) (rl_numeric_arg
* rl_arg_sign
, key
);
860 RL_UNSETSTATE(RL_STATE_DISPATCHING
);
863 /* If we have input pending, then the last command was a prefix
864 command. Don't change the state of rl_last_func. Otherwise,
865 remember the last command executed in this variable. */
866 if (rl_pending_input
== 0 && map
[key
].function
!= rl_digit_argument
)
867 rl_last_func
= map
[key
].function
;
871 else if (map
[ANYOTHERKEY
].function
)
873 /* OK, there's no function bound in this map, but there is a
874 shadow function that was overridden when the current keymap
875 was created. Return -2 to note that. */
876 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
877 _rl_prev_macro_key ();
879 _rl_unget_char (key
);
884 /* Return -1 to note that we're in a subsequence, but we don't
885 have a matching key, nor was one overridden. This means
886 we need to back up the recursion chain and find the last
887 subsequence that is bound to a function. */
888 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
889 _rl_prev_macro_key ();
891 _rl_unget_char (key
);
896 #if defined (READLINE_CALLBACKS)
897 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
898 _rl_keyseq_chain_dispose ();
900 _rl_abort_internal ();
906 if (map
[key
].function
!= 0)
908 #if defined (VI_MODE)
909 /* The only way this test will be true is if a subsequence has been
910 bound starting with ESC, generally the arrow keys. What we do is
911 check whether there's input in the queue, which there generally
912 will be if an arrow key has been pressed, and, if there's not,
913 just dispatch to (what we assume is) rl_vi_movement_mode right
914 away. This is essentially an input test with a zero timeout (by
915 default) or a timeout determined by the value of `keyseq-timeout' */
916 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
917 takes microseconds, so multiply by 1000 */
918 if (rl_editing_mode
== vi_mode
&& key
== ESC
&& map
== vi_insertion_keymap
&&
919 (RL_ISSTATE (RL_STATE_INPUTPENDING
|RL_STATE_MACROINPUT
) == 0) &&
920 _rl_pushed_input_available () == 0 &&
921 _rl_input_queued ((_rl_keyseq_timeout
> 0) ? _rl_keyseq_timeout
*1000 : 0) == 0)
922 return (_rl_dispatch (ANYOTHERKEY
, FUNCTION_TO_KEYMAP (map
, key
)));
925 RESIZE_KEYSEQ_BUFFER ();
926 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
927 _rl_dispatching_keymap
= FUNCTION_TO_KEYMAP (map
, key
);
929 /* Allocate new context here. Use linked contexts (linked through
930 cxt->ocxt) to simulate recursion */
931 #if defined (READLINE_CALLBACKS)
932 # if defined (VI_MODE)
933 /* If we're redoing a vi mode command and we know there is a shadowed
934 function corresponding to this key, just call it -- all the redoable
935 vi mode commands already have all the input they need, and rl_vi_redo
936 assumes that one call to rl_dispatch is sufficient to complete the
938 if (_rl_vi_redoing
&& RL_ISSTATE (RL_STATE_CALLBACK
) &&
939 map
[ANYOTHERKEY
].function
!= 0)
940 return (_rl_subseq_result (-2, map
, key
, got_subseq
));
942 if (RL_ISSTATE (RL_STATE_CALLBACK
))
944 /* Return 0 only the first time, to indicate success to
945 _rl_callback_read_char. The rest of the time, we're called
946 from _rl_dispatch_callback, so we return -3 to indicate
947 special handling is necessary. */
948 r
= RL_ISSTATE (RL_STATE_MULTIKEY
) ? -3 : 0;
949 cxt
= _rl_keyseq_cxt_alloc ();
952 cxt
->flags
|= KSEQ_SUBSEQ
;
955 cxt
->dmap
= _rl_dispatching_keymap
;
956 cxt
->subseq_arg
= got_subseq
|| cxt
->dmap
[ANYOTHERKEY
].function
;
958 RL_SETSTATE (RL_STATE_MULTIKEY
);
961 return r
; /* don't indicate immediate success */
965 /* Tentative inter-character timeout for potential multi-key
966 sequences? If no input within timeout, abort sequence and
967 act as if we got non-matching input. */
968 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
969 takes microseconds, so multiply by 1000 */
970 if (_rl_keyseq_timeout
> 0 &&
971 (RL_ISSTATE (RL_STATE_INPUTPENDING
|RL_STATE_MACROINPUT
) == 0) &&
972 _rl_pushed_input_available () == 0 &&
973 _rl_dispatching_keymap
[ANYOTHERKEY
].function
&&
974 _rl_input_queued (_rl_keyseq_timeout
*1000) == 0)
975 return (_rl_subseq_result (-2, map
, key
, got_subseq
));
977 newkey
= _rl_subseq_getchar (key
);
980 _rl_abort_internal ();
984 r
= _rl_dispatch_subseq (newkey
, _rl_dispatching_keymap
, got_subseq
|| map
[ANYOTHERKEY
].function
);
985 return _rl_subseq_result (r
, map
, key
, got_subseq
);
989 _rl_abort_internal (); /* XXX */
995 if (map
[key
].function
!= 0)
997 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
998 macro
= savestring ((char *)map
[key
].function
);
999 _rl_with_macro_input (macro
);
1005 #if defined (VI_MODE)
1006 if (rl_editing_mode
== vi_mode
&& _rl_keymap
== vi_movement_keymap
&&
1007 key
!= ANYOTHERKEY
&&
1008 _rl_dispatching_keymap
== vi_movement_keymap
&&
1009 _rl_vi_textmod_command (key
))
1010 _rl_vi_set_last (key
, rl_numeric_arg
, rl_arg_sign
);
1017 _rl_subseq_result (r
, map
, key
, got_subseq
)
1020 int key
, got_subseq
;
1024 rl_command_func_t
*func
, *nf
;
1027 /* We didn't match anything, and the keymap we're indexed into
1028 shadowed a function previously bound to that prefix. Call
1029 the function. The recursive call to _rl_dispatch_subseq has
1030 already taken care of pushing any necessary input back onto
1031 the input queue with _rl_unget_char. */
1033 m
= _rl_dispatching_keymap
;
1034 type
= m
[ANYOTHERKEY
].type
;
1035 func
= m
[ANYOTHERKEY
].function
;
1036 if (type
== ISFUNC
&& func
== rl_do_lowercase_version
)
1037 r
= _rl_dispatch (_rl_to_lower ((unsigned char)key
), map
);
1038 else if (type
== ISFUNC
)
1040 /* If we shadowed a function, whatever it is, we somehow need a
1041 keymap with map[key].func == shadowed-function.
1042 Let's use this one. Then we can dispatch using the original
1043 key, since there are commands (e.g., in vi mode) for which it
1046 nf
= m
[key
].function
;
1049 m
[key
].function
= func
;
1050 /* Don't change _rl_dispatching_keymap, set it here */
1051 _rl_dispatching_keymap
= map
; /* previous map */
1052 r
= _rl_dispatch_subseq (key
, m
, 0);
1054 m
[key
].function
= nf
;
1057 /* We probably shadowed a keymap, so keep going. */
1058 r
= _rl_dispatch (ANYOTHERKEY
, m
);
1060 else if (r
< 0 && map
[ANYOTHERKEY
].function
)
1062 /* We didn't match (r is probably -1), so return something to
1063 tell the caller that it should try ANYOTHERKEY for an
1064 overridden function. */
1065 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1066 _rl_prev_macro_key ();
1068 _rl_unget_char (key
);
1069 _rl_dispatching_keymap
= map
;
1072 else if (r
< 0 && got_subseq
) /* XXX */
1074 /* OK, back up the chain. */
1075 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1076 _rl_prev_macro_key ();
1078 _rl_unget_char (key
);
1079 _rl_dispatching_keymap
= map
;
1086 /* **************************************************************** */
1088 /* Initializations */
1090 /* **************************************************************** */
1092 /* Initialize readline (and terminal if not already). */
1096 /* If we have never been called before, initialize the
1097 terminal and data structures. */
1098 if (!rl_initialized
)
1100 RL_SETSTATE(RL_STATE_INITIALIZING
);
1101 readline_initialize_everything ();
1102 RL_UNSETSTATE(RL_STATE_INITIALIZING
);
1104 RL_SETSTATE(RL_STATE_INITIALIZED
);
1107 /* Initialize the current line information. */
1108 _rl_init_line_state ();
1110 /* We aren't done yet. We haven't even gotten started yet! */
1112 RL_UNSETSTATE(RL_STATE_DONE
);
1114 /* Tell the history routines what is going on. */
1115 _rl_start_using_history ();
1117 /* Make the display buffer match the state of the line. */
1118 rl_reset_line_state ();
1120 /* No such function typed yet. */
1121 rl_last_func
= (rl_command_func_t
*)NULL
;
1123 /* Parsing of key-bindings begins in an enabled state. */
1124 _rl_parsing_conditionalized_out
= 0;
1126 #if defined (VI_MODE)
1127 if (rl_editing_mode
== vi_mode
)
1128 _rl_vi_initialize_line ();
1131 /* Each line starts in insert mode (the default). */
1132 _rl_set_insert_mode (RL_IM_DEFAULT
, 1);
1138 #if defined (__EMX__)
1140 _emx_build_environ ()
1147 DosGetInfoBlocks (&tibp
, &pibp
);
1148 t
= pibp
->pib_pchenv
;
1149 for (c
= 1; *t
; c
++)
1150 t
+= strlen (t
) + 1;
1151 tp
= environ
= (char **)xmalloc ((c
+ 1) * sizeof (char *));
1152 t
= pibp
->pib_pchenv
;
1156 t
+= strlen (t
) + 1;
1160 #endif /* __EMX__ */
1163 /* Initialize the entire state of the world. */
1165 readline_initialize_everything ()
1168 #if defined (__EMX__)
1170 _emx_build_environ ();
1175 /* Find out if we are running in Emacs -- UNUSED. */
1176 running_in_emacs
= sh_get_env_value ("EMACS") != (char *)0;
1179 /* Set up input and output if they are not already set up. */
1181 rl_instream
= stdin
;
1184 rl_outstream
= stdout
;
1186 /* Bind _rl_in_stream and _rl_out_stream immediately. These values
1187 may change, but they may also be used before readline_internal ()
1189 _rl_in_stream
= rl_instream
;
1190 _rl_out_stream
= rl_outstream
;
1192 /* Allocate data structures. */
1193 if (rl_line_buffer
== 0)
1194 rl_line_buffer
= (char *)xmalloc (rl_line_buffer_len
= DEFAULT_BUFFER_SIZE
);
1196 /* Initialize the terminal interface. */
1197 if (rl_terminal_name
== 0)
1198 rl_terminal_name
= sh_get_env_value ("TERM");
1199 _rl_init_terminal_io (rl_terminal_name
);
1201 /* Bind tty characters to readline functions. */
1202 readline_default_bindings ();
1204 /* Initialize the function names. */
1205 rl_initialize_funmap ();
1207 /* Decide whether we should automatically go into eight-bit mode. */
1208 _rl_init_eightbit ();
1210 /* Read in the init file. */
1211 rl_read_init_file ((char *)NULL
);
1214 if (_rl_horizontal_scroll_mode
&& _rl_term_autowrap
)
1217 _rl_screenchars
-= _rl_screenheight
;
1220 /* Override the effect of any `set keymap' assignments in the
1222 rl_set_keymap_from_edit_mode ();
1224 /* Try to bind a common arrow key prefix, if not already bound. */
1227 /* Bind the bracketed paste prefix assuming that the user will enable
1228 it on terminals that support it. */
1229 bind_bracketed_paste_prefix ();
1231 /* If the completion parser's default word break characters haven't
1232 been set yet, then do so now. */
1233 if (rl_completer_word_break_characters
== (char *)NULL
)
1234 rl_completer_word_break_characters
= (char *)rl_basic_word_break_characters
;
1236 #if defined (COLOR_SUPPORT)
1237 if (_rl_colored_stats
|| _rl_colored_completion_prefix
)
1238 _rl_parse_colors ();
1241 rl_executing_keyseq
= malloc (_rl_executing_keyseq_size
= 16);
1242 if (rl_executing_keyseq
)
1243 rl_executing_keyseq
[0] = '\0';
1246 /* If this system allows us to look at the values of the regular
1247 input editing characters, then bind them to their readline
1248 equivalents, iff the characters are not bound to keymaps. */
1250 readline_default_bindings ()
1252 if (_rl_bind_stty_chars
)
1253 rl_tty_set_default_bindings (_rl_keymap
);
1256 /* Reset the default bindings for the terminal special characters we're
1257 interested in back to rl_insert and read the new ones. */
1259 reset_default_bindings ()
1261 if (_rl_bind_stty_chars
)
1263 rl_tty_unset_default_bindings (_rl_keymap
);
1264 rl_tty_set_default_bindings (_rl_keymap
);
1268 /* Bind some common arrow key sequences in MAP. */
1270 bind_arrow_keys_internal (map
)
1275 xkeymap
= _rl_keymap
;
1278 #if defined (__MSDOS__)
1279 rl_bind_keyseq_if_unbound ("\033[0A", rl_get_previous_history
);
1280 rl_bind_keyseq_if_unbound ("\033[0B", rl_backward_char
);
1281 rl_bind_keyseq_if_unbound ("\033[0C", rl_forward_char
);
1282 rl_bind_keyseq_if_unbound ("\033[0D", rl_get_next_history
);
1285 rl_bind_keyseq_if_unbound ("\033[A", rl_get_previous_history
);
1286 rl_bind_keyseq_if_unbound ("\033[B", rl_get_next_history
);
1287 rl_bind_keyseq_if_unbound ("\033[C", rl_forward_char
);
1288 rl_bind_keyseq_if_unbound ("\033[D", rl_backward_char
);
1289 rl_bind_keyseq_if_unbound ("\033[H", rl_beg_of_line
);
1290 rl_bind_keyseq_if_unbound ("\033[F", rl_end_of_line
);
1292 rl_bind_keyseq_if_unbound ("\033OA", rl_get_previous_history
);
1293 rl_bind_keyseq_if_unbound ("\033OB", rl_get_next_history
);
1294 rl_bind_keyseq_if_unbound ("\033OC", rl_forward_char
);
1295 rl_bind_keyseq_if_unbound ("\033OD", rl_backward_char
);
1296 rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line
);
1297 rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line
);
1299 #if defined (__MINGW32__)
1300 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history
);
1301 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history
);
1302 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char
);
1303 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char
);
1304 rl_bind_keyseq_if_unbound ("\340G", rl_beg_of_line
);
1305 rl_bind_keyseq_if_unbound ("\340O", rl_end_of_line
);
1306 rl_bind_keyseq_if_unbound ("\340S", rl_delete
);
1307 rl_bind_keyseq_if_unbound ("\340R", rl_overwrite_mode
);
1309 /* These may or may not work because of the embedded NUL. */
1310 rl_bind_keyseq_if_unbound ("\\000H", rl_get_previous_history
);
1311 rl_bind_keyseq_if_unbound ("\\000P", rl_get_next_history
);
1312 rl_bind_keyseq_if_unbound ("\\000M", rl_forward_char
);
1313 rl_bind_keyseq_if_unbound ("\\000K", rl_backward_char
);
1314 rl_bind_keyseq_if_unbound ("\\000G", rl_beg_of_line
);
1315 rl_bind_keyseq_if_unbound ("\\000O", rl_end_of_line
);
1316 rl_bind_keyseq_if_unbound ("\\000S", rl_delete
);
1317 rl_bind_keyseq_if_unbound ("\\000R", rl_overwrite_mode
);
1320 _rl_keymap
= xkeymap
;
1323 /* Try and bind the common arrow key prefixes after giving termcap and
1324 the inputrc file a chance to bind them and create `real' keymaps
1325 for the arrow key prefix. */
1329 bind_arrow_keys_internal (emacs_standard_keymap
);
1331 #if defined (VI_MODE)
1332 bind_arrow_keys_internal (vi_movement_keymap
);
1333 /* Unbind vi_movement_keymap[ESC] to allow users to repeatedly hit ESC
1334 in vi command mode while still allowing the arrow keys to work. */
1335 if (vi_movement_keymap
[ESC
].type
== ISKMAP
)
1336 rl_bind_keyseq_in_map ("\033", (rl_command_func_t
*)NULL
, vi_movement_keymap
);
1337 bind_arrow_keys_internal (vi_insertion_keymap
);
1342 bind_bracketed_paste_prefix ()
1346 xkeymap
= _rl_keymap
;
1348 _rl_keymap
= emacs_standard_keymap
;
1349 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1351 _rl_keymap
= vi_insertion_keymap
;
1352 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1354 _rl_keymap
= xkeymap
;
1357 /* **************************************************************** */
1359 /* Saving and Restoring Readline's state */
1361 /* **************************************************************** */
1365 struct readline_state
*sp
;
1370 sp
->point
= rl_point
;
1373 sp
->buffer
= rl_line_buffer
;
1374 sp
->buflen
= rl_line_buffer_len
;
1375 sp
->ul
= rl_undo_list
;
1376 sp
->prompt
= rl_prompt
;
1378 sp
->rlstate
= rl_readline_state
;
1380 sp
->kmap
= _rl_keymap
;
1382 sp
->lastfunc
= rl_last_func
;
1383 sp
->insmode
= rl_insert_mode
;
1384 sp
->edmode
= rl_editing_mode
;
1385 sp
->kseq
= rl_executing_keyseq
;
1386 sp
->kseqlen
= rl_key_sequence_length
;
1387 sp
->inf
= rl_instream
;
1388 sp
->outf
= rl_outstream
;
1389 sp
->pendingin
= rl_pending_input
;
1390 sp
->macro
= rl_executing_macro
;
1392 sp
->catchsigs
= rl_catch_signals
;
1393 sp
->catchsigwinch
= rl_catch_sigwinch
;
1395 sp
->entryfunc
= rl_completion_entry_function
;
1396 sp
->menuentryfunc
= rl_menu_completion_entry_function
;
1397 sp
->ignorefunc
= rl_ignore_some_completions_function
;
1398 sp
->attemptfunc
= rl_attempted_completion_function
;
1399 sp
->wordbreakchars
= rl_completer_word_break_characters
;
1405 rl_restore_state (sp
)
1406 struct readline_state
*sp
;
1411 rl_point
= sp
->point
;
1414 the_line
= rl_line_buffer
= sp
->buffer
;
1415 rl_line_buffer_len
= sp
->buflen
;
1416 rl_undo_list
= sp
->ul
;
1417 rl_prompt
= sp
->prompt
;
1419 rl_readline_state
= sp
->rlstate
;
1421 _rl_keymap
= sp
->kmap
;
1423 rl_last_func
= sp
->lastfunc
;
1424 rl_insert_mode
= sp
->insmode
;
1425 rl_editing_mode
= sp
->edmode
;
1426 rl_executing_keyseq
= sp
->kseq
;
1427 rl_key_sequence_length
= sp
->kseqlen
;
1428 rl_instream
= sp
->inf
;
1429 rl_outstream
= sp
->outf
;
1430 rl_pending_input
= sp
->pendingin
;
1431 rl_executing_macro
= sp
->macro
;
1433 rl_catch_signals
= sp
->catchsigs
;
1434 rl_catch_sigwinch
= sp
->catchsigwinch
;
1436 rl_completion_entry_function
= sp
->entryfunc
;
1437 rl_menu_completion_entry_function
= sp
->menuentryfunc
;
1438 rl_ignore_some_completions_function
= sp
->ignorefunc
;
1439 rl_attempted_completion_function
= sp
->attemptfunc
;
1440 rl_completer_word_break_characters
= sp
->wordbreakchars
;