1 /* readline.c -- a general facility for reading lines of input
2 with emacs style editing and completion. */
4 /* Copyright (C) 1987-2005 Free Software Foundation, Inc.
6 This file is part of the GNU Readline Library, a library for
7 reading lines of text with interactive input and history editing.
9 The GNU Readline Library is free software; you can redistribute it
10 and/or modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2, or
12 (at your option) any later version.
14 The GNU Readline Library is distributed in the hope that it will be
15 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 The GNU General Public License is often shipped with GNU software, and
20 is generally kept in a file called COPYING or LICENSE. If you do not
21 have a copy of the license, write to the Free Software Foundation,
22 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
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 readline_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 readline_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 /* **************************************************************** */
275 /* Top Level Functions */
277 /* **************************************************************** */
279 /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
280 int _rl_meta_flag = 0; /* Forward declaration */
282 /* Set up the prompt and expand it. Called from readline() and
283 rl_callback_handler_install (). */
285 rl_set_prompt (prompt)
289 rl_prompt = prompt ? savestring (prompt) : (char *)NULL;
290 rl_display_prompt = rl_prompt ? rl_prompt : "";
292 rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
296 /* Read a line of input. Prompt with PROMPT. An empty PROMPT means
297 none. A return value of NULL means that EOF was encountered. */
304 /* If we are at EOF return a NULL string. */
305 if (rl_pending_input == EOF)
307 rl_clear_pending_input ();
308 return ((char *)NULL);
311 rl_set_prompt (prompt);
314 if (rl_prep_term_function)
315 (*rl_prep_term_function) (_rl_meta_flag);
317 #if defined (HANDLE_SIGNALS)
321 value = readline_internal ();
322 if (rl_deprep_term_function)
323 (*rl_deprep_term_function) ();
325 #if defined (HANDLE_SIGNALS)
332 #if defined (READLINE_CALLBACKS)
333 # define STATIC_CALLBACK
335 # define STATIC_CALLBACK static
339 readline_internal_setup ()
343 _rl_in_stream = rl_instream;
344 _rl_out_stream = rl_outstream;
347 (*rl_startup_hook) ();
349 /* If we're not echoing, we still want to at least print a prompt, because
350 rl_redisplay will not do it for us. If the calling application has a
351 custom redisplay function, though, let that function handle it. */
352 if (readline_echoing_p == 0 && rl_redisplay_function == rl_redisplay)
354 if (rl_prompt && rl_already_prompted == 0)
356 nprompt = _rl_strip_prompt (rl_prompt);
357 fprintf (_rl_out_stream, "%s", nprompt);
358 fflush (_rl_out_stream);
364 if (rl_prompt && rl_already_prompted)
365 rl_on_new_line_with_prompt ();
368 (*rl_redisplay_function) ();
371 #if defined (VI_MODE)
372 if (rl_editing_mode == vi_mode)
373 rl_vi_insertion_mode (1, 'i');
376 if (rl_pre_input_hook)
377 (*rl_pre_input_hook) ();
380 STATIC_CALLBACK char *
381 readline_internal_teardown (eof)
387 /* Restore the original of this history line, iff the line that we
388 are editing was originally in the history, AND the line has changed. */
389 entry = current_history ();
391 if (entry && rl_undo_list)
393 temp = savestring (the_line);
394 rl_revert_line (1, 0);
395 entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);
396 _rl_free_history_entry (entry);
398 strcpy (the_line, temp);
402 /* At any rate, it is highly likely that this line has an undo list. Get
405 rl_free_undo_list ();
407 /* Restore normal cursor, if available. */
408 _rl_set_insert_mode (RL_IM_INSERT, 0);
410 return (eof ? (char *)NULL : savestring (the_line));
414 _rl_internal_char_cleanup ()
416 #if defined (VI_MODE)
417 /* In vi mode, when you exit insert mode, the cursor moves back
418 over the previous character. We explicitly check for that here. */
419 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
423 if (rl_num_chars_to_read && rl_end >= rl_num_chars_to_read)
425 (*rl_redisplay_function) ();
426 _rl_want_redisplay = 0;
427 rl_newline (1, '\n');
432 (*rl_redisplay_function) ();
433 _rl_want_redisplay = 0;
436 /* If the application writer has told us to erase the entire line if
437 the only character typed was something bound to rl_newline, do so. */
438 if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&
439 rl_point == 0 && rl_end == 0)
440 _rl_erase_entire_line ();
444 #if defined (READLINE_CALLBACKS)
445 readline_internal_char ()
447 readline_internal_charloop ()
450 static int lastc, eof_found;
456 #if !defined (READLINE_CALLBACKS)
460 lk = _rl_last_command_was_kill;
462 code = setjmp (readline_top_level);
466 (*rl_redisplay_function) ();
467 _rl_want_redisplay = 0;
468 /* If we get here, we're not being called from something dispatched
469 from _rl_callback_read_char(), which sets up its own value of
470 readline_top_level (saving and restoring the old, of course), so
471 we can just return here. */
472 if (RL_ISSTATE (RL_STATE_CALLBACK))
476 if (rl_pending_input == 0)
478 /* Then initialize the argument and number of keys read. */
479 _rl_reset_argument ();
480 rl_key_sequence_length = 0;
483 RL_SETSTATE(RL_STATE_READCMD);
485 RL_UNSETSTATE(RL_STATE_READCMD);
487 /* look at input.c:rl_getc() for the circumstances under which this will
488 be returned; punt immediately on read error without converting it to
492 #if defined (READLINE_CALLBACKS)
493 RL_SETSTATE(RL_STATE_DONE);
494 return (rl_done = 1);
501 /* EOF typed to a non-blank line is a <NL>. */
502 if (c == EOF && rl_end)
505 /* The character _rl_eof_char typed to blank line, and not as the
506 previous character is interpreted as EOF. */
507 if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
509 #if defined (READLINE_CALLBACKS)
510 RL_SETSTATE(RL_STATE_DONE);
511 return (rl_done = 1);
519 _rl_dispatch ((unsigned char)c, _rl_keymap);
521 /* If there was no change in _rl_last_command_was_kill, then no kill
522 has taken place. Note that if input is pending we are reading
523 a prefix command, so nothing has changed yet. */
524 if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)
525 _rl_last_command_was_kill = 0;
527 _rl_internal_char_cleanup ();
529 #if defined (READLINE_CALLBACKS)
538 #if defined (READLINE_CALLBACKS)
540 readline_internal_charloop ()
545 eof = readline_internal_char ();
548 #endif /* READLINE_CALLBACKS */
550 /* Read a line of input from the global rl_instream, doing output on
551 the global rl_outstream.
552 If rl_prompt is non-null, then that is our prompt. */
558 readline_internal_setup ();
559 eof = readline_internal_charloop ();
560 return (readline_internal_teardown (eof));
564 _rl_init_line_state ()
566 rl_point = rl_end = rl_mark = 0;
567 the_line = rl_line_buffer;
574 the_line = rl_line_buffer;
577 #if defined (READLINE_CALLBACKS)
579 _rl_keyseq_cxt_alloc ()
583 cxt = (_rl_keyseq_cxt *)xmalloc (sizeof (_rl_keyseq_cxt));
585 cxt->flags = cxt->subseq_arg = cxt->subseq_retval = 0;
588 cxt->ocxt = _rl_kscxt;
589 cxt->childval = 42; /* sentinel value */
595 _rl_keyseq_cxt_dispose (cxt)
602 _rl_keyseq_chain_dispose ()
609 _rl_kscxt = _rl_kscxt->ocxt;
610 _rl_keyseq_cxt_dispose (cxt);
616 _rl_subseq_getchar (key)
622 RL_SETSTATE(RL_STATE_METANEXT);
623 RL_SETSTATE(RL_STATE_MOREINPUT);
625 RL_UNSETSTATE(RL_STATE_MOREINPUT);
627 RL_UNSETSTATE(RL_STATE_METANEXT);
632 #if defined (READLINE_CALLBACKS)
634 _rl_dispatch_callback (cxt)
641 /* The first time this context is used, we want to read input and dispatch
642 on it. When traversing the chain of contexts back `up', we want to use
643 the value from the next context down. We're simulating recursion using
644 a chain of contexts. */
645 if ((cxt->flags & KSEQ_DISPATCHED) == 0)
647 nkey = _rl_subseq_getchar (cxt->okey);
648 r = _rl_dispatch_subseq (nkey, cxt->dmap, cxt->subseq_arg);
649 cxt->flags |= KSEQ_DISPATCHED;
654 r = _rl_dispatch_subseq (nkey, cxt->dmap, cxt->subseq_arg);
658 r = _rl_subseq_result (r, cxt->oldmap, cxt->okey, (cxt->flags & KSEQ_SUBSEQ));
660 if (r == 0) /* success! */
662 _rl_keyseq_chain_dispose ();
663 RL_UNSETSTATE (RL_STATE_MULTIKEY);
667 if (r != -3) /* magic value that says we added to the chain */
668 _rl_kscxt = cxt->ocxt;
670 _rl_kscxt->childval = r;
672 _rl_keyseq_cxt_dispose (cxt);
676 #endif /* READLINE_CALLBACKS */
678 /* Do the command associated with KEY in MAP.
679 If the associated command is really a keymap, then read
680 another key, and dispatch into that map. */
682 _rl_dispatch (key, map)
686 _rl_dispatching_keymap = map;
687 return _rl_dispatch_subseq (key, map, 0);
691 _rl_dispatch_subseq (key, map, got_subseq)
698 rl_command_func_t *func;
699 #if defined (READLINE_CALLBACKS)
703 if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
705 if (map[ESC].type == ISKMAP)
707 if (RL_ISSTATE (RL_STATE_MACRODEF))
708 _rl_add_macro_char (ESC);
709 map = FUNCTION_TO_KEYMAP (map, ESC);
711 rl_key_sequence_length += 2;
712 return (_rl_dispatch (key, map));
719 if (RL_ISSTATE (RL_STATE_MACRODEF))
720 _rl_add_macro_char (key);
723 switch (map[key].type)
726 func = map[key].function;
729 /* Special case rl_do_lowercase_version (). */
730 if (func == rl_do_lowercase_version)
731 return (_rl_dispatch (_rl_to_lower (key), map));
733 rl_executing_keymap = map;
736 RL_SETSTATE(RL_STATE_DISPATCHING);
737 (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
738 RL_UNSETSTATE(RL_STATE_DISPATCHING);
741 /* If we have input pending, then the last command was a prefix
742 command. Don't change the state of rl_last_func. Otherwise,
743 remember the last command executed in this variable. */
744 if (rl_pending_input == 0 && map[key].function != rl_digit_argument)
745 rl_last_func = map[key].function;
747 else if (map[ANYOTHERKEY].function)
749 /* OK, there's no function bound in this map, but there is a
750 shadow function that was overridden when the current keymap
751 was created. Return -2 to note that. */
752 _rl_unget_char (key);
757 /* Return -1 to note that we're in a subsequence, but we don't
758 have a matching key, nor was one overridden. This means
759 we need to back up the recursion chain and find the last
760 subsequence that is bound to a function. */
761 _rl_unget_char (key);
766 #if defined (READLINE_CALLBACKS)
767 RL_UNSETSTATE (RL_STATE_MULTIKEY);
768 _rl_keyseq_chain_dispose ();
770 _rl_abort_internal ();
776 if (map[key].function != 0)
778 #if defined (VI_MODE)
779 /* The only way this test will be true is if a subsequence has been
780 bound starting with ESC, generally the arrow keys. What we do is
781 check whether there's input in the queue, which there generally
782 will be if an arrow key has been pressed, and, if there's not,
783 just dispatch to (what we assume is) rl_vi_movement_mode right
784 away. This is essentially an input test with a zero timeout. */
785 if (rl_editing_mode == vi_mode && key == ESC && map == vi_insertion_keymap
786 && _rl_input_queued (0) == 0)
787 return (_rl_dispatch (ANYOTHERKEY, FUNCTION_TO_KEYMAP (map, key)));
790 rl_key_sequence_length++;
791 _rl_dispatching_keymap = FUNCTION_TO_KEYMAP (map, key);
793 /* Allocate new context here. Use linked contexts (linked through
794 cxt->ocxt) to simulate recursion */
795 #if defined (READLINE_CALLBACKS)
796 if (RL_ISSTATE (RL_STATE_CALLBACK))
798 /* Return 0 only the first time, to indicate success to
799 _rl_callback_read_char. The rest of the time, we're called
800 from _rl_dispatch_callback, so we return 3 to indicate
801 special handling is necessary. */
802 r = RL_ISSTATE (RL_STATE_MULTIKEY) ? -3 : 0;
803 cxt = _rl_keyseq_cxt_alloc ();
806 cxt->flags |= KSEQ_SUBSEQ;
809 cxt->dmap = _rl_dispatching_keymap;
810 cxt->subseq_arg = got_subseq || cxt->dmap[ANYOTHERKEY].function;
812 RL_SETSTATE (RL_STATE_MULTIKEY);
815 return r; /* don't indicate immediate success */
819 newkey = _rl_subseq_getchar (key);
822 _rl_abort_internal ();
826 r = _rl_dispatch_subseq (newkey, _rl_dispatching_keymap, got_subseq || map[ANYOTHERKEY].function);
827 return _rl_subseq_result (r, map, key, got_subseq);
831 _rl_abort_internal ();
837 if (map[key].function != 0)
839 macro = savestring ((char *)map[key].function);
840 _rl_with_macro_input (macro);
845 #if defined (VI_MODE)
846 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
847 key != ANYOTHERKEY &&
848 _rl_vi_textmod_command (key))
849 _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
856 _rl_subseq_result (r, map, key, got_subseq)
863 rl_command_func_t *func, *nf;
866 /* We didn't match anything, and the keymap we're indexed into
867 shadowed a function previously bound to that prefix. Call
868 the function. The recursive call to _rl_dispatch_subseq has
869 already taken care of pushing any necessary input back onto
870 the input queue with _rl_unget_char. */
872 m = _rl_dispatching_keymap;
873 type = m[ANYOTHERKEY].type;
874 func = m[ANYOTHERKEY].function;
875 if (type == ISFUNC && func == rl_do_lowercase_version)
876 r = _rl_dispatch (_rl_to_lower (key), map);
877 else if (type == ISFUNC && func == rl_insert)
879 /* If the function that was shadowed was self-insert, we
880 somehow need a keymap with map[key].func == self-insert.
881 Let's use this one. */
883 nf = m[key].function;
886 m[key].function = func;
887 r = _rl_dispatch (key, m);
889 m[key].function = nf;
892 r = _rl_dispatch (ANYOTHERKEY, m);
894 else if (r && map[ANYOTHERKEY].function)
896 /* We didn't match (r is probably -1), so return something to
897 tell the caller that it should try ANYOTHERKEY for an
898 overridden function. */
899 _rl_unget_char (key);
900 _rl_dispatching_keymap = map;
903 else if (r && got_subseq)
905 /* OK, back up the chain. */
906 _rl_unget_char (key);
907 _rl_dispatching_keymap = map;
914 /* **************************************************************** */
916 /* Initializations */
918 /* **************************************************************** */
920 /* Initialize readline (and terminal if not already). */
924 /* If we have never been called before, initialize the
925 terminal and data structures. */
928 RL_SETSTATE(RL_STATE_INITIALIZING);
929 readline_initialize_everything ();
930 RL_UNSETSTATE(RL_STATE_INITIALIZING);
932 RL_SETSTATE(RL_STATE_INITIALIZED);
935 /* Initalize the current line information. */
936 _rl_init_line_state ();
938 /* We aren't done yet. We haven't even gotten started yet! */
940 RL_UNSETSTATE(RL_STATE_DONE);
942 /* Tell the history routines what is going on. */
943 _rl_start_using_history ();
945 /* Make the display buffer match the state of the line. */
946 rl_reset_line_state ();
948 /* No such function typed yet. */
949 rl_last_func = (rl_command_func_t *)NULL;
951 /* Parsing of key-bindings begins in an enabled state. */
952 _rl_parsing_conditionalized_out = 0;
954 #if defined (VI_MODE)
955 if (rl_editing_mode == vi_mode)
956 _rl_vi_initialize_line ();
959 /* Each line starts in insert mode (the default). */
960 _rl_set_insert_mode (RL_IM_DEFAULT, 1);
966 #if defined (__EMX__)
968 _emx_build_environ ()
975 DosGetInfoBlocks (&tibp, &pibp);
976 t = pibp->pib_pchenv;
979 tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));
980 t = pibp->pib_pchenv;
991 /* Initialize the entire state of the world. */
993 readline_initialize_everything ()
996 #if defined (__EMX__)
998 _emx_build_environ ();
1003 /* Find out if we are running in Emacs -- UNUSED. */
1004 running_in_emacs = sh_get_env_value ("EMACS") != (char *)0;
1007 /* Set up input and output if they are not already set up. */
1009 rl_instream = stdin;
1012 rl_outstream = stdout;
1014 /* Bind _rl_in_stream and _rl_out_stream immediately. These values
1015 may change, but they may also be used before readline_internal ()
1017 _rl_in_stream = rl_instream;
1018 _rl_out_stream = rl_outstream;
1020 /* Allocate data structures. */
1021 if (rl_line_buffer == 0)
1022 rl_line_buffer = (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
1024 /* Initialize the terminal interface. */
1025 if (rl_terminal_name == 0)
1026 rl_terminal_name = sh_get_env_value ("TERM");
1027 _rl_init_terminal_io (rl_terminal_name);
1029 /* Bind tty characters to readline functions. */
1030 readline_default_bindings ();
1032 /* Initialize the function names. */
1033 rl_initialize_funmap ();
1035 /* Decide whether we should automatically go into eight-bit mode. */
1036 _rl_init_eightbit ();
1038 /* Read in the init file. */
1039 rl_read_init_file ((char *)NULL);
1042 if (_rl_horizontal_scroll_mode && _rl_term_autowrap)
1045 _rl_screenchars -= _rl_screenheight;
1048 /* Override the effect of any `set keymap' assignments in the
1050 rl_set_keymap_from_edit_mode ();
1052 /* Try to bind a common arrow key prefix, if not already bound. */
1055 /* Enable the meta key, if this terminal has one. */
1056 if (_rl_enable_meta)
1057 _rl_enable_meta_key ();
1059 /* If the completion parser's default word break characters haven't
1060 been set yet, then do so now. */
1061 if (rl_completer_word_break_characters == (char *)NULL)
1062 rl_completer_word_break_characters = (char *)rl_basic_word_break_characters;
1065 /* If this system allows us to look at the values of the regular
1066 input editing characters, then bind them to their readline
1067 equivalents, iff the characters are not bound to keymaps. */
1069 readline_default_bindings ()
1071 if (_rl_bind_stty_chars)
1072 rl_tty_set_default_bindings (_rl_keymap);
1075 /* Reset the default bindings for the terminal special characters we're
1076 interested in back to rl_insert and read the new ones. */
1078 reset_default_bindings ()
1080 if (_rl_bind_stty_chars)
1082 rl_tty_unset_default_bindings (_rl_keymap);
1083 rl_tty_set_default_bindings (_rl_keymap);
1087 /* Bind some common arrow key sequences in MAP. */
1089 bind_arrow_keys_internal (map)
1094 xkeymap = _rl_keymap;
1097 #if defined (__MSDOS__)
1098 rl_bind_keyseq_if_unbound ("\033[0A", rl_get_previous_history);
1099 rl_bind_keyseq_if_unbound ("\033[0B", rl_backward_char);
1100 rl_bind_keyseq_if_unbound ("\033[0C", rl_forward_char);
1101 rl_bind_keyseq_if_unbound ("\033[0D", rl_get_next_history);
1104 rl_bind_keyseq_if_unbound ("\033[A", rl_get_previous_history);
1105 rl_bind_keyseq_if_unbound ("\033[B", rl_get_next_history);
1106 rl_bind_keyseq_if_unbound ("\033[C", rl_forward_char);
1107 rl_bind_keyseq_if_unbound ("\033[D", rl_backward_char);
1108 rl_bind_keyseq_if_unbound ("\033[H", rl_beg_of_line);
1109 rl_bind_keyseq_if_unbound ("\033[F", rl_end_of_line);
1111 rl_bind_keyseq_if_unbound ("\033OA", rl_get_previous_history);
1112 rl_bind_keyseq_if_unbound ("\033OB", rl_get_next_history);
1113 rl_bind_keyseq_if_unbound ("\033OC", rl_forward_char);
1114 rl_bind_keyseq_if_unbound ("\033OD", rl_backward_char);
1115 rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line);
1116 rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line);
1118 #if defined (__MINGW32__)
1119 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history);
1120 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history);
1121 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char);
1122 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char);
1125 _rl_keymap = xkeymap;
1128 /* Try and bind the common arrow key prefixes after giving termcap and
1129 the inputrc file a chance to bind them and create `real' keymaps
1130 for the arrow key prefix. */
1134 bind_arrow_keys_internal (emacs_standard_keymap);
1136 #if defined (VI_MODE)
1137 bind_arrow_keys_internal (vi_movement_keymap);
1138 bind_arrow_keys_internal (vi_insertion_keymap);
1142 /* **************************************************************** */
1144 /* Saving and Restoring Readline's state */
1146 /* **************************************************************** */
1150 struct readline_state *sp;
1155 sp->point = rl_point;
1158 sp->buffer = rl_line_buffer;
1159 sp->buflen = rl_line_buffer_len;
1160 sp->ul = rl_undo_list;
1161 sp->prompt = rl_prompt;
1163 sp->rlstate = rl_readline_state;
1165 sp->kmap = _rl_keymap;
1167 sp->lastfunc = rl_last_func;
1168 sp->insmode = rl_insert_mode;
1169 sp->edmode = rl_editing_mode;
1170 sp->kseqlen = rl_key_sequence_length;
1171 sp->inf = rl_instream;
1172 sp->outf = rl_outstream;
1173 sp->pendingin = rl_pending_input;
1174 sp->macro = rl_executing_macro;
1176 sp->catchsigs = rl_catch_signals;
1177 sp->catchsigwinch = rl_catch_sigwinch;
1183 rl_restore_state (sp)
1184 struct readline_state *sp;
1189 rl_point = sp->point;
1192 the_line = rl_line_buffer = sp->buffer;
1193 rl_line_buffer_len = sp->buflen;
1194 rl_undo_list = sp->ul;
1195 rl_prompt = sp->prompt;
1197 rl_readline_state = sp->rlstate;
1199 _rl_keymap = sp->kmap;
1201 rl_last_func = sp->lastfunc;
1202 rl_insert_mode = sp->insmode;
1203 rl_editing_mode = sp->edmode;
1204 rl_key_sequence_length = sp->kseqlen;
1205 rl_instream = sp->inf;
1206 rl_outstream = sp->outf;
1207 rl_pending_input = sp->pendingin;
1208 rl_executing_macro = sp->macro;
1210 rl_catch_signals = sp->catchsigs;
1211 rl_catch_sigwinch = sp->catchsigwinch;