readline/readline.c

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