1 /* readline.c -- a general facility for reading lines of input
2 with emacs style editing and completion. */
4 /* Copyright (C) 1987-2013 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 int 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_TTY && 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_key_sequence_length
= 0;
567 rl_executing_keyseq
[0] = 0;
570 RL_SETSTATE(RL_STATE_READCMD
);
572 RL_UNSETSTATE(RL_STATE_READCMD
);
574 /* look at input.c:rl_getc() for the circumstances under which this will
575 be returned; punt immediately on read error without converting it to
576 a newline; assume that rl_read_key has already called the signal
580 #if defined (READLINE_CALLBACKS)
581 RL_SETSTATE(RL_STATE_DONE
);
582 return (rl_done
= 1);
589 /* EOF typed to a non-blank line is ^D the first time, EOF the second
590 time in a row. This won't return any partial line read from the tty.
591 If we want to change this, to force any existing line to be returned
592 when read(2) reads EOF, for example, this is the place to change. */
593 if (c
== EOF
&& rl_end
)
595 if (RL_SIG_RECEIVED ())
598 if (rl_signal_event_hook
)
599 (*rl_signal_event_hook
) (); /* XXX */
602 /* XXX - reading two consecutive EOFs returns EOF */
603 if (RL_ISSTATE (RL_STATE_TERMPREPPED
))
605 if (lastc
== _rl_eof_char
|| lastc
== EOF
)
614 /* The character _rl_eof_char typed to blank line, and not as the
615 previous character is interpreted as EOF. This doesn't work when
616 READLINE_CALLBACKS is defined, so hitting a series of ^Ds will
617 erase all the chars on the line and then return EOF. */
618 if (((c
== _rl_eof_char
&& lastc
!= c
) || c
== EOF
) && rl_end
== 0)
620 #if defined (READLINE_CALLBACKS)
621 RL_SETSTATE(RL_STATE_DONE
);
622 return (rl_done
= 1);
630 _rl_dispatch ((unsigned char)c
, _rl_keymap
);
633 /* If there was no change in _rl_last_command_was_kill, then no kill
634 has taken place. Note that if input is pending we are reading
635 a prefix command, so nothing has changed yet. */
636 if (rl_pending_input
== 0 && lk
== _rl_last_command_was_kill
)
637 _rl_last_command_was_kill
= 0;
639 _rl_internal_char_cleanup ();
641 #if defined (READLINE_CALLBACKS)
650 #if defined (READLINE_CALLBACKS)
652 readline_internal_charloop ()
657 eof
= readline_internal_char ();
660 #endif /* READLINE_CALLBACKS */
662 /* Read a line of input from the global rl_instream, doing output on
663 the global rl_outstream.
664 If rl_prompt is non-null, then that is our prompt. */
670 readline_internal_setup ();
671 eof
= readline_internal_charloop ();
672 return (readline_internal_teardown (eof
));
676 _rl_init_line_state ()
678 rl_point
= rl_end
= rl_mark
= 0;
679 the_line
= rl_line_buffer
;
686 the_line
= rl_line_buffer
;
689 #if defined (READLINE_CALLBACKS)
691 _rl_keyseq_cxt_alloc ()
695 cxt
= (_rl_keyseq_cxt
*)xmalloc (sizeof (_rl_keyseq_cxt
));
697 cxt
->flags
= cxt
->subseq_arg
= cxt
->subseq_retval
= 0;
700 cxt
->ocxt
= _rl_kscxt
;
701 cxt
->childval
= 42; /* sentinel value */
707 _rl_keyseq_cxt_dispose (cxt
)
714 _rl_keyseq_chain_dispose ()
721 _rl_kscxt
= _rl_kscxt
->ocxt
;
722 _rl_keyseq_cxt_dispose (cxt
);
728 _rl_subseq_getchar (key
)
734 RL_SETSTATE(RL_STATE_METANEXT
);
735 RL_SETSTATE(RL_STATE_MOREINPUT
);
737 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
739 RL_UNSETSTATE(RL_STATE_METANEXT
);
744 #if defined (READLINE_CALLBACKS)
746 _rl_dispatch_callback (cxt
)
752 /* The first time this context is used, we want to read input and dispatch
753 on it. When traversing the chain of contexts back `up', we want to use
754 the value from the next context down. We're simulating recursion using
755 a chain of contexts. */
756 if ((cxt
->flags
& KSEQ_DISPATCHED
) == 0)
758 nkey
= _rl_subseq_getchar (cxt
->okey
);
761 _rl_abort_internal ();
764 r
= _rl_dispatch_subseq (nkey
, cxt
->dmap
, cxt
->subseq_arg
);
765 cxt
->flags
|= KSEQ_DISPATCHED
;
771 if (r
!= -3) /* don't do this if we indicate there will be other matches */
772 r
= _rl_subseq_result (r
, cxt
->oldmap
, cxt
->okey
, (cxt
->flags
& KSEQ_SUBSEQ
));
775 /* We only treat values < 0 specially to simulate recursion. */
776 if (r
>= 0 || (r
== -1 && (cxt
->flags
& KSEQ_SUBSEQ
) == 0)) /* success! or failure! */
778 _rl_keyseq_chain_dispose ();
779 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
783 if (r
!= -3) /* magic value that says we added to the chain */
784 _rl_kscxt
= cxt
->ocxt
;
786 _rl_kscxt
->childval
= r
;
788 _rl_keyseq_cxt_dispose (cxt
);
792 #endif /* READLINE_CALLBACKS */
794 /* Do the command associated with KEY in MAP.
795 If the associated command is really a keymap, then read
796 another key, and dispatch into that map. */
798 _rl_dispatch (key
, map
)
802 _rl_dispatching_keymap
= map
;
803 return _rl_dispatch_subseq (key
, map
, 0);
807 _rl_dispatch_subseq (key
, map
, got_subseq
)
814 rl_command_func_t
*func
;
815 #if defined (READLINE_CALLBACKS)
819 if (META_CHAR (key
) && _rl_convert_meta_chars_to_ascii
)
821 if (map
[ESC
].type
== ISKMAP
)
823 if (RL_ISSTATE (RL_STATE_MACRODEF
))
824 _rl_add_macro_char (ESC
);
825 RESIZE_KEYSEQ_BUFFER ();
826 rl_executing_keyseq
[rl_key_sequence_length
++] = ESC
;
827 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
829 return (_rl_dispatch (key
, map
));
836 if (RL_ISSTATE (RL_STATE_MACRODEF
))
837 _rl_add_macro_char (key
);
840 switch (map
[key
].type
)
843 func
= map
[key
].function
;
846 /* Special case rl_do_lowercase_version (). */
847 if (func
== rl_do_lowercase_version
)
848 /* Should we do anything special if key == ANYOTHERKEY? */
849 return (_rl_dispatch (_rl_to_lower (key
), map
));
851 rl_executing_keymap
= map
;
852 rl_executing_key
= key
;
854 RESIZE_KEYSEQ_BUFFER();
855 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
856 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
859 RL_SETSTATE(RL_STATE_DISPATCHING
);
860 r
= (*func
) (rl_numeric_arg
* rl_arg_sign
, key
);
861 RL_UNSETSTATE(RL_STATE_DISPATCHING
);
864 /* If we have input pending, then the last command was a prefix
865 command. Don't change the state of rl_last_func. Otherwise,
866 remember the last command executed in this variable. */
867 if (rl_pending_input
== 0 && map
[key
].function
!= rl_digit_argument
)
868 rl_last_func
= map
[key
].function
;
872 else if (map
[ANYOTHERKEY
].function
)
874 /* OK, there's no function bound in this map, but there is a
875 shadow function that was overridden when the current keymap
876 was created. Return -2 to note that. */
877 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
878 _rl_prev_macro_key ();
880 _rl_unget_char (key
);
885 /* Return -1 to note that we're in a subsequence, but we don't
886 have a matching key, nor was one overridden. This means
887 we need to back up the recursion chain and find the last
888 subsequence that is bound to a function. */
889 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
890 _rl_prev_macro_key ();
892 _rl_unget_char (key
);
897 #if defined (READLINE_CALLBACKS)
898 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
899 _rl_keyseq_chain_dispose ();
901 _rl_abort_internal ();
907 if (map
[key
].function
!= 0)
909 #if defined (VI_MODE)
910 /* The only way this test will be true is if a subsequence has been
911 bound starting with ESC, generally the arrow keys. What we do is
912 check whether there's input in the queue, which there generally
913 will be if an arrow key has been pressed, and, if there's not,
914 just dispatch to (what we assume is) rl_vi_movement_mode right
915 away. This is essentially an input test with a zero timeout (by
916 default) or a timeout determined by the value of `keyseq-timeout' */
917 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
918 takes microseconds, so multiply by 1000 */
919 if (rl_editing_mode
== vi_mode
&& key
== ESC
&& map
== vi_insertion_keymap
920 && _rl_input_queued ((_rl_keyseq_timeout
> 0) ? _rl_keyseq_timeout
*1000 : 0) == 0)
921 return (_rl_dispatch (ANYOTHERKEY
, FUNCTION_TO_KEYMAP (map
, key
)));
924 RESIZE_KEYSEQ_BUFFER ();
925 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
926 _rl_dispatching_keymap
= FUNCTION_TO_KEYMAP (map
, key
);
928 /* Allocate new context here. Use linked contexts (linked through
929 cxt->ocxt) to simulate recursion */
930 #if defined (READLINE_CALLBACKS)
931 if (RL_ISSTATE (RL_STATE_CALLBACK
))
933 /* Return 0 only the first time, to indicate success to
934 _rl_callback_read_char. The rest of the time, we're called
935 from _rl_dispatch_callback, so we return -3 to indicate
936 special handling is necessary. */
937 r
= RL_ISSTATE (RL_STATE_MULTIKEY
) ? -3 : 0;
938 cxt
= _rl_keyseq_cxt_alloc ();
941 cxt
->flags
|= KSEQ_SUBSEQ
;
944 cxt
->dmap
= _rl_dispatching_keymap
;
945 cxt
->subseq_arg
= got_subseq
|| cxt
->dmap
[ANYOTHERKEY
].function
;
947 RL_SETSTATE (RL_STATE_MULTIKEY
);
950 return r
; /* don't indicate immediate success */
954 /* Tentative inter-character timeout for potential multi-key
955 sequences? If no input within timeout, abort sequence and
956 act as if we got non-matching input. */
957 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
958 takes microseconds, so multiply by 1000 */
959 if (_rl_keyseq_timeout
> 0 &&
960 (RL_ISSTATE (RL_STATE_INPUTPENDING
|RL_STATE_MACROINPUT
) == 0) &&
961 _rl_pushed_input_available () == 0 &&
962 _rl_dispatching_keymap
[ANYOTHERKEY
].function
&&
963 _rl_input_queued (_rl_keyseq_timeout
*1000) == 0)
964 return (_rl_subseq_result (-2, map
, key
, got_subseq
));
966 newkey
= _rl_subseq_getchar (key
);
969 _rl_abort_internal ();
973 r
= _rl_dispatch_subseq (newkey
, _rl_dispatching_keymap
, got_subseq
|| map
[ANYOTHERKEY
].function
);
974 return _rl_subseq_result (r
, map
, key
, got_subseq
);
978 _rl_abort_internal (); /* XXX */
984 if (map
[key
].function
!= 0)
986 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
987 macro
= savestring ((char *)map
[key
].function
);
988 _rl_with_macro_input (macro
);
993 #if defined (VI_MODE)
994 if (rl_editing_mode
== vi_mode
&& _rl_keymap
== vi_movement_keymap
&&
995 key
!= ANYOTHERKEY
&&
996 _rl_dispatching_keymap
== vi_movement_keymap
&&
997 _rl_vi_textmod_command (key
))
998 _rl_vi_set_last (key
, rl_numeric_arg
, rl_arg_sign
);
1005 _rl_subseq_result (r
, map
, key
, got_subseq
)
1008 int key
, got_subseq
;
1012 rl_command_func_t
*func
, *nf
;
1015 /* We didn't match anything, and the keymap we're indexed into
1016 shadowed a function previously bound to that prefix. Call
1017 the function. The recursive call to _rl_dispatch_subseq has
1018 already taken care of pushing any necessary input back onto
1019 the input queue with _rl_unget_char. */
1021 m
= _rl_dispatching_keymap
;
1022 type
= m
[ANYOTHERKEY
].type
;
1023 func
= m
[ANYOTHERKEY
].function
;
1024 if (type
== ISFUNC
&& func
== rl_do_lowercase_version
)
1025 r
= _rl_dispatch (_rl_to_lower (key
), map
);
1026 else if (type
== ISFUNC
)
1028 /* If we shadowed a function, whatever it is, we somehow need a
1029 keymap with map[key].func == shadowed-function.
1030 Let's use this one. Then we can dispatch using the original
1031 key, since there are commands (e.g., in vi mode) for which it
1034 nf
= m
[key
].function
;
1037 m
[key
].function
= func
;
1038 r
= _rl_dispatch (key
, m
);
1040 m
[key
].function
= nf
;
1043 /* We probably shadowed a keymap, so keep going. */
1044 r
= _rl_dispatch (ANYOTHERKEY
, m
);
1046 else if (r
&& map
[ANYOTHERKEY
].function
)
1048 /* We didn't match (r is probably -1), so return something to
1049 tell the caller that it should try ANYOTHERKEY for an
1050 overridden function. */
1051 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1052 _rl_prev_macro_key ();
1054 _rl_unget_char (key
);
1055 _rl_dispatching_keymap
= map
;
1058 else if (r
&& got_subseq
)
1060 /* OK, back up the chain. */
1061 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1062 _rl_prev_macro_key ();
1064 _rl_unget_char (key
);
1065 _rl_dispatching_keymap
= map
;
1072 /* **************************************************************** */
1074 /* Initializations */
1076 /* **************************************************************** */
1078 /* Initialize readline (and terminal if not already). */
1082 /* If we have never been called before, initialize the
1083 terminal and data structures. */
1084 if (!rl_initialized
)
1086 RL_SETSTATE(RL_STATE_INITIALIZING
);
1087 readline_initialize_everything ();
1088 RL_UNSETSTATE(RL_STATE_INITIALIZING
);
1090 RL_SETSTATE(RL_STATE_INITIALIZED
);
1093 /* Initialize the current line information. */
1094 _rl_init_line_state ();
1096 /* We aren't done yet. We haven't even gotten started yet! */
1098 RL_UNSETSTATE(RL_STATE_DONE
);
1100 /* Tell the history routines what is going on. */
1101 _rl_start_using_history ();
1103 /* Make the display buffer match the state of the line. */
1104 rl_reset_line_state ();
1106 /* No such function typed yet. */
1107 rl_last_func
= (rl_command_func_t
*)NULL
;
1109 /* Parsing of key-bindings begins in an enabled state. */
1110 _rl_parsing_conditionalized_out
= 0;
1112 #if defined (VI_MODE)
1113 if (rl_editing_mode
== vi_mode
)
1114 _rl_vi_initialize_line ();
1117 /* Each line starts in insert mode (the default). */
1118 _rl_set_insert_mode (RL_IM_DEFAULT
, 1);
1124 #if defined (__EMX__)
1126 _emx_build_environ ()
1133 DosGetInfoBlocks (&tibp
, &pibp
);
1134 t
= pibp
->pib_pchenv
;
1135 for (c
= 1; *t
; c
++)
1136 t
+= strlen (t
) + 1;
1137 tp
= environ
= (char **)xmalloc ((c
+ 1) * sizeof (char *));
1138 t
= pibp
->pib_pchenv
;
1142 t
+= strlen (t
) + 1;
1146 #endif /* __EMX__ */
1149 /* Initialize the entire state of the world. */
1151 readline_initialize_everything ()
1154 #if defined (__EMX__)
1156 _emx_build_environ ();
1161 /* Find out if we are running in Emacs -- UNUSED. */
1162 running_in_emacs
= sh_get_env_value ("EMACS") != (char *)0;
1165 /* Set up input and output if they are not already set up. */
1167 rl_instream
= stdin
;
1170 rl_outstream
= stdout
;
1172 /* Bind _rl_in_stream and _rl_out_stream immediately. These values
1173 may change, but they may also be used before readline_internal ()
1175 _rl_in_stream
= rl_instream
;
1176 _rl_out_stream
= rl_outstream
;
1178 /* Allocate data structures. */
1179 if (rl_line_buffer
== 0)
1180 rl_line_buffer
= (char *)xmalloc (rl_line_buffer_len
= DEFAULT_BUFFER_SIZE
);
1182 /* Initialize the terminal interface. */
1183 if (rl_terminal_name
== 0)
1184 rl_terminal_name
= sh_get_env_value ("TERM");
1185 _rl_init_terminal_io (rl_terminal_name
);
1187 /* Bind tty characters to readline functions. */
1188 readline_default_bindings ();
1190 /* Initialize the function names. */
1191 rl_initialize_funmap ();
1193 /* Decide whether we should automatically go into eight-bit mode. */
1194 _rl_init_eightbit ();
1196 /* Read in the init file. */
1197 rl_read_init_file ((char *)NULL
);
1200 if (_rl_horizontal_scroll_mode
&& _rl_term_autowrap
)
1203 _rl_screenchars
-= _rl_screenheight
;
1206 /* Override the effect of any `set keymap' assignments in the
1208 rl_set_keymap_from_edit_mode ();
1210 /* Try to bind a common arrow key prefix, if not already bound. */
1213 /* Bind the bracketed paste prefix assuming that the user will enable
1214 it on terminals that support it. */
1215 bind_bracketed_paste_prefix ();
1217 /* If the completion parser's default word break characters haven't
1218 been set yet, then do so now. */
1219 if (rl_completer_word_break_characters
== (char *)NULL
)
1220 rl_completer_word_break_characters
= (char *)rl_basic_word_break_characters
;
1222 #if defined (COLOR_SUPPORT)
1223 if (_rl_colored_stats
|| _rl_colored_completion_prefix
)
1224 _rl_parse_colors ();
1227 rl_executing_keyseq
= malloc (_rl_executing_keyseq_size
= 16);
1228 if (rl_executing_keyseq
)
1229 rl_executing_keyseq
[0] = '\0';
1232 /* If this system allows us to look at the values of the regular
1233 input editing characters, then bind them to their readline
1234 equivalents, iff the characters are not bound to keymaps. */
1236 readline_default_bindings ()
1238 if (_rl_bind_stty_chars
)
1239 rl_tty_set_default_bindings (_rl_keymap
);
1242 /* Reset the default bindings for the terminal special characters we're
1243 interested in back to rl_insert and read the new ones. */
1245 reset_default_bindings ()
1247 if (_rl_bind_stty_chars
)
1249 rl_tty_unset_default_bindings (_rl_keymap
);
1250 rl_tty_set_default_bindings (_rl_keymap
);
1254 /* Bind some common arrow key sequences in MAP. */
1256 bind_arrow_keys_internal (map
)
1261 xkeymap
= _rl_keymap
;
1264 #if defined (__MSDOS__)
1265 rl_bind_keyseq_if_unbound ("\033[0A", rl_get_previous_history
);
1266 rl_bind_keyseq_if_unbound ("\033[0B", rl_backward_char
);
1267 rl_bind_keyseq_if_unbound ("\033[0C", rl_forward_char
);
1268 rl_bind_keyseq_if_unbound ("\033[0D", rl_get_next_history
);
1271 rl_bind_keyseq_if_unbound ("\033[A", rl_get_previous_history
);
1272 rl_bind_keyseq_if_unbound ("\033[B", rl_get_next_history
);
1273 rl_bind_keyseq_if_unbound ("\033[C", rl_forward_char
);
1274 rl_bind_keyseq_if_unbound ("\033[D", rl_backward_char
);
1275 rl_bind_keyseq_if_unbound ("\033[H", rl_beg_of_line
);
1276 rl_bind_keyseq_if_unbound ("\033[F", rl_end_of_line
);
1278 rl_bind_keyseq_if_unbound ("\033OA", rl_get_previous_history
);
1279 rl_bind_keyseq_if_unbound ("\033OB", rl_get_next_history
);
1280 rl_bind_keyseq_if_unbound ("\033OC", rl_forward_char
);
1281 rl_bind_keyseq_if_unbound ("\033OD", rl_backward_char
);
1282 rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line
);
1283 rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line
);
1285 #if defined (__MINGW32__)
1286 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history
);
1287 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history
);
1288 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char
);
1289 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char
);
1290 rl_bind_keyseq_if_unbound ("\340G", rl_beg_of_line
);
1291 rl_bind_keyseq_if_unbound ("\340O", rl_end_of_line
);
1292 rl_bind_keyseq_if_unbound ("\340S", rl_delete
);
1293 rl_bind_keyseq_if_unbound ("\340R", rl_overwrite_mode
);
1295 /* These may or may not work because of the embedded NUL. */
1296 rl_bind_keyseq_if_unbound ("\\000H", rl_get_previous_history
);
1297 rl_bind_keyseq_if_unbound ("\\000P", rl_get_next_history
);
1298 rl_bind_keyseq_if_unbound ("\\000M", rl_forward_char
);
1299 rl_bind_keyseq_if_unbound ("\\000K", rl_backward_char
);
1300 rl_bind_keyseq_if_unbound ("\\000G", rl_beg_of_line
);
1301 rl_bind_keyseq_if_unbound ("\\000O", rl_end_of_line
);
1302 rl_bind_keyseq_if_unbound ("\\000S", rl_delete
);
1303 rl_bind_keyseq_if_unbound ("\\000R", rl_overwrite_mode
);
1306 _rl_keymap
= xkeymap
;
1309 /* Try and bind the common arrow key prefixes after giving termcap and
1310 the inputrc file a chance to bind them and create `real' keymaps
1311 for the arrow key prefix. */
1315 bind_arrow_keys_internal (emacs_standard_keymap
);
1317 #if defined (VI_MODE)
1318 bind_arrow_keys_internal (vi_movement_keymap
);
1319 /* Unbind vi_movement_keymap[ESC] to allow users to repeatedly hit ESC
1320 in vi command mode while still allowing the arrow keys to work. */
1321 if (vi_movement_keymap
[ESC
].type
== ISKMAP
)
1322 rl_bind_keyseq_in_map ("\033", (rl_command_func_t
*)NULL
, vi_movement_keymap
);
1323 bind_arrow_keys_internal (vi_insertion_keymap
);
1328 bind_bracketed_paste_prefix ()
1332 xkeymap
= _rl_keymap
;
1334 _rl_keymap
= emacs_standard_keymap
;
1335 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1337 _rl_keymap
= vi_insertion_keymap
;
1338 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1340 _rl_keymap
= xkeymap
;
1343 /* **************************************************************** */
1345 /* Saving and Restoring Readline's state */
1347 /* **************************************************************** */
1351 struct readline_state
*sp
;
1356 sp
->point
= rl_point
;
1359 sp
->buffer
= rl_line_buffer
;
1360 sp
->buflen
= rl_line_buffer_len
;
1361 sp
->ul
= rl_undo_list
;
1362 sp
->prompt
= rl_prompt
;
1364 sp
->rlstate
= rl_readline_state
;
1366 sp
->kmap
= _rl_keymap
;
1368 sp
->lastfunc
= rl_last_func
;
1369 sp
->insmode
= rl_insert_mode
;
1370 sp
->edmode
= rl_editing_mode
;
1371 sp
->kseq
= rl_executing_keyseq
;
1372 sp
->kseqlen
= rl_key_sequence_length
;
1373 sp
->inf
= rl_instream
;
1374 sp
->outf
= rl_outstream
;
1375 sp
->pendingin
= rl_pending_input
;
1376 sp
->macro
= rl_executing_macro
;
1378 sp
->catchsigs
= rl_catch_signals
;
1379 sp
->catchsigwinch
= rl_catch_sigwinch
;
1381 sp
->entryfunc
= rl_completion_entry_function
;
1382 sp
->menuentryfunc
= rl_menu_completion_entry_function
;
1383 sp
->ignorefunc
= rl_ignore_some_completions_function
;
1384 sp
->attemptfunc
= rl_attempted_completion_function
;
1385 sp
->wordbreakchars
= rl_completer_word_break_characters
;
1391 rl_restore_state (sp
)
1392 struct readline_state
*sp
;
1397 rl_point
= sp
->point
;
1400 the_line
= rl_line_buffer
= sp
->buffer
;
1401 rl_line_buffer_len
= sp
->buflen
;
1402 rl_undo_list
= sp
->ul
;
1403 rl_prompt
= sp
->prompt
;
1405 rl_readline_state
= sp
->rlstate
;
1407 _rl_keymap
= sp
->kmap
;
1409 rl_last_func
= sp
->lastfunc
;
1410 rl_insert_mode
= sp
->insmode
;
1411 rl_editing_mode
= sp
->edmode
;
1412 rl_executing_keyseq
= sp
->kseq
;
1413 rl_key_sequence_length
= sp
->kseqlen
;
1414 rl_instream
= sp
->inf
;
1415 rl_outstream
= sp
->outf
;
1416 rl_pending_input
= sp
->pendingin
;
1417 rl_executing_macro
= sp
->macro
;
1419 rl_catch_signals
= sp
->catchsigs
;
1420 rl_catch_sigwinch
= sp
->catchsigwinch
;
1422 rl_completion_entry_function
= sp
->entryfunc
;
1423 rl_menu_completion_entry_function
= sp
->menuentryfunc
;
1424 rl_ignore_some_completions_function
= sp
->ignorefunc
;
1425 rl_attempted_completion_function
= sp
->attemptfunc
;
1426 rl_completer_word_break_characters
= sp
->wordbreakchars
;