1 /* readline.c -- a general facility for reading lines of input
2 with emacs style editing and completion. */
4 /* Copyright (C) 1987-2017 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 /* If non-zero when readline_internal returns, it means we found EOF */
218 int _rl_eof_found
= 0;
220 /* Pointer to a useful terminal name. */
221 const char *rl_terminal_name
= (const char *)NULL
;
223 /* Non-zero means to always use horizontal scrolling in line display. */
224 int _rl_horizontal_scroll_mode
= 0;
226 /* Non-zero means to display an asterisk at the starts of history lines
227 which have been modified. */
228 int _rl_mark_modified_lines
= 0;
230 /* The style of `bell' notification preferred. This can be set to NO_BELL,
231 AUDIBLE_BELL, or VISIBLE_BELL. */
232 int _rl_bell_preference
= AUDIBLE_BELL
;
234 /* String inserted into the line by rl_insert_comment (). */
235 char *_rl_comment_begin
;
237 /* Keymap holding the function currently being executed. */
238 Keymap rl_executing_keymap
;
240 /* Keymap we're currently using to dispatch. */
241 Keymap _rl_dispatching_keymap
;
243 /* Non-zero means to erase entire line, including prompt, on empty input lines. */
244 int rl_erase_empty_line
= 0;
246 /* Non-zero means to read only this many characters rather than up to a
247 character bound to accept-line. */
248 int rl_num_chars_to_read
= 0;
250 /* Line buffer and maintenance. */
251 char *rl_line_buffer
= (char *)NULL
;
252 int rl_line_buffer_len
= 0;
254 /* Key sequence `contexts' */
255 _rl_keyseq_cxt
*_rl_kscxt
= 0;
257 int rl_executing_key
;
258 char *rl_executing_keyseq
= 0;
259 int _rl_executing_keyseq_size
= 0;
261 /* Timeout (specified in milliseconds) when reading characters making up an
262 ambiguous multiple-key sequence */
263 int _rl_keyseq_timeout
= 500;
265 #define RESIZE_KEYSEQ_BUFFER() \
268 if (rl_key_sequence_length + 2 >= _rl_executing_keyseq_size) \
270 _rl_executing_keyseq_size += 16; \
271 rl_executing_keyseq = xrealloc (rl_executing_keyseq, _rl_executing_keyseq_size); \
276 /* Forward declarations used by the display, termcap, and history code. */
278 /* **************************************************************** */
280 /* `Forward' declarations */
282 /* **************************************************************** */
284 /* Non-zero means do not parse any lines other than comments and
285 parser directives. */
286 unsigned char _rl_parsing_conditionalized_out
= 0;
288 /* Non-zero means to convert characters with the meta bit set to
289 escape-prefixed characters so we can indirect through
290 emacs_meta_keymap or vi_escape_keymap. */
291 int _rl_convert_meta_chars_to_ascii
= 1;
293 /* Non-zero means to output characters with the meta bit set directly
294 rather than as a meta-prefixed escape sequence. */
295 int _rl_output_meta_chars
= 0;
297 /* Non-zero means to look at the termios special characters and bind
298 them to equivalent readline functions at startup. */
299 int _rl_bind_stty_chars
= 1;
301 /* Non-zero means to go through the history list at every newline (or
302 whenever rl_done is set and readline returns) and revert each line to
303 its initial state. */
304 int _rl_revert_all_at_newline
= 0;
306 /* Non-zero means to honor the termios ECHOCTL bit and echo control
307 characters corresponding to keyboard-generated signals. */
308 int _rl_echo_control_chars
= 1;
310 /* Non-zero means to prefix the displayed prompt with a character indicating
311 the editing mode: @ for emacs, : for vi-command, + for vi-insert. */
312 int _rl_show_mode_in_prompt
= 0;
314 /* Non-zero means to attempt to put the terminal in `bracketed paste mode',
315 where it will prefix pasted text with an escape sequence and send
316 another to mark the end of the paste. */
317 int _rl_enable_bracketed_paste
= 0;
319 /* **************************************************************** */
321 /* Top Level Functions */
323 /* **************************************************************** */
325 /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
326 int _rl_meta_flag
= 0; /* Forward declaration */
328 /* Set up the prompt and expand it. Called from readline() and
329 rl_callback_handler_install (). */
331 rl_set_prompt (const char *prompt
)
334 rl_prompt
= prompt
? savestring (prompt
) : (char *)NULL
;
335 rl_display_prompt
= rl_prompt
? rl_prompt
: "";
337 rl_visible_prompt_length
= rl_expand_prompt (rl_prompt
);
341 /* Read a line of input. Prompt with PROMPT. An empty PROMPT means
342 none. A return value of NULL means that EOF was encountered. */
344 readline (const char *prompt
)
351 /* If we are at EOF return a NULL string. */
352 if (rl_pending_input
== EOF
)
354 rl_clear_pending_input ();
355 return ((char *)NULL
);
359 /* If readline() is called after installing a callback handler, temporarily
360 turn off the callback state to avoid ensuing messiness. Patch supplied
361 by the gdb folks. XXX -- disabled. This can be fooled and readline
362 left in a strange state by a poorly-timed longjmp. */
363 if (in_callback
= RL_ISSTATE (RL_STATE_CALLBACK
))
364 RL_UNSETSTATE (RL_STATE_CALLBACK
);
367 rl_set_prompt (prompt
);
370 if (rl_prep_term_function
)
371 (*rl_prep_term_function
) (_rl_meta_flag
);
373 #if defined (HANDLE_SIGNALS)
377 value
= readline_internal ();
378 if (rl_deprep_term_function
)
379 (*rl_deprep_term_function
) ();
381 #if defined (HANDLE_SIGNALS)
387 RL_SETSTATE (RL_STATE_CALLBACK
);
390 #if HAVE_DECL_AUDIT_USER_TTY && defined (HAVE_LIBAUDIT_H) && defined (ENABLE_TTY_AUDIT_SUPPORT)
392 _rl_audit_tty (value
);
398 #if defined (READLINE_CALLBACKS)
399 # define STATIC_CALLBACK
401 # define STATIC_CALLBACK static
405 readline_internal_setup (void)
409 _rl_in_stream
= rl_instream
;
410 _rl_out_stream
= rl_outstream
;
412 /* Enable the meta key only for the duration of readline(), if this
413 terminal has one and the terminal has been initialized */
414 if (_rl_enable_meta
& RL_ISSTATE (RL_STATE_TERMPREPPED
))
415 _rl_enable_meta_key ();
418 (*rl_startup_hook
) ();
420 #if defined (VI_MODE)
421 if (rl_editing_mode
== vi_mode
)
422 rl_vi_insertion_mode (1, 'i'); /* don't want to reset last */
425 if (_rl_show_mode_in_prompt
)
428 /* If we're not echoing, we still want to at least print a prompt, because
429 rl_redisplay will not do it for us. If the calling application has a
430 custom redisplay function, though, let that function handle it. */
431 if (_rl_echoing_p
== 0 && rl_redisplay_function
== rl_redisplay
)
433 if (rl_prompt
&& rl_already_prompted
== 0)
435 nprompt
= _rl_strip_prompt (rl_prompt
);
436 fprintf (_rl_out_stream
, "%s", nprompt
);
437 fflush (_rl_out_stream
);
443 if (rl_prompt
&& rl_already_prompted
)
444 rl_on_new_line_with_prompt ();
447 (*rl_redisplay_function
) ();
450 if (rl_pre_input_hook
)
451 (*rl_pre_input_hook
) ();
456 STATIC_CALLBACK
char *
457 readline_internal_teardown (int eof
)
464 /* Restore the original of this history line, iff the line that we
465 are editing was originally in the history, AND the line has changed. */
466 entry
= current_history ();
468 if (entry
&& rl_undo_list
)
470 temp
= savestring (the_line
);
471 rl_revert_line (1, 0);
472 entry
= replace_history_entry (where_history (), the_line
, (histdata_t
)NULL
);
473 _rl_free_history_entry (entry
);
475 strcpy (the_line
, temp
);
479 if (_rl_revert_all_at_newline
)
480 _rl_revert_all_lines ();
482 /* At any rate, it is highly likely that this line has an undo list. Get
485 rl_free_undo_list ();
487 /* Disable the meta key, if this terminal has one and we were told to use it.
488 The check whether or not we sent the enable string is in
489 _rl_disable_meta_key(); the flag is set in _rl_enable_meta_key */
490 _rl_disable_meta_key ();
492 /* Restore normal cursor, if available. */
493 _rl_set_insert_mode (RL_IM_INSERT
, 0);
495 return (eof
? (char *)NULL
: savestring (the_line
));
499 _rl_internal_char_cleanup (void)
501 #if defined (VI_MODE)
502 /* In vi mode, when you exit insert mode, the cursor moves back
503 over the previous character. We explicitly check for that here. */
504 if (rl_editing_mode
== vi_mode
&& _rl_keymap
== vi_movement_keymap
)
508 if (rl_num_chars_to_read
&& rl_end
>= rl_num_chars_to_read
)
510 (*rl_redisplay_function
) ();
511 _rl_want_redisplay
= 0;
512 rl_newline (1, '\n');
517 (*rl_redisplay_function
) ();
518 _rl_want_redisplay
= 0;
521 /* If the application writer has told us to erase the entire line if
522 the only character typed was something bound to rl_newline, do so. */
523 if (rl_erase_empty_line
&& rl_done
&& rl_last_func
== rl_newline
&&
524 rl_point
== 0 && rl_end
== 0)
525 _rl_erase_entire_line ();
529 #if defined (READLINE_CALLBACKS)
530 readline_internal_char (void)
532 readline_internal_charloop (void)
535 static int lastc
, eof_found
;
540 #if !defined (READLINE_CALLBACKS)
545 lk
= _rl_last_command_was_kill
;
547 #if defined (HAVE_POSIX_SIGSETJMP)
548 code
= sigsetjmp (_rl_top_level
, 0);
550 code
= setjmp (_rl_top_level
);
555 (*rl_redisplay_function
) ();
556 _rl_want_redisplay
= 0;
557 /* If we get here, we're not being called from something dispatched
558 from _rl_callback_read_char(), which sets up its own value of
559 _rl_top_level (saving and restoring the old, of course), so
560 we can just return here. */
561 if (RL_ISSTATE (RL_STATE_CALLBACK
))
565 if (rl_pending_input
== 0)
567 /* Then initialize the argument and number of keys read. */
568 _rl_reset_argument ();
569 rl_executing_keyseq
[rl_key_sequence_length
= 0] = '\0';
572 RL_SETSTATE(RL_STATE_READCMD
);
574 RL_UNSETSTATE(RL_STATE_READCMD
);
576 /* look at input.c:rl_getc() for the circumstances under which this will
577 be returned; punt immediately on read error without converting it to
578 a newline; assume that rl_read_key has already called the signal
582 #if defined (READLINE_CALLBACKS)
583 RL_SETSTATE(RL_STATE_DONE
);
584 return (rl_done
= 1);
591 /* EOF typed to a non-blank line is ^D the first time, EOF the second
592 time in a row. This won't return any partial line read from the tty.
593 If we want to change this, to force any existing line to be returned
594 when read(2) reads EOF, for example, this is the place to change. */
595 if (c
== EOF
&& rl_end
)
597 if (RL_SIG_RECEIVED ())
600 if (rl_signal_event_hook
)
601 (*rl_signal_event_hook
) (); /* XXX */
604 /* XXX - reading two consecutive EOFs returns EOF */
605 if (RL_ISSTATE (RL_STATE_TERMPREPPED
))
607 if (lastc
== _rl_eof_char
|| lastc
== EOF
)
616 /* The character _rl_eof_char typed to blank line, and not as the
617 previous character is interpreted as EOF. This doesn't work when
618 READLINE_CALLBACKS is defined, so hitting a series of ^Ds will
619 erase all the chars on the line and then return EOF. */
620 if (((c
== _rl_eof_char
&& lastc
!= c
) || c
== EOF
) && rl_end
== 0)
622 #if defined (READLINE_CALLBACKS)
623 RL_SETSTATE(RL_STATE_DONE
);
624 return (rl_done
= 1);
632 r
= _rl_dispatch ((unsigned char)c
, _rl_keymap
);
635 /* If there was no change in _rl_last_command_was_kill, then no kill
636 has taken place. Note that if input is pending we are reading
637 a prefix command, so nothing has changed yet. */
638 if (rl_pending_input
== 0 && lk
== _rl_last_command_was_kill
)
639 _rl_last_command_was_kill
= 0;
641 _rl_internal_char_cleanup ();
643 #if defined (READLINE_CALLBACKS)
652 #if defined (READLINE_CALLBACKS)
654 readline_internal_charloop (void)
659 eof
= readline_internal_char ();
662 #endif /* READLINE_CALLBACKS */
664 /* Read a line of input from the global rl_instream, doing output on
665 the global rl_outstream.
666 If rl_prompt is non-null, then that is our prompt. */
668 readline_internal (void)
670 readline_internal_setup ();
671 _rl_eof_found
= readline_internal_charloop ();
672 return (readline_internal_teardown (_rl_eof_found
));
676 _rl_init_line_state (void)
678 rl_point
= rl_end
= rl_mark
= 0;
679 the_line
= rl_line_buffer
;
684 _rl_set_the_line (void)
686 the_line
= rl_line_buffer
;
689 #if defined (READLINE_CALLBACKS)
691 _rl_keyseq_cxt_alloc (void)
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 (_rl_keyseq_cxt
*cxt
)
713 _rl_keyseq_chain_dispose (void)
720 _rl_kscxt
= _rl_kscxt
->ocxt
;
721 _rl_keyseq_cxt_dispose (cxt
);
727 _rl_subseq_getchar (int key
)
732 RL_SETSTATE(RL_STATE_METANEXT
);
733 RL_SETSTATE(RL_STATE_MOREINPUT
);
735 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
737 RL_UNSETSTATE(RL_STATE_METANEXT
);
742 #if defined (READLINE_CALLBACKS)
744 _rl_dispatch_callback (_rl_keyseq_cxt
*cxt
)
749 /* The first time this context is used, we want to read input and dispatch
750 on it. When traversing the chain of contexts back `up', we want to use
751 the value from the next context down. We're simulating recursion using
752 a chain of contexts. */
753 if ((cxt
->flags
& KSEQ_DISPATCHED
) == 0)
755 nkey
= _rl_subseq_getchar (cxt
->okey
);
758 _rl_abort_internal ();
761 r
= _rl_dispatch_subseq (nkey
, cxt
->dmap
, cxt
->subseq_arg
);
762 cxt
->flags
|= KSEQ_DISPATCHED
;
768 if (r
!= -3) /* don't do this if we indicate there will be other matches */
769 r
= _rl_subseq_result (r
, cxt
->oldmap
, cxt
->okey
, (cxt
->flags
& KSEQ_SUBSEQ
));
772 /* We only treat values < 0 specially to simulate recursion. */
773 if (r
>= 0 || (r
== -1 && (cxt
->flags
& KSEQ_SUBSEQ
) == 0)) /* success! or failure! */
775 _rl_keyseq_chain_dispose ();
776 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
780 if (r
!= -3) /* magic value that says we added to the chain */
781 _rl_kscxt
= cxt
->ocxt
;
783 _rl_kscxt
->childval
= r
;
785 _rl_keyseq_cxt_dispose (cxt
);
789 #endif /* READLINE_CALLBACKS */
791 /* Do the command associated with KEY in MAP.
792 If the associated command is really a keymap, then read
793 another key, and dispatch into that map. */
795 _rl_dispatch (register int key
, Keymap map
)
797 _rl_dispatching_keymap
= map
;
798 return _rl_dispatch_subseq (key
, map
, 0);
802 _rl_dispatch_subseq (register int key
, Keymap map
, int got_subseq
)
806 rl_command_func_t
*func
;
807 #if defined (READLINE_CALLBACKS)
811 if (META_CHAR (key
) && _rl_convert_meta_chars_to_ascii
)
813 if (map
[ESC
].type
== ISKMAP
)
815 if (RL_ISSTATE (RL_STATE_MACRODEF
))
816 _rl_add_macro_char (ESC
);
817 RESIZE_KEYSEQ_BUFFER ();
818 rl_executing_keyseq
[rl_key_sequence_length
++] = ESC
;
819 map
= FUNCTION_TO_KEYMAP (map
, ESC
);
821 return (_rl_dispatch (key
, map
));
828 if (RL_ISSTATE (RL_STATE_MACRODEF
))
829 _rl_add_macro_char (key
);
832 switch (map
[key
].type
)
835 func
= map
[key
].function
;
838 /* Special case rl_do_lowercase_version (). */
839 if (func
== rl_do_lowercase_version
)
840 /* Should we do anything special if key == ANYOTHERKEY? */
841 return (_rl_dispatch (_rl_to_lower ((unsigned char)key
), map
));
843 rl_executing_keymap
= map
;
844 rl_executing_key
= key
;
846 RESIZE_KEYSEQ_BUFFER();
847 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
848 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
851 RL_SETSTATE(RL_STATE_DISPATCHING
);
852 r
= (*func
) (rl_numeric_arg
* rl_arg_sign
, key
);
853 RL_UNSETSTATE(RL_STATE_DISPATCHING
);
856 /* If we have input pending, then the last command was a prefix
857 command. Don't change the state of rl_last_func. Otherwise,
858 remember the last command executed in this variable. */
859 if (rl_pending_input
== 0 && map
[key
].function
!= rl_digit_argument
)
860 rl_last_func
= map
[key
].function
;
864 else if (map
[ANYOTHERKEY
].function
)
866 /* OK, there's no function bound in this map, but there is a
867 shadow function that was overridden when the current keymap
868 was created. Return -2 to note that. */
869 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
870 _rl_prev_macro_key ();
872 _rl_unget_char (key
);
877 /* Return -1 to note that we're in a subsequence, but we don't
878 have a matching key, nor was one overridden. This means
879 we need to back up the recursion chain and find the last
880 subsequence that is bound to a function. */
881 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
882 _rl_prev_macro_key ();
884 _rl_unget_char (key
);
889 #if defined (READLINE_CALLBACKS)
890 RL_UNSETSTATE (RL_STATE_MULTIKEY
);
891 _rl_keyseq_chain_dispose ();
893 _rl_abort_internal ();
899 if (map
[key
].function
!= 0)
901 #if defined (VI_MODE)
902 /* The only way this test will be true is if a subsequence has been
903 bound starting with ESC, generally the arrow keys. What we do is
904 check whether there's input in the queue, which there generally
905 will be if an arrow key has been pressed, and, if there's not,
906 just dispatch to (what we assume is) rl_vi_movement_mode right
907 away. This is essentially an input test with a zero timeout (by
908 default) or a timeout determined by the value of `keyseq-timeout' */
909 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
910 takes microseconds, so multiply by 1000 */
911 if (rl_editing_mode
== vi_mode
&& key
== ESC
&& map
== vi_insertion_keymap
&&
912 (RL_ISSTATE (RL_STATE_INPUTPENDING
|RL_STATE_MACROINPUT
) == 0) &&
913 _rl_pushed_input_available () == 0 &&
914 _rl_input_queued ((_rl_keyseq_timeout
> 0) ? _rl_keyseq_timeout
*1000 : 0) == 0)
915 return (_rl_dispatch (ANYOTHERKEY
, FUNCTION_TO_KEYMAP (map
, key
)));
916 /* This is a very specific test. It can possibly be generalized in
917 the future, but for now it handles a specific case of ESC being
918 the last character in a keyboard macro. */
919 if (rl_editing_mode
== vi_mode
&& key
== ESC
&& map
== vi_insertion_keymap
&&
920 (RL_ISSTATE (RL_STATE_INPUTPENDING
) == 0) &&
921 (RL_ISSTATE (RL_STATE_MACROINPUT
) && _rl_peek_macro_key () == 0) &&
922 _rl_pushed_input_available () == 0 &&
923 _rl_input_queued ((_rl_keyseq_timeout
> 0) ? _rl_keyseq_timeout
*1000 : 0) == 0)
924 return (_rl_dispatch (ANYOTHERKEY
, FUNCTION_TO_KEYMAP (map
, key
)));
927 RESIZE_KEYSEQ_BUFFER ();
928 rl_executing_keyseq
[rl_key_sequence_length
++] = key
;
929 _rl_dispatching_keymap
= FUNCTION_TO_KEYMAP (map
, key
);
931 /* Allocate new context here. Use linked contexts (linked through
932 cxt->ocxt) to simulate recursion */
933 #if defined (READLINE_CALLBACKS)
934 # if defined (VI_MODE)
935 /* If we're redoing a vi mode command and we know there is a shadowed
936 function corresponding to this key, just call it -- all the redoable
937 vi mode commands already have all the input they need, and rl_vi_redo
938 assumes that one call to rl_dispatch is sufficient to complete the
940 if (_rl_vi_redoing
&& RL_ISSTATE (RL_STATE_CALLBACK
) &&
941 map
[ANYOTHERKEY
].function
!= 0)
942 return (_rl_subseq_result (-2, map
, key
, got_subseq
));
944 if (RL_ISSTATE (RL_STATE_CALLBACK
))
946 /* Return 0 only the first time, to indicate success to
947 _rl_callback_read_char. The rest of the time, we're called
948 from _rl_dispatch_callback, so we return -3 to indicate
949 special handling is necessary. */
950 r
= RL_ISSTATE (RL_STATE_MULTIKEY
) ? -3 : 0;
951 cxt
= _rl_keyseq_cxt_alloc ();
954 cxt
->flags
|= KSEQ_SUBSEQ
;
957 cxt
->dmap
= _rl_dispatching_keymap
;
958 cxt
->subseq_arg
= got_subseq
|| cxt
->dmap
[ANYOTHERKEY
].function
;
960 RL_SETSTATE (RL_STATE_MULTIKEY
);
963 return r
; /* don't indicate immediate success */
967 /* Tentative inter-character timeout for potential multi-key
968 sequences? If no input within timeout, abort sequence and
969 act as if we got non-matching input. */
970 /* _rl_keyseq_timeout specified in milliseconds; _rl_input_queued
971 takes microseconds, so multiply by 1000 */
972 if (_rl_keyseq_timeout
> 0 &&
973 (RL_ISSTATE (RL_STATE_INPUTPENDING
|RL_STATE_MACROINPUT
) == 0) &&
974 _rl_pushed_input_available () == 0 &&
975 _rl_dispatching_keymap
[ANYOTHERKEY
].function
&&
976 _rl_input_queued (_rl_keyseq_timeout
*1000) == 0)
977 return (_rl_subseq_result (-2, map
, key
, got_subseq
));
979 newkey
= _rl_subseq_getchar (key
);
982 _rl_abort_internal ();
986 r
= _rl_dispatch_subseq (newkey
, _rl_dispatching_keymap
, got_subseq
|| map
[ANYOTHERKEY
].function
);
987 return _rl_subseq_result (r
, map
, key
, got_subseq
);
991 _rl_abort_internal (); /* XXX */
997 if (map
[key
].function
!= 0)
999 rl_executing_keyseq
[rl_key_sequence_length
] = '\0';
1000 macro
= savestring ((char *)map
[key
].function
);
1001 _rl_with_macro_input (macro
);
1007 #if defined (VI_MODE)
1008 if (rl_editing_mode
== vi_mode
&& _rl_keymap
== vi_movement_keymap
&&
1009 key
!= ANYOTHERKEY
&&
1010 _rl_dispatching_keymap
== vi_movement_keymap
&&
1011 _rl_vi_textmod_command (key
))
1012 _rl_vi_set_last (key
, rl_numeric_arg
, rl_arg_sign
);
1019 _rl_subseq_result (int r
, Keymap map
, int key
, int got_subseq
)
1023 rl_command_func_t
*func
, *nf
;
1026 /* We didn't match anything, and the keymap we're indexed into
1027 shadowed a function previously bound to that prefix. Call
1028 the function. The recursive call to _rl_dispatch_subseq has
1029 already taken care of pushing any necessary input back onto
1030 the input queue with _rl_unget_char. */
1032 m
= _rl_dispatching_keymap
;
1033 type
= m
[ANYOTHERKEY
].type
;
1034 func
= m
[ANYOTHERKEY
].function
;
1035 if (type
== ISFUNC
&& func
== rl_do_lowercase_version
)
1036 r
= _rl_dispatch (_rl_to_lower ((unsigned char)key
), map
);
1037 else if (type
== ISFUNC
)
1039 /* If we shadowed a function, whatever it is, we somehow need a
1040 keymap with map[key].func == shadowed-function.
1041 Let's use this one. Then we can dispatch using the original
1042 key, since there are commands (e.g., in vi mode) for which it
1045 nf
= m
[key
].function
;
1048 m
[key
].function
= func
;
1049 /* Don't change _rl_dispatching_keymap, set it here */
1050 _rl_dispatching_keymap
= map
; /* previous map */
1051 r
= _rl_dispatch_subseq (key
, m
, 0);
1053 m
[key
].function
= nf
;
1056 /* We probably shadowed a keymap, so keep going. */
1057 r
= _rl_dispatch (ANYOTHERKEY
, m
);
1059 else if (r
< 0 && map
[ANYOTHERKEY
].function
)
1061 /* We didn't match (r is probably -1), so return something to
1062 tell the caller that it should try ANYOTHERKEY for an
1063 overridden function. */
1064 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1065 _rl_prev_macro_key ();
1067 _rl_unget_char (key
);
1068 _rl_dispatching_keymap
= map
;
1071 else if (r
< 0 && got_subseq
) /* XXX */
1073 /* OK, back up the chain. */
1074 if (RL_ISSTATE (RL_STATE_MACROINPUT
))
1075 _rl_prev_macro_key ();
1077 _rl_unget_char (key
);
1078 _rl_dispatching_keymap
= map
;
1085 /* **************************************************************** */
1087 /* Initializations */
1089 /* **************************************************************** */
1091 /* Initialize readline (and terminal if not already). */
1093 rl_initialize (void)
1095 /* If we have never been called before, initialize the
1096 terminal and data structures. */
1097 if (rl_initialized
== 0)
1099 RL_SETSTATE(RL_STATE_INITIALIZING
);
1100 readline_initialize_everything ();
1101 RL_UNSETSTATE(RL_STATE_INITIALIZING
);
1103 RL_SETSTATE(RL_STATE_INITIALIZED
);
1106 (void)_rl_init_locale (); /* check current locale */
1108 /* Initialize the current line information. */
1109 _rl_init_line_state ();
1111 /* We aren't done yet. We haven't even gotten started yet! */
1113 RL_UNSETSTATE(RL_STATE_DONE
);
1115 /* Tell the history routines what is going on. */
1116 _rl_start_using_history ();
1118 /* Make the display buffer match the state of the line. */
1119 rl_reset_line_state ();
1121 /* No such function typed yet. */
1122 rl_last_func
= (rl_command_func_t
*)NULL
;
1124 /* Parsing of key-bindings begins in an enabled state. */
1125 _rl_parsing_conditionalized_out
= 0;
1127 #if defined (VI_MODE)
1128 if (rl_editing_mode
== vi_mode
)
1129 _rl_vi_initialize_line ();
1132 /* Each line starts in insert mode (the default). */
1133 _rl_set_insert_mode (RL_IM_DEFAULT
, 1);
1139 #if defined (__EMX__)
1141 _emx_build_environ (void)
1148 DosGetInfoBlocks (&tibp
, &pibp
);
1149 t
= pibp
->pib_pchenv
;
1150 for (c
= 1; *t
; c
++)
1151 t
+= strlen (t
) + 1;
1152 tp
= environ
= (char **)xmalloc ((c
+ 1) * sizeof (char *));
1153 t
= pibp
->pib_pchenv
;
1157 t
+= strlen (t
) + 1;
1161 #endif /* __EMX__ */
1164 /* Initialize the entire state of the world. */
1166 readline_initialize_everything (void)
1169 #if defined (__EMX__)
1171 _emx_build_environ ();
1176 /* Find out if we are running in Emacs -- UNUSED. */
1177 running_in_emacs
= sh_get_env_value ("EMACS") != (char *)0;
1180 /* Set up input and output if they are not already set up. */
1182 rl_instream
= stdin
;
1185 rl_outstream
= stdout
;
1187 /* Bind _rl_in_stream and _rl_out_stream immediately. These values
1188 may change, but they may also be used before readline_internal ()
1190 _rl_in_stream
= rl_instream
;
1191 _rl_out_stream
= rl_outstream
;
1193 /* Allocate data structures. */
1194 if (rl_line_buffer
== 0)
1195 rl_line_buffer
= (char *)xmalloc (rl_line_buffer_len
= DEFAULT_BUFFER_SIZE
);
1197 /* Initialize the terminal interface. */
1198 if (rl_terminal_name
== 0)
1199 rl_terminal_name
= sh_get_env_value ("TERM");
1200 _rl_init_terminal_io (rl_terminal_name
);
1202 /* Bind tty characters to readline functions. */
1203 readline_default_bindings ();
1205 /* Initialize the function names. */
1206 rl_initialize_funmap ();
1208 /* Decide whether we should automatically go into eight-bit mode. */
1209 _rl_init_eightbit ();
1211 /* Read in the init file. */
1212 rl_read_init_file ((char *)NULL
);
1215 if (_rl_horizontal_scroll_mode
&& _rl_term_autowrap
)
1218 _rl_screenchars
-= _rl_screenheight
;
1221 /* Override the effect of any `set keymap' assignments in the
1223 rl_set_keymap_from_edit_mode ();
1225 /* Try to bind a common arrow key prefix, if not already bound. */
1228 /* Bind the bracketed paste prefix assuming that the user will enable
1229 it on terminals that support it. */
1230 bind_bracketed_paste_prefix ();
1232 /* If the completion parser's default word break characters haven't
1233 been set yet, then do so now. */
1234 if (rl_completer_word_break_characters
== (char *)NULL
)
1235 rl_completer_word_break_characters
= (char *)rl_basic_word_break_characters
;
1237 #if defined (COLOR_SUPPORT)
1238 if (_rl_colored_stats
|| _rl_colored_completion_prefix
)
1239 _rl_parse_colors ();
1242 rl_executing_keyseq
= malloc (_rl_executing_keyseq_size
= 16);
1243 if (rl_executing_keyseq
)
1244 rl_executing_keyseq
[0] = '\0';
1247 /* If this system allows us to look at the values of the regular
1248 input editing characters, then bind them to their readline
1249 equivalents, iff the characters are not bound to keymaps. */
1251 readline_default_bindings (void)
1253 if (_rl_bind_stty_chars
)
1254 rl_tty_set_default_bindings (_rl_keymap
);
1257 /* Reset the default bindings for the terminal special characters we're
1258 interested in back to rl_insert and read the new ones. */
1260 reset_default_bindings (void)
1262 if (_rl_bind_stty_chars
)
1264 rl_tty_unset_default_bindings (_rl_keymap
);
1265 rl_tty_set_default_bindings (_rl_keymap
);
1269 /* Bind some common arrow key sequences in MAP. */
1271 bind_arrow_keys_internal (Keymap 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 /* Key bindings for control-arrow keys */
1300 rl_bind_keyseq_if_unbound ("\033[1;5C", rl_forward_word
);
1301 rl_bind_keyseq_if_unbound ("\033[1;5D", rl_backward_word
);
1302 rl_bind_keyseq_if_unbound ("\033[3;5~", rl_kill_word
);
1304 /* Key bindings for alt-arrow keys */
1305 rl_bind_keyseq_if_unbound ("\033[1;3C", rl_forward_word
);
1306 rl_bind_keyseq_if_unbound ("\033[1;3D", rl_backward_word
);
1308 #if defined (__MINGW32__)
1309 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history
);
1310 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history
);
1311 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char
);
1312 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char
);
1313 rl_bind_keyseq_if_unbound ("\340G", rl_beg_of_line
);
1314 rl_bind_keyseq_if_unbound ("\340O", rl_end_of_line
);
1315 rl_bind_keyseq_if_unbound ("\340S", rl_delete
);
1316 rl_bind_keyseq_if_unbound ("\340R", rl_overwrite_mode
);
1318 /* These may or may not work because of the embedded NUL. */
1319 rl_bind_keyseq_if_unbound ("\\000H", rl_get_previous_history
);
1320 rl_bind_keyseq_if_unbound ("\\000P", rl_get_next_history
);
1321 rl_bind_keyseq_if_unbound ("\\000M", rl_forward_char
);
1322 rl_bind_keyseq_if_unbound ("\\000K", rl_backward_char
);
1323 rl_bind_keyseq_if_unbound ("\\000G", rl_beg_of_line
);
1324 rl_bind_keyseq_if_unbound ("\\000O", rl_end_of_line
);
1325 rl_bind_keyseq_if_unbound ("\\000S", rl_delete
);
1326 rl_bind_keyseq_if_unbound ("\\000R", rl_overwrite_mode
);
1329 _rl_keymap
= xkeymap
;
1332 /* Try and bind the common arrow key prefixes after giving termcap and
1333 the inputrc file a chance to bind them and create `real' keymaps
1334 for the arrow key prefix. */
1336 bind_arrow_keys (void)
1338 bind_arrow_keys_internal (emacs_standard_keymap
);
1340 #if defined (VI_MODE)
1341 bind_arrow_keys_internal (vi_movement_keymap
);
1342 /* Unbind vi_movement_keymap[ESC] to allow users to repeatedly hit ESC
1343 in vi command mode while still allowing the arrow keys to work. */
1344 if (vi_movement_keymap
[ESC
].type
== ISKMAP
)
1345 rl_bind_keyseq_in_map ("\033", (rl_command_func_t
*)NULL
, vi_movement_keymap
);
1346 bind_arrow_keys_internal (vi_insertion_keymap
);
1351 bind_bracketed_paste_prefix (void)
1355 xkeymap
= _rl_keymap
;
1357 _rl_keymap
= emacs_standard_keymap
;
1358 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1360 _rl_keymap
= vi_insertion_keymap
;
1361 rl_bind_keyseq_if_unbound (BRACK_PASTE_PREF
, rl_bracketed_paste_begin
);
1363 _rl_keymap
= xkeymap
;
1366 /* **************************************************************** */
1368 /* Saving and Restoring Readline's state */
1370 /* **************************************************************** */
1373 rl_save_state (struct readline_state
*sp
)
1378 sp
->point
= rl_point
;
1381 sp
->buffer
= rl_line_buffer
;
1382 sp
->buflen
= rl_line_buffer_len
;
1383 sp
->ul
= rl_undo_list
;
1384 sp
->prompt
= rl_prompt
;
1386 sp
->rlstate
= rl_readline_state
;
1388 sp
->kmap
= _rl_keymap
;
1390 sp
->lastfunc
= rl_last_func
;
1391 sp
->insmode
= rl_insert_mode
;
1392 sp
->edmode
= rl_editing_mode
;
1393 sp
->kseq
= rl_executing_keyseq
;
1394 sp
->kseqlen
= rl_key_sequence_length
;
1395 sp
->inf
= rl_instream
;
1396 sp
->outf
= rl_outstream
;
1397 sp
->pendingin
= rl_pending_input
;
1398 sp
->macro
= rl_executing_macro
;
1400 sp
->catchsigs
= rl_catch_signals
;
1401 sp
->catchsigwinch
= rl_catch_sigwinch
;
1403 sp
->entryfunc
= rl_completion_entry_function
;
1404 sp
->menuentryfunc
= rl_menu_completion_entry_function
;
1405 sp
->ignorefunc
= rl_ignore_some_completions_function
;
1406 sp
->attemptfunc
= rl_attempted_completion_function
;
1407 sp
->wordbreakchars
= rl_completer_word_break_characters
;
1413 rl_restore_state (struct readline_state
*sp
)
1418 rl_point
= sp
->point
;
1421 the_line
= rl_line_buffer
= sp
->buffer
;
1422 rl_line_buffer_len
= sp
->buflen
;
1423 rl_undo_list
= sp
->ul
;
1424 rl_prompt
= sp
->prompt
;
1426 rl_readline_state
= sp
->rlstate
;
1428 _rl_keymap
= sp
->kmap
;
1430 rl_last_func
= sp
->lastfunc
;
1431 rl_insert_mode
= sp
->insmode
;
1432 rl_editing_mode
= sp
->edmode
;
1433 rl_executing_keyseq
= sp
->kseq
;
1434 rl_key_sequence_length
= sp
->kseqlen
;
1435 rl_instream
= sp
->inf
;
1436 rl_outstream
= sp
->outf
;
1437 rl_pending_input
= sp
->pendingin
;
1438 rl_executing_macro
= sp
->macro
;
1440 rl_catch_signals
= sp
->catchsigs
;
1441 rl_catch_sigwinch
= sp
->catchsigwinch
;
1443 rl_completion_entry_function
= sp
->entryfunc
;
1444 rl_menu_completion_entry_function
= sp
->menuentryfunc
;
1445 rl_ignore_some_completions_function
= sp
->ignorefunc
;
1446 rl_attempted_completion_function
= sp
->attemptfunc
;
1447 rl_completer_word_break_characters
= sp
->wordbreakchars
;