开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
readline.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：49k
源码类别：

MySQL数据库

开发平台：

Visual C++

readline.c：源码内容
  1. /* readline.c -- a general facility for reading lines of input
  2.    with emacs style editing and completion. */
  4. /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
  6.    This file is part of the GNU Readline Library, a library for
  7.    reading lines of text with interactive input and history editing.
  9.    The GNU Readline Library is free software; you can redistribute it
  10.    and/or modify it under the terms of the GNU General Public License
  11.    as published by the Free Software Foundation; either version 1, or
  12.    (at your option) any later version.
  14.    The GNU Readline Library is distributed in the hope that it will be
  15.    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  16.    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  19.    The GNU General Public License is often shipped with GNU software, and
  20.    is generally kept in a file called COPYING or LICENSE.  If you do not
  21.    have a copy of the license, write to the Free Software Foundation,
  22.    675 Mass Ave, Cambridge, MA 02139, USA. */
  23. #define READLINE_LIBRARY
  25. #if defined (HAVE_CONFIG_H)
  26. #  include <config.h>
  27. #endif
  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 */
  36. #if defined (HAVE_UNISTD_H)
  37. #  include <unistd.h>
  38. #endif /* HAVE_UNISTD_H */
  40. #if defined (HAVE_STDLIB_H)
  41. #  include <stdlib.h>
  42. #else
  43. #  include "ansi_stdlib.h"
  44. #endif /* HAVE_STDLIB_H */
  46. #if defined (HAVE_LOCALE_H)
  47. #  include <locale.h>
  48. #endif
  50. #include <signal.h>
  51. #include <stdio.h>
  52. #include "posixjmp.h"
  54. /* System-specific feature definitions and include files. */
  55. #include "rldefs.h"
  57. #if defined (__EMX__)
  58. #  define INCL_DOSPROCESS
  59. #  include <os2.h>
  60. #endif /* __EMX__ */
  62. /* Some standard library routines. */
  63. #include "readline.h"
  64. #include "history.h"
  66. #ifndef RL_LIBRARY_VERSION
  67. #  define RL_LIBRARY_VERSION "4.0"
  68. #endif
  70. /* Evaluates its arguments multiple times. */
  71. #define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)
  73. /* NOTE: Functions and variables prefixed with `_rl_' are
  74.    pseudo-global: they are global so they can be shared
  75.    between files in the readline library, but are not intended
  76.    to be visible to readline callers. */
  78. /* Variables and functions imported from terminal.c */
  79. extern int _rl_init_terminal_io ();
  80. extern void _rl_enable_meta_key ();
  81. #ifdef _MINIX
  82. extern void _rl_output_character_function ();
  83. #else
  84. extern int _rl_output_character_function ();
  85. #endif
  87. extern int _rl_enable_meta;
  88. extern int _rl_term_autowrap;
  89. extern int screenwidth, screenheight, screenchars;
  91. /* Variables and functions imported from rltty.c. */
  92. extern void rl_prep_terminal (), rl_deprep_terminal ();
  93. extern void rltty_set_default_bindings ();
  95. /* Functions imported from util.c. */
  96. extern void _rl_abort_internal ();
  97. extern void rl_extend_line_buffer ();
  98. extern int alphabetic ();
  100. /* Functions imported from bind.c. */
  101. extern void _rl_bind_if_unbound ();
  103. /* Functions imported from input.c. */
  104. extern int _rl_any_typein ();
  105. extern void _rl_insert_typein ();
  106. extern int rl_read_key ();
  108. /* Functions imported from nls.c */
  109. extern int _rl_init_eightbit ();
  111. /* Functions imported from shell.c */
  112. extern char *get_env_value ();
  114. /* External redisplay functions and variables from display.c */
  115. extern void _rl_move_vert ();
  116. extern void _rl_update_final ();
  117. extern void _rl_clear_to_eol ();
  118. extern void _rl_clear_screen ();
  119. extern void _rl_erase_entire_line ();
  121. extern void _rl_erase_at_end_of_line ();
  122. extern void _rl_move_cursor_relative ();
  124. extern int _rl_vis_botlin;
  125. extern int _rl_last_c_pos;
  126. extern int _rl_horizontal_scroll_mode;
  127. extern int rl_display_fixed;
  128. extern int _rl_suppress_redisplay;
  129. extern char *rl_display_prompt;
  131. /* Variables imported from complete.c. */
  132. extern char *rl_completer_word_break_characters;
  133. extern char *rl_basic_word_break_characters;
  134. extern int rl_completion_query_items;
  135. extern int rl_complete_with_tilde_expansion;
  137. /* Variables and functions from macro.c. */
  138. extern void _rl_add_macro_char ();
  139. extern void _rl_with_macro_input ();
  140. extern int _rl_next_macro_key ();
  141. extern int _rl_defining_kbd_macro;
  143. #if defined (VI_MODE)
  144. /* Functions imported from vi_mode.c. */
  145. extern void _rl_vi_set_last ();
  146. extern void _rl_vi_reset_last ();
  147. extern void _rl_vi_done_inserting ();
  148. extern int _rl_vi_textmod_command ();
  149. extern void _rl_vi_initialize_line ();
  150. #endif /* VI_MODE */
  152. extern UNDO_LIST *rl_undo_list;
  153. extern int _rl_doing_an_undo;
  155. /* Forward declarations used in this file. */
  156. void _rl_free_history_entry ();
  158. int _rl_dispatch ();
  159. int _rl_init_argument ();
  161. static char *readline_internal ();
  162. static void readline_initialize_everything ();
  163. static void start_using_history ();
  164. static void bind_arrow_keys ();
  166. #if !defined (__GO32__)
  167. static void readline_default_bindings ();
  168. #endif /* !__GO32__ */
  170. #if defined (__GO32__)
  171. #  include <go32.h>
  172. #  include <pc.h>
  173. #  undef HANDLE_SIGNALS
  174. #endif /* __GO32__ */
  176. extern char *xmalloc (), *xrealloc ();
  178. /* **************************************************************** */
  179. /*     */
  180. /* Line editing input utility     */
  181. /*     */
  182. /* **************************************************************** */
  184. char *rl_library_version = RL_LIBRARY_VERSION;
  186. /* A pointer to the keymap that is currently in use.
  187.    By default, it is the standard emacs keymap. */
  188. Keymap _rl_keymap = emacs_standard_keymap;
  190. /* The current style of editing. */
  191. int rl_editing_mode = emacs_mode;
  193. /* Non-zero if we called this function from _rl_dispatch().  It's present
  194.    so functions can find out whether they were called from a key binding
  195.    or directly from an application. */
  196. int rl_dispatching;
  198. /* Non-zero if the previous command was a kill command. */
  199. int _rl_last_command_was_kill = 0;
  201. /* The current value of the numeric argument specified by the user. */
  202. int rl_numeric_arg = 1;
  204. /* Non-zero if an argument was typed. */
  205. int rl_explicit_arg = 0;
  207. /* Temporary value used while generating the argument. */
  208. int rl_arg_sign = 1;
  210. /* Non-zero means we have been called at least once before. */
  211. static int rl_initialized;
  213. /* If non-zero, this program is running in an EMACS buffer. */
  214. static int running_in_emacs;
  216. /* The current offset in the current input line. */
  217. int rl_point;
  219. /* Mark in the current input line. */
  220. int rl_mark;
  222. /* Length of the current input line. */
  223. int rl_end;
  225. /* Make this non-zero to return the current input_line. */
  226. int rl_done;
  228. /* The last function executed by readline. */
  229. Function *rl_last_func = (Function *)NULL;
  231. /* Top level environment for readline_internal (). */
  232. procenv_t readline_top_level;
  234. /* The streams we interact with. */
  235. FILE *_rl_in_stream, *_rl_out_stream;
  237. /* The names of the streams that we do input and output to. */
  238. FILE *rl_instream = (FILE *)NULL;
  239. FILE *rl_outstream = (FILE *)NULL;
  241. /* Non-zero means echo characters as they are read. */
  242. int readline_echoing_p = 1;
  244. /* Current prompt. */
  245. char *rl_prompt;
  246. int rl_visible_prompt_length = 0;
  248. /* The number of characters read in order to type this complete command. */
  249. int rl_key_sequence_length = 0;
  251. /* If non-zero, then this is the address of a function to call just
  252.    before readline_internal_setup () prints the first prompt. */
  253. Function *rl_startup_hook = (Function *)NULL;
  255. /* If non-zero, this is the address of a function to call just before
  256.    readline_internal_setup () returns and readline_internal starts
  257.    reading input characters. */
  258. Function *rl_pre_input_hook = (Function *)NULL;
  260. /* What we use internally.  You should always refer to RL_LINE_BUFFER. */
  261. static char *the_line;
  263. /* The character that can generate an EOF.  Really read from
  264.    the terminal driver... just defaulted here. */
  265. int _rl_eof_char = CTRL ('D');
  267. /* Non-zero makes this the next keystroke to read. */
  268. int rl_pending_input = 0;
  270. /* Pointer to a useful terminal name. */
  271. char *rl_terminal_name = (char *)NULL;
  273. /* Non-zero means to always use horizontal scrolling in line display. */
  274. int _rl_horizontal_scroll_mode = 0;
  276. /* Non-zero means to display an asterisk at the starts of history lines
  277.    which have been modified. */
  278. int _rl_mark_modified_lines = 0;  
  280. /* The style of `bell' notification preferred.  This can be set to NO_BELL,
  281.    AUDIBLE_BELL, or VISIBLE_BELL. */
  282. int _rl_bell_preference = AUDIBLE_BELL;
  283.      
  284. /* String inserted into the line by rl_insert_comment (). */
  285. char *_rl_comment_begin;
  287. /* Keymap holding the function currently being executed. */
  288. Keymap rl_executing_keymap;
  290. /* Non-zero means to erase entire line, including prompt, on empty input lines. */
  291. int rl_erase_empty_line = 0;
  293. /* Line buffer and maintenence. */
  294. char *rl_line_buffer = (char *)NULL;
  295. int rl_line_buffer_len = 0;
  297. /* Forward declarations used by the display and termcap code. */
  299. /* **************************************************************** */
  300. /*     */
  301. /* `Forward' declarations       */
  302. /*     */
  303. /* **************************************************************** */
  305. /* Non-zero means do not parse any lines other than comments and
  306.    parser directives. */
  307. unsigned char _rl_parsing_conditionalized_out = 0;
  309. /* Non-zero means to convert characters with the meta bit set to
  310.    escape-prefixed characters so we can indirect through
  311.    emacs_meta_keymap or vi_escape_keymap. */
  312. int _rl_convert_meta_chars_to_ascii = 1;
  314. /* Non-zero means to output characters with the meta bit set directly
  315.    rather than as a meta-prefixed escape sequence. */
  316. int _rl_output_meta_chars = 0;
  318. /* **************************************************************** */
  319. /*     */
  320. /* Top Level Functions     */
  321. /*     */
  322. /* **************************************************************** */
  324. /* Non-zero means treat 0200 bit in terminal input as Meta bit. */
  325. int _rl_meta_flag = 0; /* Forward declaration */
  327. /* Read a line of input.  Prompt with PROMPT.  An empty PROMPT means
  328.    none.  A return value of NULL means that EOF was encountered. */
  329. char *
  330. readline (prompt)
  331.      char *prompt;
  332. {
  333.   char *value;
  335.   rl_prompt = prompt;
  337.   /* If we are at EOF return a NULL string. */
  338.   if (rl_pending_input == EOF)
  339.     {
  340.       rl_pending_input = 0;
  341.       return ((char *)NULL);
  342.     }
  344.   rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
  346.   rl_initialize ();
  347.   (*rl_prep_term_function) (_rl_meta_flag);
  349. #if defined (HANDLE_SIGNALS)
  350.   rl_set_signals ();
  351. #endif
  353.   value = readline_internal ();
  354.   (*rl_deprep_term_function) ();
  356. #if defined (HANDLE_SIGNALS)
  357.   rl_clear_signals ();
  358. #endif
  360.   return (value);
  361. }
  363. #if defined (READLINE_CALLBACKS)
  364. #  define STATIC_CALLBACK
  365. #else
  366. #  define STATIC_CALLBACK static
  367. #endif
  369. STATIC_CALLBACK void
  370. readline_internal_setup ()
  371. {
  372.   _rl_in_stream = rl_instream;
  373.   _rl_out_stream = rl_outstream;
  375.   if (rl_startup_hook)
  376.     (*rl_startup_hook) ();
  378.   if (readline_echoing_p == 0)
  379.     {
  380.       if (rl_prompt)
  381. {
  382.   fprintf (_rl_out_stream, "%s", rl_prompt);
  383.   fflush (_rl_out_stream);
  384. }
  385.     }
  386.   else
  387.     {
  388.       rl_on_new_line ();
  389.       (*rl_redisplay_function) ();
  390. #if defined (VI_MODE)
  391.       if (rl_editing_mode == vi_mode)
  392. rl_vi_insertion_mode (1, 0);
  393. #endif /* VI_MODE */
  394.     }
  396.   if (rl_pre_input_hook)
  397.     (*rl_pre_input_hook) ();
  398. }
  400. STATIC_CALLBACK char *
  401. readline_internal_teardown (eof)
  402.      int eof;
  403. {
  404.   char *temp;
  405.   HIST_ENTRY *entry;
  407.   /* Restore the original of this history line, iff the line that we
  408.      are editing was originally in the history, AND the line has changed. */
  409.   entry = current_history ();
  411.   if (entry && rl_undo_list)
  412.     {
  413.       temp = savestring (the_line);
  414.       rl_revert_line (1, 0);
  415.       entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);
  416.       _rl_free_history_entry (entry);
  418.       strcpy (the_line, temp);
  419.       free (temp);
  420.     }
  422.   /* At any rate, it is highly likely that this line has an undo list.  Get
  423.      rid of it now. */
  424.   if (rl_undo_list)
  425.     free_undo_list ();
  427.   return (eof ? (char *)NULL : savestring (the_line));
  428. }
  430. STATIC_CALLBACK int
  431. #if defined (READLINE_CALLBACKS)
  432. readline_internal_char ()
  433. #else
  434. readline_internal_charloop ()
  435. #endif
  436. {
  437.   static int lastc, eof_found;
  438.   int c, code, lk;
  440.   lastc = -1;
  441.   eof_found = 0;
  443. #if !defined (READLINE_CALLBACKS)
  444.   while (rl_done == 0)
  445.     {
  446. #endif
  447.       lk = _rl_last_command_was_kill;
  449.       code = setjmp (readline_top_level);
  451.       if (code)
  452. (*rl_redisplay_function) ();
  454.       if (rl_pending_input == 0)
  455. {
  456.   /* Then initialize the argument and number of keys read. */
  457.   _rl_init_argument ();
  458.   rl_key_sequence_length = 0;
  459. }
  461.       c = rl_read_key ();
  463.       /* EOF typed to a non-blank line is a <NL>. */
  464.       if (c == EOF && rl_end)
  465. c = NEWLINE;
  467.       /* The character _rl_eof_char typed to blank line, and not as the
  468.  previous character is interpreted as EOF. */
  469.       if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
  470. {
  471. #if defined (READLINE_CALLBACKS)
  472.   return (rl_done = 1);
  473. #else
  474.   eof_found = 1;
  475.   break;
  476. #endif
  477. }
  479.       lastc = c;
  480.       _rl_dispatch (c, _rl_keymap);
  482.       /* If there was no change in _rl_last_command_was_kill, then no kill
  483.  has taken place.  Note that if input is pending we are reading
  484.  a prefix command, so nothing has changed yet. */
  485.       if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)
  486. _rl_last_command_was_kill = 0;
  488. #if defined (VI_MODE)
  489.       /* In vi mode, when you exit insert mode, the cursor moves back
  490.  over the previous character.  We explicitly check for that here. */
  491.       if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
  492. rl_vi_check ();
  493. #endif /* VI_MODE */
  495.       if (rl_done == 0)
  496. (*rl_redisplay_function) ();
  498.       /* If the application writer has told us to erase the entire line if
  499.   the only character typed was something bound to rl_newline, do so. */
  500.       if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&
  501.   rl_point == 0 && rl_end == 0)
  502. _rl_erase_entire_line ();
  504. #if defined (READLINE_CALLBACKS)
  505.       return 0;
  506. #else
  507.     }
  509.   return (eof_found);
  510. #endif
  511. }
  513. #if defined (READLINE_CALLBACKS)
  514. static int
  515. readline_internal_charloop ()
  516. {
  517.   int eof = 1;
  519.   while (rl_done == 0)
  520.     eof = readline_internal_char ();
  521.   return (eof);
  522. }
  523. #endif /* READLINE_CALLBACKS */
  525. /* Read a line of input from the global rl_instream, doing output on
  526.    the global rl_outstream.
  527.    If rl_prompt is non-null, then that is our prompt. */
  528. static char *
  529. readline_internal ()
  530. {
  531.   int eof;
  533.   readline_internal_setup ();
  534.   eof = readline_internal_charloop ();
  535.   return (readline_internal_teardown (eof));
  536. }
  538. void
  539. _rl_init_line_state ()
  540. {
  541.   rl_point = rl_end = 0;
  542.   the_line = rl_line_buffer;
  543.   the_line[0] = 0;
  544. }
  546. void
  547. _rl_set_the_line ()
  548. {
  549.   the_line = rl_line_buffer;
  550. }
  552. /* Do the command associated with KEY in MAP.
  553.    If the associated command is really a keymap, then read
  554.    another key, and dispatch into that map. */
  555. int
  556. _rl_dispatch (key, map)
  557.      register int key;
  558.      Keymap map;
  559. {
  560.   int r, newkey;
  561.   char *macro;
  562.   Function *func;
  564.   if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
  565.     {
  566.       if (map[ESC].type == ISKMAP)
  567. {
  568.   if (_rl_defining_kbd_macro)
  569.     _rl_add_macro_char (ESC);
  570.   map = FUNCTION_TO_KEYMAP (map, ESC);
  571.   key = UNMETA (key);
  572.   rl_key_sequence_length += 2;
  573.   return (_rl_dispatch (key, map));
  574. }
  575.       else
  576. ding ();
  577.       return 0;
  578.     }
  580.   if (_rl_defining_kbd_macro)
  581.     _rl_add_macro_char (key);
  583.   r = 0;
  584.   switch (map[key].type)
  585.     {
  586.     case ISFUNC:
  587.       func = map[key].function;
  588.       if (func != (Function *)NULL)
  589. {
  590.   /* Special case rl_do_lowercase_version (). */
  591.   if (func == rl_do_lowercase_version)
  592.     return (_rl_dispatch (_rl_to_lower (key), map));
  594.   rl_executing_keymap = map;
  596. #if 0
  597.   _rl_suppress_redisplay = (map[key].function == rl_insert) && _rl_input_available ();
  598. #endif
  600.   rl_dispatching = 1;
  601.   r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
  602.   rl_dispatching = 0;
  604.   /* If we have input pending, then the last command was a prefix
  605.      command.  Don't change the state of rl_last_func.  Otherwise,
  606.      remember the last command executed in this variable. */
  607.   if (!rl_pending_input && map[key].function != rl_digit_argument)
  608.     rl_last_func = map[key].function;
  609. }
  610.       else
  611. {
  612.   _rl_abort_internal ();
  613.   return -1;
  614. }
  615.       break;
  617.     case ISKMAP:
  618.       if (map[key].function != (Function *)NULL)
  619. {
  620.   rl_key_sequence_length++;
  621.   newkey = rl_read_key ();
  622.   r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));
  623. }
  624.       else
  625. {
  626.   _rl_abort_internal ();
  627.   return -1;
  628. }
  629.       break;
  631.     case ISMACR:
  632.       if (map[key].function != (Function *)NULL)
  633. {
  634.   macro = savestring ((char *)map[key].function);
  635.   _rl_with_macro_input (macro);
  636.   return 0;
  637. }
  638.       break;
  639.     }
  640. #if defined (VI_MODE)
  641.   if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
  642.       _rl_vi_textmod_command (key))
  643.     _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
  644. #endif
  645.   return (r);
  646. }
  648. /* **************************************************************** */
  649. /*     */
  650. /* Initializations      */
  651. /*     */
  652. /* **************************************************************** */
  654. /* Initialize readline (and terminal if not already). */
  655. int
  656. rl_initialize ()
  657. {
  658.   /* If we have never been called before, initialize the
  659.      terminal and data structures. */
  660.   if (!rl_initialized)
  661.     {
  662.       readline_initialize_everything ();
  663.       rl_initialized++;
  664.     }
  666.   /* Initalize the current line information. */
  667.   _rl_init_line_state ();
  669.   /* We aren't done yet.  We haven't even gotten started yet! */
  670.   rl_done = 0;
  672.   /* Tell the history routines what is going on. */
  673.   start_using_history ();
  675.   /* Make the display buffer match the state of the line. */
  676.   rl_reset_line_state ();
  678.   /* No such function typed yet. */
  679.   rl_last_func = (Function *)NULL;
  681.   /* Parsing of key-bindings begins in an enabled state. */
  682.   _rl_parsing_conditionalized_out = 0;
  684. #if defined (VI_MODE)
  685.   if (rl_editing_mode == vi_mode)
  686.     _rl_vi_initialize_line ();
  687. #endif
  689.   return 0;
  690. }
  692. #if defined (__EMX__)
  693. static void
  694. _emx_build_environ ()
  695. {
  696.   TIB *tibp;
  697.   PIB *pibp;
  698.   char *t, **tp;
  699.   int c;
  701.   DosGetInfoBlocks (&tibp, &pibp);
  702.   t = pibp->pib_pchenv;
  703.   for (c = 1; *t; c++)
  704.     t += strlen (t) + 1;
  705.   tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));
  706.   t = pibp->pib_pchenv;
  707.   while (*t)
  708.     {
  709.       *tp++ = t;
  710.       t += strlen (t) + 1;
  711.     }
  712.   *tp = 0;
  713. }
  714. #endif /* __EMX__ */
  716. /* Initialize the entire state of the world. */
  717. static void
  718. readline_initialize_everything ()
  719. {
  720. #if defined (__EMX__)
  721.   if (environ == 0)
  722.     _emx_build_environ ();
  723. #endif
  725.   /* Find out if we are running in Emacs. */
  726.   running_in_emacs = get_env_value ("EMACS") != (char *)0;
  728.   /* Set up input and output if they are not already set up. */
  729.   if (!rl_instream)
  730.     rl_instream = stdin;
  732.   if (!rl_outstream)
  733.     rl_outstream = stdout;
  735.   /* Bind _rl_in_stream and _rl_out_stream immediately.  These values
  736.      may change, but they may also be used before readline_internal ()
  737.      is called. */
  738.   _rl_in_stream = rl_instream;
  739.   _rl_out_stream = rl_outstream;
  741.   /* Allocate data structures. */
  742.   if (rl_line_buffer == 0)
  743.     rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
  745.   /* Initialize the terminal interface. */
  746.   _rl_init_terminal_io ((char *)NULL);
  748. #if !defined (__GO32__)
  749.   /* Bind tty characters to readline functions. */
  750.   readline_default_bindings ();
  751. #endif /* !__GO32__ */
  753.   /* Initialize the function names. */
  754.   rl_initialize_funmap ();
  756.   /* Decide whether we should automatically go into eight-bit mode. */
  757.   _rl_init_eightbit ();
  758.       
  759.   /* Read in the init file. */
  760.   rl_read_init_file ((char *)NULL);
  762.   /* XXX */
  763.   if (_rl_horizontal_scroll_mode && _rl_term_autowrap)
  764.     {
  765.       screenwidth--;
  766.       screenchars -= screenheight;
  767.     }
  769.   /* Override the effect of any `set keymap' assignments in the
  770.      inputrc file. */
  771.   rl_set_keymap_from_edit_mode ();
  773.   /* Try to bind a common arrow key prefix, if not already bound. */
  774.   bind_arrow_keys ();
  776.   /* Enable the meta key, if this terminal has one. */
  777.   if (_rl_enable_meta)
  778.     _rl_enable_meta_key ();
  780.   /* If the completion parser's default word break characters haven't
  781.      been set yet, then do so now. */
  782.   if (rl_completer_word_break_characters == (char *)NULL)
  783.     rl_completer_word_break_characters = rl_basic_word_break_characters;
  784. }
  786. /* If this system allows us to look at the values of the regular
  787.    input editing characters, then bind them to their readline
  788.    equivalents, iff the characters are not bound to keymaps. */
  789. static void
  790. readline_default_bindings ()
  791. {
  792.   rltty_set_default_bindings (_rl_keymap);
  793. }
  795. static void
  796. bind_arrow_keys_internal ()
  797. {
  798.   Function *f;
  800.   f = rl_function_of_keyseq ("33[A", _rl_keymap, (int *)NULL);
  801.   if (!f || f == rl_do_lowercase_version)
  802.     {
  803.       _rl_bind_if_unbound ("33[A", rl_get_previous_history);
  804.       _rl_bind_if_unbound ("33[B", rl_get_next_history);
  805.       _rl_bind_if_unbound ("33[C", rl_forward);
  806.       _rl_bind_if_unbound ("33[D", rl_backward);
  807.     }
  809.   f = rl_function_of_keyseq ("33OA", _rl_keymap, (int *)NULL);
  810.   if (!f || f == rl_do_lowercase_version)
  811.     {
  812.       _rl_bind_if_unbound ("33OA", rl_get_previous_history);
  813.       _rl_bind_if_unbound ("33OB", rl_get_next_history);
  814.       _rl_bind_if_unbound ("33OC", rl_forward);
  815.       _rl_bind_if_unbound ("33OD", rl_backward);
  816.     }
  817. }
  819. /* Try and bind the common arrow key prefix after giving termcap and
  820.    the inputrc file a chance to bind them and create `real' keymaps
  821.    for the arrow key prefix. */
  822. static void
  823. bind_arrow_keys ()
  824. {
  825.   Keymap xkeymap;
  827.   xkeymap = _rl_keymap;
  829.   _rl_keymap = emacs_standard_keymap;
  830.   bind_arrow_keys_internal ();
  832. #if defined (VI_MODE)
  833.   _rl_keymap = vi_movement_keymap;
  834.   bind_arrow_keys_internal ();
  835. #endif
  837.   _rl_keymap = xkeymap;
  838. }
  841. /* **************************************************************** */
  842. /*     */
  843. /* Numeric Arguments     */
  844. /*     */
  845. /* **************************************************************** */
  847. /* Handle C-u style numeric args, as well as M--, and M-digits. */
  848. static int
  849. rl_digit_loop ()
  850. {
  851.   int key, c, sawminus, sawdigits;
  853.   rl_save_prompt ();
  855.   sawminus = sawdigits = 0;
  856.   while (1)
  857.     {
  858.       if (rl_numeric_arg > 1000000)
  859. {
  860.   sawdigits = rl_explicit_arg = rl_numeric_arg = 0;
  861.   ding ();
  862.   rl_restore_prompt ();
  863.   rl_clear_message ();
  864.   return 1;
  865. }
  866.       rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
  867.       key = c = rl_read_key ();
  869.       /* If we see a key bound to `universal-argument' after seeing digits,
  870.  it ends the argument but is otherwise ignored. */
  871.       if (_rl_keymap[c].type == ISFUNC &&
  872.   _rl_keymap[c].function == rl_universal_argument)
  873. {
  874.   if (sawdigits == 0)
  875.     {
  876.       rl_numeric_arg *= 4;
  877.       continue;
  878.     }
  879.   else
  880.     {
  881.       key = rl_read_key ();
  882.       rl_restore_prompt ();
  883.       rl_clear_message ();
  884.       return (_rl_dispatch (key, _rl_keymap));
  885.     }
  886. }
  888.       c = UNMETA (c);
  890.       if (_rl_digit_p (c))
  891. {
  892.   rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + c - '0' : c - '0';
  893.   sawdigits = rl_explicit_arg = 1;
  894. }
  895.       else if (c == '-' && rl_explicit_arg == 0)
  896. {
  897.   rl_numeric_arg = sawminus = 1;
  898.   rl_arg_sign = -1;
  899. }
  900.       else
  901. {
  902.   /* Make M-- command equivalent to M--1 command. */
  903.   if (sawminus && rl_numeric_arg == 1 && rl_explicit_arg == 0)
  904.     rl_explicit_arg = 1;
  905.   rl_restore_prompt ();
  906.   rl_clear_message ();
  907.   return (_rl_dispatch (key, _rl_keymap));
  908. }
  909.     }
  911.   return 0;
  912. }
  914. /* Add the current digit to the argument in progress. */
  915. int
  916. rl_digit_argument (ignore, key)
  917.      int ignore, key;
  918. {
  919.   rl_pending_input = key;
  920.   return (rl_digit_loop ());
  921. }
  923. /* What to do when you abort reading an argument. */
  924. int
  925. rl_discard_argument ()
  926. {
  927.   ding ();
  928.   rl_clear_message ();
  929.   _rl_init_argument ();
  930.   return 0;
  931. }
  933. /* Create a default argument. */
  934. int
  935. _rl_init_argument ()
  936. {
  937.   rl_numeric_arg = rl_arg_sign = 1;
  938.   rl_explicit_arg = 0;
  939.   return 0;
  940. }
  942. /* C-u, universal argument.  Multiply the current argument by 4.
  943.    Read a key.  If the key has nothing to do with arguments, then
  944.    dispatch on it.  If the key is the abort character then abort. */
  945. int
  946. rl_universal_argument (count, key)
  947.      int count, key;
  948. {
  949.   rl_numeric_arg *= 4;
  950.   return (rl_digit_loop ());
  951. }
  953. /* **************************************************************** */
  954. /*     */
  955. /* Insert and Delete     */
  956. /*     */
  957. /* **************************************************************** */
  959. /* Insert a string of text into the line at point.  This is the only
  960.    way that you should do insertion.  rl_insert () calls this
  961.    function. */
  962. int
  963. rl_insert_text (string)
  964.      char *string;
  965. {
  966.   register int i, l = strlen (string);
  968.   if (rl_end + l >= rl_line_buffer_len)
  969.     rl_extend_line_buffer (rl_end + l);
  971.   for (i = rl_end; i >= rl_point; i--)
  972.     the_line[i + l] = the_line[i];
  973.   strncpy (the_line + rl_point, string, l);
  975.   /* Remember how to undo this if we aren't undoing something. */
  976.   if (!_rl_doing_an_undo)
  977.     {
  978.       /* If possible and desirable, concatenate the undos. */
  979.       if ((l == 1) &&
  980.   rl_undo_list &&
  981.   (rl_undo_list->what == UNDO_INSERT) &&
  982.   (rl_undo_list->end == rl_point) &&
  983.   (rl_undo_list->end - rl_undo_list->start < 20))
  984. rl_undo_list->end++;
  985.       else
  986. rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
  987.     }
  988.   rl_point += l;
  989.   rl_end += l;
  990.   the_line[rl_end] = '';
  991.   return l;
  992. }
  994. /* Delete the string between FROM and TO.  FROM is
  995.    inclusive, TO is not. */
  996. int
  997. rl_delete_text (from, to)
  998.      int from, to;
  999. {
  1000.   register char *text;
  1001.   register int diff, i;
  1003.   /* Fix it if the caller is confused. */
  1004.   if (from > to)
  1005.     SWAP (from, to);
  1007.   /* fix boundaries */
  1008.   if (to > rl_end)
  1009.     {
  1010.       to = rl_end;
  1011.       if (from > to)
  1012.         from = to;
  1013.     }
  1015.   text = rl_copy_text (from, to);
  1017.   /* Some versions of strncpy() can't handle overlapping arguments. */
  1018.   diff = to - from;
  1019.   for (i = from; i < rl_end - diff; i++)
  1020.     the_line[i] = the_line[i + diff];
  1022.   /* Remember how to undo this delete. */
  1023.   if (_rl_doing_an_undo == 0)
  1024.     rl_add_undo (UNDO_DELETE, from, to, text);
  1025.   else
  1026.     free (text);
  1028.   rl_end -= diff;
  1029.   the_line[rl_end] = '';
  1030.   return (diff);
  1031. }
  1033. /* Fix up point so that it is within the line boundaries after killing
  1034.    text.  If FIX_MARK_TOO is non-zero, the mark is forced within line
  1035.    boundaries also. */
  1037. #define _RL_FIX_POINT(x) 
  1038. do { 
  1039. if (x > rl_end) 
  1040.   x = rl_end; 
  1041. else if (x < 0) 
  1042.   x = 0; 
  1043. } while (0)
  1045. void
  1046. _rl_fix_point (fix_mark_too)
  1047.      int fix_mark_too;
  1048. {
  1049.   _RL_FIX_POINT (rl_point);
  1050.   if (fix_mark_too)
  1051.     _RL_FIX_POINT (rl_mark);
  1052. }
  1053. #undef _RL_FIX_POINT
  1055. void
  1056. _rl_replace_text (text, start, end)
  1057.      char *text;
  1058.      int start, end;
  1059. {
  1060.   rl_begin_undo_group ();
  1061.   rl_delete_text (start, end + 1);
  1062.   rl_point = start;
  1063.   rl_insert_text (text);
  1064.   rl_end_undo_group ();
  1065. }
  1067. /* **************************************************************** */
  1068. /*     */
  1069. /* Readline character functions     */
  1070. /*     */
  1071. /* **************************************************************** */
  1073. /* This is not a gap editor, just a stupid line input routine.  No hair
  1074.    is involved in writing any of the functions, and none should be. */
  1076. /* Note that:
  1078.    rl_end is the place in the string that we would place '';
  1079.    i.e., it is always safe to place '' there.
  1081.    rl_point is the place in the string where the cursor is.  Sometimes
  1082.    this is the same as rl_end.
  1084.    Any command that is called interactively receives two arguments.
  1085.    The first is a count: the numeric arg pased to this command.
  1086.    The second is the key which invoked this command.
  1087. */
  1089. /* **************************************************************** */
  1090. /*     */
  1091. /* Movement Commands     */
  1092. /*     */
  1093. /* **************************************************************** */
  1095. /* Note that if you `optimize' the display for these functions, you cannot
  1096.    use said functions in other functions which do not do optimizing display.
  1097.    I.e., you will have to update the data base for rl_redisplay, and you
  1098.    might as well let rl_redisplay do that job. */
  1100. /* Move forward COUNT characters. */
  1101. int
  1102. rl_forward (count, key)
  1103.      int count, key;
  1104. {
  1105.   if (count < 0)
  1106.     rl_backward (-count, key);
  1107.   else if (count > 0)
  1108.     {
  1109.       int end = rl_point + count;
  1110. #if defined (VI_MODE)
  1111.       int lend = rl_end - (rl_editing_mode == vi_mode);
  1112. #else
  1113.       int lend = rl_end;
  1114. #endif
  1116.       if (end > lend)
  1117. {
  1118.   rl_point = lend;
  1119.   ding ();
  1120. }
  1121.       else
  1122. rl_point = end;
  1123.     }
  1124.   return 0;
  1125. }
  1127. /* Move backward COUNT characters. */
  1128. int
  1129. rl_backward (count, key)
  1130.      int count, key;
  1131. {
  1132.   if (count < 0)
  1133.     rl_forward (-count, key);
  1134.   else if (count > 0)
  1135.     {
  1136.       if (rl_point < count)
  1137. {
  1138.   rl_point = 0;
  1139.   ding ();
  1140. }
  1141.       else
  1142.         rl_point -= count;
  1143.     }
  1144.   return 0;
  1145. }
  1147. /* Move to the beginning of the line. */
  1148. int
  1149. rl_beg_of_line (count, key)
  1150.      int count, key;
  1151. {
  1152.   rl_point = 0;
  1153.   return 0;
  1154. }
  1156. /* Move to the end of the line. */
  1157. int
  1158. rl_end_of_line (count, key)
  1159.      int count, key;
  1160. {
  1161.   rl_point = rl_end;
  1162.   return 0;
  1163. }
  1165. /* Move forward a word.  We do what Emacs does. */
  1166. int
  1167. rl_forward_word (count, key)
  1168.      int count, key;
  1169. {
  1170.   int c;
  1172.   if (count < 0)
  1173.     {
  1174.       rl_backward_word (-count, key);
  1175.       return 0;
  1176.     }
  1178.   while (count)
  1179.     {
  1180.       if (rl_point == rl_end)
  1181. return 0;
  1183.       /* If we are not in a word, move forward until we are in one.
  1184.  Then, move forward until we hit a non-alphabetic character. */
  1185.       c = the_line[rl_point];
  1186.       if (alphabetic (c) == 0)
  1187. {
  1188.   while (++rl_point < rl_end)
  1189.     {
  1190.       c = the_line[rl_point];
  1191.       if (alphabetic (c))
  1192. break;
  1193.     }
  1194. }
  1195.       if (rl_point == rl_end)
  1196. return 0;
  1197.       while (++rl_point < rl_end)
  1198. {
  1199.   c = the_line[rl_point];
  1200.   if (alphabetic (c) == 0)
  1201.     break;
  1202. }
  1203.       --count;
  1204.     }
  1205.   return 0;
  1206. }
  1208. /* Move backward a word.  We do what Emacs does. */
  1209. int
  1210. rl_backward_word (count, key)
  1211.      int count, key;
  1212. {
  1213.   int c;
  1215.   if (count < 0)
  1216.     {
  1217.       rl_forward_word (-count, key);
  1218.       return 0;
  1219.     }
  1221.   while (count)
  1222.     {
  1223.       if (!rl_point)
  1224. return 0;
  1226.       /* Like rl_forward_word (), except that we look at the characters
  1227.  just before point. */
  1229.       c = the_line[rl_point - 1];
  1230.       if (alphabetic (c) == 0)
  1231. {
  1232.   while (--rl_point)
  1233.     {
  1234.       c = the_line[rl_point - 1];
  1235.       if (alphabetic (c))
  1236. break;
  1237.     }
  1238. }
  1240.       while (rl_point)
  1241. {
  1242.   c = the_line[rl_point - 1];
  1243.   if (alphabetic (c) == 0)
  1244.     break;
  1245.   else
  1246.     --rl_point;
  1247. }
  1248.       --count;
  1249.     }
  1250.   return 0;
  1251. }
  1253. /* Clear the current line.  Numeric argument to C-l does this. */
  1254. int
  1255. rl_refresh_line (ignore1, ignore2)
  1256.      int ignore1, ignore2;
  1257. {
  1258.   int curr_line, nleft;
  1260.   /* Find out whether or not there might be invisible characters in the
  1261.      editing buffer. */
  1262.   if (rl_display_prompt == rl_prompt)
  1263.     nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length;
  1264.   else
  1265.     nleft = _rl_last_c_pos - screenwidth;
  1267.   if (nleft > 0)
  1268.     curr_line = 1 + nleft / screenwidth;
  1269.   else
  1270.     curr_line = 0;
  1272.   _rl_move_vert (curr_line);
  1273.   _rl_move_cursor_relative (0, the_line);   /* XXX is this right */
  1275. #if defined (__GO32__)
  1276.   {
  1277.     int row, col, width, row_start;
  1279.     ScreenGetCursor (&row, &col);
  1280.     width = ScreenCols ();
  1281.     row_start = ScreenPrimary + (row * width);
  1282.     memset (row_start + col, 0, (width - col) * 2);
  1283.   }
  1284. #else /* !__GO32__ */
  1285.   _rl_clear_to_eol (0); /* arg of 0 means to not use spaces */
  1286. #endif /* !__GO32__ */
  1288.   rl_forced_update_display ();
  1289.   rl_display_fixed = 1;
  1291.   return 0;
  1292. }
  1294. /* C-l typed to a line without quoting clears the screen, and then reprints
  1295.    the prompt and the current input line.  Given a numeric arg, redraw only
  1296.    the current line. */
  1297. int
  1298. rl_clear_screen (count, key)
  1299.      int count, key;
  1300. {
  1301.   if (rl_explicit_arg)
  1302.     {
  1303.       rl_refresh_line (count, key);
  1304.       return 0;
  1305.     }
  1307.   _rl_clear_screen (); /* calls termcap function to clear screen */
  1308.   rl_forced_update_display ();
  1309.   rl_display_fixed = 1;
  1311.   return 0;
  1312. }
  1314. int
  1315. rl_arrow_keys (count, c)
  1316.      int count, c;
  1317. {
  1318.   int ch;
  1320.   ch = rl_read_key ();
  1322.   switch (_rl_to_upper (ch))
  1323.     {
  1324.     case 'A':
  1325.       rl_get_previous_history (count, ch);
  1326.       break;
  1328.     case 'B':
  1329.       rl_get_next_history (count, ch);
  1330.       break;
  1332.     case 'C':
  1333.       rl_forward (count, ch);
  1334.       break;
  1336.     case 'D':
  1337.       rl_backward (count, ch);
  1338.       break;
  1340.     default:
  1341.       ding ();
  1342.     }
  1343.   return 0;
  1344. }
  1347. /* **************************************************************** */
  1348. /*     */
  1349. /* Text commands     */
  1350. /*     */
  1351. /* **************************************************************** */
  1353. /* Insert the character C at the current location, moving point forward. */
  1354. int
  1355. rl_insert (count, c)
  1356.      int count, c;
  1357. {
  1358.   register int i;
  1359.   char *string;
  1361.   if (count <= 0)
  1362.     return 0;
  1364.   /* If we can optimize, then do it.  But don't let people crash
  1365.      readline because of extra large arguments. */
  1366.   if (count > 1 && count <= 1024)
  1367.     {
  1368.       string = xmalloc (1 + count);
  1370.       for (i = 0; i < count; i++)
  1371. string[i] = c;
  1373.       string[i] = '';
  1374.       rl_insert_text (string);
  1375.       free (string);
  1377.       return 0;
  1378.     }
  1380.   if (count > 1024)
  1381.     {
  1382.       int decreaser;
  1383.       char str[1024+1];
  1385.       for (i = 0; i < 1024; i++)
  1386. str[i] = c;
  1388.       while (count)
  1389. {
  1390.   decreaser = (count > 1024 ? 1024 : count);
  1391.   str[decreaser] = '';
  1392.   rl_insert_text (str);
  1393.   count -= decreaser;
  1394. }
  1396.       return 0;
  1397.     }
  1399.   /* We are inserting a single character.
  1400.      If there is pending input, then make a string of all of the
  1401.      pending characters that are bound to rl_insert, and insert
  1402.      them all. */
  1403.   if (_rl_any_typein ())
  1404.     _rl_insert_typein (c);
  1405.   else
  1406.     {
  1407.       /* Inserting a single character. */
  1408.       char str[2];
  1410.       str[1] = '';
  1411.       str[0] = c;
  1412.       rl_insert_text (str);
  1413.     }
  1414.   return 0;
  1415. }
  1417. /* Insert the next typed character verbatim. */
  1418. int
  1419. rl_quoted_insert (count, key)
  1420.      int count, key;
  1421. {
  1422.   int c;
  1424.   c = rl_read_key ();
  1425.   return (rl_insert (count, c));  
  1426. }
  1428. /* Insert a tab character. */
  1429. int
  1430. rl_tab_insert (count, key)
  1431.      int count, key;
  1432. {
  1433.   return (rl_insert (count, 't'));
  1434. }
  1436. /* What to do when a NEWLINE is pressed.  We accept the whole line.
  1437.    KEY is the key that invoked this command.  I guess it could have
  1438.    meaning in the future. */
  1439. int
  1440. rl_newline (count, key)
  1441.      int count, key;
  1442. {
  1443.   rl_done = 1;
  1445. #if defined (VI_MODE)
  1446.   if (rl_editing_mode == vi_mode)
  1447.     {
  1448.       _rl_vi_done_inserting ();
  1449.       _rl_vi_reset_last ();
  1450.     }
  1451. #endif /* VI_MODE */
  1453.   /* If we've been asked to erase empty lines, suppress the final update,
  1454.      since _rl_update_final calls crlf(). */
  1455.   if (rl_erase_empty_line && rl_point == 0 && rl_end == 0)
  1456.     return 0;
  1458.   if (readline_echoing_p)
  1459.     _rl_update_final ();
  1460.   return 0;
  1461. }
  1463. /* What to do for some uppercase characters, like meta characters,
  1464.    and some characters appearing in emacs_ctlx_keymap.  This function
  1465.    is just a stub, you bind keys to it and the code in _rl_dispatch ()
  1466.    is special cased. */
  1467. int
  1468. rl_do_lowercase_version (ignore1, ignore2)
  1469.      int ignore1, ignore2;
  1470. {
  1471.   return 0;
  1472. }
  1474. /* Rubout the character behind point. */
  1475. int
  1476. rl_rubout (count, key)
  1477.      int count, key;
  1478. {
  1479.   if (count < 0)
  1480.     {
  1481.       rl_delete (-count, key);
  1482.       return 0;
  1483.     }
  1485.   if (!rl_point)
  1486.     {
  1487.       ding ();
  1488.       return -1;
  1489.     }
  1491.   if (count > 1 || rl_explicit_arg)
  1492.     {
  1493.       int orig_point = rl_point;
  1494.       rl_backward (count, key);
  1495.       rl_kill_text (orig_point, rl_point);
  1496.     }
  1497.   else
  1498.     {
  1499.       int c = the_line[--rl_point];
  1500.       rl_delete_text (rl_point, rl_point + 1);
  1502.       if (rl_point == rl_end && isprint (c) && _rl_last_c_pos)
  1503. {
  1504.   int l;
  1505.   l = rl_character_len (c, rl_point);
  1506.   _rl_erase_at_end_of_line (l);
  1507. }
  1508.     }
  1509.   return 0;
  1510. }
  1512. /* Delete the character under the cursor.  Given a numeric argument,
  1513.    kill that many characters instead. */
  1514. int
  1515. rl_delete (count, key)
  1516.      int count, key;
  1517. {
  1518.   if (count < 0)
  1519.     return (rl_rubout (-count, key));
  1521.   if (rl_point == rl_end)
  1522.     {
  1523.       ding ();
  1524.       return -1;
  1525.     }
  1527.   if (count > 1 || rl_explicit_arg)
  1528.     {
  1529.       int orig_point = rl_point;
  1530.       rl_forward (count, key);
  1531.       rl_kill_text (orig_point, rl_point);
  1532.       rl_point = orig_point;
  1533.       return 0;
  1534.     }
  1535.   else
  1536.     return (rl_delete_text (rl_point, rl_point + 1));
  1537. }
  1539. /* Delete the character under the cursor, unless the insertion
  1540.    point is at the end of the line, in which case the character
  1541.    behind the cursor is deleted.  COUNT is obeyed and may be used
  1542.    to delete forward or backward that many characters. */      
  1543. int
  1544. rl_rubout_or_delete (count, key)
  1545.      int count, key;
  1546. {
  1547.   if (rl_end != 0 && rl_point == rl_end)
  1548.     return (rl_rubout (count, key));
  1549.   else
  1550.     return (rl_delete (count, key));
  1551. }  
  1553. /* Delete all spaces and tabs around point. */
  1554. int
  1555. rl_delete_horizontal_space (count, ignore)
  1556.      int count, ignore;
  1557. {
  1558.   int start = rl_point;
  1560.   while (rl_point && whitespace (the_line[rl_point - 1]))
  1561.     rl_point--;
  1563.   start = rl_point;
  1565.   while (rl_point < rl_end && whitespace (the_line[rl_point]))
  1566.     rl_point++;
  1568.   if (start != rl_point)
  1569.     {
  1570.       rl_delete_text (start, rl_point);
  1571.       rl_point = start;
  1572.     }
  1573.   return 0;
  1574. }
  1576. /* Like the tcsh editing function delete-char-or-list.  The eof character
  1577.    is caught before this is invoked, so this really does the same thing as
  1578.    delete-char-or-list-or-eof, as long as it's bound to the eof character. */
  1579. int
  1580. rl_delete_or_show_completions (count, key)
  1581.      int count, key;
  1582. {
  1583.   if (rl_end != 0 && rl_point == rl_end)
  1584.     return (rl_possible_completions (count, key));
  1585.   else
  1586.     return (rl_delete (count, key));
  1587. }
  1589. #ifndef RL_COMMENT_BEGIN_DEFAULT
  1590. #define RL_COMMENT_BEGIN_DEFAULT "#"
  1591. #endif
  1593. /* Turn the current line into a comment in shell history.
  1594.    A K*rn shell style function. */
  1595. int
  1596. rl_insert_comment (count, key)
  1597.      int count, key;
  1598. {
  1599.   rl_beg_of_line (1, key);
  1600.   rl_insert_text (_rl_comment_begin ? _rl_comment_begin
  1601.     : RL_COMMENT_BEGIN_DEFAULT);
  1602.   (*rl_redisplay_function) ();
  1603.   rl_newline (1, 'n');
  1604.   return (0);
  1605. }
  1607. /* **************************************************************** */
  1608. /*     */
  1609. /* Changing Case     */
  1610. /*     */
  1611. /* **************************************************************** */
  1613. /* The three kinds of things that we know how to do. */
  1614. #define UpCase 1
  1615. #define DownCase 2
  1616. #define CapCase 3
  1618. static int rl_change_case ();
  1620. /* Uppercase the word at point. */
  1621. int
  1622. rl_upcase_word (count, key)
  1623.      int count, key;
  1624. {
  1625.   return (rl_change_case (count, UpCase));
  1626. }
  1628. /* Lowercase the word at point. */
  1629. int
  1630. rl_downcase_word (count, key)
  1631.      int count, key;
  1632. {
  1633.   return (rl_change_case (count, DownCase));
  1634. }
  1636. /* Upcase the first letter, downcase the rest. */
  1637. int
  1638. rl_capitalize_word (count, key)
  1639.      int count, key;
  1640. {
  1641.  return (rl_change_case (count, CapCase));
  1642. }
  1644. /* The meaty function.
  1645.    Change the case of COUNT words, performing OP on them.
  1646.    OP is one of UpCase, DownCase, or CapCase.
  1647.    If a negative argument is given, leave point where it started,
  1648.    otherwise, leave it where it moves to. */
  1649. static int
  1650. rl_change_case (count, op)
  1651.      int count, op;
  1652. {
  1653.   register int start, end;
  1654.   int inword, c;
  1656.   start = rl_point;
  1657.   rl_forward_word (count, 0);
  1658.   end = rl_point;
  1660.   if (count < 0)
  1661.     SWAP (start, end);
  1663.   /* We are going to modify some text, so let's prepare to undo it. */
  1664.   rl_modifying (start, end);
  1666.   for (inword = 0; start < end; start++)
  1667.     {
  1668.       c = the_line[start];
  1669.       switch (op)
  1670. {
  1671. case UpCase:
  1672.   the_line[start] = _rl_to_upper (c);
  1673.   break;
  1675. case DownCase:
  1676.   the_line[start] = _rl_to_lower (c);
  1677.   break;
  1679. case CapCase:
  1680.   the_line[start] = (inword == 0) ? _rl_to_upper (c) : _rl_to_lower (c);
  1681.   inword = alphabetic (the_line[start]);
  1682.   break;
  1684. default:
  1685.   ding ();
  1686.   return -1;
  1687. }
  1688.     }
  1689.   rl_point = end;
  1690.   return 0;
  1691. }
  1693. /* **************************************************************** */
  1694. /*     */
  1695. /* Transposition     */
  1696. /*     */
  1697. /* **************************************************************** */
  1699. /* Transpose the words at point. */
  1700. int
  1701. rl_transpose_words (count, key)
  1702.      int count, key;
  1703. {
  1704.   char *word1, *word2;
  1705.   int w1_beg, w1_end, w2_beg, w2_end;
  1706.   int orig_point = rl_point;
  1708.   if (!count)
  1709.     return 0;
  1711.   /* Find the two words. */
  1712.   rl_forward_word (count, key);
  1713.   w2_end = rl_point;
  1714.   rl_backward_word (1, key);
  1715.   w2_beg = rl_point;
  1716.   rl_backward_word (count, key);
  1717.   w1_beg = rl_point;
  1718.   rl_forward_word (1, key);
  1719.   w1_end = rl_point;
  1721.   /* Do some check to make sure that there really are two words. */
  1722.   if ((w1_beg == w2_beg) || (w2_beg < w1_end))
  1723.     {
  1724.       ding ();
  1725.       rl_point = orig_point;
  1726.       return -1;
  1727.     }
  1729.   /* Get the text of the words. */
  1730.   word1 = rl_copy_text (w1_beg, w1_end);
  1731.   word2 = rl_copy_text (w2_beg, w2_end);
  1733.   /* We are about to do many insertions and deletions.  Remember them
  1734.      as one operation. */
  1735.   rl_begin_undo_group ();
  1737.   /* Do the stuff at word2 first, so that we don't have to worry
  1738.      about word1 moving. */
  1739.   rl_point = w2_beg;
  1740.   rl_delete_text (w2_beg, w2_end);
  1741.   rl_insert_text (word1);
  1743.   rl_point = w1_beg;
  1744.   rl_delete_text (w1_beg, w1_end);
  1745.   rl_insert_text (word2);
  1747.   /* This is exactly correct since the text before this point has not
  1748.      changed in length. */
  1749.   rl_point = w2_end;
  1751.   /* I think that does it. */
  1752.   rl_end_undo_group ();
  1753.   free (word1);
  1754.   free (word2);
  1756.   return 0;
  1757. }
  1759. /* Transpose the characters at point.  If point is at the end of the line,
  1760.    then transpose the characters before point. */
  1761. int
  1762. rl_transpose_chars (count, key)
  1763.      int count, key;
  1764. {
  1765.   char dummy[2];
  1767.   if (!count)
  1768.     return 0;
  1770.   if (!rl_point || rl_end < 2)
  1771.     {
  1772.       ding ();
  1773.       return -1;
  1774.     }
  1776.   rl_begin_undo_group ();
  1778.   if (rl_point == rl_end)
  1779.     {
  1780.       --rl_point;
  1781.       count = 1;
  1782.     }
  1783.   rl_point--;
  1785.   dummy[0] = the_line[rl_point];
  1786.   dummy[1] = '';
  1788.   rl_delete_text (rl_point, rl_point + 1);
  1790.   rl_point += count;
  1791.   _rl_fix_point (0);
  1792.   rl_insert_text (dummy);
  1794.   rl_end_undo_group ();
  1795.   return 0;
  1796. }
  1798. /* **************************************************************** */
  1799. /*     */
  1800. /* Character Searching     */
  1801. /*     */
  1802. /* **************************************************************** */
  1804. int
  1805. _rl_char_search_internal (count, dir, schar)
  1806.      int count, dir, schar;
  1807. {
  1808.   int pos, inc;
  1810.   pos = rl_point;
  1811.   inc = (dir < 0) ? -1 : 1;
  1812.   while (count)
  1813.     {
  1814.       if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
  1815. {
  1816.   ding ();
  1817.   return -1;
  1818. }
  1820.       pos += inc;
  1821.       do
  1822. {
  1823.   if (rl_line_buffer[pos] == schar)
  1824.     {
  1825.       count--;
  1826.       if (dir < 0)
  1827.         rl_point = (dir == BTO) ? pos + 1 : pos;
  1828.       else
  1829. rl_point = (dir == FTO) ? pos - 1 : pos;
  1830.       break;
  1831.     }
  1832. }
  1833.       while ((dir < 0) ? pos-- : ++pos < rl_end);
  1834.     }
  1835.   return (0);
  1836. }
  1838. /* Search COUNT times for a character read from the current input stream.
  1839.    FDIR is the direction to search if COUNT is non-negative; otherwise
  1840.    the search goes in BDIR. */
  1841. static int
  1842. _rl_char_search (count, fdir, bdir)
  1843.      int count, fdir, bdir;
  1844. {
  1845.   int c;
  1847.   c = rl_read_key ();
  1848.   if (count < 0)
  1849.     return (_rl_char_search_internal (-count, bdir, c));
  1850.   else
  1851.     return (_rl_char_search_internal (count, fdir, c));
  1852. }
  1854. int
  1855. rl_char_search (count, key)
  1856.      int count, key;
  1857. {
  1858.   return (_rl_char_search (count, FFIND, BFIND));
  1859. }
  1861. int
  1862. rl_backward_char_search (count, key)
  1863.      int count, key;
  1864. {
  1865.   return (_rl_char_search (count, BFIND, FFIND));
  1866. }
  1868. /* **************************************************************** */
  1869. /*     */
  1870. /* History Utilities     */
  1871. /*     */
  1872. /* **************************************************************** */
  1874. /* We already have a history library, and that is what we use to control
  1875.    the history features of readline.  This is our local interface to
  1876.    the history mechanism. */
  1878. /* While we are editing the history, this is the saved
  1879.    version of the original line. */
  1880. HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
  1882. /* Set the history pointer back to the last entry in the history. */
  1883. static void
  1884. start_using_history ()
  1885. {
  1886.   using_history ();
  1887.   if (saved_line_for_history)
  1888.     _rl_free_history_entry (saved_line_for_history);
  1890.   saved_line_for_history = (HIST_ENTRY *)NULL;
  1891. }
  1893. /* Free the contents (and containing structure) of a HIST_ENTRY. */
  1894. void
  1895. _rl_free_history_entry (entry)
  1896.      HIST_ENTRY *entry;
  1897. {
  1898.   if (entry == 0)
  1899.     return;
  1900.   if (entry->line)
  1901.     free (entry->line);
  1902.   free (entry);
  1903. }
  1905. /* Perhaps put back the current line if it has changed. */
  1906. int
  1907. maybe_replace_line ()
  1908. {
  1909.   HIST_ENTRY *temp;
  1911.   temp = current_history ();
  1912.   /* If the current line has changed, save the changes. */
  1913.   if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
  1914.     {
  1915.       temp = replace_history_entry (where_history (), the_line, (histdata_t)rl_undo_list);
  1916.       free (temp->line);
  1917.       free (temp);
  1918.     }
  1919.   return 0;
  1920. }
  1922. /* Put back the saved_line_for_history if there is one. */
  1923. int
  1924. maybe_unsave_line ()
  1925. {
  1926.   int line_len;
  1928.   if (saved_line_for_history)
  1929.     {
  1930.       line_len = strlen (saved_line_for_history->line);
  1932.       if (line_len >= rl_line_buffer_len)
  1933. rl_extend_line_buffer (line_len);
  1935.       strcpy (the_line, saved_line_for_history->line);
  1936.       rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
  1937.       _rl_free_history_entry (saved_line_for_history);
  1938.       saved_line_for_history = (HIST_ENTRY *)NULL;
  1939.       rl_end = rl_point = strlen (the_line);
  1940.     }
  1941.   else
  1942.     ding ();
  1943.   return 0;
  1944. }
  1946. /* Save the current line in saved_line_for_history. */
  1947. int
  1948. maybe_save_line ()
  1949. {
  1950.   if (saved_line_for_history == 0)
  1951.     {
  1952.       saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
  1953.       saved_line_for_history->line = savestring (the_line);
  1954.       saved_line_for_history->data = (char *)rl_undo_list;
  1955.     }
  1956.   return 0;
  1957. }
  1959. /* **************************************************************** */
  1960. /*     */
  1961. /* History Commands     */
  1962. /*     */
  1963. /* **************************************************************** */
  1965. /* Meta-< goes to the start of the history. */
  1966. int
  1967. rl_beginning_of_history (count, key)
  1968.      int count, key;
  1969. {
  1970.   return (rl_get_previous_history (1 + where_history (), key));
  1971. }
  1973. /* Meta-> goes to the end of the history.  (The current line). */
  1974. int
  1975. rl_end_of_history (count, key)
  1976.      int count, key;
  1977. {
  1978.   maybe_replace_line ();
  1979.   using_history ();
  1980.   maybe_unsave_line ();
  1981.   return 0;
  1982. }
  1984. /* Move down to the next history line. */
  1985. int
  1986. rl_get_next_history (count, key)
  1987.      int count, key;
  1988. {
  1989.   HIST_ENTRY *temp;
  1990.   int line_len;
  1992.   if (count < 0)
  1993.     return (rl_get_previous_history (-count, key));
  1995.   if (count == 0)
  1996.     return 0;
  1998.   maybe_replace_line ();
  2000.   temp = (HIST_ENTRY *)NULL;
  2001.   while (count)
  2002.     {
  2003.       temp = next_history ();
  2004.       if (!temp)
  2005. break;
  2006.       --count;
  2007.     }
  2009.   if (temp == 0)
  2010.     maybe_unsave_line ();
  2011.   else
  2012.     {
  2013.       line_len = strlen (temp->line);
  2015.       if (line_len >= rl_line_buffer_len)
  2016. rl_extend_line_buffer (line_len);
  2018.       strcpy (the_line, temp->line);
  2019.       rl_undo_list = (UNDO_LIST *)temp->data;
  2020.       rl_end = rl_point = strlen (the_line);
  2021. #if defined (VI_MODE)
  2022.       if (rl_editing_mode == vi_mode)
  2023. rl_point = 0;
  2024. #endif /* VI_MODE */
  2025.     }
  2026.   return 0;
  2027. }
  2029. /* Get the previous item out of our interactive history, making it the current
  2030.    line.  If there is no previous history, just ding. */
  2031. int
  2032. rl_get_previous_history (count, key)
  2033.      int count, key;
  2034. {
  2035.   HIST_ENTRY *old_temp, *temp;
  2036.   int line_len;
  2038.   if (count < 0)
  2039.     return (rl_get_next_history (-count, key));
  2041.   if (count == 0)
  2042.     return 0;
  2044.   /* If we don't have a line saved, then save this one. */
  2045.   maybe_save_line ();
  2047.   /* If the current line has changed, save the changes. */
  2048.   maybe_replace_line ();
  2050.   temp = old_temp = (HIST_ENTRY *)NULL;
  2051.   while (count)
  2052.     {
  2053.       temp = previous_history ();
  2054.       if (temp == 0)
  2055. break;
  2057.       old_temp = temp;
  2058.       --count;
  2059.     }
  2061.   /* If there was a large argument, and we moved back to the start of the
  2062.      history, that is not an error.  So use the last value found. */
  2063.   if (!temp && old_temp)
  2064.     temp = old_temp;
  2066.   if (temp == 0)
  2067.     ding ();
  2068.   else
  2069.     {
  2070.       line_len = strlen (temp->line);
  2072.       if (line_len >= rl_line_buffer_len)
  2073. rl_extend_line_buffer (line_len);
  2075.       strcpy (the_line, temp->line);
  2076.       rl_undo_list = (UNDO_LIST *)temp->data;
  2077.       rl_end = rl_point = line_len;
  2079. #if defined (VI_MODE)
  2080.       if (rl_editing_mode == vi_mode)
  2081. rl_point = 0;
  2082. #endif /* VI_MODE */
  2083.     }
  2084.   return 0;
  2085. }
  2087. /* **************************************************************** */
  2088. /*     */
  2089. /*    The Mark and the Region.     */
  2090. /*     */
  2091. /* **************************************************************** */
  2093. /* Set the mark at POSITION. */
  2094. int
  2095. _rl_set_mark_at_pos (position)
  2096.      int position;
  2097. {
  2098.   if (position > rl_end)
  2099.     return -1;
  2101.   rl_mark = position;
  2102.   return 0;
  2103. }
  2105. /* A bindable command to set the mark. */
  2106. int
  2107. rl_set_mark (count, key)
  2108.      int count, key;
  2109. {
  2110.   return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
  2111. }
  2113. /* Exchange the position of mark and point. */
  2114. int
  2115. rl_exchange_point_and_mark (count, key)
  2116.      int count, key;
  2117. {
  2118.   if (rl_mark > rl_end)
  2119.     rl_mark = -1;
  2121.   if (rl_mark == -1)
  2122.     {
  2123.       ding ();
  2124.       return -1;
  2125.     }
  2126.   else
  2127.     SWAP (rl_point, rl_mark);
  2129.   return 0;
  2130. }
  2132. /* **************************************************************** */
  2133. /*     */
  2134. /*     Editing Modes     */
  2135. /*     */
  2136. /* **************************************************************** */
  2137. /* How to toggle back and forth between editing modes. */
  2138. int
  2139. rl_vi_editing_mode (count, key)
  2140.      int count, key;
  2141. {
  2142. #if defined (VI_MODE)
  2143.   rl_editing_mode = vi_mode;
  2144.   rl_vi_insertion_mode (1, key);
  2145. #endif /* VI_MODE */
  2146.   return 0;
  2147. }
  2149. int
  2150. rl_emacs_editing_mode (count, key)
  2151.      int count, key;
  2152. {
  2153.   rl_editing_mode = emacs_mode;
  2154.   _rl_keymap = emacs_standard_keymap;
  2155.   return 0;
  2156. }