Annotation of embedaddon/readline/readline.c, revision 1.1.1.1.2.2

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>