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)
26
# include "config_readline.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)) __attribute__((unused));
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;
added
removed
cmd-line-utils/readline/readline.c
