1 /* readline.c -- a general facility for reading lines of input
2 with emacs style editing and completion. */
4 /* Copyright (C) 1987-2009 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 /* Forward declarations used in this file. */
86 static char *readline_internal PARAMS((void));
87 static void readline_initialize_everything PARAMS((void));
89 static void bind_arrow_keys_internal PARAMS((Keymap));
90 static void bind_arrow_keys PARAMS((void));
92 static void readline_default_bindings PARAMS((void));
93 static void reset_default_bindings PARAMS((void));
95 static int _rl_subseq_result PARAMS((int, Keymap, int, int));
96 static int _rl_subseq_getchar PARAMS((int));
98 /* **************************************************************** */
100 /* Line editing input utility */
102 /* **************************************************************** */
104 const char *rl_library_version = RL_LIBRARY_VERSION;
106 int rl_readline_version = RL_READLINE_VERSION;
108 /* True if this is `real' readline as opposed to some stub substitute. */
109 int rl_gnu_readline_p = 1;
111 /* A pointer to the keymap that is currently in use.
112 By default, it is the standard emacs keymap. */
113 Keymap _rl_keymap = emacs_standard_keymap;
116 /* The current style of editing. */
117 int rl_editing_mode = emacs_mode;
119 /* The current insert mode: input (the default) or overwrite */
120 int rl_insert_mode = RL_IM_DEFAULT;
122 /* Non-zero if we called this function from _rl_dispatch(). It's present
123 so functions can find out whether they were called from a key binding
124 or directly from an application. */
127 /* Non-zero if the previous command was a kill command. */
128 int _rl_last_command_was_kill = 0;
130 /* The current value of the numeric argument specified by the user. */
131 int rl_numeric_arg = 1;
133 /* Non-zero if an argument was typed. */
134 int rl_explicit_arg = 0;
136 /* Temporary value used while generating the argument. */
139 /* Non-zero means we have been called at least once before. */
140 static int rl_initialized;
143 /* If non-zero, this program is running in an EMACS buffer. */
144 static int running_in_emacs;
147 /* Flags word encapsulating the current readline state. */
148 int rl_readline_state = RL_STATE_NONE;
150 /* The current offset in the current input line. */
153 /* Mark in the current input line. */
156 /* Length of the current input line. */
159 /* Make this non-zero to return the current input_line. */
162 /* The last function executed by readline. */
163 rl_command_func_t *rl_last_func = (rl_command_func_t *)NULL;
165 /* Top level environment for readline_internal (). */
166 procenv_t _rl_top_level;
168 /* The streams we interact with. */
169 FILE *_rl_in_stream, *_rl_out_stream;
171 /* The names of the streams that we do input and output to. */
172 FILE *rl_instream = (FILE *)NULL;
173 FILE *rl_outstream = (FILE *)NULL;
175 /* Non-zero means echo characters as they are read. Defaults to no echo;
176 set to 1 if there is a controlling terminal, we can get its attributes,
177 and the attributes include `echo'. Look at rltty.c:prepare_terminal_settings
178 for the code that sets it. */
179 int _rl_echoing_p = 0;
181 /* Current prompt. */
182 char *rl_prompt = (char *)NULL;
183 int rl_visible_prompt_length = 0;
185 /* Set to non-zero by calling application if it has already printed rl_prompt
186 and does not want readline to do it the first time. */
187 int rl_already_prompted = 0;
189 /* The number of characters read in order to type this complete command. */
190 int rl_key_sequence_length = 0;
192 /* If non-zero, then this is the address of a function to call just
193 before readline_internal_setup () prints the first prompt. */
194 rl_hook_func_t *rl_startup_hook = (rl_hook_func_t *)NULL;
196 /* If non-zero, this is the address of a function to call just before
197 readline_internal_setup () returns and readline_internal starts
198 reading input characters. */
199 rl_hook_func_t *rl_pre_input_hook = (rl_hook_func_t *)NULL;
201 /* What we use internally. You should always refer to RL_LINE_BUFFER. */
202 static char *the_line;
204 /* The character that can generate an EOF. Really read from
205 the terminal driver... just defaulted here. */
206 int _rl_eof_char = CTRL ('D');
208 /* Non-zero makes this the next keystroke to read. */
209 int rl_pending_input = 0;
211 /* Pointer to a useful terminal name. */
212 const char *rl_terminal_name = (const char *)NULL;
214 /* Non-zero means to always use horizontal scrolling in line display. */
215 int _rl_horizontal_scroll_mode = 0;
217 /* Non-zero means to display an asterisk at the starts of history lines
218 which have been modified. */
219 int _rl_mark_modified_lines = 0;
221 /* The style of `bell' notification preferred. This can be set to NO_BELL,
222 AUDIBLE_BELL, or VISIBLE_BELL. */
223 int _rl_bell_preference = AUDIBLE_BELL;
225 /* String inserted into the line by rl_insert_comment (). */
226 char *_rl_comment_begin;
228 /* Keymap holding the function currently being executed. */
229 Keymap rl_executing_keymap;
231 /* Keymap we're currently using to dispatch. */
232 Keymap _rl_dispatching_keymap;
234 /* Non-zero means to erase entire line, including prompt, on empty input lines. */
235 int rl_erase_empty_line = 0;
237 /* Non-zero means to read only this many characters rather than up to a
238 character bound to accept-line. */
239 int rl_num_chars_to_read;
241 /* Line buffer and maintenence. */
242 char *rl_line_buffer = (char *)NULL;
243 int rl_line_buffer_len = 0;
245 /* Key sequence `contexts' */
246 _rl_keyseq_cxt *_rl_kscxt = 0;
248 /* Forward declarations used by the display, termcap, and history code. */
250 /* **************************************************************** */
252 /* `Forward' declarations */
254 /* **************************************************************** */
256 /* Non-zero means do not parse any lines other than comments and
257 parser directives. */
258 unsigned char _rl_parsing_conditionalized_out = 0;
260 /* Non-zero means to convert characters with the meta bit set to
261 escape-prefixed characters so we can indirect through
262 emacs_meta_keymap or vi_escape_keymap. */
263 int _rl_convert_meta_chars_to_ascii = 1;
265 /* Non-zero means to output characters with the meta bit set directly
266 rather than as a meta-prefixed escape sequence. */
267 int _rl_output_meta_chars = 0;
269 /* Non-zero means to look at the termios special characters and bind
270 them to equivalent readline functions at startup. */
271 int _rl_bind_stty_chars = 1;
273 /* Non-zero means to go through the history list at every newline (or
274 whenever rl_done is set and readline returns) and revert each line to
275 its initial state. */
276 int _rl_revert_all_at_newline = 0;
278 /* **************************************************************** */
280 /* Top Level Functions */
282 /* **************************************************************** */
284 /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
285 int _rl_meta_flag = 0; /* Forward declaration */
287 /* Set up the prompt and expand it. Called from readline() and
288 rl_callback_handler_install (). */
290 rl_set_prompt (prompt)
294 rl_prompt = prompt ? savestring (prompt) : (char *)NULL;
295 rl_display_prompt = rl_prompt ? rl_prompt : "";
297 rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
301 /* Read a line of input. Prompt with PROMPT. An empty PROMPT means
302 none. A return value of NULL means that EOF was encountered. */
312 /* If we are at EOF return a NULL string. */
313 if (rl_pending_input == EOF)
315 rl_clear_pending_input ();
316 return ((char *)NULL);
320 /* If readline() is called after installing a callback handler, temporarily
321 turn off the callback state to avoid ensuing messiness. Patch supplied
322 by the gdb folks. XXX -- disabled. This can be fooled and readline
323 left in a strange state by a poorly-timed longjmp. */
324 if (in_callback = RL_ISSTATE (RL_STATE_CALLBACK))
325 RL_UNSETSTATE (RL_STATE_CALLBACK);
328 rl_set_prompt (prompt);
331 if (rl_prep_term_function)
332 (*rl_prep_term_function) (_rl_meta_flag);
334 #if defined (HANDLE_SIGNALS)
338 value = readline_internal ();
339 if (rl_deprep_term_function)
340 (*rl_deprep_term_function) ();
342 #if defined (HANDLE_SIGNALS)
348 RL_SETSTATE (RL_STATE_CALLBACK);
354 #if defined (READLINE_CALLBACKS)
355 # define STATIC_CALLBACK
357 # define STATIC_CALLBACK static
361 readline_internal_setup ()
365 _rl_in_stream = rl_instream;
366 _rl_out_stream = rl_outstream;
369 (*rl_startup_hook) ();
371 /* If we're not echoing, we still want to at least print a prompt, because
372 rl_redisplay will not do it for us. If the calling application has a
373 custom redisplay function, though, let that function handle it. */
374 if (_rl_echoing_p == 0 && rl_redisplay_function == rl_redisplay)
376 if (rl_prompt && rl_already_prompted == 0)
378 nprompt = _rl_strip_prompt (rl_prompt);
379 fprintf (_rl_out_stream, "%s", nprompt);
380 fflush (_rl_out_stream);
386 if (rl_prompt && rl_already_prompted)
387 rl_on_new_line_with_prompt ();
390 (*rl_redisplay_function) ();
393 #if defined (VI_MODE)
394 if (rl_editing_mode == vi_mode)
395 rl_vi_insert_mode (1, 'i');
398 if (rl_pre_input_hook)
399 (*rl_pre_input_hook) ();
404 STATIC_CALLBACK char *
405 readline_internal_teardown (eof)
413 /* Restore the original of this history line, iff the line that we
414 are editing was originally in the history, AND the line has changed. */
415 entry = current_history ();
417 if (entry && rl_undo_list)
419 temp = savestring (the_line);
420 rl_revert_line (1, 0);
421 entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);
422 _rl_free_history_entry (entry);
424 strcpy (the_line, temp);
428 if (_rl_revert_all_at_newline)
429 _rl_revert_all_lines ();
431 /* At any rate, it is highly likely that this line has an undo list. Get
434 rl_free_undo_list ();
436 /* Restore normal cursor, if available. */
437 _rl_set_insert_mode (RL_IM_INSERT, 0);
439 return (eof ? (char *)NULL : savestring (the_line));
443 _rl_internal_char_cleanup ()
445 #if defined (VI_MODE)
446 /* In vi mode, when you exit insert mode, the cursor moves back
447 over the previous character. We explicitly check for that here. */
448 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
452 if (rl_num_chars_to_read && rl_end >= rl_num_chars_to_read)
454 (*rl_redisplay_function) ();
455 _rl_want_redisplay = 0;
456 rl_newline (1, '\n');
461 (*rl_redisplay_function) ();
462 _rl_want_redisplay = 0;
465 /* If the application writer has told us to erase the entire line if
466 the only character typed was something bound to rl_newline, do so. */
467 if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&
468 rl_point == 0 && rl_end == 0)
469 _rl_erase_entire_line ();
473 #if defined (READLINE_CALLBACKS)
474 readline_internal_char ()
476 readline_internal_charloop ()
479 static int lastc, eof_found;
485 #if !defined (READLINE_CALLBACKS)
489 lk = _rl_last_command_was_kill;
491 code = setjmp (_rl_top_level);
495 (*rl_redisplay_function) ();
496 _rl_want_redisplay = 0;
497 /* If we get here, we're not being called from something dispatched
498 from _rl_callback_read_char(), which sets up its own value of
499 _rl_top_level (saving and restoring the old, of course), so
500 we can just return here. */
501 if (RL_ISSTATE (RL_STATE_CALLBACK))
505 if (rl_pending_input == 0)
507 /* Then initialize the argument and number of keys read. */
508 _rl_reset_argument ();
509 rl_key_sequence_length = 0;
512 RL_SETSTATE(RL_STATE_READCMD);
514 RL_UNSETSTATE(RL_STATE_READCMD);
516 /* look at input.c:rl_getc() for the circumstances under which this will
517 be returned; punt immediately on read error without converting it to
521 #if defined (READLINE_CALLBACKS)
522 RL_SETSTATE(RL_STATE_DONE);
523 return (rl_done = 1);
530 /* EOF typed to a non-blank line is a <NL>. */
531 if (c == EOF && rl_end)
534 /* The character _rl_eof_char typed to blank line, and not as the
535 previous character is interpreted as EOF. */
536 if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
538 #if defined (READLINE_CALLBACKS)
539 RL_SETSTATE(RL_STATE_DONE);
540 return (rl_done = 1);
548 _rl_dispatch ((unsigned char)c, _rl_keymap);
551 /* If there was no change in _rl_last_command_was_kill, then no kill
552 has taken place. Note that if input is pending we are reading
553 a prefix command, so nothing has changed yet. */
554 if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)
555 _rl_last_command_was_kill = 0;
557 _rl_internal_char_cleanup ();
559 #if defined (READLINE_CALLBACKS)
568 #if defined (READLINE_CALLBACKS)
570 readline_internal_charloop ()
575 eof = readline_internal_char ();
578 #endif /* READLINE_CALLBACKS */
580 /* Read a line of input from the global rl_instream, doing output on
581 the global rl_outstream.
582 If rl_prompt is non-null, then that is our prompt. */
588 readline_internal_setup ();
589 eof = readline_internal_charloop ();
590 return (readline_internal_teardown (eof));
594 _rl_init_line_state ()
596 rl_point = rl_end = rl_mark = 0;
597 the_line = rl_line_buffer;
604 the_line = rl_line_buffer;
607 #if defined (READLINE_CALLBACKS)
609 _rl_keyseq_cxt_alloc ()
613 cxt = (_rl_keyseq_cxt *)xmalloc (sizeof (_rl_keyseq_cxt));
615 cxt->flags = cxt->subseq_arg = cxt->subseq_retval = 0;
618 cxt->ocxt = _rl_kscxt;
619 cxt->childval = 42; /* sentinel value */
625 _rl_keyseq_cxt_dispose (cxt)
632 _rl_keyseq_chain_dispose ()
639 _rl_kscxt = _rl_kscxt->ocxt;
640 _rl_keyseq_cxt_dispose (cxt);
646 _rl_subseq_getchar (key)
652 RL_SETSTATE(RL_STATE_METANEXT);
653 RL_SETSTATE(RL_STATE_MOREINPUT);
655 RL_UNSETSTATE(RL_STATE_MOREINPUT);
657 RL_UNSETSTATE(RL_STATE_METANEXT);
662 #if defined (READLINE_CALLBACKS)
664 _rl_dispatch_callback (cxt)
670 /* The first time this context is used, we want to read input and dispatch
671 on it. When traversing the chain of contexts back `up', we want to use
672 the value from the next context down. We're simulating recursion using
673 a chain of contexts. */
674 if ((cxt->flags & KSEQ_DISPATCHED) == 0)
676 nkey = _rl_subseq_getchar (cxt->okey);
679 _rl_abort_internal ();
682 r = _rl_dispatch_subseq (nkey, cxt->dmap, cxt->subseq_arg);
683 cxt->flags |= KSEQ_DISPATCHED;
689 r = _rl_subseq_result (r, cxt->oldmap, cxt->okey, (cxt->flags & KSEQ_SUBSEQ));
692 if (r == 0) /* success! */
694 _rl_keyseq_chain_dispose ();
695 RL_UNSETSTATE (RL_STATE_MULTIKEY);
699 if (r != -3) /* magic value that says we added to the chain */
700 _rl_kscxt = cxt->ocxt;
702 _rl_kscxt->childval = r;
704 _rl_keyseq_cxt_dispose (cxt);
708 #endif /* READLINE_CALLBACKS */
710 /* Do the command associated with KEY in MAP.
711 If the associated command is really a keymap, then read
712 another key, and dispatch into that map. */
714 _rl_dispatch (key, map)
718 _rl_dispatching_keymap = map;
719 return _rl_dispatch_subseq (key, map, 0);
723 _rl_dispatch_subseq (key, map, got_subseq)
730 rl_command_func_t *func;
731 #if defined (READLINE_CALLBACKS)
735 if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
737 if (map[ESC].type == ISKMAP)
739 if (RL_ISSTATE (RL_STATE_MACRODEF))
740 _rl_add_macro_char (ESC);
741 map = FUNCTION_TO_KEYMAP (map, ESC);
743 rl_key_sequence_length += 2;
744 return (_rl_dispatch (key, map));
751 if (RL_ISSTATE (RL_STATE_MACRODEF))
752 _rl_add_macro_char (key);
755 switch (map[key].type)
758 func = map[key].function;
761 /* Special case rl_do_lowercase_version (). */
762 if (func == rl_do_lowercase_version)
763 return (_rl_dispatch (_rl_to_lower (key), map));
765 rl_executing_keymap = map;
768 RL_SETSTATE(RL_STATE_DISPATCHING);
769 (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
770 RL_UNSETSTATE(RL_STATE_DISPATCHING);
773 /* If we have input pending, then the last command was a prefix
774 command. Don't change the state of rl_last_func. Otherwise,
775 remember the last command executed in this variable. */
776 if (rl_pending_input == 0 && map[key].function != rl_digit_argument)
777 rl_last_func = map[key].function;
781 else if (map[ANYOTHERKEY].function)
783 /* OK, there's no function bound in this map, but there is a
784 shadow function that was overridden when the current keymap
785 was created. Return -2 to note that. */
786 _rl_unget_char (key);
791 /* Return -1 to note that we're in a subsequence, but we don't
792 have a matching key, nor was one overridden. This means
793 we need to back up the recursion chain and find the last
794 subsequence that is bound to a function. */
795 _rl_unget_char (key);
800 #if defined (READLINE_CALLBACKS)
801 RL_UNSETSTATE (RL_STATE_MULTIKEY);
802 _rl_keyseq_chain_dispose ();
804 _rl_abort_internal ();
810 if (map[key].function != 0)
812 #if defined (VI_MODE)
813 /* The only way this test will be true is if a subsequence has been
814 bound starting with ESC, generally the arrow keys. What we do is
815 check whether there's input in the queue, which there generally
816 will be if an arrow key has been pressed, and, if there's not,
817 just dispatch to (what we assume is) rl_vi_movement_mode right
818 away. This is essentially an input test with a zero timeout. */
819 if (rl_editing_mode == vi_mode && key == ESC && map == vi_insertion_keymap
820 && _rl_input_queued (0) == 0)
821 return (_rl_dispatch (ANYOTHERKEY, FUNCTION_TO_KEYMAP (map, key)));
824 rl_key_sequence_length++;
825 _rl_dispatching_keymap = FUNCTION_TO_KEYMAP (map, key);
827 /* Allocate new context here. Use linked contexts (linked through
828 cxt->ocxt) to simulate recursion */
829 #if defined (READLINE_CALLBACKS)
830 if (RL_ISSTATE (RL_STATE_CALLBACK))
832 /* Return 0 only the first time, to indicate success to
833 _rl_callback_read_char. The rest of the time, we're called
834 from _rl_dispatch_callback, so we return 3 to indicate
835 special handling is necessary. */
836 r = RL_ISSTATE (RL_STATE_MULTIKEY) ? -3 : 0;
837 cxt = _rl_keyseq_cxt_alloc ();
840 cxt->flags |= KSEQ_SUBSEQ;
843 cxt->dmap = _rl_dispatching_keymap;
844 cxt->subseq_arg = got_subseq || cxt->dmap[ANYOTHERKEY].function;
846 RL_SETSTATE (RL_STATE_MULTIKEY);
849 return r; /* don't indicate immediate success */
853 newkey = _rl_subseq_getchar (key);
856 _rl_abort_internal ();
860 r = _rl_dispatch_subseq (newkey, _rl_dispatching_keymap, got_subseq || map[ANYOTHERKEY].function);
861 return _rl_subseq_result (r, map, key, got_subseq);
865 _rl_abort_internal ();
871 if (map[key].function != 0)
873 macro = savestring ((char *)map[key].function);
874 _rl_with_macro_input (macro);
879 #if defined (VI_MODE)
880 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
881 key != ANYOTHERKEY &&
882 _rl_vi_textmod_command (key))
883 _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
890 _rl_subseq_result (r, map, key, got_subseq)
897 rl_command_func_t *func, *nf;
900 /* We didn't match anything, and the keymap we're indexed into
901 shadowed a function previously bound to that prefix. Call
902 the function. The recursive call to _rl_dispatch_subseq has
903 already taken care of pushing any necessary input back onto
904 the input queue with _rl_unget_char. */
906 m = _rl_dispatching_keymap;
907 type = m[ANYOTHERKEY].type;
908 func = m[ANYOTHERKEY].function;
909 if (type == ISFUNC && func == rl_do_lowercase_version)
910 r = _rl_dispatch (_rl_to_lower (key), map);
911 else if (type == ISFUNC && func == rl_insert)
913 /* If the function that was shadowed was self-insert, we
914 somehow need a keymap with map[key].func == self-insert.
915 Let's use this one. */
917 nf = m[key].function;
920 m[key].function = func;
921 r = _rl_dispatch (key, m);
923 m[key].function = nf;
926 r = _rl_dispatch (ANYOTHERKEY, m);
928 else if (r && map[ANYOTHERKEY].function)
930 /* We didn't match (r is probably -1), so return something to
931 tell the caller that it should try ANYOTHERKEY for an
932 overridden function. */
933 _rl_unget_char (key);
934 _rl_dispatching_keymap = map;
937 else if (r && got_subseq)
939 /* OK, back up the chain. */
940 _rl_unget_char (key);
941 _rl_dispatching_keymap = map;
948 /* **************************************************************** */
950 /* Initializations */
952 /* **************************************************************** */
954 /* Initialize readline (and terminal if not already). */
958 /* If we have never been called before, initialize the
959 terminal and data structures. */
962 RL_SETSTATE(RL_STATE_INITIALIZING);
963 readline_initialize_everything ();
964 RL_UNSETSTATE(RL_STATE_INITIALIZING);
966 RL_SETSTATE(RL_STATE_INITIALIZED);
969 /* Initalize the current line information. */
970 _rl_init_line_state ();
972 /* We aren't done yet. We haven't even gotten started yet! */
974 RL_UNSETSTATE(RL_STATE_DONE);
976 /* Tell the history routines what is going on. */
977 _rl_start_using_history ();
979 /* Make the display buffer match the state of the line. */
980 rl_reset_line_state ();
982 /* No such function typed yet. */
983 rl_last_func = (rl_command_func_t *)NULL;
985 /* Parsing of key-bindings begins in an enabled state. */
986 _rl_parsing_conditionalized_out = 0;
988 #if defined (VI_MODE)
989 if (rl_editing_mode == vi_mode)
990 _rl_vi_initialize_line ();
993 /* Each line starts in insert mode (the default). */
994 _rl_set_insert_mode (RL_IM_DEFAULT, 1);
1000 #if defined (__EMX__)
1002 _emx_build_environ ()
1009 DosGetInfoBlocks (&tibp, &pibp);
1010 t = pibp->pib_pchenv;
1011 for (c = 1; *t; c++)
1012 t += strlen (t) + 1;
1013 tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));
1014 t = pibp->pib_pchenv;
1018 t += strlen (t) + 1;
1022 #endif /* __EMX__ */
1025 /* Initialize the entire state of the world. */
1027 readline_initialize_everything ()
1030 #if defined (__EMX__)
1032 _emx_build_environ ();
1037 /* Find out if we are running in Emacs -- UNUSED. */
1038 running_in_emacs = sh_get_env_value ("EMACS") != (char *)0;
1041 /* Set up input and output if they are not already set up. */
1043 rl_instream = stdin;
1046 rl_outstream = stdout;
1048 /* Bind _rl_in_stream and _rl_out_stream immediately. These values
1049 may change, but they may also be used before readline_internal ()
1051 _rl_in_stream = rl_instream;
1052 _rl_out_stream = rl_outstream;
1054 /* Allocate data structures. */
1055 if (rl_line_buffer == 0)
1056 rl_line_buffer = (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
1058 /* Initialize the terminal interface. */
1059 if (rl_terminal_name == 0)
1060 rl_terminal_name = sh_get_env_value ("TERM");
1061 _rl_init_terminal_io (rl_terminal_name);
1063 /* Bind tty characters to readline functions. */
1064 readline_default_bindings ();
1066 /* Initialize the function names. */
1067 rl_initialize_funmap ();
1069 /* Decide whether we should automatically go into eight-bit mode. */
1070 _rl_init_eightbit ();
1072 /* Read in the init file. */
1073 rl_read_init_file ((char *)NULL);
1076 if (_rl_horizontal_scroll_mode && _rl_term_autowrap)
1079 _rl_screenchars -= _rl_screenheight;
1082 /* Override the effect of any `set keymap' assignments in the
1084 rl_set_keymap_from_edit_mode ();
1086 /* Try to bind a common arrow key prefix, if not already bound. */
1089 /* Enable the meta key, if this terminal has one. */
1090 if (_rl_enable_meta)
1091 _rl_enable_meta_key ();
1093 /* If the completion parser's default word break characters haven't
1094 been set yet, then do so now. */
1095 if (rl_completer_word_break_characters == (char *)NULL)
1096 rl_completer_word_break_characters = (char *)rl_basic_word_break_characters;
1099 /* If this system allows us to look at the values of the regular
1100 input editing characters, then bind them to their readline
1101 equivalents, iff the characters are not bound to keymaps. */
1103 readline_default_bindings ()
1105 if (_rl_bind_stty_chars)
1106 rl_tty_set_default_bindings (_rl_keymap);
1109 /* Reset the default bindings for the terminal special characters we're
1110 interested in back to rl_insert and read the new ones. */
1112 reset_default_bindings ()
1114 if (_rl_bind_stty_chars)
1116 rl_tty_unset_default_bindings (_rl_keymap);
1117 rl_tty_set_default_bindings (_rl_keymap);
1121 /* Bind some common arrow key sequences in MAP. */
1123 bind_arrow_keys_internal (map)
1128 xkeymap = _rl_keymap;
1131 #if defined (__MSDOS__)
1132 rl_bind_keyseq_if_unbound ("\033[0A", rl_get_previous_history);
1133 rl_bind_keyseq_if_unbound ("\033[0B", rl_backward_char);
1134 rl_bind_keyseq_if_unbound ("\033[0C", rl_forward_char);
1135 rl_bind_keyseq_if_unbound ("\033[0D", rl_get_next_history);
1138 rl_bind_keyseq_if_unbound ("\033[A", rl_get_previous_history);
1139 rl_bind_keyseq_if_unbound ("\033[B", rl_get_next_history);
1140 rl_bind_keyseq_if_unbound ("\033[C", rl_forward_char);
1141 rl_bind_keyseq_if_unbound ("\033[D", rl_backward_char);
1142 rl_bind_keyseq_if_unbound ("\033[H", rl_beg_of_line);
1143 rl_bind_keyseq_if_unbound ("\033[F", rl_end_of_line);
1145 rl_bind_keyseq_if_unbound ("\033OA", rl_get_previous_history);
1146 rl_bind_keyseq_if_unbound ("\033OB", rl_get_next_history);
1147 rl_bind_keyseq_if_unbound ("\033OC", rl_forward_char);
1148 rl_bind_keyseq_if_unbound ("\033OD", rl_backward_char);
1149 rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line);
1150 rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line);
1152 #if defined (__MINGW32__)
1153 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history);
1154 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history);
1155 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char);
1156 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char);
1159 _rl_keymap = xkeymap;
1162 /* Try and bind the common arrow key prefixes after giving termcap and
1163 the inputrc file a chance to bind them and create `real' keymaps
1164 for the arrow key prefix. */
1168 bind_arrow_keys_internal (emacs_standard_keymap);
1170 #if defined (VI_MODE)
1171 bind_arrow_keys_internal (vi_movement_keymap);
1172 bind_arrow_keys_internal (vi_insertion_keymap);
1176 /* **************************************************************** */
1178 /* Saving and Restoring Readline's state */
1180 /* **************************************************************** */
1184 struct readline_state *sp;
1189 sp->point = rl_point;
1192 sp->buffer = rl_line_buffer;
1193 sp->buflen = rl_line_buffer_len;
1194 sp->ul = rl_undo_list;
1195 sp->prompt = rl_prompt;
1197 sp->rlstate = rl_readline_state;
1199 sp->kmap = _rl_keymap;
1201 sp->lastfunc = rl_last_func;
1202 sp->insmode = rl_insert_mode;
1203 sp->edmode = rl_editing_mode;
1204 sp->kseqlen = rl_key_sequence_length;
1205 sp->inf = rl_instream;
1206 sp->outf = rl_outstream;
1207 sp->pendingin = rl_pending_input;
1208 sp->macro = rl_executing_macro;
1210 sp->catchsigs = rl_catch_signals;
1211 sp->catchsigwinch = rl_catch_sigwinch;
1217 rl_restore_state (sp)
1218 struct readline_state *sp;
1223 rl_point = sp->point;
1226 the_line = rl_line_buffer = sp->buffer;
1227 rl_line_buffer_len = sp->buflen;
1228 rl_undo_list = sp->ul;
1229 rl_prompt = sp->prompt;
1231 rl_readline_state = sp->rlstate;
1233 _rl_keymap = sp->kmap;
1235 rl_last_func = sp->lastfunc;
1236 rl_insert_mode = sp->insmode;
1237 rl_editing_mode = sp->edmode;
1238 rl_key_sequence_length = sp->kseqlen;
1239 rl_instream = sp->inf;
1240 rl_outstream = sp->outf;
1241 rl_pending_input = sp->pendingin;
1242 rl_executing_macro = sp->macro;
1244 rl_catch_signals = sp->catchsigs;
1245 rl_catch_sigwinch = sp->catchsigwinch;