1 /* readline.c -- a general facility for reading lines of input 2 with emacs style editing and completion. */ 3 4 /* Copyright (C) 1987-2009 Free Software Foundation, Inc. 5 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. 8 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. 13 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. 18 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/>. 21 */ 22 23 #define READLINE_LIBRARY 24 25 #if defined (HAVE_CONFIG_H) 26 # include <config.h> 27 #endif 28 29 #include <sys/types.h> 30 #include "posixstat.h" 31 #include <fcntl.h> 32 #if defined (HAVE_SYS_FILE_H) 33 # include <sys/file.h> 34 #endif /* HAVE_SYS_FILE_H */ 35 36 #if defined (HAVE_UNISTD_H) 37 # include <unistd.h> 38 #endif /* HAVE_UNISTD_H */ 39 40 #if defined (HAVE_STDLIB_H) 41 # include <stdlib.h> 42 #else 43 # include "ansi_stdlib.h" 44 #endif /* HAVE_STDLIB_H */ 45 46 #if defined (HAVE_LOCALE_H) 47 # include <locale.h> 48 #endif 49 50 #include <stdio.h> 51 #include "posixjmp.h" 52 #include <errno.h> 53 54 #if !defined (errno) 55 extern int errno; 56 #endif /* !errno */ 57 58 /* System-specific feature definitions and include files. */ 59 #include "rldefs.h" 60 #include "rlmbutil.h" 61 62 #if defined (__EMX__) 63 # define INCL_DOSPROCESS 64 # include <os2.h> 65 #endif /* __EMX__ */ 66 67 /* Some standard library routines. */ 68 #include "readline.h" 69 #include "history.h" 70 71 #include "rlprivate.h" 72 #include "rlshell.h" 73 #include "xmalloc.h" 74 75 #ifndef RL_LIBRARY_VERSION 76 # define RL_LIBRARY_VERSION "5.1" 77 #endif 78 79 #ifndef RL_READLINE_VERSION 80 # define RL_READLINE_VERSION 0x0501 81 #endif 82 83 extern void _rl_free_history_entry PARAMS((HIST_ENTRY *)); 84 85 /* Forward declarations used in this file. */ 86 static char *readline_internal PARAMS((void)); 87 static void readline_initialize_everything PARAMS((void)); 88 89 static void bind_arrow_keys_internal PARAMS((Keymap)); 90 static void bind_arrow_keys PARAMS((void)); 91 92 static void readline_default_bindings PARAMS((void)); 93 static void reset_default_bindings PARAMS((void)); 94 95 static int _rl_subseq_result PARAMS((int, Keymap, int, int)); 96 static int _rl_subseq_getchar PARAMS((int)); 97 98 /* **************************************************************** */ 99 /* */ 100 /* Line editing input utility */ 101 /* */ 102 /* **************************************************************** */ 103 104 const char *rl_library_version = RL_LIBRARY_VERSION; 105 106 int rl_readline_version = RL_READLINE_VERSION; 107 108 /* True if this is `real' readline as opposed to some stub substitute. */ 109 int rl_gnu_readline_p = 1; 110 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; 114 115 116 /* The current style of editing. */ 117 int rl_editing_mode = emacs_mode; 118 119 /* The current insert mode: input (the default) or overwrite */ 120 int rl_insert_mode = RL_IM_DEFAULT; 121 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. */ 125 int rl_dispatching; 126 127 /* Non-zero if the previous command was a kill command. */ 128 int _rl_last_command_was_kill = 0; 129 130 /* The current value of the numeric argument specified by the user. */ 131 int rl_numeric_arg = 1; 132 133 /* Non-zero if an argument was typed. */ 134 int rl_explicit_arg = 0; 135 136 /* Temporary value used while generating the argument. */ 137 int rl_arg_sign = 1; 138 139 /* Non-zero means we have been called at least once before. */ 140 static int rl_initialized; 141 142 #if 0 143 /* If non-zero, this program is running in an EMACS buffer. */ 144 static int running_in_emacs; 145 #endif 146 147 /* Flags word encapsulating the current readline state. */ 148 int rl_readline_state = RL_STATE_NONE; 149 150 /* The current offset in the current input line. */ 151 int rl_point; 152 153 /* Mark in the current input line. */ 154 int rl_mark; 155 156 /* Length of the current input line. */ 157 int rl_end; 158 159 /* Make this non-zero to return the current input_line. */ 160 int rl_done; 161 162 /* The last function executed by readline. */ 163 rl_command_func_t *rl_last_func = (rl_command_func_t *)NULL; 164 165 /* Top level environment for readline_internal (). */ 166 procenv_t _rl_top_level; 167 168 /* The streams we interact with. */ 169 FILE *_rl_in_stream, *_rl_out_stream; 170 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; 174 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; 180 181 /* Current prompt. */ 182 char *rl_prompt = (char *)NULL; 183 int rl_visible_prompt_length = 0; 184 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; 188 189 /* The number of characters read in order to type this complete command. */ 190 int rl_key_sequence_length = 0; 191 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; 195 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; 200 201 /* What we use internally. You should always refer to RL_LINE_BUFFER. */ 202 static char *the_line; 203 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'); 207 208 /* Non-zero makes this the next keystroke to read. */ 209 int rl_pending_input = 0; 210 211 /* Pointer to a useful terminal name. */ 212 const char *rl_terminal_name = (const char *)NULL; 213 214 /* Non-zero means to always use horizontal scrolling in line display. */ 215 int _rl_horizontal_scroll_mode = 0; 216 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; 220 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; 224 225 /* String inserted into the line by rl_insert_comment (). */ 226 char *_rl_comment_begin; 227 228 /* Keymap holding the function currently being executed. */ 229 Keymap rl_executing_keymap; 230 231 /* Keymap we're currently using to dispatch. */ 232 Keymap _rl_dispatching_keymap; 233 234 /* Non-zero means to erase entire line, including prompt, on empty input lines. */ 235 int rl_erase_empty_line = 0; 236 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; 240 241 /* Line buffer and maintenence. */ 242 char *rl_line_buffer = (char *)NULL; 243 int rl_line_buffer_len = 0; 244 245 /* Key sequence `contexts' */ 246 _rl_keyseq_cxt *_rl_kscxt = 0; 247 248 /* Forward declarations used by the display, termcap, and history code. */ 249 250 /* **************************************************************** */ 251 /* */ 252 /* `Forward' declarations */ 253 /* */ 254 /* **************************************************************** */ 255 256 /* Non-zero means do not parse any lines other than comments and 257 parser directives. */ 258 unsigned char _rl_parsing_conditionalized_out = 0; 259 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; 264 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; 268 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; 272 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; 277 278 /* Non-zero means to honor the termios ECHOCTL bit and echo control 279 characters corresponding to keyboard-generated signals. */ 280 int _rl_echo_control_chars = 1; 281 282 /* **************************************************************** */ 283 /* */ 284 /* Top Level Functions */ 285 /* */ 286 /* **************************************************************** */ 287 288 /* Non-zero means treat 0200 bit in terminal input as Meta bit. */ 289 int _rl_meta_flag = 0; /* Forward declaration */ 290 291 /* Set up the prompt and expand it. Called from readline() and 292 rl_callback_handler_install (). */ 293 int 294 rl_set_prompt (prompt) 295 const char *prompt; 296 { 297 FREE (rl_prompt); 298 rl_prompt = prompt ? savestring (prompt) : (char *)NULL; 299 rl_display_prompt = rl_prompt ? rl_prompt : ""; 300 301 rl_visible_prompt_length = rl_expand_prompt (rl_prompt); 302 return 0; 303 } 304 305 /* Read a line of input. Prompt with PROMPT. An empty PROMPT means 306 none. A return value of NULL means that EOF was encountered. */ 307 char * 308 readline (prompt) 309 const char *prompt; 310 { 311 char *value; 312 #if 0 313 int in_callback; 314 #endif 315 316 /* If we are at EOF return a NULL string. */ 317 if (rl_pending_input == EOF) 318 { 319 rl_clear_pending_input (); 320 return ((char *)NULL); 321 } 322 323 #if 0 324 /* If readline() is called after installing a callback handler, temporarily 325 turn off the callback state to avoid ensuing messiness. Patch supplied 326 by the gdb folks. XXX -- disabled. This can be fooled and readline 327 left in a strange state by a poorly-timed longjmp. */ 328 if (in_callback = RL_ISSTATE (RL_STATE_CALLBACK)) 329 RL_UNSETSTATE (RL_STATE_CALLBACK); 330 #endif 331 332 rl_set_prompt (prompt); 333 334 rl_initialize (); 335 if (rl_prep_term_function) 336 (*rl_prep_term_function) (_rl_meta_flag); 337 338 #if defined (HANDLE_SIGNALS) 339 rl_set_signals (); 340 #endif 341 342 value = readline_internal (); 343 if (rl_deprep_term_function) 344 (*rl_deprep_term_function) (); 345 346 #if defined (HANDLE_SIGNALS) 347 rl_clear_signals (); 348 #endif 349 350 #if 0 351 if (in_callback) 352 RL_SETSTATE (RL_STATE_CALLBACK); 353 #endif 354 355 return (value); 356 } 357 358 #if defined (READLINE_CALLBACKS) 359 # define STATIC_CALLBACK 360 #else 361 # define STATIC_CALLBACK static 362 #endif 363 364 STATIC_CALLBACK void 365 readline_internal_setup () 366 { 367 char *nprompt; 368 369 _rl_in_stream = rl_instream; 370 _rl_out_stream = rl_outstream; 371 372 if (rl_startup_hook) 373 (*rl_startup_hook) (); 374 375 /* If we're not echoing, we still want to at least print a prompt, because 376 rl_redisplay will not do it for us. If the calling application has a 377 custom redisplay function, though, let that function handle it. */ 378 if (_rl_echoing_p == 0 && rl_redisplay_function == rl_redisplay) 379 { 380 if (rl_prompt && rl_already_prompted == 0) 381 { 382 nprompt = _rl_strip_prompt (rl_prompt); 383 fprintf (_rl_out_stream, "%s", nprompt); 384 fflush (_rl_out_stream); 385 xfree (nprompt); 386 } 387 } 388 else 389 { 390 if (rl_prompt && rl_already_prompted) 391 rl_on_new_line_with_prompt (); 392 else 393 rl_on_new_line (); 394 (*rl_redisplay_function) (); 395 } 396 397 #if defined (VI_MODE) 398 if (rl_editing_mode == vi_mode) 399 rl_vi_insert_mode (1, 'i'); 400 #endif /* VI_MODE */ 401 402 if (rl_pre_input_hook) 403 (*rl_pre_input_hook) (); 404 405 RL_CHECK_SIGNALS (); 406 } 407 408 STATIC_CALLBACK char * 409 readline_internal_teardown (eof) 410 int eof; 411 { 412 char *temp; 413 HIST_ENTRY *entry; 414 415 RL_CHECK_SIGNALS (); 416 417 /* Restore the original of this history line, iff the line that we 418 are editing was originally in the history, AND the line has changed. */ 419 entry = current_history (); 420 421 if (entry && rl_undo_list) 422 { 423 temp = savestring (the_line); 424 rl_revert_line (1, 0); 425 entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL); 426 _rl_free_history_entry (entry); 427 428 strcpy (the_line, temp); 429 xfree (temp); 430 } 431 432 if (_rl_revert_all_at_newline) 433 _rl_revert_all_lines (); 434 435 /* At any rate, it is highly likely that this line has an undo list. Get 436 rid of it now. */ 437 if (rl_undo_list) 438 rl_free_undo_list (); 439 440 /* Restore normal cursor, if available. */ 441 _rl_set_insert_mode (RL_IM_INSERT, 0); 442 443 return (eof ? (char *)NULL : savestring (the_line)); 444 } 445 446 void 447 _rl_internal_char_cleanup () 448 { 449 #if defined (VI_MODE) 450 /* In vi mode, when you exit insert mode, the cursor moves back 451 over the previous character. We explicitly check for that here. */ 452 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap) 453 rl_vi_check (); 454 #endif /* VI_MODE */ 455 456 if (rl_num_chars_to_read && rl_end >= rl_num_chars_to_read) 457 { 458 (*rl_redisplay_function) (); 459 _rl_want_redisplay = 0; 460 rl_newline (1, '\n'); 461 } 462 463 if (rl_done == 0) 464 { 465 (*rl_redisplay_function) (); 466 _rl_want_redisplay = 0; 467 } 468 469 /* If the application writer has told us to erase the entire line if 470 the only character typed was something bound to rl_newline, do so. */ 471 if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline && 472 rl_point == 0 && rl_end == 0) 473 _rl_erase_entire_line (); 474 } 475 476 STATIC_CALLBACK int 477 #if defined (READLINE_CALLBACKS) 478 readline_internal_char () 479 #else 480 readline_internal_charloop () 481 #endif 482 { 483 static int lastc, eof_found; 484 int c, code, lk; 485 486 lastc = -1; 487 eof_found = 0; 488 489 #if !defined (READLINE_CALLBACKS) 490 while (rl_done == 0) 491 { 492 #endif 493 lk = _rl_last_command_was_kill; 494 495 code = setjmp (_rl_top_level); 496 497 if (code) 498 { 499 (*rl_redisplay_function) (); 500 _rl_want_redisplay = 0; 501 /* If we get here, we're not being called from something dispatched 502 from _rl_callback_read_char(), which sets up its own value of 503 _rl_top_level (saving and restoring the old, of course), so 504 we can just return here. */ 505 if (RL_ISSTATE (RL_STATE_CALLBACK)) 506 return (0); 507 } 508 509 if (rl_pending_input == 0) 510 { 511 /* Then initialize the argument and number of keys read. */ 512 _rl_reset_argument (); 513 rl_key_sequence_length = 0; 514 } 515 516 RL_SETSTATE(RL_STATE_READCMD); 517 c = rl_read_key (); 518 RL_UNSETSTATE(RL_STATE_READCMD); 519 520 /* look at input.c:rl_getc() for the circumstances under which this will 521 be returned; punt immediately on read error without converting it to 522 a newline. */ 523 if (c == READERR) 524 { 525 #if defined (READLINE_CALLBACKS) 526 RL_SETSTATE(RL_STATE_DONE); 527 return (rl_done = 1); 528 #else 529 eof_found = 1; 530 break; 531 #endif 532 } 533 534 /* EOF typed to a non-blank line is a <NL>. */ 535 if (c == EOF && rl_end) 536 c = NEWLINE; 537 538 /* The character _rl_eof_char typed to blank line, and not as the 539 previous character is interpreted as EOF. */ 540 if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end) 541 { 542 #if defined (READLINE_CALLBACKS) 543 RL_SETSTATE(RL_STATE_DONE); 544 return (rl_done = 1); 545 #else 546 eof_found = 1; 547 break; 548 #endif 549 } 550 551 lastc = c; 552 _rl_dispatch ((unsigned char)c, _rl_keymap); 553 RL_CHECK_SIGNALS (); 554 555 /* If there was no change in _rl_last_command_was_kill, then no kill 556 has taken place. Note that if input is pending we are reading 557 a prefix command, so nothing has changed yet. */ 558 if (rl_pending_input == 0 && lk == _rl_last_command_was_kill) 559 _rl_last_command_was_kill = 0; 560 561 _rl_internal_char_cleanup (); 562 563 #if defined (READLINE_CALLBACKS) 564 return 0; 565 #else 566 } 567 568 return (eof_found); 569 #endif 570 } 571 572 #if defined (READLINE_CALLBACKS) 573 static int 574 readline_internal_charloop () 575 { 576 int eof = 1; 577 578 while (rl_done == 0) 579 eof = readline_internal_char (); 580 return (eof); 581 } 582 #endif /* READLINE_CALLBACKS */ 583 584 /* Read a line of input from the global rl_instream, doing output on 585 the global rl_outstream. 586 If rl_prompt is non-null, then that is our prompt. */ 587 static char * 588 readline_internal () 589 { 590 int eof; 591 592 readline_internal_setup (); 593 eof = readline_internal_charloop (); 594 return (readline_internal_teardown (eof)); 595 } 596 597 void 598 _rl_init_line_state () 599 { 600 rl_point = rl_end = rl_mark = 0; 601 the_line = rl_line_buffer; 602 the_line[0] = 0; 603 } 604 605 void 606 _rl_set_the_line () 607 { 608 the_line = rl_line_buffer; 609 } 610 611 #if defined (READLINE_CALLBACKS) 612 _rl_keyseq_cxt * 613 _rl_keyseq_cxt_alloc () 614 { 615 _rl_keyseq_cxt *cxt; 616 617 cxt = (_rl_keyseq_cxt *)xmalloc (sizeof (_rl_keyseq_cxt)); 618 619 cxt->flags = cxt->subseq_arg = cxt->subseq_retval = 0; 620 621 cxt->okey = 0; 622 cxt->ocxt = _rl_kscxt; 623 cxt->childval = 42; /* sentinel value */ 624 625 return cxt; 626 } 627 628 void 629 _rl_keyseq_cxt_dispose (cxt) 630 _rl_keyseq_cxt *cxt; 631 { 632 xfree (cxt); 633 } 634 635 void 636 _rl_keyseq_chain_dispose () 637 { 638 _rl_keyseq_cxt *cxt; 639 640 while (_rl_kscxt) 641 { 642 cxt = _rl_kscxt; 643 _rl_kscxt = _rl_kscxt->ocxt; 644 _rl_keyseq_cxt_dispose (cxt); 645 } 646 } 647 #endif 648 649 static int 650 _rl_subseq_getchar (key) 651 int key; 652 { 653 int k; 654 655 if (key == ESC) 656 RL_SETSTATE(RL_STATE_METANEXT); 657 RL_SETSTATE(RL_STATE_MOREINPUT); 658 k = rl_read_key (); 659 RL_UNSETSTATE(RL_STATE_MOREINPUT); 660 if (key == ESC) 661 RL_UNSETSTATE(RL_STATE_METANEXT); 662 663 return k; 664 } 665 666 #if defined (READLINE_CALLBACKS) 667 int 668 _rl_dispatch_callback (cxt) 669 _rl_keyseq_cxt *cxt; 670 { 671 int nkey, r; 672 673 /* For now */ 674 /* The first time this context is used, we want to read input and dispatch 675 on it. When traversing the chain of contexts back `up', we want to use 676 the value from the next context down. We're simulating recursion using 677 a chain of contexts. */ 678 if ((cxt->flags & KSEQ_DISPATCHED) == 0) 679 { 680 nkey = _rl_subseq_getchar (cxt->okey); 681 if (nkey < 0) 682 { 683 _rl_abort_internal (); 684 return -1; 685 } 686 r = _rl_dispatch_subseq (nkey, cxt->dmap, cxt->subseq_arg); 687 cxt->flags |= KSEQ_DISPATCHED; 688 } 689 else 690 r = cxt->childval; 691 692 /* For now */ 693 if (r != -3) /* don't do this if we indicate there will be other matches */ 694 r = _rl_subseq_result (r, cxt->oldmap, cxt->okey, (cxt->flags & KSEQ_SUBSEQ)); 695 696 RL_CHECK_SIGNALS (); 697 if (r == 0) /* success! */ 698 { 699 _rl_keyseq_chain_dispose (); 700 RL_UNSETSTATE (RL_STATE_MULTIKEY); 701 return r; 702 } 703 704 if (r != -3) /* magic value that says we added to the chain */ 705 _rl_kscxt = cxt->ocxt; 706 if (_rl_kscxt) 707 _rl_kscxt->childval = r; 708 if (r != -3) 709 _rl_keyseq_cxt_dispose (cxt); 710 711 return r; 712 } 713 #endif /* READLINE_CALLBACKS */ 714 715 /* Do the command associated with KEY in MAP. 716 If the associated command is really a keymap, then read 717 another key, and dispatch into that map. */ 718 int 719 _rl_dispatch (key, map) 720 register int key; 721 Keymap map; 722 { 723 _rl_dispatching_keymap = map; 724 return _rl_dispatch_subseq (key, map, 0); 725 } 726 727 int 728 _rl_dispatch_subseq (key, map, got_subseq) 729 register int key; 730 Keymap map; 731 int got_subseq; 732 { 733 int r, newkey; 734 char *macro; 735 rl_command_func_t *func; 736 #if defined (READLINE_CALLBACKS) 737 _rl_keyseq_cxt *cxt; 738 #endif 739 740 if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii) 741 { 742 if (map[ESC].type == ISKMAP) 743 { 744 if (RL_ISSTATE (RL_STATE_MACRODEF)) 745 _rl_add_macro_char (ESC); 746 map = FUNCTION_TO_KEYMAP (map, ESC); 747 key = UNMETA (key); 748 rl_key_sequence_length += 2; 749 return (_rl_dispatch (key, map)); 750 } 751 else 752 rl_ding (); 753 return 0; 754 } 755 756 if (RL_ISSTATE (RL_STATE_MACRODEF)) 757 _rl_add_macro_char (key); 758 759 r = 0; 760 switch (map[key].type) 761 { 762 case ISFUNC: 763 func = map[key].function; 764 if (func) 765 { 766 /* Special case rl_do_lowercase_version (). */ 767 if (func == rl_do_lowercase_version) 768 return (_rl_dispatch (_rl_to_lower (key), map)); 769 770 rl_executing_keymap = map; 771 772 rl_dispatching = 1; 773 RL_SETSTATE(RL_STATE_DISPATCHING); 774 (*map[key].function)(rl_numeric_arg * rl_arg_sign, key); 775 RL_UNSETSTATE(RL_STATE_DISPATCHING); 776 rl_dispatching = 0; 777 778 /* If we have input pending, then the last command was a prefix 779 command. Don't change the state of rl_last_func. Otherwise, 780 remember the last command executed in this variable. */ 781 if (rl_pending_input == 0 && map[key].function != rl_digit_argument) 782 rl_last_func = map[key].function; 783 784 RL_CHECK_SIGNALS (); 785 } 786 else if (map[ANYOTHERKEY].function) 787 { 788 /* OK, there's no function bound in this map, but there is a 789 shadow function that was overridden when the current keymap 790 was created. Return -2 to note that. */ 791 _rl_unget_char (key); 792 return -2; 793 } 794 else if (got_subseq) 795 { 796 /* Return -1 to note that we're in a subsequence, but we don't 797 have a matching key, nor was one overridden. This means 798 we need to back up the recursion chain and find the last 799 subsequence that is bound to a function. */ 800 _rl_unget_char (key); 801 return -1; 802 } 803 else 804 { 805 #if defined (READLINE_CALLBACKS) 806 RL_UNSETSTATE (RL_STATE_MULTIKEY); 807 _rl_keyseq_chain_dispose (); 808 #endif 809 _rl_abort_internal (); 810 return -1; 811 } 812 break; 813 814 case ISKMAP: 815 if (map[key].function != 0) 816 { 817 #if defined (VI_MODE) 818 /* The only way this test will be true is if a subsequence has been 819 bound starting with ESC, generally the arrow keys. What we do is 820 check whether there's input in the queue, which there generally 821 will be if an arrow key has been pressed, and, if there's not, 822 just dispatch to (what we assume is) rl_vi_movement_mode right 823 away. This is essentially an input test with a zero timeout. */ 824 if (rl_editing_mode == vi_mode && key == ESC && map == vi_insertion_keymap 825 && _rl_input_queued (0) == 0) 826 return (_rl_dispatch (ANYOTHERKEY, FUNCTION_TO_KEYMAP (map, key))); 827 #endif 828 829 rl_key_sequence_length++; 830 _rl_dispatching_keymap = FUNCTION_TO_KEYMAP (map, key); 831 832 /* Allocate new context here. Use linked contexts (linked through 833 cxt->ocxt) to simulate recursion */ 834 #if defined (READLINE_CALLBACKS) 835 if (RL_ISSTATE (RL_STATE_CALLBACK)) 836 { 837 /* Return 0 only the first time, to indicate success to 838 _rl_callback_read_char. The rest of the time, we're called 839 from _rl_dispatch_callback, so we return -3 to indicate 840 special handling is necessary. */ 841 r = RL_ISSTATE (RL_STATE_MULTIKEY) ? -3 : 0; 842 cxt = _rl_keyseq_cxt_alloc (); 843 844 if (got_subseq) 845 cxt->flags |= KSEQ_SUBSEQ; 846 cxt->okey = key; 847 cxt->oldmap = map; 848 cxt->dmap = _rl_dispatching_keymap; 849 cxt->subseq_arg = got_subseq || cxt->dmap[ANYOTHERKEY].function; 850 851 RL_SETSTATE (RL_STATE_MULTIKEY); 852 _rl_kscxt = cxt; 853 854 return r; /* don't indicate immediate success */ 855 } 856 #endif 857 858 newkey = _rl_subseq_getchar (key); 859 if (newkey < 0) 860 { 861 _rl_abort_internal (); 862 return -1; 863 } 864 865 r = _rl_dispatch_subseq (newkey, _rl_dispatching_keymap, got_subseq || map[ANYOTHERKEY].function); 866 return _rl_subseq_result (r, map, key, got_subseq); 867 } 868 else 869 { 870 _rl_abort_internal (); 871 return -1; 872 } 873 break; 874 875 case ISMACR: 876 if (map[key].function != 0) 877 { 878 macro = savestring ((char *)map[key].function); 879 _rl_with_macro_input (macro); 880 return 0; 881 } 882 break; 883 } 884 #if defined (VI_MODE) 885 if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap && 886 key != ANYOTHERKEY && 887 _rl_vi_textmod_command (key)) 888 _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign); 889 #endif 890 891 return (r); 892 } 893 894 static int 895 _rl_subseq_result (r, map, key, got_subseq) 896 int r; 897 Keymap map; 898 int key, got_subseq; 899 { 900 Keymap m; 901 int type, nt; 902 rl_command_func_t *func, *nf; 903 904 if (r == -2) 905 /* We didn't match anything, and the keymap we're indexed into 906 shadowed a function previously bound to that prefix. Call 907 the function. The recursive call to _rl_dispatch_subseq has 908 already taken care of pushing any necessary input back onto 909 the input queue with _rl_unget_char. */ 910 { 911 m = _rl_dispatching_keymap; 912 type = m[ANYOTHERKEY].type; 913 func = m[ANYOTHERKEY].function; 914 if (type == ISFUNC && func == rl_do_lowercase_version) 915 r = _rl_dispatch (_rl_to_lower (key), map); 916 else if (type == ISFUNC && func == rl_insert) 917 { 918 /* If the function that was shadowed was self-insert, we 919 somehow need a keymap with map[key].func == self-insert. 920 Let's use this one. */ 921 nt = m[key].type; 922 nf = m[key].function; 923 924 m[key].type = type; 925 m[key].function = func; 926 r = _rl_dispatch (key, m); 927 m[key].type = nt; 928 m[key].function = nf; 929 } 930 else 931 r = _rl_dispatch (ANYOTHERKEY, m); 932 } 933 else if (r && map[ANYOTHERKEY].function) 934 { 935 /* We didn't match (r is probably -1), so return something to 936 tell the caller that it should try ANYOTHERKEY for an 937 overridden function. */ 938 _rl_unget_char (key); 939 _rl_dispatching_keymap = map; 940 return -2; 941 } 942 else if (r && got_subseq) 943 { 944 /* OK, back up the chain. */ 945 _rl_unget_char (key); 946 _rl_dispatching_keymap = map; 947 return -1; 948 } 949 950 return r; 951 } 952 953 /* **************************************************************** */ 954 /* */ 955 /* Initializations */ 956 /* */ 957 /* **************************************************************** */ 958 959 /* Initialize readline (and terminal if not already). */ 960 int 961 rl_initialize () 962 { 963 /* If we have never been called before, initialize the 964 terminal and data structures. */ 965 if (!rl_initialized) 966 { 967 RL_SETSTATE(RL_STATE_INITIALIZING); 968 readline_initialize_everything (); 969 RL_UNSETSTATE(RL_STATE_INITIALIZING); 970 rl_initialized++; 971 RL_SETSTATE(RL_STATE_INITIALIZED); 972 } 973 974 /* Initalize the current line information. */ 975 _rl_init_line_state (); 976 977 /* We aren't done yet. We haven't even gotten started yet! */ 978 rl_done = 0; 979 RL_UNSETSTATE(RL_STATE_DONE); 980 981 /* Tell the history routines what is going on. */ 982 _rl_start_using_history (); 983 984 /* Make the display buffer match the state of the line. */ 985 rl_reset_line_state (); 986 987 /* No such function typed yet. */ 988 rl_last_func = (rl_command_func_t *)NULL; 989 990 /* Parsing of key-bindings begins in an enabled state. */ 991 _rl_parsing_conditionalized_out = 0; 992 993 #if defined (VI_MODE) 994 if (rl_editing_mode == vi_mode) 995 _rl_vi_initialize_line (); 996 #endif 997 998 /* Each line starts in insert mode (the default). */ 999 _rl_set_insert_mode (RL_IM_DEFAULT, 1); 1000 1001 return 0; 1002 } 1003 1004 #if 0 1005 #if defined (__EMX__) 1006 static void 1007 _emx_build_environ () 1008 { 1009 TIB *tibp; 1010 PIB *pibp; 1011 char *t, **tp; 1012 int c; 1013 1014 DosGetInfoBlocks (&tibp, &pibp); 1015 t = pibp->pib_pchenv; 1016 for (c = 1; *t; c++) 1017 t += strlen (t) + 1; 1018 tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *)); 1019 t = pibp->pib_pchenv; 1020 while (*t) 1021 { 1022 *tp++ = t; 1023 t += strlen (t) + 1; 1024 } 1025 *tp = 0; 1026 } 1027 #endif /* __EMX__ */ 1028 #endif 1029 1030 /* Initialize the entire state of the world. */ 1031 static void 1032 readline_initialize_everything () 1033 { 1034 #if 0 1035 #if defined (__EMX__) 1036 if (environ == 0) 1037 _emx_build_environ (); 1038 #endif 1039 #endif 1040 1041 #if 0 1042 /* Find out if we are running in Emacs -- UNUSED. */ 1043 running_in_emacs = sh_get_env_value ("EMACS") != (char *)0; 1044 #endif 1045 1046 /* Set up input and output if they are not already set up. */ 1047 if (!rl_instream) 1048 rl_instream = stdin; 1049 1050 if (!rl_outstream) 1051 rl_outstream = stdout; 1052 1053 /* Bind _rl_in_stream and _rl_out_stream immediately. These values 1054 may change, but they may also be used before readline_internal () 1055 is called. */ 1056 _rl_in_stream = rl_instream; 1057 _rl_out_stream = rl_outstream; 1058 1059 /* Allocate data structures. */ 1060 if (rl_line_buffer == 0) 1061 rl_line_buffer = (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE); 1062 1063 /* Initialize the terminal interface. */ 1064 if (rl_terminal_name == 0) 1065 rl_terminal_name = sh_get_env_value ("TERM"); 1066 _rl_init_terminal_io (rl_terminal_name); 1067 1068 /* Bind tty characters to readline functions. */ 1069 readline_default_bindings (); 1070 1071 /* Initialize the function names. */ 1072 rl_initialize_funmap (); 1073 1074 /* Decide whether we should automatically go into eight-bit mode. */ 1075 _rl_init_eightbit (); 1076 1077 /* Read in the init file. */ 1078 rl_read_init_file ((char *)NULL); 1079 1080 /* XXX */ 1081 if (_rl_horizontal_scroll_mode && _rl_term_autowrap) 1082 { 1083 _rl_screenwidth--; 1084 _rl_screenchars -= _rl_screenheight; 1085 } 1086 1087 /* Override the effect of any `set keymap' assignments in the 1088 inputrc file. */ 1089 rl_set_keymap_from_edit_mode (); 1090 1091 /* Try to bind a common arrow key prefix, if not already bound. */ 1092 bind_arrow_keys (); 1093 1094 /* Enable the meta key, if this terminal has one. */ 1095 if (_rl_enable_meta) 1096 _rl_enable_meta_key (); 1097 1098 /* If the completion parser's default word break characters haven't 1099 been set yet, then do so now. */ 1100 if (rl_completer_word_break_characters == (char *)NULL) 1101 rl_completer_word_break_characters = (char *)rl_basic_word_break_characters; 1102 } 1103 1104 /* If this system allows us to look at the values of the regular 1105 input editing characters, then bind them to their readline 1106 equivalents, iff the characters are not bound to keymaps. */ 1107 static void 1108 readline_default_bindings () 1109 { 1110 if (_rl_bind_stty_chars) 1111 rl_tty_set_default_bindings (_rl_keymap); 1112 } 1113 1114 /* Reset the default bindings for the terminal special characters we're 1115 interested in back to rl_insert and read the new ones. */ 1116 static void 1117 reset_default_bindings () 1118 { 1119 if (_rl_bind_stty_chars) 1120 { 1121 rl_tty_unset_default_bindings (_rl_keymap); 1122 rl_tty_set_default_bindings (_rl_keymap); 1123 } 1124 } 1125 1126 /* Bind some common arrow key sequences in MAP. */ 1127 static void 1128 bind_arrow_keys_internal (map) 1129 Keymap map; 1130 { 1131 Keymap xkeymap; 1132 1133 xkeymap = _rl_keymap; 1134 _rl_keymap = map; 1135 1136 #if defined (__MSDOS__) 1137 rl_bind_keyseq_if_unbound ("\033[0A", rl_get_previous_history); 1138 rl_bind_keyseq_if_unbound ("\033[0B", rl_backward_char); 1139 rl_bind_keyseq_if_unbound ("\033[0C", rl_forward_char); 1140 rl_bind_keyseq_if_unbound ("\033[0D", rl_get_next_history); 1141 #endif 1142 1143 rl_bind_keyseq_if_unbound ("\033[A", rl_get_previous_history); 1144 rl_bind_keyseq_if_unbound ("\033[B", rl_get_next_history); 1145 rl_bind_keyseq_if_unbound ("\033[C", rl_forward_char); 1146 rl_bind_keyseq_if_unbound ("\033[D", rl_backward_char); 1147 rl_bind_keyseq_if_unbound ("\033[H", rl_beg_of_line); 1148 rl_bind_keyseq_if_unbound ("\033[F", rl_end_of_line); 1149 1150 rl_bind_keyseq_if_unbound ("\033OA", rl_get_previous_history); 1151 rl_bind_keyseq_if_unbound ("\033OB", rl_get_next_history); 1152 rl_bind_keyseq_if_unbound ("\033OC", rl_forward_char); 1153 rl_bind_keyseq_if_unbound ("\033OD", rl_backward_char); 1154 rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line); 1155 rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line); 1156 1157 #if defined (__MINGW32__) 1158 rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history); 1159 rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history); 1160 rl_bind_keyseq_if_unbound ("\340M", rl_forward_char); 1161 rl_bind_keyseq_if_unbound ("\340K", rl_backward_char); 1162 #endif 1163 1164 _rl_keymap = xkeymap; 1165 } 1166 1167 /* Try and bind the common arrow key prefixes after giving termcap and 1168 the inputrc file a chance to bind them and create `real' keymaps 1169 for the arrow key prefix. */ 1170 static void 1171 bind_arrow_keys () 1172 { 1173 bind_arrow_keys_internal (emacs_standard_keymap); 1174 1175 #if defined (VI_MODE) 1176 bind_arrow_keys_internal (vi_movement_keymap); 1177 /* Unbind vi_movement_keymap[ESC] to allow users to repeatedly hit ESC 1178 in vi command mode while still allowing the arrow keys to work. */ 1179 if (vi_movement_keymap[ESC].type == ISKMAP) 1180 rl_bind_keyseq_in_map ("\033", (rl_command_func_t *)NULL, vi_movement_keymap); 1181 bind_arrow_keys_internal (vi_insertion_keymap); 1182 #endif 1183 } 1184 1185 /* **************************************************************** */ 1186 /* */ 1187 /* Saving and Restoring Readline's state */ 1188 /* */ 1189 /* **************************************************************** */ 1190 1191 int 1192 rl_save_state (sp) 1193 struct readline_state *sp; 1194 { 1195 if (sp == 0) 1196 return -1; 1197 1198 sp->point = rl_point; 1199 sp->end = rl_end; 1200 sp->mark = rl_mark; 1201 sp->buffer = rl_line_buffer; 1202 sp->buflen = rl_line_buffer_len; 1203 sp->ul = rl_undo_list; 1204 sp->prompt = rl_prompt; 1205 1206 sp->rlstate = rl_readline_state; 1207 sp->done = rl_done; 1208 sp->kmap = _rl_keymap; 1209 1210 sp->lastfunc = rl_last_func; 1211 sp->insmode = rl_insert_mode; 1212 sp->edmode = rl_editing_mode; 1213 sp->kseqlen = rl_key_sequence_length; 1214 sp->inf = rl_instream; 1215 sp->outf = rl_outstream; 1216 sp->pendingin = rl_pending_input; 1217 sp->macro = rl_executing_macro; 1218 1219 sp->catchsigs = rl_catch_signals; 1220 sp->catchsigwinch = rl_catch_sigwinch; 1221 1222 return (0); 1223 } 1224 1225 int 1226 rl_restore_state (sp) 1227 struct readline_state *sp; 1228 { 1229 if (sp == 0) 1230 return -1; 1231 1232 rl_point = sp->point; 1233 rl_end = sp->end; 1234 rl_mark = sp->mark; 1235 the_line = rl_line_buffer = sp->buffer; 1236 rl_line_buffer_len = sp->buflen; 1237 rl_undo_list = sp->ul; 1238 rl_prompt = sp->prompt; 1239 1240 rl_readline_state = sp->rlstate; 1241 rl_done = sp->done; 1242 _rl_keymap = sp->kmap; 1243 1244 rl_last_func = sp->lastfunc; 1245 rl_insert_mode = sp->insmode; 1246 rl_editing_mode = sp->edmode; 1247 rl_key_sequence_length = sp->kseqlen; 1248 rl_instream = sp->inf; 1249 rl_outstream = sp->outf; 1250 rl_pending_input = sp->pendingin; 1251 rl_executing_macro = sp->macro; 1252 1253 rl_catch_signals = sp->catchsigs; 1254 rl_catch_sigwinch = sp->catchsigwinch; 1255 1256 return (0); 1257 } 1258