initial import of NetBSD tree

14 files changed, 11821 insertions, 0 deletions

diff --git a/gnu/usr.bin/gdb/readline/Makefile b/gnu/usr.bin/gdb/readline/Makefile
new file mode 100644
index 00000000000..85985d69a9a
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/Makefile
@@ -0,0 +1,12 @@
+# $Id: Makefile,v 1.1 1995/10/18 08:40:14 deraadt Exp $
+
+LIB=		readline
+NOPROFILE=
+NOPIC=
+
+CFLAGS+=	-DVOID_SIGHANDLER -DVI_MODE
+SRCS=		funmap.c history.c keymaps.c readline.c vi_mode.c tilde.c
+
+install:
+
+.include <bsd.lib.mk>
diff --git a/gnu/usr.bin/gdb/readline/chardefs.h b/gnu/usr.bin/gdb/readline/chardefs.h
new file mode 100644
index 00000000000..9749ae489f4
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/chardefs.h
@@ -0,0 +1,50 @@
+/* chardefs.h -- Character definitions for readline. */
+#ifndef _CHARDEFS_
+
+#ifndef savestring
+#define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
+#endif
+
+#ifndef whitespace
+#define whitespace(c) (((c) == ' ') || ((c) == '\t'))
+#endif
+
+#ifdef CTRL
+#undef CTRL
+#endif
+
+/* Some character stuff. */
+#define control_character_threshold 0x020   /* smaller than this is control */
+#define meta_character_threshold 0x07f	    /* larger than this is Meta. */
+#define control_character_bit 0x40	    /* 0x000000, must be off. */
+#define meta_character_bit 0x080	    /* x0000000, must be on. */
+
+#define CTRL(c) ((c) & (~control_character_bit))
+#define META(c) ((c) | meta_character_bit)
+
+#define UNMETA(c) ((c) & (~meta_character_bit))
+#define UNCTRL(c) to_upper(((c)|control_character_bit))
+
+#define lowercase_p(c) (((c) > ('a' - 1) && (c) < ('z' + 1)))
+#define uppercase_p(c) (((c) > ('A' - 1) && (c) < ('Z' + 1)))
+
+#define pure_alphabetic(c) (lowercase_p(c) || uppercase_p(c))
+
+#ifndef to_upper
+#define to_upper(c) (lowercase_p(c) ? ((c) - 32) : (c))
+#define to_lower(c) (uppercase_p(c) ? ((c) + 32) : (c))
+#endif
+
+#define CTRL_P(c) ((c) < control_character_threshold)
+#define META_P(c) ((c) > meta_character_threshold)
+
+#define NEWLINE '\n'
+#define RETURN CTRL('M')
+#define RUBOUT 0x07f
+#define TAB '\t'
+#define ABORT_CHAR CTRL('G')
+#define PAGE CTRL('L')
+#define SPACE 0x020
+#define ESC CTRL('[')
+
+#endif  /* _CHARDEFS_ */
diff --git a/gnu/usr.bin/gdb/readline/emacs_keymap.c b/gnu/usr.bin/gdb/readline/emacs_keymap.c
new file mode 100644
index 00000000000..d66b2a6ab2f
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/emacs_keymap.c
@@ -0,0 +1,469 @@
+/* emacs_keymap.c -- the keymap for emacs_mode in readline (). */
+
+/* Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+
+   This file is part of GNU Readline, a library for reading lines
+   of text with interactive input and history editing.
+
+   Readline is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: emacs_keymap.c,v 1.1 1995/10/18 08:40:14 deraadt Exp $
+*/
+
+/* An array of function pointers, one for each possible key.
+   If the type byte is ISKMAP, then the pointer is the address of
+   a keymap. */
+
+KEYMAP_ENTRY_ARRAY emacs_standard_keymap = {
+
+  /* Control keys. */
+  { ISFUNC, (Function *)0x0 },		/* Control-@ */
+  { ISFUNC, rl_beg_of_line },		/* Control-a */
+  { ISFUNC, rl_backward },		/* Control-b */
+  { ISFUNC, (Function *)0x0 },		/* Control-c */
+  { ISFUNC, rl_delete },		/* Control-d */
+  { ISFUNC, rl_end_of_line },		/* Control-e */
+  { ISFUNC, rl_forward },		/* Control-f */
+  { ISFUNC, rl_abort },			/* Control-g */
+  { ISFUNC, rl_rubout },		/* Control-h */
+  { ISFUNC, rl_complete },		/* Control-i */
+  { ISFUNC, rl_newline },		/* Control-j */
+  { ISFUNC, rl_kill_line },		/* Control-k */
+  { ISFUNC, rl_clear_screen },		/* Control-l */
+  { ISFUNC, rl_newline },		/* Control-m */
+  { ISFUNC, rl_get_next_history },	/* Control-n */
+  { ISFUNC, (Function *)0x0 },		/* Control-o */
+  { ISFUNC, rl_get_previous_history },	/* Control-p */
+  { ISFUNC, rl_quoted_insert },		/* Control-q */
+  { ISFUNC, rl_reverse_search_history }, /* Control-r */
+  { ISFUNC, rl_forward_search_history }, /* Control-s */
+  { ISFUNC, rl_transpose_chars },	/* Control-t */
+  { ISFUNC, rl_unix_line_discard },	/* Control-u */
+  { ISFUNC, rl_quoted_insert },		/* Control-v */
+  { ISFUNC, rl_unix_word_rubout },	/* Control-w */
+  { ISKMAP, (Function *)emacs_ctlx_keymap },	/* Control-x */
+  { ISFUNC, rl_yank },			/* Control-y */
+  { ISFUNC, (Function *)0x0 },		/* Control-z */
+  { ISKMAP, (Function *)emacs_meta_keymap }, /* Control-[ */
+  { ISFUNC, (Function *)0x0 },		/* Control-\ */
+  { ISFUNC, (Function *)0x0 },		/* Control-] */
+  { ISFUNC, (Function *)0x0 },		/* Control-^ */
+  { ISFUNC, rl_undo_command },		/* Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, rl_insert },	/* SPACE */
+  { ISFUNC, rl_insert },	/* ! */
+  { ISFUNC, rl_insert },	/* " */
+  { ISFUNC, rl_insert },	/* # */
+  { ISFUNC, rl_insert },	/* $ */
+  { ISFUNC, rl_insert },	/* % */
+  { ISFUNC, rl_insert },	/* & */
+  { ISFUNC, rl_insert },	/* ' */
+  { ISFUNC, rl_insert },	/* ( */
+  { ISFUNC, rl_insert },	/* ) */
+  { ISFUNC, rl_insert },	/* * */
+  { ISFUNC, rl_insert },	/* + */
+  { ISFUNC, rl_insert },	/* , */
+  { ISFUNC, rl_insert },	/* - */
+  { ISFUNC, rl_insert },	/* . */
+  { ISFUNC, rl_insert },	/* / */
+
+  /* Regular digits. */
+  { ISFUNC, rl_insert },	/* 0 */
+  { ISFUNC, rl_insert },	/* 1 */
+  { ISFUNC, rl_insert },	/* 2 */
+  { ISFUNC, rl_insert },	/* 3 */
+  { ISFUNC, rl_insert },	/* 4 */
+  { ISFUNC, rl_insert },	/* 5 */
+  { ISFUNC, rl_insert },	/* 6 */
+  { ISFUNC, rl_insert },	/* 7 */
+  { ISFUNC, rl_insert },	/* 8 */
+  { ISFUNC, rl_insert },	/* 9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, rl_insert },	/* : */
+  { ISFUNC, rl_insert },	/* ; */
+  { ISFUNC, rl_insert },	/* < */
+  { ISFUNC, rl_insert },	/* = */
+  { ISFUNC, rl_insert },	/* > */
+  { ISFUNC, rl_insert },	/* ? */
+  { ISFUNC, rl_insert },	/* @ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_insert },	/* A */
+  { ISFUNC, rl_insert },	/* B */
+  { ISFUNC, rl_insert },	/* C */
+  { ISFUNC, rl_insert },	/* D */
+  { ISFUNC, rl_insert },	/* E */
+  { ISFUNC, rl_insert },	/* F */
+  { ISFUNC, rl_insert },	/* G */
+  { ISFUNC, rl_insert },	/* H */
+  { ISFUNC, rl_insert },	/* I */
+  { ISFUNC, rl_insert },	/* J */
+  { ISFUNC, rl_insert },	/* K */
+  { ISFUNC, rl_insert },	/* L */
+  { ISFUNC, rl_insert },	/* M */
+  { ISFUNC, rl_insert },	/* N */
+  { ISFUNC, rl_insert },	/* O */
+  { ISFUNC, rl_insert },	/* P */
+  { ISFUNC, rl_insert },	/* Q */
+  { ISFUNC, rl_insert },	/* R */
+  { ISFUNC, rl_insert },	/* S */
+  { ISFUNC, rl_insert },	/* T */
+  { ISFUNC, rl_insert },	/* U */
+  { ISFUNC, rl_insert },	/* V */
+  { ISFUNC, rl_insert },	/* W */
+  { ISFUNC, rl_insert },	/* X */
+  { ISFUNC, rl_insert },	/* Y */
+  { ISFUNC, rl_insert },	/* Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, rl_insert },	/* [ */
+  { ISFUNC, rl_insert },	/* \ */
+  { ISFUNC, rl_insert },	/* ] */
+  { ISFUNC, rl_insert },	/* ^ */
+  { ISFUNC, rl_insert },	/* _ */
+  { ISFUNC, rl_insert },	/* ` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, rl_insert },	/* a */
+  { ISFUNC, rl_insert },	/* b */
+  { ISFUNC, rl_insert },	/* c */
+  { ISFUNC, rl_insert },	/* d */
+  { ISFUNC, rl_insert },	/* e */
+  { ISFUNC, rl_insert },	/* f */
+  { ISFUNC, rl_insert },	/* g */
+  { ISFUNC, rl_insert },	/* h */
+  { ISFUNC, rl_insert },	/* i */
+  { ISFUNC, rl_insert },	/* j */
+  { ISFUNC, rl_insert },	/* k */
+  { ISFUNC, rl_insert },	/* l */
+  { ISFUNC, rl_insert },	/* m */
+  { ISFUNC, rl_insert },	/* n */
+  { ISFUNC, rl_insert },	/* o */
+  { ISFUNC, rl_insert },	/* p */
+  { ISFUNC, rl_insert },	/* q */
+  { ISFUNC, rl_insert },	/* r */
+  { ISFUNC, rl_insert },	/* s */
+  { ISFUNC, rl_insert },	/* t */
+  { ISFUNC, rl_insert },	/* u */
+  { ISFUNC, rl_insert },	/* v */
+  { ISFUNC, rl_insert },	/* w */
+  { ISFUNC, rl_insert },	/* x */
+  { ISFUNC, rl_insert },	/* y */
+  { ISFUNC, rl_insert },	/* z */
+
+  /* Final punctuation. */
+  { ISFUNC, rl_insert },	/* { */
+  { ISFUNC, rl_insert },	/* | */
+  { ISFUNC, rl_insert },	/* } */
+  { ISFUNC, rl_insert },	/* ~ */
+  { ISFUNC, rl_rubout }		/* RUBOUT */
+};
+
+KEYMAP_ENTRY_ARRAY emacs_meta_keymap = {
+
+  /* Meta keys.  Just like above, but the high bit is set. */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-@ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-a */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-b */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-c */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-d */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-e */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-f */
+  { ISFUNC, rl_abort },		/* Meta-Control-g */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-h */
+  { ISFUNC, rl_tab_insert },	/* Meta-Control-i */
+  { ISFUNC, rl_vi_editing_mode }, /* Meta-Control-j */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-k */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-l */
+  { ISFUNC, rl_vi_editing_mode }, /* Meta-Control-m */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-n */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-o */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-p */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-q */
+  { ISFUNC, rl_revert_line },	/* Meta-Control-r */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-s */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-t */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-u */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-v */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-w */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-x */
+  { ISFUNC, rl_yank_nth_arg },	/* Meta-Control-y */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-z */
+
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-[ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-\ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-] */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-^ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, (Function *)0x0 },	/* Meta-SPACE */
+  { ISFUNC, (Function *)0x0 },	/* Meta-! */
+  { ISFUNC, (Function *)0x0 },	/* Meta-" */
+  { ISFUNC, (Function *)0x0 },	/* Meta-# */
+  { ISFUNC, (Function *)0x0 },	/* Meta-$ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-% */
+  { ISFUNC, (Function *)0x0 },	/* Meta-& */
+  { ISFUNC, (Function *)0x0 },	/* Meta-' */
+  { ISFUNC, (Function *)0x0 },	/* Meta-( */
+  { ISFUNC, (Function *)0x0 },	/* Meta-) */
+  { ISFUNC, (Function *)0x0 },	/* Meta-* */
+  { ISFUNC, (Function *)0x0 },	/* Meta-+ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-, */
+  { ISFUNC, rl_digit_argument }, /* Meta-- */
+  { ISFUNC, (Function *)0x0 },	/* Meta-. */
+  { ISFUNC, (Function *)0x0 },	/* Meta-/ */
+
+  /* Regular digits. */
+  { ISFUNC, rl_digit_argument }, /* Meta-0 */
+  { ISFUNC, rl_digit_argument }, /* Meta-1 */
+  { ISFUNC, rl_digit_argument }, /* Meta-2 */
+  { ISFUNC, rl_digit_argument }, /* Meta-3 */
+  { ISFUNC, rl_digit_argument }, /* Meta-4 */
+  { ISFUNC, rl_digit_argument }, /* Meta-5 */
+  { ISFUNC, rl_digit_argument }, /* Meta-6 */
+  { ISFUNC, rl_digit_argument }, /* Meta-7 */
+  { ISFUNC, rl_digit_argument }, /* Meta-8 */
+  { ISFUNC, rl_digit_argument }, /* Meta-9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* Meta-: */
+  { ISFUNC, (Function *)0x0 },		/* Meta-; */
+  { ISFUNC, rl_beginning_of_history },	/* Meta-< */
+  { ISFUNC, (Function *)0x0 },		/* Meta-= */
+  { ISFUNC, rl_end_of_history },	/* Meta-> */
+  { ISFUNC, rl_possible_completions },	/* Meta-? */
+  { ISFUNC, (Function *)0x0 },		/* Meta-@ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-A */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-B */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-C */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-D */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-E */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-F */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-G */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-H */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-I */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-J */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-K */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-L */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-M */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-N */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-O */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-P */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-Q */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-R */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-S */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-T */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-U */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-V */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-W */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-X */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-Y */
+  { ISFUNC, rl_do_lowercase_version },	/* Meta-Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, rl_arrow_keys },	/* Meta-[ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-\ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-] */
+  { ISFUNC, (Function *)0x0 },	/* Meta-^ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-_ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, (Function *)0x0 },	/* Meta-a */
+  { ISFUNC, rl_backward_word },	/* Meta-b */
+  { ISFUNC, rl_capitalize_word }, /* Meta-c */
+  { ISFUNC, rl_kill_word },	/* Meta-d */
+  { ISFUNC, (Function *)0x0 },	/* Meta-e */
+  { ISFUNC, rl_forward_word },	/* Meta-f */
+  { ISFUNC, (Function *)0x0 },	/* Meta-g */
+  { ISFUNC, (Function *)0x0 },	/* Meta-h */
+  { ISFUNC, (Function *)0x0 },	/* Meta-i */
+  { ISFUNC, (Function *)0x0 },	/* Meta-j */
+  { ISFUNC, (Function *)0x0 },	/* Meta-k */
+  { ISFUNC, rl_downcase_word },	/* Meta-l */
+  { ISFUNC, (Function *)0x0 },	/* Meta-m */
+  { ISFUNC, (Function *)0x0 },	/* Meta-n */
+  { ISFUNC, rl_arrow_keys },	/* Meta-o */
+  { ISFUNC, (Function *)0x0 },	/* Meta-p */
+  { ISFUNC, (Function *)0x0 },	/* Meta-q */
+  { ISFUNC, rl_revert_line },	/* Meta-r */
+  { ISFUNC, (Function *)0x0 },	/* Meta-s */
+  { ISFUNC, rl_transpose_words }, /* Meta-t */
+  { ISFUNC, rl_upcase_word },	/* Meta-u */
+  { ISFUNC, (Function *)0x0 },	/* Meta-v */
+  { ISFUNC, (Function *)0x0 },	/* Meta-w */
+  { ISFUNC, (Function *)0x0 },	/* Meta-x */
+  { ISFUNC, rl_yank_pop },	/* Meta-y */
+  { ISFUNC, (Function *)0x0 },	/* Meta-z */
+
+  /* Final punctuation. */
+  { ISFUNC, (Function *)0x0 },	/* Meta-{ */
+  { ISFUNC, (Function *)0x0 },	/* Meta-| */
+  { ISFUNC, (Function *)0x0 },	/* Meta-} */
+  { ISFUNC, (Function *)0x0 },	/* Meta-~ */
+  { ISFUNC, rl_backward_kill_word } /* Meta-rubout */
+};
+
+KEYMAP_ENTRY_ARRAY emacs_ctlx_keymap = {
+
+  /* Control keys. */
+  { ISFUNC, (Function *)0x0 },		/* Control-@ */
+  { ISFUNC, (Function *)0x0 },		/* Control-a */
+  { ISFUNC, (Function *)0x0 },		/* Control-b */
+  { ISFUNC, (Function *)0x0 },		/* Control-c */
+  { ISFUNC, (Function *)0x0 },		/* Control-d */
+  { ISFUNC, (Function *)0x0 },		/* Control-e */
+  { ISFUNC, (Function *)0x0 },		/* Control-f */
+  { ISFUNC, rl_abort },			/* Control-g */
+  { ISFUNC, (Function *)0x0 },		/* Control-h */
+  { ISFUNC, (Function *)0x0 },		/* Control-i */
+  { ISFUNC, (Function *)0x0 },		/* Control-j */
+  { ISFUNC, (Function *)0x0 },		/* Control-k */
+  { ISFUNC, (Function *)0x0 },		/* Control-l */
+  { ISFUNC, (Function *)0x0 },		/* Control-m */
+  { ISFUNC, (Function *)0x0 },		/* Control-n */
+  { ISFUNC, (Function *)0x0 },		/* Control-o */
+  { ISFUNC, (Function *)0x0 },		/* Control-p */
+  { ISFUNC, (Function *)0x0 },		/* Control-q */
+  { ISFUNC, rl_re_read_init_file },	/* Control-r */
+  { ISFUNC, (Function *)0x0 },		/* Control-s */
+  { ISFUNC, (Function *)0x0 },		/* Control-t */
+  { ISFUNC, rl_undo_command },		/* Control-u */
+  { ISFUNC, (Function *)0x0 },		/* Control-v */
+  { ISFUNC, (Function *)0x0 },		/* Control-w */
+  { ISFUNC, (Function *)0x0 },		/* Control-x */
+  { ISFUNC, (Function *)0x0 },		/* Control-y */
+  { ISFUNC, (Function *)0x0 },		/* Control-z */
+  { ISFUNC, (Function *)0x0 },		/* Control-[ */
+  { ISFUNC, (Function *)0x0 },		/* Control-\ */
+  { ISFUNC, (Function *)0x0 },		/* Control-] */
+  { ISFUNC, (Function *)0x0 },		/* Control-^ */
+  { ISFUNC, (Function *)0x0 },		/* Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, (Function *)0x0 },		/* SPACE */
+  { ISFUNC, (Function *)0x0 },		/* ! */
+  { ISFUNC, (Function *)0x0 },		/* " */
+  { ISFUNC, (Function *)0x0 },		/* # */
+  { ISFUNC, (Function *)0x0 },		/* $ */
+  { ISFUNC, (Function *)0x0 },		/* % */
+  { ISFUNC, (Function *)0x0 },		/* & */
+  { ISFUNC, (Function *)0x0 },		/* ' */
+  { ISFUNC, rl_start_kbd_macro },	/* ( */
+  { ISFUNC, rl_end_kbd_macro  },	/* ) */
+  { ISFUNC, (Function *)0x0 },		/* * */
+  { ISFUNC, (Function *)0x0 },		/* + */
+  { ISFUNC, (Function *)0x0 },		/* , */
+  { ISFUNC, (Function *)0x0 },		/* - */
+  { ISFUNC, (Function *)0x0 },		/* . */
+  { ISFUNC, (Function *)0x0 },		/* / */
+
+  /* Regular digits. */
+  { ISFUNC, (Function *)0x0 },		/* 0 */
+  { ISFUNC, (Function *)0x0 },		/* 1 */
+  { ISFUNC, (Function *)0x0 },		/* 2 */
+  { ISFUNC, (Function *)0x0 },		/* 3 */
+  { ISFUNC, (Function *)0x0 },		/* 4 */
+  { ISFUNC, (Function *)0x0 },		/* 5 */
+  { ISFUNC, (Function *)0x0 },		/* 6 */
+  { ISFUNC, (Function *)0x0 },		/* 7 */
+  { ISFUNC, (Function *)0x0 },		/* 8 */
+  { ISFUNC, (Function *)0x0 },		/* 9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, (Function *)0x0 },	/* : */
+  { ISFUNC, (Function *)0x0 },	/* ; */
+  { ISFUNC, (Function *)0x0 },	/* < */
+  { ISFUNC, (Function *)0x0 },	/* = */
+  { ISFUNC, (Function *)0x0 },	/* > */
+  { ISFUNC, (Function *)0x0 },	/* ? */
+  { ISFUNC, (Function *)0x0 },	/* @ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_do_lowercase_version },	/* A */
+  { ISFUNC, rl_do_lowercase_version },	/* B */
+  { ISFUNC, rl_do_lowercase_version },	/* C */
+  { ISFUNC, rl_do_lowercase_version },	/* D */
+  { ISFUNC, rl_do_lowercase_version },	/* E */
+  { ISFUNC, rl_do_lowercase_version },	/* F */
+  { ISFUNC, rl_do_lowercase_version },	/* G */
+  { ISFUNC, rl_do_lowercase_version },	/* H */
+  { ISFUNC, rl_do_lowercase_version },	/* I */
+  { ISFUNC, rl_do_lowercase_version },	/* J */
+  { ISFUNC, rl_do_lowercase_version },	/* K */
+  { ISFUNC, rl_do_lowercase_version },	/* L */
+  { ISFUNC, rl_do_lowercase_version },	/* M */
+  { ISFUNC, rl_do_lowercase_version },	/* N */
+  { ISFUNC, rl_do_lowercase_version },	/* O */
+  { ISFUNC, rl_do_lowercase_version },	/* P */
+  { ISFUNC, rl_do_lowercase_version },	/* Q */
+  { ISFUNC, rl_do_lowercase_version },	/* R */
+  { ISFUNC, rl_do_lowercase_version },	/* S */
+  { ISFUNC, rl_do_lowercase_version },	/* T */
+  { ISFUNC, rl_do_lowercase_version },	/* U */
+  { ISFUNC, rl_do_lowercase_version },	/* V */
+  { ISFUNC, rl_do_lowercase_version },	/* W */
+  { ISFUNC, rl_do_lowercase_version },	/* X */
+  { ISFUNC, rl_do_lowercase_version },	/* Y */
+  { ISFUNC, rl_do_lowercase_version },	/* Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* [ */
+  { ISFUNC, (Function *)0x0 },		/* \ */
+  { ISFUNC, (Function *)0x0 },		/* ] */
+  { ISFUNC, (Function *)0x0 },		/* ^ */
+  { ISFUNC, (Function *)0x0 },		/* _ */
+  { ISFUNC, (Function *)0x0 },		/* ` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, (Function *)0x0 },		/* a */
+  { ISFUNC, (Function *)0x0 },		/* b */
+  { ISFUNC, (Function *)0x0 },		/* c */
+  { ISFUNC, (Function *)0x0 },		/* d */
+  { ISFUNC, rl_call_last_kbd_macro },	/* e */
+  { ISFUNC, (Function *)0x0 },		/* f */
+  { ISFUNC, (Function *)0x0 },		/* g */
+  { ISFUNC, (Function *)0x0 },		/* h */
+  { ISFUNC, (Function *)0x0 },		/* i */
+  { ISFUNC, (Function *)0x0 },		/* j */
+  { ISFUNC, (Function *)0x0 },		/* k */
+  { ISFUNC, (Function *)0x0 },		/* l */
+  { ISFUNC, (Function *)0x0 },		/* m */
+  { ISFUNC, (Function *)0x0 },		/* n */
+  { ISFUNC, (Function *)0x0 },		/* o */
+  { ISFUNC, (Function *)0x0 },		/* p */
+  { ISFUNC, (Function *)0x0 },		/* q */
+  { ISFUNC, (Function *)0x0 },		/* r */
+  { ISFUNC, (Function *)0x0 },		/* s */
+  { ISFUNC, (Function *)0x0 },		/* t */
+  { ISFUNC, (Function *)0x0 },		/* u */
+  { ISFUNC, (Function *)0x0 },		/* v */
+  { ISFUNC, (Function *)0x0 },		/* w */
+  { ISFUNC, (Function *)0x0 },		/* x */
+  { ISFUNC, (Function *)0x0 },		/* y */
+  { ISFUNC, (Function *)0x0 },		/* z */
+
+  /* Final punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* { */
+  { ISFUNC, (Function *)0x0 },		/* | */
+  { ISFUNC, (Function *)0x0 },		/* } */
+  { ISFUNC, (Function *)0x0 },		/* ~ */
+  { ISFUNC, rl_backward_kill_line }	/* RUBOUT */
+};
diff --git a/gnu/usr.bin/gdb/readline/funmap.c b/gnu/usr.bin/gdb/readline/funmap.c
new file mode 100644
index 00000000000..ae3969c6a5f
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/funmap.c
@@ -0,0 +1,272 @@
+/* funmap.c -- attach names to functions. */
+
+/* Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+
+   This file is part of GNU Readline, a library for reading lines
+   of text with interactive input and history editing.
+
+   Readline is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: funmap.c,v 1.1 1995/10/18 08:40:15 deraadt Exp $
+*/
+
+/* #define STATIC_MALLOC */
+#if !defined (STATIC_MALLOC)
+extern char *xmalloc (), *xrealloc ();
+#else
+static char *xmalloc (), *xrealloc ();
+#endif /* STATIC_MALLOC */
+
+#include "sysdep.h"
+#include <stdio.h>
+
+#include "readline.h"
+
+FUNMAP **funmap = (FUNMAP **)NULL;
+static int funmap_size = 0;
+static int funmap_entry = 0;
+
+/* After initializing the function map, this is the index of the first
+   program specific function. */
+int funmap_program_specific_entry_start;
+
+static FUNMAP default_funmap[] = {
+
+  { "abort", rl_abort },
+  { "accept-line", rl_newline },
+  { "arrow-key-prefix", rl_arrow_keys },
+  { "backward-char", rl_backward },
+  { "backward-delete-char", rl_rubout },
+  { "backward-kill-line", rl_backward_kill_line },
+  { "backward-kill-word", rl_backward_kill_word },
+  { "backward-word", rl_backward_word },
+  { "beginning-of-history", rl_beginning_of_history },
+  { "beginning-of-line", rl_beg_of_line },
+  { "call-last-kbd-macro", rl_call_last_kbd_macro },
+  { "capitalize-word", rl_capitalize_word },
+  { "clear-screen", rl_clear_screen },
+  { "complete", rl_complete },
+  { "delete-char", rl_delete },
+  { "digit-argument", rl_digit_argument },
+  { "do-lowercase-version", rl_do_lowercase_version },
+  { "downcase-word", rl_downcase_word },
+  { "dump-functions", rl_dump_functions },
+  { "end-kbd-macro", rl_end_kbd_macro },
+  { "end-of-history", rl_end_of_history },
+  { "end-of-line", rl_end_of_line },
+  { "forward-char", rl_forward },
+  { "forward-search-history", rl_forward_search_history },
+  { "forward-word", rl_forward_word },
+  { "kill-line", rl_kill_line },
+  { "kill-word", rl_kill_word },
+  { "next-history", rl_get_next_history },
+  { "possible-completions", rl_possible_completions },
+  { "previous-history", rl_get_previous_history },
+  { "quoted-insert", rl_quoted_insert },
+  { "re-read-init-file", rl_re_read_init_file },
+  { "redraw-current-line", rl_refresh_line},
+  { "reverse-search-history", rl_reverse_search_history },
+  { "revert-line", rl_revert_line },
+  { "self-insert", rl_insert },
+  { "start-kbd-macro", rl_start_kbd_macro },
+  { "tab-insert", rl_tab_insert },
+  { "transpose-chars", rl_transpose_chars },
+  { "transpose-words", rl_transpose_words },
+  { "undo", rl_undo_command },
+  { "universal-argument", rl_universal_argument },
+  { "unix-line-discard", rl_unix_line_discard },
+  { "unix-word-rubout", rl_unix_word_rubout },
+  { "upcase-word", rl_upcase_word },
+  { "yank", rl_yank },
+  { "yank-nth-arg", rl_yank_nth_arg },
+  { "yank-pop", rl_yank_pop },
+
+#if defined (VI_MODE)
+
+  { "vi-append-eol", rl_vi_append_eol },
+  { "vi-append-mode", rl_vi_append_mode },
+  { "vi-arg-digit", rl_vi_arg_digit },
+  { "vi-bWord", rl_vi_bWord },
+  { "vi-bracktype", rl_vi_bracktype },
+  { "vi-bword", rl_vi_bword },
+  { "vi-change-case", rl_vi_change_case },
+  { "vi-change-char", rl_vi_change_char },
+  { "vi-change-to", rl_vi_change_to },
+  { "vi-char-search", rl_vi_char_search },
+  { "vi-column", rl_vi_column },
+  { "vi-comment", rl_vi_comment },
+  { "vi-complete", rl_vi_complete },
+  { "vi-delete", rl_vi_delete },
+  { "vi-delete-to", rl_vi_delete_to },
+  { "vi-dosearch", rl_vi_dosearch },
+  { "vi-eWord", rl_vi_eWord },
+  { "vi-editing-mode", rl_vi_editing_mode },
+  { "vi-end-word", rl_vi_end_word },
+  { "vi-eof-maybe", rl_vi_eof_maybe },
+  { "vi-eword", rl_vi_eword },
+  { "vi-fWord", rl_vi_fWord },
+  { "vi-first-print", rl_vi_first_print },
+  { "vi-fword", rl_vi_fword },
+  { "vi-insert-beg", rl_vi_insert_beg },
+  { "vi-insertion-mode", rl_vi_insertion_mode },
+  { "vi-match", rl_vi_match },
+  { "vi-movement-mode", rl_vi_movement_mode },
+  { "vi-next-word", rl_vi_next_word },
+  { "vi-overstrike", rl_vi_overstrike },
+  { "vi-overstrike-delete", rl_vi_overstrike_delete },
+  { "vi-prev-word", rl_vi_prev_word },
+  { "vi-put", rl_vi_put },
+  { "vi-replace, ", rl_vi_replace },
+  { "vi-search", rl_vi_search },
+  { "vi-search-again", rl_vi_search_again },
+  { "vi-subst", rl_vi_subst },
+  { "vi-yank-arg", rl_vi_yank_arg },
+  { "vi-yank-to", rl_vi_yank_to },
+
+#endif /* VI_MODE */
+
+ {(char *)NULL, (Function *)NULL }
+};
+
+rl_add_funmap_entry (name, function)
+     char *name;
+     Function *function;
+{
+  if (funmap_entry + 2 >= funmap_size)
+    if (!funmap)
+      funmap = (FUNMAP **)xmalloc ((funmap_size = 80) * sizeof (FUNMAP *));
+    else
+      funmap =
+	(FUNMAP **)xrealloc (funmap, (funmap_size += 80) * sizeof (FUNMAP *));
+  
+  funmap[funmap_entry] = (FUNMAP *)xmalloc (sizeof (FUNMAP));
+  funmap[funmap_entry]->name = name;
+  funmap[funmap_entry]->function = function;
+
+  funmap[++funmap_entry] = (FUNMAP *)NULL;
+}
+
+static int funmap_initialized = 0;
+
+/* Make the funmap contain all of the default entries. */
+rl_initialize_funmap ()
+{
+  register int i;
+
+  if (funmap_initialized)
+    return;
+
+  for (i = 0; default_funmap[i].name; i++)
+    rl_add_funmap_entry (default_funmap[i].name, default_funmap[i].function);
+
+  funmap_initialized = 1;
+  funmap_program_specific_entry_start = i;
+}
+
+/* Stupid comparison routine for qsort () ing strings. */
+static int
+qsort_string_compare (s1, s2)
+     register char **s1, **s2;
+{
+  return (strcmp (*s1, *s2));
+}
+
+/* Produce a NULL terminated array of known function names.  The array
+   is sorted.  The array itself is allocated, but not the strings inside.
+   You should free () the array when you done, but not the pointrs. */
+char **
+rl_funmap_names ()
+{
+  char **result = (char **)NULL;
+  int result_size, result_index;
+
+  result_size = result_index = 0;
+
+  /* Make sure that the function map has been initialized. */
+  rl_initialize_funmap ();
+
+  for (result_index = 0; funmap[result_index]; result_index++)
+    {
+      if (result_index + 2 > result_size)
+	{
+	  if (!result)
+	    result = (char **)xmalloc ((result_size = 20) * sizeof (char *));
+	  else
+	    result = (char **)
+	      xrealloc (result, (result_size += 20) * sizeof (char *));
+	}
+
+      result[result_index] = funmap[result_index]->name;
+      result[result_index + 1] = (char *)NULL;
+    }
+
+  qsort (result, result_index, sizeof (char *), qsort_string_compare);
+  return (result);
+}
+
+/* Things that mean `Control'. */
+char *possible_control_prefixes[] = {
+  "Control-", "C-", "CTRL-", (char *)NULL
+};
+
+char *possible_meta_prefixes[] = {
+  "Meta", "M-", (char *)NULL
+};
+
+#if defined (STATIC_MALLOC)
+
+/* **************************************************************** */
+/*								    */
+/*			xmalloc and xrealloc ()		     	    */
+/*								    */
+/* **************************************************************** */
+
+static void memory_error_and_abort ();
+
+static char *
+xmalloc (bytes)
+     int bytes;
+{
+  char *temp = (char *)malloc (bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static char *
+xrealloc (pointer, bytes)
+     char *pointer;
+     int bytes;
+{
+  char *temp;
+
+  if (!pointer)
+    temp = (char *)malloc (bytes);
+  else
+    temp = (char *)realloc (pointer, bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static void
+memory_error_and_abort ()
+{
+  fprintf (stderr, "history: Out of virtual memory!\n");
+  abort ();
+}
+#endif /* STATIC_MALLOC */
diff --git a/gnu/usr.bin/gdb/readline/history.c b/gnu/usr.bin/gdb/readline/history.c
new file mode 100644
index 00000000000..5c4ee00187e
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/history.c
@@ -0,0 +1,1696 @@
+/* History.c -- standalone history library */
+
+/* Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+
+   This file contains the GNU History Library (the Library), a set of
+   routines for managing the text of previously typed lines.
+
+   The Library is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   The Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: history.c,v 1.1 1995/10/18 08:40:15 deraadt Exp $
+*/
+
+/* The goal is to make the implementation transparent, so that you
+   don't have to know what data types are used, just what functions
+   you can call.  I think I have done that. */
+
+/* Remove these declarations when we have a complete libgnu.a. */
+#if !defined (STATIC_MALLOC)
+extern char *xmalloc (), *xrealloc ();
+#else
+static char *xmalloc (), *xrealloc ();
+#endif
+
+#include "sysdep.h"
+#include <stdio.h>
+#include <errno.h>
+#ifndef	NO_SYS_FILE
+#include <sys/file.h>
+#endif
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "history.h"
+
+#ifndef savestring
+#define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
+#endif
+
+#ifndef whitespace
+#define whitespace(c) (((c) == ' ') || ((c) == '\t'))
+#endif
+
+#ifndef digit
+#define digit(c)  ((c) >= '0' && (c) <= '9')
+#endif
+
+#ifndef member
+#define member(c, s) ((c) ? index ((s), (c)) : 0)
+#endif
+
+/* **************************************************************** */
+/*								    */
+/*			History Functions			    */
+/*								    */
+/* **************************************************************** */
+
+/* An array of HIST_ENTRY.  This is where we store the history. */
+static HIST_ENTRY **the_history = (HIST_ENTRY **)NULL;
+
+/* Non-zero means that we have enforced a limit on the amount of
+   history that we save. */
+int history_stifled = 0;
+
+/* If HISTORY_STIFLED is non-zero, then this is the maximum number of
+   entries to remember. */
+int max_input_history;
+
+/* The current location of the interactive history pointer.  Just makes
+   life easier for outside callers. */
+static int history_offset = 0;
+
+/* The number of strings currently stored in the input_history list. */
+int history_length = 0;
+
+/* The current number of slots allocated to the input_history. */
+static int history_size = 0;
+
+/* The number of slots to increase the_history by. */
+#define DEFAULT_HISTORY_GROW_SIZE 50
+
+/* The character that represents the start of a history expansion
+   request.  This is usually `!'. */
+char history_expansion_char = '!';
+
+/* The character that invokes word substitution if found at the start of
+   a line.  This is usually `^'. */
+char history_subst_char = '^';
+
+/* During tokenization, if this character is seen as the first character
+   of a word, then it, and all subsequent characters upto a newline are
+   ignored.  For a Bourne shell, this should be '#'.  Bash special cases
+   the interactive comment character to not be a comment delimiter. */
+char history_comment_char = '\0';
+
+/* The list of characters which inhibit the expansion of text if found
+   immediately following history_expansion_char. */
+char *history_no_expand_chars = " \t\n\r=";
+
+/* The logical `base' of the history array.  It defaults to 1. */
+int history_base = 1;
+
+/* Begin a session in which the history functions might be used.  This
+   initializes interactive variables. */
+void
+using_history ()
+{
+  history_offset = history_length;
+}
+
+/* Return the number of bytes that the primary history entries are using.
+   This just adds up the lengths of the_history->lines. */
+int
+history_total_bytes ()
+{
+  register int i, result;
+
+  result = 0;
+
+  for (i = 0; the_history && the_history[i]; i++)
+    result += strlen (the_history[i]->line);
+
+  return (result);
+}
+
+/* Place STRING at the end of the history list.  The data field
+   is  set to NULL. */
+void
+add_history (string)
+     char *string;
+{
+  HIST_ENTRY *temp;
+
+  if (history_stifled && (history_length == max_input_history))
+    {
+      register int i;
+
+      /* If the history is stifled, and history_length is zero,
+	 and it equals max_input_history, we don't save items. */
+      if (!history_length)
+	return;
+
+      /* If there is something in the slot, then remove it. */
+      if (the_history[0])
+	{
+	  free (the_history[0]->line);
+	  free (the_history[0]);
+	}
+
+      for (i = 0; i < history_length; i++)
+	the_history[i] = the_history[i + 1];
+
+      history_base++;
+
+    }
+  else
+    {
+      if (!history_size)
+	{
+	  the_history = (HIST_ENTRY **)
+	    xmalloc ((history_size = DEFAULT_HISTORY_GROW_SIZE)
+		     * sizeof (HIST_ENTRY *));
+	  history_length = 1;
+
+	}
+      else
+	{
+	  if (history_length == (history_size - 1))
+	    {
+	      the_history = (HIST_ENTRY **)
+		xrealloc (the_history,
+			  ((history_size += DEFAULT_HISTORY_GROW_SIZE)
+			   * sizeof (HIST_ENTRY *)));
+	  }
+	  history_length++;
+	}
+    }
+
+  temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
+  temp->line = savestring (string);
+  temp->data = (char *)NULL;
+
+  the_history[history_length] = (HIST_ENTRY *)NULL;
+  the_history[history_length - 1] = temp;
+}
+
+/* Make the history entry at WHICH have LINE and DATA.  This returns
+   the old entry so you can dispose of the data.  In the case of an
+   invalid WHICH, a NULL pointer is returned. */
+HIST_ENTRY *
+replace_history_entry (which, line, data)
+     int which;
+     char *line;
+     char *data;
+{
+  HIST_ENTRY *temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
+  HIST_ENTRY *old_value;
+
+  if (which >= history_length)
+    return ((HIST_ENTRY *)NULL);
+
+  old_value = the_history[which];
+
+  temp->line = savestring (line);
+  temp->data = data;
+  the_history[which] = temp;
+
+  return (old_value);
+}
+
+/* Returns the magic number which says what history element we are
+   looking at now.  In this implementation, it returns history_offset. */
+int
+where_history ()
+{
+  return (history_offset);
+}
+
+/* Search the history for STRING, starting at history_offset.
+   If DIRECTION < 0, then the search is through previous entries, else
+   through subsequent.  If ANCHORED is non-zero, the string must
+   appear at the beginning of a history line, otherwise, the string
+   may appear anywhere in the line.  If the string is found, then
+   current_history () is the history entry, and the value of this
+   function is the offset in the line of that history entry that the
+   string was found in.  Otherwise, nothing is changed, and a -1 is
+   returned. */
+
+#define ANCHORED_SEARCH 1
+#define NON_ANCHORED_SEARCH 0
+
+static int
+history_search_internal (string, direction, anchored)
+     char *string;
+     int direction, anchored;
+{
+  register int i = history_offset;
+  register int reverse = (direction < 0);
+  register char *line;
+  register int index;
+  int string_len = strlen (string);
+
+  /* Take care of trivial cases first. */
+
+  if (!history_length || ((i == history_length) && !reverse))
+    return (-1);
+
+  if (reverse && (i == history_length))
+    i--;
+
+  while (1)
+    {
+      /* Search each line in the history list for STRING. */
+
+      /* At limit for direction? */
+      if ((reverse && i < 0) ||
+	  (!reverse && i == history_length))
+	return (-1);
+
+      line = the_history[i]->line;
+      index = strlen (line);
+
+      /* If STRING is longer than line, no match. */
+      if (string_len > index)
+	goto next_line;
+
+      /* Handle anchored searches first. */
+      if (anchored == ANCHORED_SEARCH)
+	{
+	  if (strncmp (string, line, string_len) == 0)
+	    {
+	      history_offset = i;
+	      return (0);
+	    }
+
+	  goto next_line;
+	}
+
+      /* Do substring search. */
+      if (reverse)
+	{
+	  index -= string_len;
+
+	  while (index >= 0)
+	    {
+	      if (strncmp (string, line + index, string_len) == 0)
+		{
+		  history_offset = i;
+		  return (index);
+		}
+	      index--;
+	    }
+	}
+      else
+	{
+	  register int limit = index - string_len + 1;
+	  index = 0;
+
+	  while (index < limit)
+	    {
+	      if (strncmp (string, line + index, string_len) == 0)
+		{
+		  history_offset = i;
+		  return (index);
+		}
+	      index++;
+	    }
+	}
+    next_line:
+      if (reverse)
+	i--;
+      else
+	i++;
+    }
+}
+
+/* Do a non-anchored search for STRING through the history in DIRECTION. */
+int
+history_search (string, direction)
+     char *string;
+     int direction;
+{
+  return (history_search_internal (string, direction, NON_ANCHORED_SEARCH));
+}
+
+/* Do an anchored search for string through the history in DIRECTION. */
+int
+history_search_prefix (string, direction)
+     char *string;
+     int direction;
+{
+  return (history_search_internal (string, direction, ANCHORED_SEARCH));
+}
+
+/* Remove history element WHICH from the history.  The removed
+   element is returned to you so you can free the line, data,
+   and containing structure. */
+HIST_ENTRY *
+remove_history (which)
+     int which;
+{
+  HIST_ENTRY *return_value;
+
+  if (which >= history_length || !history_length)
+    return_value = (HIST_ENTRY *)NULL;
+  else
+    {
+      register int i;
+      return_value = the_history[which];
+
+      for (i = which; i < history_length; i++)
+	the_history[i] = the_history[i + 1];
+
+      history_length--;
+    }
+
+  return (return_value);
+}
+
+/* Stifle the history list, remembering only MAX number of lines. */
+void
+stifle_history (max)
+     int max;
+{
+  if (max < 0)
+    max = 0;
+  if (history_length > max)
+    {
+      register int i, j;
+
+      /* This loses because we cannot free the data. */
+      for (i = 0; i < (history_length - max); i++)
+	{
+	  free (the_history[i]->line);
+	  free (the_history[i]);
+	}
+      history_base = i;
+      for (j = 0, i = history_length - max; j < max; i++, j++)
+	the_history[j] = the_history[i];
+      the_history[j] = (HIST_ENTRY *)NULL;
+      history_length = j;
+    }
+  history_stifled = 1;
+  max_input_history = max;
+}
+
+/* Stop stifling the history.  This returns the previous amount the history
+ was stifled by.  The value is positive if the history was stifled, negative
+ if it wasn't. */
+int
+unstifle_history ()
+{
+  int result = max_input_history;
+  if (history_stifled)
+    {
+      result = - result;
+      history_stifled = 0;
+    }
+  return (result);
+}
+
+/* Return the string that should be used in the place of this
+   filename.  This only matters when you don't specify the
+   filename to read_history (), or write_history (). */
+static char *
+history_filename (filename)
+     char *filename;
+{
+  char *return_val = filename ? savestring (filename) : (char *)NULL;
+
+  if (!return_val)
+    {
+      char *home = (char *)getenv ("HOME");
+      if (!home) home = ".";
+      return_val = (char *)xmalloc (2 + strlen (home) + strlen (".history"));
+      sprintf (return_val, "%s/.history", home);
+    }
+  return (return_val);
+}
+
+/* Add the contents of FILENAME to the history list, a line at a time.
+   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
+   successful, or errno if not. */
+int
+read_history (filename)
+     char *filename;
+{
+  return (read_history_range (filename, 0, -1));
+}
+
+/* Read a range of lines from FILENAME, adding them to the history list.
+   Start reading at the FROM'th line and end at the TO'th.  If FROM
+   is zero, start at the beginning.  If TO is less than FROM, read
+   until the end of the file.  If FILENAME is NULL, then read from
+   ~/.history.  Returns 0 if successful, or errno if not. */
+int
+read_history_range (filename, from, to)
+     char *filename;
+     int from, to;
+{
+  register int line_start, line_end;
+  char *input, *buffer = (char *)NULL;
+  int file, current_line;
+  struct stat finfo;
+  extern int errno;
+
+  input = history_filename (filename);
+  file = open (input, O_RDONLY, 0666);
+
+  if ((file < 0) ||
+      (stat (input, &finfo) == -1))
+    goto error_and_exit;
+
+  buffer = (char *)xmalloc (finfo.st_size + 1);
+
+  if (read (file, buffer, finfo.st_size) != finfo.st_size)
+  error_and_exit:
+    {
+      if (file >= 0)
+	close (file);
+
+      if (buffer)
+	free (buffer);
+
+      return (errno);
+    }
+
+  close (file);
+
+  /* Set TO to larger than end of file if negative. */
+  if (to < 0)
+    to = finfo.st_size;
+
+  /* Start at beginning of file, work to end. */
+  line_start = line_end = current_line = 0;
+
+  /* Skip lines until we are at FROM. */
+  while (line_start < finfo.st_size && current_line < from)
+    {
+      for (line_end = line_start; line_end < finfo.st_size; line_end++)
+	if (buffer[line_end] == '\n')
+	  {
+	    current_line++;
+	    line_start = line_end + 1;
+	    if (current_line == from)
+	      break;
+	  }
+    }
+
+  /* If there are lines left to gobble, then gobble them now. */
+  for (line_end = line_start; line_end < finfo.st_size; line_end++)
+    if (buffer[line_end] == '\n')
+      {
+	buffer[line_end] = '\0';
+
+	if (buffer[line_start])
+	  add_history (buffer + line_start);
+
+	current_line++;
+
+	if (current_line >= to)
+	  break;
+
+	line_start = line_end + 1;
+      }
+  return (0);
+}
+
+/* Truncate the history file FNAME, leaving only LINES trailing lines.
+   If FNAME is NULL, then use ~/.history. */
+history_truncate_file (fname, lines)
+     char *fname;
+     register int lines;
+{
+  register int i;
+  int file;
+  char *buffer = (char *)NULL, *filename;
+  struct stat finfo;
+
+  filename = history_filename (fname);
+  if (stat (filename, &finfo) == -1)
+    goto truncate_exit;
+
+  file = open (filename, O_RDONLY, 0666);
+
+  if (file == -1)
+    goto truncate_exit;
+
+  buffer = (char *)xmalloc (finfo.st_size + 1);
+  read (file, buffer, finfo.st_size);
+  close (file);
+
+  /* Count backwards from the end of buffer until we have passed
+     LINES lines. */
+  for (i = finfo.st_size; lines && i; i--)
+    {
+      if (buffer[i] == '\n')
+	lines--;
+    }
+
+  /* If there are fewer lines in the file than we want to truncate to,
+     then we are all done. */
+  if (!i)
+    goto truncate_exit;
+
+  /* Otherwise, write from the start of this line until the end of the
+     buffer. */
+  for (--i; i; i--)
+    if (buffer[i] == '\n')
+      {
+	i++;
+	break;
+      }
+
+  file = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
+  if (file == -1)
+    goto truncate_exit;
+
+  write (file, buffer + i, finfo.st_size - i);
+  close (file);
+
+ truncate_exit:
+  if (buffer)
+    free (buffer);
+
+  free (filename);
+}
+
+#define HISTORY_APPEND 0
+#define HISTORY_OVERWRITE 1
+
+/* Workhorse function for writing history.  Writes NELEMENT entries
+   from the history list to FILENAME.  OVERWRITE is non-zero if you
+   wish to replace FILENAME with the entries. */
+static int
+history_do_write (filename, nelements, overwrite)
+     char *filename;
+     int nelements, overwrite;
+{
+  extern int errno;
+  register int i, j;
+  char *output = history_filename (filename);
+  int file, mode;
+
+  if (overwrite)
+    mode = O_WRONLY | O_CREAT | O_TRUNC;
+  else
+    mode = O_WRONLY | O_APPEND;
+
+  if ((file = open (output, mode, 0666)) == -1)
+    return (errno);
+
+  if (nelements > history_length)
+    nelements = history_length;
+
+  /* Build a buffer of all the lines to write, and write them in one syscall.
+     Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */
+  {
+    register int j = 0;
+    int buffer_size = 0;
+    char *buffer;
+
+    /* Calculate the total number of bytes to write. */
+    for (i = history_length - nelements; i < history_length; i++)
+      buffer_size += 1 + strlen (the_history[i]->line);
+
+    /* Allocate the buffer, and fill it. */
+    buffer = (char *)xmalloc (buffer_size);
+
+    for (i = history_length - nelements; i < history_length; i++)
+      {
+	strcpy (buffer + j, the_history[i]->line);
+	j += strlen (the_history[i]->line);
+	buffer[j++] = '\n';
+      }
+
+    write (file, buffer, buffer_size);
+    free (buffer);
+  }
+
+  close (file);
+  return (0);
+}
+  
+/* Append NELEMENT entries to FILENAME.  The entries appended are from
+   the end of the list minus NELEMENTs up to the end of the list. */
+int
+append_history (nelements, filename)
+     int nelements;
+     char *filename;
+{
+  return (history_do_write (filename, nelements, HISTORY_APPEND));
+}
+
+/* Overwrite FILENAME with the current history.  If FILENAME is NULL,
+   then write the history list to ~/.history.  Values returned
+   are as in read_history ().*/
+int
+write_history (filename)
+     char *filename;
+{
+  return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
+}
+
+/* Return the history entry at the current position, as determined by
+   history_offset.  If there is no entry there, return a NULL pointer. */
+HIST_ENTRY *
+current_history ()
+{
+  if ((history_offset == history_length) || !the_history)
+    return ((HIST_ENTRY *)NULL);
+  else
+    return (the_history[history_offset]);
+}
+
+/* Back up history_offset to the previous history entry, and return
+   a pointer to that entry.  If there is no previous entry then return
+   a NULL pointer. */
+HIST_ENTRY *
+previous_history ()
+{
+  if (!history_offset)
+    return ((HIST_ENTRY *)NULL);
+  else
+    return (the_history[--history_offset]);
+}
+
+/* Move history_offset forward to the next history entry, and return
+   a pointer to that entry.  If there is no next entry then return a
+   NULL pointer. */
+HIST_ENTRY *
+next_history ()
+{
+  if (history_offset == history_length)
+    return ((HIST_ENTRY *)NULL);
+  else
+    return (the_history[++history_offset]);
+}
+
+/* Return the current history array.  The caller has to be carefull, since this
+   is the actual array of data, and could be bashed or made corrupt easily.
+   The array is terminated with a NULL pointer. */
+HIST_ENTRY **
+history_list ()
+{
+  return (the_history);
+}
+
+/* Return the history entry which is logically at OFFSET in the history array.
+   OFFSET is relative to history_base. */
+HIST_ENTRY *
+history_get (offset)
+     int offset;
+{
+  int index = offset - history_base;
+
+  if (index >= history_length ||
+      index < 0 ||
+      !the_history)
+    return ((HIST_ENTRY *)NULL);
+  return (the_history[index]);
+}
+
+/* Search for STRING in the history list.  DIR is < 0 for searching
+   backwards.  POS is an absolute index into the history list at
+   which point to begin searching. */
+int
+history_search_pos (string, dir, pos)
+     char *string;
+     int dir, pos;
+{
+  int ret, old = where_history ();
+  history_set_pos (pos);
+  if (history_search (string, dir) == -1)
+    {
+      history_set_pos (old);
+      return (-1);
+    }
+  ret = where_history ();
+  history_set_pos (old);
+  return ret;
+}
+
+/* Make the current history item be the one at POS, an absolute index.
+   Returns zero if POS is out of range, else non-zero. */
+int
+history_set_pos (pos)
+     int pos;
+{
+  if (pos > history_length || pos < 0 || !the_history)
+    return (0);
+  history_offset = pos;
+  return (1);
+}
+ 
+
+/* **************************************************************** */
+/*								    */
+/*			History Expansion			    */
+/*								    */
+/* **************************************************************** */
+
+/* Hairy history expansion on text, not tokens.  This is of general
+   use, and thus belongs in this library. */
+
+/* The last string searched for in a !?string? search. */
+static char *search_string = (char *)NULL;
+
+/* Return the event specified at TEXT + OFFSET modifying OFFSET to
+   point to after the event specifier.  Just a pointer to the history
+   line is returned; NULL is returned in the event of a bad specifier.
+   You pass STRING with *INDEX equal to the history_expansion_char that
+   begins this specification.
+   DELIMITING_QUOTE is a character that is allowed to end the string
+   specification for what to search for in addition to the normal
+   characters `:', ` ', `\t', `\n', and sometimes `?'.
+   So you might call this function like:
+   line = get_history_event ("!echo:p", &index, 0);  */
+char *
+get_history_event (string, caller_index, delimiting_quote)
+     char *string;
+     int *caller_index;
+     int delimiting_quote;
+{
+  register int i = *caller_index;
+  int which, sign = 1;
+  HIST_ENTRY *entry;
+
+  /* The event can be specified in a number of ways.
+
+     !!   the previous command
+     !n   command line N
+     !-n  current command-line minus N
+     !str the most recent command starting with STR
+     !?str[?]
+	  the most recent command containing STR
+
+     All values N are determined via HISTORY_BASE. */
+
+  if (string[i] != history_expansion_char)
+    return ((char *)NULL);
+
+  /* Move on to the specification. */
+  i++;
+
+  /* Handle !! case. */
+  if (string[i] == history_expansion_char)
+    {
+      i++;
+      which = history_base + (history_length - 1);
+      *caller_index = i;
+      goto get_which;
+    }
+
+  /* Hack case of numeric line specification. */
+ read_which:
+  if (string[i] == '-')
+    {
+      sign = -1;
+      i++;
+    }
+
+  if (digit (string[i]))
+    {
+      int start = i;
+
+      /* Get the extent of the digits. */
+      for (; digit (string[i]); i++);
+
+      /* Get the digit value. */
+      sscanf (string + start, "%d", &which);
+
+      *caller_index = i;
+
+      if (sign < 0)
+	which = (history_length + history_base) - which;
+
+    get_which:
+      if (entry = history_get (which))
+	return (entry->line);
+
+      return ((char *)NULL);
+    }
+
+  /* This must be something to search for.  If the spec begins with
+     a '?', then the string may be anywhere on the line.  Otherwise,
+     the string must be found at the start of a line. */
+  {
+    int index;
+    char *temp;
+    int substring_okay = 0;
+
+    if (string[i] == '?')
+      {
+	substring_okay++;
+	i++;
+      }
+
+    for (index = i; string[i]; i++)
+      if (whitespace (string[i]) ||
+	  string[i] == '\n' ||
+	  string[i] == ':' ||
+	  (substring_okay && string[i] == '?') ||
+	  string[i] == delimiting_quote)
+	break;
+
+    temp = (char *)alloca (1 + (i - index));
+    strncpy (temp, &string[index], (i - index));
+    temp[i - index] = '\0';
+
+    if (string[i] == '?')
+      i++;
+
+    *caller_index = i;
+
+  search_again:
+
+    index = history_search_internal
+      (temp, -1, substring_okay ? NON_ANCHORED_SEARCH : ANCHORED_SEARCH);
+
+    if (index < 0)
+    search_lost:
+      {
+	history_offset = history_length;
+	return ((char *)NULL);
+      }
+
+    if (index == 0)
+      {
+      search_won:
+	entry = current_history ();
+	history_offset = history_length;
+	
+	/* If this was a substring search, then remember the string that
+	   we matched for word substitution. */
+	if (substring_okay)
+	  {
+	    if (search_string)
+	      free (search_string);
+	    search_string = savestring (temp);
+	  }
+
+	return (entry->line);
+      }
+
+    if (history_offset)
+      history_offset--;
+    else
+      goto search_lost;
+    
+    goto search_again;
+  }
+}
+
+/* Expand the string STRING, placing the result into OUTPUT, a pointer
+   to a string.  Returns:
+
+   0) If no expansions took place (or, if the only change in
+      the text was the de-slashifying of the history expansion
+      character)
+   1) If expansions did take place
+  -1) If there was an error in expansion.
+
+  If an error ocurred in expansion, then OUTPUT contains a descriptive
+  error message. */
+int
+history_expand (string, output)
+     char *string;
+     char **output;
+{
+  register int j, l = strlen (string);
+  int i, word_spec_error = 0;
+  int cc, modified = 0;
+  char *word_spec, *event;
+  int starting_index, only_printing = 0, substitute_globally = 0;
+
+  char *get_history_word_specifier (), *rindex ();
+
+  /* The output string, and its length. */
+  int len = 0;
+  char *result = (char *)NULL;
+
+  /* Used in add_string; */
+  char *temp, tt[2], tbl[3];
+
+  /* Prepare the buffer for printing error messages. */
+  result = (char *)xmalloc (len = 255);
+
+  result[0] = tt[1] = tbl[2] = '\0';
+  tbl[0] = '\\';
+  tbl[1] = history_expansion_char;
+
+  /* Grovel the string.  Only backslash can quote the history escape
+     character.  We also handle arg specifiers. */
+
+  /* Before we grovel forever, see if the history_expansion_char appears
+     anywhere within the text. */
+
+  /* The quick substitution character is a history expansion all right.  That
+     is to say, "^this^that^" is equivalent to "!!:s^this^that^", and in fact,
+     that is the substitution that we do. */
+  if (string[0] == history_subst_char)
+    {
+      char *format_string = (char *)alloca (10 + strlen (string));
+
+      sprintf (format_string, "%c%c:s%s",
+	       history_expansion_char, history_expansion_char,
+	       string);
+      string = format_string;
+      l += 4;
+      goto grovel;
+    }
+
+  /* If not quick substitution, still maybe have to do expansion. */
+
+  /* `!' followed by one of the characters in history_no_expand_chars
+     is NOT an expansion. */
+  for (i = 0; string[i]; i++)
+    if (string[i] == history_expansion_char)
+      if (!string[i + 1] || member (string[i + 1], history_no_expand_chars))
+	continue;
+      else
+	goto grovel;
+
+  free (result);
+  *output = savestring (string);
+  return (0);
+
+ grovel:
+
+  for (i = j = 0; i < l; i++)
+    {
+      int tchar = string[i];
+      if (tchar == history_expansion_char)
+	tchar = -3;
+
+      switch (tchar)
+	{
+	case '\\':
+	  if (string[i + 1] == history_expansion_char)
+	    {
+	      i++;
+	      temp = tbl;
+	      goto do_add;
+	    }
+	  else
+	    goto add_char;
+
+	  /* case history_expansion_char: */
+	case -3:
+	  starting_index = i + 1;
+	  cc = string[i + 1];
+
+	  /* If the history_expansion_char is followed by one of the
+	     characters in history_no_expand_chars, then it is not a
+	     candidate for expansion of any kind. */
+	  if (member (cc, history_no_expand_chars))
+	    goto add_char;
+
+	  /* There is something that is listed as a `word specifier' in csh
+	     documentation which means `the expanded text to this point'.
+	     That is not a word specifier, it is an event specifier. */
+
+	  if (cc == '#')
+	    goto hack_pound_sign;
+
+	  /* If it is followed by something that starts a word specifier,
+	     then !! is implied as the event specifier. */
+
+	  if (member (cc, ":$*%^"))
+	    {
+	      char fake_s[3];
+	      int fake_i = 0;
+	      i++;
+	      fake_s[0] = fake_s[1] = history_expansion_char;
+	      fake_s[2] = '\0';
+	      event = get_history_event (fake_s, &fake_i, 0);
+	    }
+	  else
+	    {
+	      int quoted_search_delimiter = 0;
+
+	      /* If the character before this `!' is a double or single
+		 quote, then this expansion takes place inside of the
+		 quoted string.  If we have to search for some text ("!foo"),
+		 allow the delimiter to end the search string. */
+	      if (i && (string[i - 1] == '\'' || string[i - 1] == '"'))
+		quoted_search_delimiter = string[i - 1];
+
+	      event = get_history_event (string, &i, quoted_search_delimiter);
+	    }
+	  
+	  if (!event)
+	  event_not_found:
+	    {
+	    int l = 1 + (i - starting_index);
+
+	    temp = (char *)alloca (1 + l);
+	    strncpy (temp, string + starting_index, l);
+	    temp[l - 1] = 0;
+	    sprintf (result, "%s: %s.", temp,
+		     word_spec_error ? "Bad word specifier" : "Event not found");
+	  error_exit:
+	    *output = result;
+	    return (-1);
+	  }
+
+	  /* If a word specifier is found, then do what that requires. */
+	  starting_index = i;
+
+	  word_spec = get_history_word_specifier (string, event, &i);
+
+	  /* There is no such thing as a `malformed word specifier'.  However,
+	     it is possible for a specifier that has no match.  In that case,
+	     we complain. */
+	  if (word_spec == (char *)-1)
+	  bad_word_spec:
+	  {
+	    word_spec_error++;
+	    goto event_not_found;
+	  }
+
+	  /* If no word specifier, than the thing of interest was the event. */
+	  if (!word_spec)
+	    temp = event;
+	  else
+	    {
+	      temp = (char *)alloca (1 + strlen (word_spec));
+	      strcpy (temp, word_spec);
+	      free (word_spec);
+	    }
+
+	  /* Perhaps there are other modifiers involved.  Do what they say. */
+
+	hack_specials:
+
+	  if (string[i] == ':')
+	    {
+	      char *tstr;
+
+	      switch (string[i + 1])
+		{
+		  /* :p means make this the last executed line.  So we
+		     return an error state after adding this line to the
+		     history. */
+		case 'p':
+		  only_printing++;
+		  goto next_special;
+
+		  /* :t discards all but the last part of the pathname. */
+		case 't':
+		  tstr = rindex (temp, '/');
+		  if (tstr)
+		    temp = ++tstr;
+		  goto next_special;
+
+		  /* :h discards the last part of a pathname. */
+		case 'h':
+		  tstr = rindex (temp, '/');
+		  if (tstr)
+		    *tstr = '\0';
+		  goto next_special;
+
+		  /* :r discards the suffix. */
+		case 'r':
+		  tstr = rindex (temp, '.');
+		  if (tstr)
+		    *tstr = '\0';
+		  goto next_special;
+
+		  /* :e discards everything but the suffix. */
+		case 'e':
+		  tstr = rindex (temp, '.');
+		  if (tstr)
+		    temp = tstr;
+		  goto next_special;
+
+		  /* :s/this/that substitutes `this' for `that'. */
+		  /* :gs/this/that substitutes `this' for `that' globally. */
+		case 'g':
+		  if (string[i + 2] == 's')
+		    {
+		      i++;
+		      substitute_globally = 1;
+		      goto substitute;
+		    }
+		  else
+		    
+		case 's':
+		  substitute:
+		  {
+		    char *this, *that, *new_event;
+		    int delimiter = 0;
+		    int si, l_this, l_that, l_temp = strlen (temp);
+
+		    if (i + 2 < strlen (string))
+		      delimiter = string[i + 2];
+
+		    if (!delimiter)
+		      break;
+
+		    i += 3;
+
+		    /* Get THIS. */
+		    for (si = i; string[si] && string[si] != delimiter; si++);
+		    l_this = (si - i);
+		    this = (char *)alloca (1 + l_this);
+		    strncpy (this, string + i, l_this);
+		    this[l_this] = '\0';
+
+		    i = si;
+		    if (string[si])
+		      i++;
+
+		    /* Get THAT. */
+		    for (si = i; string[si] && string[si] != delimiter; si++);
+		    l_that = (si - i);
+		    that = (char *)alloca (1 + l_that);
+		    strncpy (that, string + i, l_that);
+		    that[l_that] = '\0';
+
+		    i = si;
+		    if (string[si]) i++;
+
+		    /* Ignore impossible cases. */
+		    if (l_this > l_temp)
+		      goto cant_substitute;
+
+		    /* Find the first occurrence of THIS in TEMP. */
+		    si = 0;
+		    for (; (si + l_this) <= l_temp; si++)
+		      if (strncmp (temp + si, this, l_this) == 0)
+			{
+			  new_event =
+			    (char *)alloca (1 + (l_that - l_this) + l_temp);
+			  strncpy (new_event, temp, si);
+			  strncpy (new_event + si, that, l_that);
+			  strncpy (new_event + si + l_that,
+				   temp + si + l_this,
+				   l_temp - (si + l_this));
+			  new_event[(l_that - l_this) + l_temp] = '\0';
+			  temp = new_event;
+
+			  if (substitute_globally)
+			    {
+			      si += l_that;
+			      l_temp = strlen (temp);
+			      substitute_globally++;
+			      continue;
+			    }
+
+			  goto hack_specials;
+			}
+
+		  cant_substitute:
+
+		    if (substitute_globally > 1)
+		      {
+			substitute_globally = 0;
+			goto hack_specials;
+		      }
+
+		    goto event_not_found;
+		  }
+
+		  /* :# is the line so far.  Note that we have to
+		     alloca () it since RESULT could be realloc ()'ed
+		     below in add_string. */
+		case '#':
+		hack_pound_sign:
+		  if (result)
+		    {
+		      temp = (char *)alloca (1 + strlen (result));
+		      strcpy (temp, result);
+		    }
+		  else
+		    temp = "";
+
+		next_special:
+		  i += 2;
+		  goto hack_specials;
+		}
+
+	    }
+	  /* Believe it or not, we have to back the pointer up by one. */
+	  --i;
+	  goto add_string;
+
+	  /* A regular character.  Just add it to the output string. */
+	default:
+	add_char:
+	  tt[0] = string[i];
+	  temp = tt;
+	  goto do_add;
+
+	add_string:
+	  modified++;
+
+	do_add:
+	  j += strlen (temp);
+	  while (j > len)
+	    result = (char *)xrealloc (result, (len += 255));
+
+	  strcpy (result + (j - strlen (temp)), temp);
+	}
+    }
+
+  *output = result;
+
+  if (only_printing)
+    {
+      add_history (result);
+      return (-1);
+    }
+
+  return (modified != 0);
+}
+
+/* Return a consed string which is the word specified in SPEC, and found
+   in FROM.  NULL is returned if there is no spec.  -1 is returned if
+   the word specified cannot be found.  CALLER_INDEX is the offset in
+   SPEC to start looking; it is updated to point to just after the last
+   character parsed. */
+char *
+get_history_word_specifier (spec, from, caller_index)
+     char *spec, *from;
+     int *caller_index;
+{
+  register int i = *caller_index;
+  int first, last;
+  int expecting_word_spec = 0;
+  char *history_arg_extract ();
+
+  /* The range of words to return doesn't exist yet. */
+  first = last = 0;
+
+  /* If we found a colon, then this *must* be a word specification.  If
+     it isn't, then it is an error. */
+  if (spec[i] == ':')
+    i++, expecting_word_spec++;
+
+  /* Handle special cases first. */
+
+  /* `%' is the word last searched for. */
+  if (spec[i] == '%')
+    {
+      *caller_index = i + 1;
+      if (search_string)
+	return (savestring (search_string));
+      else
+	return (savestring (""));
+    }
+
+  /* `*' matches all of the arguments, but not the command. */
+  if (spec[i] == '*')
+    {
+      char *star_result;
+
+      *caller_index = i + 1;
+      star_result = history_arg_extract (1, '$', from);
+
+      if (!star_result)
+	star_result = savestring ("");
+
+      return (star_result);
+    }
+
+  /* `$' is last arg. */
+  if (spec[i] == '$')
+    {
+      *caller_index = i + 1;
+      return (history_arg_extract ('$', '$', from));
+    }
+
+  /* Try to get FIRST and LAST figured out. */
+  if (spec[i] == '-' || spec[i] == '^')
+    {
+      first = 1;
+      goto get_last;
+    }
+
+ get_first:
+  if (digit (spec[i]) && expecting_word_spec)
+    {
+      sscanf (spec + i, "%d", &first);
+      for (; digit (spec[i]); i++);
+    }
+  else
+    return ((char *)NULL);
+
+ get_last:
+  if (spec[i] == '^')
+    {
+      i++;
+      last = 1;
+      goto get_args;
+    }
+
+  if (spec[i] != '-')
+    {
+      last = first;
+      goto get_args;
+    }
+
+  i++;
+
+  if (digit (spec[i]))
+    {
+      sscanf (spec + i, "%d", &last);
+      for (; digit (spec[i]); i++);
+    }
+  else
+    if (spec[i] == '$')
+      {
+	i++;
+	last = '$';
+      }
+
+ get_args:
+  {
+    char *result = (char *)NULL;
+
+    *caller_index = i;
+
+    if (last >= first)
+      result = history_arg_extract (first, last, from);
+
+    if (result)
+      return (result);
+    else
+      return ((char *)-1);
+  }
+}
+
+/* Extract the args specified, starting at FIRST, and ending at LAST.
+   The args are taken from STRING.  If either FIRST or LAST is < 0,
+   then make that arg count from the right (subtract from the number of
+   tokens, so that FIRST = -1 means the next to last token on the line). */
+char *
+history_arg_extract (first, last, string)
+     int first, last;
+     char *string;
+{
+  register int i, len;
+  char *result = (char *)NULL;
+  int size = 0, offset = 0;
+
+  char **history_tokenize (), **list;
+
+  if (!(list = history_tokenize (string)))
+    return ((char *)NULL);
+
+  for (len = 0; list[len]; len++);
+
+  if (last < 0)
+    last = len + last - 1;
+
+  if (first < 0)
+    first = len + first - 1;
+
+  if (last == '$')
+    last = len - 1;
+
+  if (first == '$')
+    first = len - 1;
+
+  last++;
+
+  if (first > len || last > len || first < 0 || last < 0)
+    result = ((char *)NULL);
+  else
+    {
+      for (i = first; i < last; i++)
+	{
+	  int l = strlen (list[i]);
+
+	  if (!result)
+	    result = (char *)xmalloc ((size = (2 + l)));
+	  else
+	    result = (char *)xrealloc (result, (size += (2 + l)));
+	  strcpy (result + offset, list[i]);
+	  offset += l;
+	  if (i + 1 < last)
+	    {
+	      strcpy (result + offset, " ");
+	      offset++;
+	    }
+	}
+    }
+
+  for (i = 0; i < len; i++)
+    free (list[i]);
+
+  free (list);
+
+  return (result);
+}
+
+#define slashify_in_quotes "\\`\"$"
+
+/* Return an array of tokens, much as the shell might.  The tokens are
+   parsed out of STRING. */
+char **
+history_tokenize (string)
+     char *string;
+{
+  char **result = (char **)NULL;
+  register int i, start, result_index, size;
+  int len;
+
+  i = result_index = size = 0;
+
+  /* Get a token, and stuff it into RESULT.  The tokens are split
+     exactly where the shell would split them. */
+ get_token:
+
+  /* Skip leading whitespace. */
+  for (; string[i] && whitespace(string[i]); i++);
+
+  start = i;
+
+  if (!string[i] || string[i] == history_comment_char)
+    return (result);
+
+  if (member (string[i], "()\n")) {
+    i++;
+    goto got_token;
+  }
+
+  if (member (string[i], "<>;&|")) {
+    int peek = string[i + 1];
+
+    if (peek == string[i]) {
+      if (peek ==  '<') {
+	if (string[1 + 2] == '-')
+	  i++;
+	i += 2;
+	goto got_token;
+      }
+
+      if (member (peek, ">:&|")) {
+	i += 2;
+	goto got_token;
+      }
+    } else {
+      if ((peek == '&' &&
+	  (string[i] == '>' || string[i] == '<')) ||
+	  ((peek == '>') &&
+	  (string[i] == '&'))) {
+	i += 2;
+	goto got_token;
+      }
+    }
+    i++;
+    goto got_token;
+  }
+
+  /* Get word from string + i; */
+  {
+    int delimiter = 0;
+
+    if (member (string[i], "\"'`"))
+      delimiter = string[i++];
+
+    for (;string[i]; i++) {
+
+      if (string[i] == '\\') {
+
+	if (string[i + 1] == '\n') {
+	  i++;
+	  continue;
+	} else {
+	  if (delimiter != '\'')
+	    if ((delimiter != '"') ||
+		(member (string[i], slashify_in_quotes))) {
+	      i++;
+	      continue;
+	    }
+	}
+      }
+
+      if (delimiter && string[i] == delimiter) {
+	delimiter = 0;
+	continue;
+      }
+
+      if (!delimiter && (member (string[i], " \t\n;&()|<>")))
+	goto got_token;
+
+      if (!delimiter && member (string[i], "\"'`")) {
+	delimiter = string[i];
+	continue;
+      }
+    }
+    got_token:
+
+    len = i - start;
+    if (result_index + 2 >= size) {
+      if (!size)
+	result = (char **)xmalloc ((size = 10) * (sizeof (char *)));
+      else
+	result =
+	  (char **)xrealloc (result, ((size += 10) * (sizeof (char *))));
+    }
+    result[result_index] = (char *)xmalloc (1 + len);
+    strncpy (result[result_index], string + start, len);
+    result[result_index][len] = '\0';
+    result_index++;
+    result[result_index] = (char *)NULL;
+  }
+  if (string[i])
+    goto get_token;
+
+  return (result);
+}
+
+#if defined (STATIC_MALLOC)
+
+/* **************************************************************** */
+/*								    */
+/*			xmalloc and xrealloc ()		     	    */
+/*								    */
+/* **************************************************************** */
+
+static void memory_error_and_abort ();
+
+static char *
+xmalloc (bytes)
+     int bytes;
+{
+  char *temp = (char *)malloc (bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static char *
+xrealloc (pointer, bytes)
+     char *pointer;
+     int bytes;
+{
+  char *temp;
+
+  if (!pointer)
+    temp = (char *)xmalloc (bytes);
+  else
+    temp = (char *)realloc (pointer, bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+
+  return (temp);
+}
+
+static void
+memory_error_and_abort ()
+{
+  fprintf (stderr, "history: Out of virtual memory!\n");
+  abort ();
+}
+#endif /* STATIC_MALLOC */
+
+
+/* **************************************************************** */
+/*								    */
+/*				Test Code			    */
+/*								    */
+/* **************************************************************** */
+#ifdef TEST
+main ()
+{
+  char line[1024], *t;
+  int done = 0;
+
+  line[0] = 0;
+
+  while (!done)
+    {
+      fprintf (stdout, "history%% ");
+      t = gets (line);
+
+      if (!t)
+	strcpy (line, "quit");
+
+      if (line[0])
+	{
+	  char *expansion;
+	  int result;
+
+	  using_history ();
+
+	  result = history_expand (line, &expansion);
+	  strcpy (line, expansion);
+	  free (expansion);
+	  if (result)
+	    fprintf (stderr, "%s\n", line);
+
+	  if (result < 0)
+	    continue;
+
+	  add_history (line);
+	}
+
+      if (strcmp (line, "quit") == 0) done = 1;
+      if (strcmp (line, "save") == 0) write_history (0);
+      if (strcmp (line, "read") == 0) read_history (0);
+      if (strcmp (line, "list") == 0)
+	{
+	  register HIST_ENTRY **the_list = history_list ();
+	  register int i;
+
+	  if (the_list)
+	    for (i = 0; the_list[i]; i++)
+	      fprintf (stdout, "%d: %s\n", i + history_base, the_list[i]->line);
+	}
+      if (strncmp (line, "delete", strlen ("delete")) == 0)
+	{
+	  int which;
+	  if ((sscanf (line + strlen ("delete"), "%d", &which)) == 1)
+	    {
+	      HIST_ENTRY *entry = remove_history (which);
+	      if (!entry)
+		fprintf (stderr, "No such entry %d\n", which);
+	      else
+		{
+		  free (entry->line);
+		  free (entry);
+		}
+	    }
+	  else
+	    {
+	      fprintf (stderr, "non-numeric arg given to `delete'\n");
+	    }
+	}
+    }
+}
+
+#endif				/* TEST */
+
+/*
+* Local variables:
+* compile-command: "gcc -g -DTEST -o history history.c"
+* end:
+*/
diff --git a/gnu/usr.bin/gdb/readline/history.h b/gnu/usr.bin/gdb/readline/history.h
new file mode 100644
index 00000000000..c30ac5247e2
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/history.h
@@ -0,0 +1,122 @@
+/* History.h -- the names of functions that you can call in history. */
+/* $Id: history.h,v 1.1 1995/10/18 08:40:15 deraadt Exp $ */
+
+/* The structure used to store a history entry. */
+typedef struct _hist_entry {
+  char *line;
+  char *data;
+} HIST_ENTRY;
+
+/* For convenience only.  You set this when interpreting history commands.
+   It is the logical offset of the first history element. */
+extern int history_base;
+
+/* Begin a session in which the history functions might be used.  This
+   just initializes the interactive variables. */
+extern void using_history ();
+
+/* Place STRING at the end of the history list.
+   The associated data field (if any) is set to NULL. */
+extern void add_history ();
+
+/* Returns the number which says what history element we are now
+   looking at.  */
+extern int where_history ();
+  
+/* Set the position in the history list to POS. */
+int history_set_pos ();
+
+/* Search for STRING in the history list, starting at POS, an
+   absolute index into the list.  DIR, if negative, says to search
+   backwards from POS, else forwards.
+   Returns the absolute index of the history element where STRING
+   was found, or -1 otherwise. */
+extern int history_search_pos ();
+
+/* A reasonably useless function, only here for completeness.  WHICH
+   is the magic number that tells us which element to delete.  The
+   elements are numbered from 0. */
+extern HIST_ENTRY *remove_history ();
+
+/* Stifle the history list, remembering only MAX number of entries. */
+extern void stifle_history ();
+
+/* Stop stifling the history.  This returns the previous amount the
+   history was stifled by.  The value is positive if the history was
+   stifled, negative if it wasn't. */
+extern int unstifle_history ();
+
+/* Add the contents of FILENAME to the history list, a line at a time.
+   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
+   successful, or errno if not. */
+extern int read_history ();
+
+/* Read a range of lines from FILENAME, adding them to the history list.
+   Start reading at the FROM'th line and end at the TO'th.  If FROM
+   is zero, start at the beginning.  If TO is less than FROM, read
+   until the end of the file.  If FILENAME is NULL, then read from
+   ~/.history.  Returns 0 if successful, or errno if not. */
+extern int read_history_range ();
+
+/* Append the current history to FILENAME.  If FILENAME is NULL,
+   then append the history list to ~/.history.  Values returned
+   are as in read_history ().  */
+extern int write_history ();
+
+/* Append NELEMENT entries to FILENAME.  The entries appended are from
+   the end of the list minus NELEMENTs up to the end of the list. */
+int append_history ();
+
+/* Make the history entry at WHICH have LINE and DATA.  This returns
+   the old entry so you can dispose of the data.  In the case of an
+   invalid WHICH, a NULL pointer is returned. */
+extern HIST_ENTRY *replace_history_entry ();
+
+/* Return the history entry at the current position, as determined by
+   history_offset.  If there is no entry there, return a NULL pointer. */
+HIST_ENTRY *current_history ();
+
+/* Back up history_offset to the previous history entry, and return
+   a pointer to that entry.  If there is no previous entry, return
+   a NULL pointer. */
+extern HIST_ENTRY *previous_history ();
+
+/* Move history_offset forward to the next item in the input_history,
+   and return the a pointer to that entry.  If there is no next entry,
+   return a NULL pointer. */
+extern HIST_ENTRY *next_history ();
+
+/* Return a NULL terminated array of HIST_ENTRY which is the current input
+   history.  Element 0 of this list is the beginning of time.  If there
+   is no history, return NULL. */
+extern HIST_ENTRY **history_list ();
+
+/* Search the history for STRING, starting at history_offset.
+   If DIRECTION < 0, then the search is through previous entries,
+   else through subsequent.  If the string is found, then
+   current_history () is the history entry, and the value of this function
+   is the offset in the line of that history entry that the string was
+   found in.  Otherwise, nothing is changed, and a -1 is returned. */
+extern int history_search ();
+
+/* Expand the string STRING, placing the result into OUTPUT, a pointer
+   to a string.  Returns:
+
+   0) If no expansions took place (or, if the only change in
+      the text was the de-slashifying of the history expansion
+      character)
+   1) If expansions did take place
+  -1) If there was an error in expansion.
+
+  If an error ocurred in expansion, then OUTPUT contains a descriptive
+  error message. */
+extern int history_expand ();
+
+/* Extract a string segment consisting of the FIRST through LAST
+   arguments present in STRING.  Arguments are broken up as in
+   the shell. */
+extern char *history_arg_extract ();
+
+/* Return the number of bytes that the primary history entries are using.
+   This just adds up the lengths of the_history->lines. */
+extern int history_total_bytes ();
diff --git a/gnu/usr.bin/gdb/readline/keymaps.c b/gnu/usr.bin/gdb/readline/keymaps.c
new file mode 100644
index 00000000000..652a2c48cec
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/keymaps.c
@@ -0,0 +1,183 @@
+/* keymaps.c -- Functions and keymaps for the GNU Readline library. */
+
+/* Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+
+   This file is part of GNU Readline, a library for reading lines
+   of text with interactive input and history editing.
+
+   Readline is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: keymaps.c,v 1.1 1995/10/18 08:40:15 deraadt Exp $
+*/
+
+#include "sysdep.h"
+#include <stdio.h>
+#include "readline.h"
+#include "keymaps.h"
+#include "emacs_keymap.c"
+
+#ifdef VI_MODE
+#include "vi_keymap.c"
+#endif
+
+/* Remove these declarations when we have a complete libgnu.a. */
+/* #define STATIC_MALLOC */
+#if !defined (STATIC_MALLOC)
+extern char *xmalloc (), *xrealloc ();
+#else
+static char *xmalloc (), *xrealloc ();
+#endif /* STATIC_MALLOC */
+
+/* **************************************************************** */
+/*								    */
+/*		      Functions for manipulating Keymaps.	    */
+/*								    */
+/* **************************************************************** */
+
+
+/* Return a new, empty keymap.
+   Free it with free() when you are done. */
+Keymap
+rl_make_bare_keymap ()
+{
+  register int i;
+  Keymap keymap = (Keymap)xmalloc (128 * sizeof (KEYMAP_ENTRY));
+
+  for (i = 0; i < 128; i++)
+    {
+      keymap[i].type = ISFUNC;
+      keymap[i].function = (Function *)NULL;
+    }
+
+  for (i = 'A'; i < ('Z' + 1); i++)
+    {
+      keymap[i].type = ISFUNC;
+      keymap[i].function = rl_do_lowercase_version;
+    }
+
+  return (keymap);
+}
+
+/* Return a new keymap which is a copy of MAP. */
+Keymap
+rl_copy_keymap (map)
+     Keymap map;
+{
+  register int i;
+  Keymap temp = rl_make_bare_keymap ();
+
+  for (i = 0; i < 128; i++)
+    {
+      temp[i].type = map[i].type;
+      temp[i].function = map[i].function;
+    }
+  return (temp);
+}
+
+/* Return a new keymap with the printing characters bound to rl_insert,
+   the uppercase Meta characters bound to run their lowercase equivalents,
+   and the Meta digits bound to produce numeric arguments. */
+Keymap
+rl_make_keymap ()
+{
+  extern rl_insert (), rl_rubout ();
+  register int i;
+  Keymap newmap;
+
+  newmap = rl_make_bare_keymap ();
+
+  /* All printing characters are self-inserting. */
+  for (i = ' '; i < 126; i++)
+    newmap[i].function = rl_insert;
+
+  newmap[TAB].function = rl_insert;
+  newmap[RUBOUT].function = rl_rubout;
+  newmap[CTRL('H')].function = rl_rubout;
+
+  return (newmap);
+}
+
+/* Free the storage associated with MAP. */
+rl_discard_keymap (map)
+     Keymap (map);
+{
+  int i;
+
+  if (!map)
+    return;
+
+  for (i = 0; i < 128; i++)
+    {
+      switch (map[i].type)
+	{
+	case ISFUNC:
+	  break;
+
+	case ISKMAP:
+	  rl_discard_keymap ((Keymap)map[i].function);
+	  break;
+
+	case ISMACR:
+	  free ((char *)map[i].function);
+	  break;
+	}
+    }
+}
+
+#ifdef STATIC_MALLOC
+
+/* **************************************************************** */
+/*								    */
+/*			xmalloc and xrealloc ()		     	    */
+/*								    */
+/* **************************************************************** */
+
+static void memory_error_and_abort ();
+
+static char *
+xmalloc (bytes)
+     int bytes;
+{
+  char *temp = (char *)malloc (bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static char *
+xrealloc (pointer, bytes)
+     char *pointer;
+     int bytes;
+{
+  char *temp;
+
+  if (!pointer)
+    temp = (char *)malloc (bytes);
+  else
+    temp = (char *)realloc (pointer, bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static void
+memory_error_and_abort ()
+{
+  fprintf (stderr, "readline: Out of virtual memory!\n");
+  abort ();
+}
+#endif /* STATIC_MALLOC */
diff --git a/gnu/usr.bin/gdb/readline/keymaps.h b/gnu/usr.bin/gdb/readline/keymaps.h
new file mode 100644
index 00000000000..f40ddcbd391
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/keymaps.h
@@ -0,0 +1,52 @@
+/* keymaps.h -- Manipulation of readline keymaps. */
+/* $Id: keymaps.h,v 1.1 1995/10/18 08:40:15 deraadt Exp $ */
+
+#ifndef _KEYMAPS_H_
+#define _KEYMAPS_H_
+
+#include "chardefs.h"
+
+#ifndef __FUNCTION_DEF
+typedef int Function ();
+#define __FUNCTION_DEF
+#endif
+
+/* A keymap contains one entry for each key in the ASCII set.
+   Each entry consists of a type and a pointer.
+   POINTER is the address of a function to run, or the
+   address of a keymap to indirect through.
+   TYPE says which kind of thing POINTER is. */
+typedef struct _keymap_entry {
+  char type;
+  Function *function;
+} KEYMAP_ENTRY;
+
+/* I wanted to make the above structure contain a union of:
+   union { Function *function; struct _keymap_entry *keymap; } value;
+   but this made it impossible for me to create a static array.
+   Maybe I need C lessons. */
+
+typedef KEYMAP_ENTRY KEYMAP_ENTRY_ARRAY[128];
+typedef KEYMAP_ENTRY *Keymap;
+
+/* The values that TYPE can have in a keymap entry. */
+#define ISFUNC 0
+#define ISKMAP 1
+#define ISMACR 2
+
+extern KEYMAP_ENTRY_ARRAY emacs_standard_keymap, emacs_meta_keymap, emacs_ctlx_keymap;
+extern KEYMAP_ENTRY_ARRAY vi_insertion_keymap, vi_movement_keymap;
+
+/* Return a new, empty keymap.
+   Free it with free() when you are done. */
+Keymap rl_make_bare_keymap ();
+
+/* Return a new keymap which is a copy of MAP. */
+Keymap rl_copy_keymap ();
+
+/* Return a new keymap with the printing characters bound to rl_insert,
+   the lowercase Meta characters bound to run their equivalents, and
+   the Meta digits bound to produce numeric arguments. */
+Keymap rl_make_keymap ();
+
+#endif /* _KEYMAPS_H_ */
diff --git a/gnu/usr.bin/gdb/readline/readline.c b/gnu/usr.bin/gdb/readline/readline.c
new file mode 100644
index 00000000000..1446c416f89
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/readline.c
@@ -0,0 +1,6655 @@
+/* readline.c -- a general facility for reading lines of input
+   with emacs style editing and completion.  */
+
+/* Copyright 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
+
+   This file contains the Readline Library (the Library), a set of
+   routines for providing Emacs style line input to programs that ask
+   for it.
+
+   The Library is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   The Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: readline.c,v 1.1 1995/10/18 08:40:15 deraadt Exp $
+*/
+
+/* Remove these declarations when we have a complete libgnu.a. */
+/* #define STATIC_MALLOC */
+#if !defined (STATIC_MALLOC)
+extern char *xmalloc (), *xrealloc ();
+#else
+static char *xmalloc (), *xrealloc ();
+#endif /* STATIC_MALLOC */
+
+#include "sysdep.h"
+#include <stdio.h>
+#include <fcntl.h>
+#ifndef	NO_SYS_FILE
+#include <sys/file.h>
+#endif
+#include <signal.h>
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#define NEW_TTY_DRIVER
+#define HAVE_BSD_SIGNALS
+/* #define USE_XON_XOFF */
+
+#ifdef __MSDOS__
+#undef NEW_TTY_DRIVER
+#undef HAVE_BSD_SIGNALS
+#endif
+
+/* Some USG machines have BSD signal handling (sigblock, sigsetmask, etc.) */
+#if defined (USG) && !defined (hpux)
+#undef HAVE_BSD_SIGNALS
+#endif
+
+/* System V machines use termio. */
+#if !defined (_POSIX_VERSION)
+#  if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi) || defined (DGUX) || defined (__H3050R) || defined (__H3050RX)
+#    undef NEW_TTY_DRIVER
+#    define TERMIO_TTY_DRIVER
+#    include <termio.h>
+#    if !defined (TCOON)
+#      define TCOON 1
+#    endif
+#  endif /* USG || hpux || Xenix || sgi || DUGX */
+#endif /* !_POSIX_VERSION */
+
+/* Posix systems use termios and the Posix signal functions. */
+#if defined (_POSIX_VERSION)
+#  if !defined (TERMIOS_MISSING)
+#    undef NEW_TTY_DRIVER
+#    define TERMIOS_TTY_DRIVER
+#    include <termios.h>
+#  endif /* !TERMIOS_MISSING */
+#  define HAVE_POSIX_SIGNALS
+#  if !defined (O_NDELAY)
+#    define O_NDELAY O_NONBLOCK	/* Posix-style non-blocking i/o */
+#  endif /* O_NDELAY */
+#endif /* _POSIX_VERSION */
+
+/* Other (BSD) machines use sgtty. */
+#if defined (NEW_TTY_DRIVER)
+#include <sgtty.h>
+#endif
+
+/* Define _POSIX_VDISABLE if we are not using the `new' tty driver and
+   it is not already defined.  It is used both to determine if a
+   special character is disabled and to disable certain special
+   characters.  Posix systems should set to 0, USG systems to -1. */
+#if !defined (NEW_TTY_DRIVER) && !defined (_POSIX_VDISABLE)
+#  if defined (_POSIX_VERSION)
+#    define _POSIX_VDISABLE 0
+#  else /* !_POSIX_VERSION */
+#    define _POSIX_VDISABLE -1
+#  endif /* !_POSIX_VERSION */
+#endif /* !NEW_TTY_DRIVER && !_POSIX_VDISABLE */
+
+/* Define some macros for dealing with assorted signalling disciplines.
+
+   These macros provide a way to use signal blocking and disabling
+   without smothering your code in a pile of #ifdef's.
+
+   SIGNALS_UNBLOCK;			Stop blocking all signals.
+
+   {
+     SIGNALS_DECLARE_SAVED (name);	Declare a variable to save the 
+					signal blocking state.
+	...
+     SIGNALS_BLOCK (SIGSTOP, name);	Block a signal, and save the previous
+					state for restoration later.
+	...
+     SIGNALS_RESTORE (name);		Restore previous signals.
+   }
+
+*/
+
+#ifdef HAVE_POSIX_SIGNALS
+							/* POSIX signals */
+
+#define	SIGNALS_UNBLOCK \
+      do { sigset_t set;	\
+	sigemptyset (&set);	\
+	sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);	\
+      } while (0)
+
+#define	SIGNALS_DECLARE_SAVED(name)	sigset_t name
+
+#define	SIGNALS_BLOCK(SIG, saved)	\
+	do { sigset_t set;		\
+	  sigemptyset (&set);		\
+	  sigaddset (&set, SIG);	\
+	  sigprocmask (SIG_BLOCK, &set, &saved);	\
+	} while (0)
+
+#define	SIGNALS_RESTORE(saved)		\
+  sigprocmask (SIG_SETMASK, &saved, (sigset_t *)NULL)
+
+
+#else	/* HAVE_POSIX_SIGNALS */
+#ifdef HAVE_BSD_SIGNALS
+							/* BSD signals */
+
+#define	SIGNALS_UNBLOCK			sigsetmask (0)
+#define	SIGNALS_DECLARE_SAVED(name)	int name
+#define	SIGNALS_BLOCK(SIG, saved)	saved = sigblock (sigmask (SIG))
+#define	SIGNALS_RESTORE(saved)		sigsetmask (saved)
+
+
+#else  /* HAVE_BSD_SIGNALS */
+							/* None of the Above */
+
+#define	SIGNALS_UNBLOCK			/* nothing */
+#define	SIGNALS_DECLARE_SAVED(name)	/* nothing */
+#define	SIGNALS_BLOCK(SIG, saved)	/* nothing */
+#define	SIGNALS_RESTORE(saved)		/* nothing */
+
+
+#endif /* HAVE_BSD_SIGNALS */
+#endif /* HAVE_POSIX_SIGNALS */
+
+/*  End of signal handling definitions.  */
+
+
+#include <errno.h>
+extern int errno;
+
+#include <setjmp.h>
+#include <sys/stat.h>
+
+/* Posix macro to check file in statbuf for directory-ness. */
+#if defined (S_IFDIR) && !defined (S_ISDIR)
+#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
+#endif
+
+#ifndef __MSDOS__
+/* These next are for filename completion.  Perhaps this belongs
+   in a different place. */
+#include <pwd.h>
+#endif /* __MSDOS__ */
+
+#if defined (USG) && !defined (isc386) && !defined (sgi)
+struct passwd *getpwuid (), *getpwent ();
+#endif
+
+/* #define HACK_TERMCAP_MOTION */
+
+/* Some standard library routines. */
+#include "readline.h"
+#include "history.h"
+
+#ifndef digit
+#define digit(c)  ((c) >= '0' && (c) <= '9')
+#endif
+
+#ifndef isletter
+#define isletter(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+#endif
+
+#ifndef digit_value
+#define digit_value(c) ((c) - '0')
+#endif
+
+#ifndef member
+#define member(c, s) ((c) ? index ((s), (c)) : 0)
+#endif
+
+#ifndef isident
+#define isident(c) ((isletter(c) || digit(c) || c == '_'))
+#endif
+
+#ifndef exchange
+#define exchange(x, y) {int temp = x; x = y; y = temp;}
+#endif
+
+#if !defined (rindex)
+extern char *rindex ();
+#endif /* rindex */
+
+#if !defined (index)
+extern char *index ();
+#endif /* index */
+
+extern char *getenv ();
+extern char *tilde_expand ();
+
+static update_line ();
+static void output_character_function ();
+static delete_chars ();
+static void insert_some_chars ();
+
+#if defined (VOID_SIGHANDLER)
+#  define sighandler void
+#else
+#  define sighandler int
+#endif /* VOID_SIGHANDLER */
+
+/* This typedef is equivalant to the one for Function; it allows us
+   to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
+typedef sighandler SigHandler ();
+
+/* If on, then readline handles signals in a way that doesn't screw. */
+#define HANDLE_SIGNALS
+
+#ifdef __GO32__
+#include <sys/pc.h>
+#undef HANDLE_SIGNALS
+#endif
+
+
+/* **************************************************************** */
+/*								    */
+/*			Line editing input utility		    */
+/*								    */
+/* **************************************************************** */
+
+/* A pointer to the keymap that is currently in use.
+   By default, it is the standard emacs keymap. */
+Keymap keymap = emacs_standard_keymap;
+
+#define no_mode -1
+#define vi_mode 0
+#define emacs_mode 1
+
+/* The current style of editing. */
+int rl_editing_mode = emacs_mode;
+
+/* Non-zero if the previous command was a kill command. */
+static int last_command_was_kill = 0;
+
+/* The current value of the numeric argument specified by the user. */
+int rl_numeric_arg = 1;
+
+/* Non-zero if an argument was typed. */
+int rl_explicit_arg = 0;
+
+/* Temporary value used while generating the argument. */
+int rl_arg_sign = 1;
+
+/* Non-zero means we have been called at least once before. */
+static int rl_initialized = 0;
+
+/* If non-zero, this program is running in an EMACS buffer. */
+static char *running_in_emacs = (char *)NULL;
+
+/* The current offset in the current input line. */
+int rl_point;
+
+/* Mark in the current input line. */
+int rl_mark;
+
+/* Length of the current input line. */
+int rl_end;
+
+/* Make this non-zero to return the current input_line. */
+int rl_done;
+
+/* The last function executed by readline. */
+Function *rl_last_func = (Function *)NULL;
+
+/* Top level environment for readline_internal (). */
+static jmp_buf readline_top_level;
+
+/* The streams we interact with. */
+static FILE *in_stream, *out_stream;
+
+/* The names of the streams that we do input and output to. */
+FILE *rl_instream, *rl_outstream;
+
+/* Non-zero means echo characters as they are read. */
+int readline_echoing_p = 1;
+
+/* Current prompt. */
+char *rl_prompt;
+
+/* The number of characters read in order to type this complete command. */
+int rl_key_sequence_length = 0;
+
+/* If non-zero, then this is the address of a function to call just
+   before readline_internal () prints the first prompt. */
+Function *rl_startup_hook = (Function *)NULL;
+
+/* If non-zero, then this is the address of a function to call when
+   completing on a directory name.  The function is called with
+   the address of a string (the current directory name) as an arg. */
+Function *rl_symbolic_link_hook = (Function *)NULL;
+
+/* What we use internally.  You should always refer to RL_LINE_BUFFER. */
+static char *the_line;
+
+/* The character that can generate an EOF.  Really read from
+   the terminal driver... just defaulted here. */
+static int eof_char = CTRL ('D');
+
+/* Non-zero makes this the next keystroke to read. */
+int rl_pending_input = 0;
+
+/* Pointer to a useful terminal name. */
+char *rl_terminal_name = (char *)NULL;
+
+/* Line buffer and maintenence. */
+char *rl_line_buffer = (char *)NULL;
+int rl_line_buffer_len = 0;
+#define DEFAULT_BUFFER_SIZE 256
+
+
+/* **************************************************************** */
+/*								    */
+/*			`Forward' declarations  		    */
+/*								    */
+/* **************************************************************** */
+
+/* Non-zero means do not parse any lines other than comments and
+   parser directives. */
+static unsigned char parsing_conditionalized_out = 0;
+
+/* Caseless strcmp (). */
+static int stricmp (), strnicmp ();
+static char *strpbrk ();
+
+/* Non-zero means to save keys that we dispatch on in a kbd macro. */
+static int defining_kbd_macro = 0;
+
+
+/* **************************************************************** */
+/*								    */
+/*			Top Level Functions			    */
+/*								    */
+/* **************************************************************** */
+
+static void rl_prep_terminal (), rl_deprep_terminal ();
+static void clear_to_eol (), rl_generic_bind ();
+
+/* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means
+   none.  A return value of NULL means that EOF was encountered. */
+char *
+readline (prompt)
+     char *prompt;
+{
+  char *readline_internal ();
+  char *value;
+
+  rl_prompt = prompt;
+
+  /* If we are at EOF return a NULL string. */
+  if (rl_pending_input == EOF)
+    {
+      rl_pending_input = 0;
+      return ((char *)NULL);
+    }
+
+  rl_initialize ();
+  rl_prep_terminal ();
+
+#if defined (HANDLE_SIGNALS)
+  rl_set_signals ();
+#endif
+
+  value = readline_internal ();
+  rl_deprep_terminal ();
+
+#if defined (HANDLE_SIGNALS)
+  rl_clear_signals ();
+#endif
+
+  return (value);
+}
+
+/* Read a line of input from the global rl_instream, doing output on
+   the global rl_outstream.
+   If rl_prompt is non-null, then that is our prompt. */
+char *
+readline_internal ()
+{
+  int lastc, c, eof_found;
+
+  in_stream  = rl_instream;
+  out_stream = rl_outstream;
+
+  lastc = -1;
+  eof_found = 0;
+
+  if (rl_startup_hook)
+    (*rl_startup_hook) ();
+
+  if (!readline_echoing_p)
+    {
+      if (rl_prompt)
+	{
+	  fprintf (out_stream, "%s", rl_prompt);
+	  fflush (out_stream);
+	}
+    }
+  else
+    {
+      rl_on_new_line ();
+      rl_redisplay ();
+#if defined (VI_MODE)
+      if (rl_editing_mode == vi_mode)
+	rl_vi_insertion_mode ();
+#endif /* VI_MODE */
+    }
+
+  while (!rl_done)
+    {
+      int lk = last_command_was_kill;
+      int code = setjmp (readline_top_level);
+
+      if (code)
+	rl_redisplay ();
+
+      if (!rl_pending_input)
+	{
+	  /* Then initialize the argument and number of keys read. */
+	  rl_init_argument ();
+	  rl_key_sequence_length = 0;
+	}
+
+      c = rl_read_key ();
+
+      /* EOF typed to a non-blank line is a <NL>. */
+      if (c == EOF && rl_end)
+	c = NEWLINE;
+
+      /* The character eof_char typed to blank line, and not as the
+	 previous character is interpreted as EOF. */
+      if (((c == eof_char && lastc != c) || c == EOF) && !rl_end)
+	{
+	  eof_found = 1;
+	  break;
+	}
+
+      lastc = c;
+      rl_dispatch (c, keymap);
+
+      /* If there was no change in last_command_was_kill, then no kill
+	 has taken place.  Note that if input is pending we are reading
+	 a prefix command, so nothing has changed yet. */
+      if (!rl_pending_input)
+	{
+	  if (lk == last_command_was_kill)
+	    last_command_was_kill = 0;
+	}
+
+#if defined (VI_MODE)
+      /* In vi mode, when you exit insert mode, the cursor moves back
+	 over the previous character.  We explicitly check for that here. */
+      if (rl_editing_mode == vi_mode && keymap == vi_movement_keymap)
+	rl_vi_check ();
+#endif /* VI_MODE */
+
+      if (!rl_done)
+	rl_redisplay ();
+    }
+
+  /* Restore the original of this history line, iff the line that we
+     are editing was originally in the history, AND the line has changed. */
+  {
+    HIST_ENTRY *entry = current_history ();
+
+    if (entry && rl_undo_list)
+      {
+	char *temp = savestring (the_line);
+	rl_revert_line ();
+	entry = replace_history_entry (where_history (), the_line,
+				       (HIST_ENTRY *)NULL);
+	free_history_entry (entry);
+
+	strcpy (the_line, temp);
+	free (temp);
+      }
+  }
+
+  /* At any rate, it is highly likely that this line has an undo list.  Get
+     rid of it now. */
+  if (rl_undo_list)
+    free_undo_list ();
+
+  if (eof_found)
+    return (char *)NULL;
+  else
+    return (savestring (the_line));
+}
+
+
+/* **************************************************************** */
+/*					        		    */
+/*			   Signal Handling                          */
+/*								    */
+/* **************************************************************** */
+
+#if defined (SIGWINCH)
+static SigHandler *old_sigwinch = (SigHandler *)NULL;
+
+static sighandler
+rl_handle_sigwinch (sig)
+     int sig;
+{
+  char *term;
+
+  term = rl_terminal_name;
+
+  if (readline_echoing_p)
+    {
+      if (!term)
+	term = getenv ("TERM");
+      if (!term)
+	term = "dumb";
+      rl_reset_terminal (term);
+#if defined (NOTDEF)
+      crlf ();
+      rl_forced_update_display ();
+#endif /* NOTDEF */
+    }
+
+  if (old_sigwinch &&
+      old_sigwinch != (SigHandler *)SIG_IGN &&
+      old_sigwinch != (SigHandler *)SIG_DFL)
+    (*old_sigwinch) (sig);
+#if !defined (VOID_SIGHANDLER)
+  return (0);
+#endif /* VOID_SIGHANDLER */
+}
+#endif  /* SIGWINCH */
+
+#if defined (HANDLE_SIGNALS)
+/* Interrupt handling. */
+static SigHandler
+  *old_int  = (SigHandler *)NULL,
+  *old_tstp = (SigHandler *)NULL,
+  *old_ttou = (SigHandler *)NULL,
+  *old_ttin = (SigHandler *)NULL,
+  *old_cont = (SigHandler *)NULL,
+  *old_alrm = (SigHandler *)NULL;
+
+/* Handle an interrupt character. */
+static sighandler
+rl_signal_handler (sig)
+     int sig;
+{
+#if !defined (HAVE_BSD_SIGNALS)
+  /* Since the signal will not be blocked while we are in the signal
+     handler, ignore it until rl_clear_signals resets the catcher. */
+  if (sig == SIGINT)
+    signal (sig, SIG_IGN);
+#endif /* !HAVE_BSD_SIGNALS */
+
+  switch (sig)
+    {
+    case SIGINT:
+      free_undo_list ();
+      rl_clear_message ();
+      rl_init_argument ();
+
+#if defined (SIGTSTP)
+    case SIGTSTP:
+    case SIGTTOU:
+    case SIGTTIN:
+#endif /* SIGTSTP */
+    case SIGALRM:
+      rl_clean_up_for_exit ();
+      rl_deprep_terminal ();
+      rl_clear_signals ();
+      rl_pending_input = 0;
+
+      kill (getpid (), sig);
+
+      SIGNALS_UNBLOCK;
+
+      rl_prep_terminal ();
+      rl_set_signals ();
+    }
+
+#if !defined (VOID_SIGHANDLER)
+  return (0);
+#endif /* !VOID_SIGHANDLER */
+}
+
+rl_set_signals ()
+{
+  old_int = (SigHandler *)signal (SIGINT, rl_signal_handler);
+  if (old_int == (SigHandler *)SIG_IGN)
+    signal (SIGINT, SIG_IGN);
+
+  old_alrm = (SigHandler *)signal (SIGALRM, rl_signal_handler);
+  if (old_alrm == (SigHandler *)SIG_IGN)
+    signal (SIGALRM, SIG_IGN);
+
+#if defined (SIGTSTP)
+  old_tstp = (SigHandler *)signal (SIGTSTP, rl_signal_handler);
+  if (old_tstp == (SigHandler *)SIG_IGN)
+    signal (SIGTSTP, SIG_IGN);
+#endif
+#if defined (SIGTTOU)
+  old_ttou = (SigHandler *)signal (SIGTTOU, rl_signal_handler);
+  old_ttin = (SigHandler *)signal (SIGTTIN, rl_signal_handler);
+
+  if (old_tstp == (SigHandler *)SIG_IGN)
+    {
+      signal (SIGTTOU, SIG_IGN);
+      signal (SIGTTIN, SIG_IGN);
+    }
+#endif
+
+#if defined (SIGWINCH)
+  old_sigwinch = (SigHandler *)signal (SIGWINCH, rl_handle_sigwinch);
+#endif
+}
+
+rl_clear_signals ()
+{
+  signal (SIGINT, old_int);
+  signal (SIGALRM, old_alrm);
+
+#if defined (SIGTSTP)
+  signal (SIGTSTP, old_tstp);
+#endif
+
+#if defined (SIGTTOU)
+  signal (SIGTTOU, old_ttou);
+  signal (SIGTTIN, old_ttin);
+#endif
+
+#if defined (SIGWINCH)
+      signal (SIGWINCH, old_sigwinch);
+#endif
+}
+#endif  /* HANDLE_SIGNALS */
+
+
+/* **************************************************************** */
+/*								    */
+/*			Character Input Buffering       	    */
+/*								    */
+/* **************************************************************** */
+
+#if defined (USE_XON_XOFF)
+/* If the terminal was in xoff state when we got to it, then xon_char
+   contains the character that is supposed to start it again. */
+static int xon_char, xoff_state;
+#endif /* USE_XON_XOFF */
+
+static int pop_index = 0, push_index = 0, ibuffer_len = 511;
+static unsigned char ibuffer[512];
+
+/* Non-null means it is a pointer to a function to run while waiting for
+   character input. */
+Function *rl_event_hook = (Function *)NULL;
+
+#define any_typein (push_index != pop_index)
+
+/* Add KEY to the buffer of characters to be read. */
+rl_stuff_char (key)
+     int key;
+{
+  if (key == EOF)
+    {
+      key = NEWLINE;
+      rl_pending_input = EOF;
+    }
+  ibuffer[push_index++] = key;
+  if (push_index >= ibuffer_len)
+    push_index = 0;
+}
+
+/* Return the amount of space available in the
+   buffer for stuffing characters. */
+int
+ibuffer_space ()
+{
+  if (pop_index > push_index)
+    return (pop_index - push_index);
+  else
+    return (ibuffer_len - (push_index - pop_index));
+}
+
+/* Get a key from the buffer of characters to be read.
+   Return the key in KEY.
+   Result is KEY if there was a key, or 0 if there wasn't. */
+int
+rl_get_char (key)
+     int *key;
+{
+  if (push_index == pop_index)
+    return (0);
+
+  *key = ibuffer[pop_index++];
+
+  if (pop_index >= ibuffer_len)
+    pop_index = 0;
+
+  return (1);
+}
+
+/* Stuff KEY into the *front* of the input buffer.
+   Returns non-zero if successful, zero if there is
+   no space left in the buffer. */
+int
+rl_unget_char (key)
+     int key;
+{
+  if (ibuffer_space ())
+    {
+      pop_index--;
+      if (pop_index < 0)
+	pop_index = ibuffer_len - 1;
+      ibuffer[pop_index] = key;
+      return (1);
+    }
+  return (0);
+}
+
+/* If a character is available to be read, then read it
+   and stuff it into IBUFFER.  Otherwise, just return. */
+rl_gather_tyi ()
+{
+#ifdef __GO32__
+  char input;
+  if (isatty(0))
+  {
+    int i = rl_getc();
+    if (i != EOF)
+      rl_stuff_char(i);
+  }
+  else
+    if (kbhit() && ibuffer_space())
+      rl_stuff_char(getkey());
+#else
+  int tty = fileno (in_stream);
+  register int tem, result = -1;
+  long chars_avail;
+  char input;
+
+#if defined (FIONREAD)
+  result = ioctl (tty, FIONREAD, &chars_avail);
+#endif
+
+  if (result == -1)
+    {
+      int flags;
+
+      flags = fcntl (tty, F_GETFL, 0);
+
+      fcntl (tty, F_SETFL, (flags | O_NDELAY));
+      chars_avail = read (tty, &input, 1);
+
+      fcntl (tty, F_SETFL, flags);
+      if (chars_avail == -1 && errno == EAGAIN)
+	return;
+    }
+
+  /* If there's nothing available, don't waste time trying to read
+     something. */
+  if (chars_avail == 0)
+    return;
+
+  tem = ibuffer_space ();
+
+  if (chars_avail > tem)
+    chars_avail = tem;
+
+  /* One cannot read all of the available input.  I can only read a single
+     character at a time, or else programs which require input can be
+     thwarted.  If the buffer is larger than one character, I lose.
+     Damn! */
+  if (tem < ibuffer_len)
+    chars_avail = 0;
+
+  if (result != -1)
+    {
+      while (chars_avail--)
+	rl_stuff_char (rl_getc (in_stream));
+    }
+  else
+    {
+      if (chars_avail)
+	rl_stuff_char (input);
+    }
+#endif /* def __GO32__/else */
+}
+
+static int next_macro_key ();
+/* Read a key, including pending input. */
+int
+rl_read_key ()
+{
+  int c;
+
+  rl_key_sequence_length++;
+
+  if (rl_pending_input)
+    {
+      c = rl_pending_input;
+      rl_pending_input = 0;
+    }
+  else
+    {
+      /* If input is coming from a macro, then use that. */
+      if (c = next_macro_key ())
+	return (c);
+
+      /* If the user has an event function, then call it periodically. */
+      if (rl_event_hook)
+	{
+	  while (rl_event_hook && !rl_get_char (&c))
+	    {
+	      (*rl_event_hook) ();
+	      rl_gather_tyi ();
+	    }
+	}
+      else
+	{
+	  if (!rl_get_char (&c))
+	    c = rl_getc (in_stream);
+	}
+    }
+
+  return (c);
+}
+
+/* I'm beginning to hate the declaration rules for various compilers. */
+static void add_macro_char (), with_macro_input ();
+
+/* Do the command associated with KEY in MAP.
+   If the associated command is really a keymap, then read
+   another key, and dispatch into that map. */
+rl_dispatch (key, map)
+     register int key;
+     Keymap map;
+{
+
+  if (defining_kbd_macro)
+    add_macro_char (key);
+
+  if (key > 127 && key < 256)
+    {
+      if (map[ESC].type == ISKMAP)
+	{
+	  map = (Keymap)map[ESC].function;
+	  key -= 128;
+	  rl_dispatch (key, map);
+	}
+      else
+	ding ();
+      return;
+    }
+
+  switch (map[key].type)
+    {
+    case ISFUNC:
+      {
+	Function *func = map[key].function;
+
+	if (func != (Function *)NULL)
+	  {
+	    /* Special case rl_do_lowercase_version (). */
+	    if (func == rl_do_lowercase_version)
+	      {
+		rl_dispatch (to_lower (key), map);
+		return;
+	      }
+
+	    (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
+
+	    /* If we have input pending, then the last command was a prefix
+	       command.  Don't change the state of rl_last_func.  Otherwise,
+	       remember the last command executed in this variable. */
+	    if (!rl_pending_input)
+	      rl_last_func = map[key].function;
+	  }
+	else
+	  {
+	    rl_abort ();
+	    return;
+	  }
+      }
+      break;
+
+    case ISKMAP:
+      if (map[key].function != (Function *)NULL)
+	{
+	  int newkey;
+
+	  rl_key_sequence_length++;
+	  newkey = rl_read_key ();
+	  rl_dispatch (newkey, (Keymap)map[key].function);
+	}
+      else
+	{
+	  rl_abort ();
+	  return;
+	}
+      break;
+
+    case ISMACR:
+      if (map[key].function != (Function *)NULL)
+	{
+	  char *macro;
+
+	  macro = savestring ((char *)map[key].function);
+	  with_macro_input (macro);
+	  return;
+	}
+      break;
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Hacking Keyboard Macros 		    */
+/*								    */
+/* **************************************************************** */
+
+/* The currently executing macro string.  If this is non-zero,
+   then it is a malloc ()'ed string where input is coming from. */
+static char *executing_macro = (char *)NULL;
+
+/* The offset in the above string to the next character to be read. */
+static int executing_macro_index = 0;
+
+/* The current macro string being built.  Characters get stuffed
+   in here by add_macro_char (). */
+static char *current_macro = (char *)NULL;
+
+/* The size of the buffer allocated to current_macro. */
+static int current_macro_size = 0;
+
+/* The index at which characters are being added to current_macro. */
+static int current_macro_index = 0;
+
+/* A structure used to save nested macro strings.
+   It is a linked list of string/index for each saved macro. */
+struct saved_macro {
+  struct saved_macro *next;
+  char *string;
+  int index;
+};
+
+/* The list of saved macros. */
+struct saved_macro *macro_list = (struct saved_macro *)NULL;
+
+/* Forward declarations of static functions.  Thank you C. */
+static void push_executing_macro (), pop_executing_macro ();
+
+/* This one has to be declared earlier in the file. */
+/* static void add_macro_char (); */
+
+/* Set up to read subsequent input from STRING.
+   STRING is free ()'ed when we are done with it. */
+static void
+with_macro_input (string)
+     char *string;
+{
+  push_executing_macro ();
+  executing_macro = string;
+  executing_macro_index = 0;
+}
+
+/* Return the next character available from a macro, or 0 if
+   there are no macro characters. */
+static int
+next_macro_key ()
+{
+  if (!executing_macro)
+    return (0);
+
+  if (!executing_macro[executing_macro_index])
+    {
+      pop_executing_macro ();
+      return (next_macro_key ());
+    }
+
+  return (executing_macro[executing_macro_index++]);
+}
+
+/* Save the currently executing macro on a stack of saved macros. */
+static void
+push_executing_macro ()
+{
+  struct saved_macro *saver;
+
+  saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
+  saver->next = macro_list;
+  saver->index = executing_macro_index;
+  saver->string = executing_macro;
+
+  macro_list = saver;
+}
+
+/* Discard the current macro, replacing it with the one
+   on the top of the stack of saved macros. */
+static void
+pop_executing_macro ()
+{
+  if (executing_macro)
+    free (executing_macro);
+
+  executing_macro = (char *)NULL;
+  executing_macro_index = 0;
+
+  if (macro_list)
+    {
+      struct saved_macro *disposer = macro_list;
+      executing_macro = macro_list->string;
+      executing_macro_index = macro_list->index;
+      macro_list = macro_list->next;
+      free (disposer);
+    }
+}
+
+/* Add a character to the macro being built. */
+static void
+add_macro_char (c)
+     int c;
+{
+  if (current_macro_index + 1 >= current_macro_size)
+    {
+      if (!current_macro)
+	current_macro = (char *)xmalloc (current_macro_size = 25);
+      else
+	current_macro =
+	  (char *)xrealloc (current_macro, current_macro_size += 25);
+    }
+
+  current_macro[current_macro_index++] = c;
+  current_macro[current_macro_index] = '\0';
+}
+
+/* Begin defining a keyboard macro.
+   Keystrokes are recorded as they are executed.
+   End the definition with rl_end_kbd_macro ().
+   If a numeric argument was explicitly typed, then append this
+   definition to the end of the existing macro, and start by
+   re-executing the existing macro. */
+rl_start_kbd_macro (ignore1, ignore2)
+     int ignore1, ignore2;
+{
+  if (defining_kbd_macro)
+    rl_abort ();
+
+  if (rl_explicit_arg)
+    {
+      if (current_macro)
+	with_macro_input (savestring (current_macro));
+    }
+  else
+    current_macro_index = 0;
+
+  defining_kbd_macro = 1;
+}
+
+/* Stop defining a keyboard macro.
+   A numeric argument says to execute the macro right now,
+   that many times, counting the definition as the first time. */
+rl_end_kbd_macro (count, ignore)
+     int count, ignore;
+{
+  if (!defining_kbd_macro)
+    rl_abort ();
+
+  current_macro_index -= (rl_key_sequence_length - 1);
+  current_macro[current_macro_index] = '\0';
+
+  defining_kbd_macro = 0;
+
+  rl_call_last_kbd_macro (--count, 0);
+}
+
+/* Execute the most recently defined keyboard macro.
+   COUNT says how many times to execute it. */
+rl_call_last_kbd_macro (count, ignore)
+     int count, ignore;
+{
+  if (!current_macro)
+    rl_abort ();
+
+  while (count--)
+    with_macro_input (savestring (current_macro));
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Initializations 			    */
+/*								    */
+/* **************************************************************** */
+
+/* Initliaze readline (and terminal if not already). */
+rl_initialize ()
+{
+  extern char *rl_display_prompt;
+
+  /* If we have never been called before, initialize the
+     terminal and data structures. */
+  if (!rl_initialized)
+    {
+      readline_initialize_everything ();
+      rl_initialized++;
+    }
+
+  /* Initalize the current line information. */
+  rl_point = rl_end = 0;
+  the_line = rl_line_buffer;
+  the_line[0] = 0;
+
+  /* We aren't done yet.  We haven't even gotten started yet! */
+  rl_done = 0;
+
+  /* Tell the history routines what is going on. */
+  start_using_history ();
+
+  /* Make the display buffer match the state of the line. */
+  {
+    extern char *rl_display_prompt;
+    extern int forced_display;
+
+    rl_on_new_line ();
+
+    rl_display_prompt = rl_prompt ? rl_prompt : "";
+    forced_display = 1;
+  }
+
+  /* No such function typed yet. */
+  rl_last_func = (Function *)NULL;
+
+  /* Parsing of key-bindings begins in an enabled state. */
+  parsing_conditionalized_out = 0;
+}
+
+/* Initialize the entire state of the world. */
+readline_initialize_everything ()
+{
+  /* Find out if we are running in Emacs. */
+  running_in_emacs = getenv ("EMACS");
+
+  /* Set up input and output if they aren't already.  */
+  if (!rl_instream)
+    rl_instream = stdin;
+  if (!rl_outstream)
+    rl_outstream = stdout;
+
+  /* Allocate data structures. */
+  if (!rl_line_buffer)
+    rl_line_buffer =
+      (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
+
+  /* Initialize the terminal interface. */
+  init_terminal_io ((char *)NULL);
+
+  /* Bind tty characters to readline functions. */
+  readline_default_bindings ();
+
+  /* Initialize the function names. */
+  rl_initialize_funmap ();
+
+  /* Read in the init file. */
+  rl_read_init_file ((char *)NULL);
+
+  /* If the completion parser's default word break characters haven't
+     been set yet, then do so now. */
+  {
+    extern char *rl_completer_word_break_characters;
+    extern char *rl_basic_word_break_characters;
+
+    if (rl_completer_word_break_characters == (char *)NULL)
+      rl_completer_word_break_characters = rl_basic_word_break_characters;
+  }
+}
+
+/* If this system allows us to look at the values of the regular
+   input editing characters, then bind them to their readline
+   equivalents, iff the characters are not bound to keymaps. */
+readline_default_bindings ()
+{
+#ifndef __GO32__
+
+#if defined (NEW_TTY_DRIVER)
+  struct sgttyb ttybuff;
+  int tty = fileno (rl_instream);
+
+  if (ioctl (tty, TIOCGETP, &ttybuff) != -1)
+    {
+      int erase, kill;
+
+      erase = ttybuff.sg_erase;
+      kill  = ttybuff.sg_kill;
+
+      if (erase != -1 && keymap[erase].type == ISFUNC)
+	keymap[erase].function = rl_rubout;
+
+      if (kill != -1 && keymap[kill].type == ISFUNC)
+	keymap[kill].function = rl_unix_line_discard;
+    }
+
+#if defined (TIOCGLTC)
+  {
+    struct ltchars lt;
+
+    if (ioctl (tty, TIOCGLTC, &lt) != -1)
+      {
+	int erase, nextc;
+
+	erase = lt.t_werasc;
+	nextc = lt.t_lnextc;
+
+	if (erase != -1 && keymap[erase].type == ISFUNC)
+	  keymap[erase].function = rl_unix_word_rubout;
+
+	if (nextc != -1 && keymap[nextc].type == ISFUNC)
+	  keymap[nextc].function = rl_quoted_insert;
+      }
+  }
+#endif /* TIOCGLTC */
+#else /* not NEW_TTY_DRIVER */
+
+#if defined (TERMIOS_TTY_DRIVER)
+  struct termios ttybuff;
+#else
+  struct termio ttybuff;
+#endif /* TERMIOS_TTY_DRIVER */
+  int tty = fileno (rl_instream);
+
+#if defined (TERMIOS_TTY_DRIVER)
+  if (tcgetattr (tty, &ttybuff) != -1)
+#else
+  if (ioctl (tty, TCGETA, &ttybuff) != -1)
+#endif /* !TERMIOS_TTY_DRIVER */
+    {
+      int erase, kill;
+
+      erase = ttybuff.c_cc[VERASE];
+      kill = ttybuff.c_cc[VKILL];
+
+      if (erase != _POSIX_VDISABLE &&
+	  keymap[(unsigned char)erase].type == ISFUNC)
+	keymap[(unsigned char)erase].function = rl_rubout;
+
+      if (kill != _POSIX_VDISABLE &&
+	  keymap[(unsigned char)kill].type == ISFUNC)
+	keymap[(unsigned char)kill].function = rl_unix_line_discard;
+
+#if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
+      {
+	int nextc;
+
+	nextc = ttybuff.c_cc[VLNEXT];
+
+	if (nextc != _POSIX_VDISABLE &&
+	    keymap[(unsigned char)nextc].type == ISFUNC)
+	  keymap[(unsigned char)nextc].function = rl_quoted_insert;
+      }
+#endif /* VLNEXT && TERMIOS_TTY_DRIVER */
+
+#if defined (VWERASE)
+      {
+	int werase;
+
+	werase = ttybuff.c_cc[VWERASE];
+
+	if (werase != _POSIX_VDISABLE &&
+	    keymap[(unsigned char)werase].type == ISFUNC)
+	  keymap[(unsigned char)werase].function = rl_unix_word_rubout;
+      }
+#endif /* VWERASE */
+    }
+#endif /* !NEW_TTY_DRIVER */
+#endif /* def __GO32__ */
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Numeric Arguments			    */
+/*								    */
+/* **************************************************************** */
+
+/* Handle C-u style numeric args, as well as M--, and M-digits. */
+
+/* Add the current digit to the argument in progress. */
+rl_digit_argument (ignore, key)
+     int ignore, key;
+{
+  rl_pending_input = key;
+  rl_digit_loop ();
+}
+
+/* What to do when you abort reading an argument. */
+rl_discard_argument ()
+{
+  ding ();
+  rl_clear_message ();
+  rl_init_argument ();
+}
+
+/* Create a default argument. */
+rl_init_argument ()
+{
+  rl_numeric_arg = rl_arg_sign = 1;
+  rl_explicit_arg = 0;
+}
+
+/* C-u, universal argument.  Multiply the current argument by 4.
+   Read a key.  If the key has nothing to do with arguments, then
+   dispatch on it.  If the key is the abort character then abort. */
+rl_universal_argument ()
+{
+  rl_numeric_arg *= 4;
+  rl_digit_loop ();
+}
+
+rl_digit_loop ()
+{
+  int key, c;
+  while (1)
+    {
+      rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg, 0);
+      key = c = rl_read_key ();
+
+      if (keymap[c].type == ISFUNC &&
+	  keymap[c].function == rl_universal_argument)
+	{
+	  rl_numeric_arg *= 4;
+	  continue;
+	}
+      c = UNMETA (c);
+      if (numeric (c))
+	{
+	  if (rl_explicit_arg)
+	    rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0');
+	  else
+	    rl_numeric_arg = (c - '0');
+	  rl_explicit_arg = 1;
+	}
+      else
+	{
+	  if (c == '-' && !rl_explicit_arg)
+	    {
+	      rl_numeric_arg = 1;
+	      rl_arg_sign = -1;
+	    }
+	  else
+	    {
+	      rl_clear_message ();
+	      rl_dispatch (key, keymap);
+	      return;
+	    }
+	}
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Display stuff				    */
+/*								    */
+/* **************************************************************** */
+
+/* This is the stuff that is hard for me.  I never seem to write good
+   display routines in C.  Let's see how I do this time. */
+
+/* (PWP) Well... Good for a simple line updater, but totally ignores
+   the problems of input lines longer than the screen width.
+
+   update_line and the code that calls it makes a multiple line,
+   automatically wrapping line update.  Carefull attention needs
+   to be paid to the vertical position variables.
+
+   handling of terminals with autowrap on (incl. DEC braindamage)
+   could be improved a bit.  Right now I just cheat and decrement
+   screenwidth by one. */
+
+/* Keep two buffers; one which reflects the current contents of the
+   screen, and the other to draw what we think the new contents should
+   be.  Then compare the buffers, and make whatever changes to the
+   screen itself that we should.  Finally, make the buffer that we
+   just drew into be the one which reflects the current contents of the
+   screen, and place the cursor where it belongs.
+
+   Commands that want to can fix the display themselves, and then let
+   this function know that the display has been fixed by setting the
+   RL_DISPLAY_FIXED variable.  This is good for efficiency. */
+
+/* Termcap variables: */
+extern char *term_up, *term_dc, *term_cr;
+extern int screenheight, screenwidth, terminal_can_insert;
+
+/* What YOU turn on when you have handled all redisplay yourself. */
+int rl_display_fixed = 0;
+
+/* The visible cursor position.  If you print some text, adjust this. */
+int last_c_pos = 0;
+int last_v_pos = 0;
+
+/* The last left edge of text that was displayed.  This is used when
+   doing horizontal scrolling.  It shifts in thirds of a screenwidth. */
+static int last_lmargin = 0;
+
+/* The line display buffers.  One is the line currently displayed on
+   the screen.  The other is the line about to be displayed. */
+static char *visible_line = (char *)NULL;
+static char *invisible_line = (char *)NULL;
+
+/* Number of lines currently on screen minus 1. */
+int vis_botlin = 0;
+
+/* A buffer for `modeline' messages. */
+char msg_buf[128];
+
+/* Non-zero forces the redisplay even if we thought it was unnecessary. */
+int forced_display = 0;
+
+/* The stuff that gets printed out before the actual text of the line.
+   This is usually pointing to rl_prompt. */
+char *rl_display_prompt = (char *)NULL;
+
+/* Default and initial buffer size.  Can grow. */
+static int line_size = 1024;
+
+/* Non-zero means to always use horizontal scrolling in line display. */
+static int horizontal_scroll_mode = 0;
+
+/* Non-zero means to display an asterisk at the starts of history lines
+   which have been modified. */
+static int mark_modified_lines = 0;
+
+/* Non-zero means to use a visible bell if one is available rather than
+   simply ringing the terminal bell. */
+static int prefer_visible_bell = 0;
+
+/* I really disagree with this, but my boss (among others) insists that we
+   support compilers that don't work.  I don't think we are gaining by doing
+   so; what is the advantage in producing better code if we can't use it? */
+/* The following two declarations belong inside the
+   function block, not here. */
+static void move_cursor_relative ();
+static void output_some_chars ();
+static void output_character_function ();
+static int compare_strings ();
+
+/* Basic redisplay algorithm. */
+rl_redisplay ()
+{
+  register int in, out, c, linenum;
+  register char *line = invisible_line;
+  char *prompt_this_line;
+  int c_pos = 0;
+  int inv_botlin = 0;		/* Number of lines in newly drawn buffer. */
+
+  extern int readline_echoing_p;
+
+  if (!readline_echoing_p)
+    return;
+
+  if (!rl_display_prompt)
+    rl_display_prompt = "";
+
+  if (!invisible_line)
+    {
+      visible_line = (char *)xmalloc (line_size);
+      invisible_line = (char *)xmalloc (line_size);
+      line = invisible_line;
+      for (in = 0; in < line_size; in++)
+	{
+	  visible_line[in] = 0;
+	  invisible_line[in] = 1;
+	}
+      rl_on_new_line ();
+    }
+
+  /* Draw the line into the buffer. */
+  c_pos = -1;
+
+  /* Mark the line as modified or not.  We only do this for history
+     lines. */
+  out = 0;
+  if (mark_modified_lines && current_history () && rl_undo_list)
+    {
+      line[out++] = '*';
+      line[out] = '\0';
+    }
+
+  /* If someone thought that the redisplay was handled, but the currently
+     visible line has a different modification state than the one about
+     to become visible, then correct the callers misconception. */
+  if (visible_line[0] != invisible_line[0])
+    rl_display_fixed = 0;
+
+  prompt_this_line = rindex (rl_display_prompt, '\n');
+  if (!prompt_this_line)
+    prompt_this_line = rl_display_prompt;
+  else
+    {
+      prompt_this_line++;
+      if (forced_display)
+	output_some_chars (rl_display_prompt,
+			   prompt_this_line - rl_display_prompt);
+    }
+
+  strncpy (line + out,  prompt_this_line, strlen (prompt_this_line));
+  out += strlen (prompt_this_line);
+  line[out] = '\0';
+
+  for (in = 0; in < rl_end; in++)
+    {
+      c = (unsigned char)the_line[in];
+
+      if (out + 1 >= line_size)
+	{
+	  line_size *= 2;
+	  visible_line = (char *)xrealloc (visible_line, line_size);
+	  invisible_line = (char *)xrealloc (invisible_line, line_size);
+	  line = invisible_line;
+	}
+
+      if (in == rl_point)
+	c_pos = out;
+
+      if (c > 127)
+	{
+	  line[out++] = 'M';
+	  line[out++] = '-';
+	  line[out++] = c - 128;
+	}
+#define DISPLAY_TABS
+#if defined (DISPLAY_TABS)
+      else if (c == '\t')
+	{
+	  register int newout = (out | (int)7) + 1;
+	  while (out < newout)
+	    line[out++] = ' ';
+	}
+#endif
+      else if (c < 32)
+	{
+	  line[out++] = 'C';
+	  line[out++] = '-';
+	  line[out++] = c + 64;
+	}
+      else if (c == 127)
+	{
+	  line[out++] = 'C';
+	  line[out++] = '-';
+	  line[out++] = '?';
+	}
+      else
+	line[out++] = c;
+    }
+  line[out] = '\0';
+  if (c_pos < 0)
+    c_pos = out;
+
+  /* PWP: now is when things get a bit hairy.  The visible and invisible
+     line buffers are really multiple lines, which would wrap every
+     (screenwidth - 1) characters.  Go through each in turn, finding
+     the changed region and updating it.  The line order is top to bottom. */
+
+  /* If we can move the cursor up and down, then use multiple lines,
+     otherwise, let long lines display in a single terminal line, and
+     horizontally scroll it. */
+
+  if (!horizontal_scroll_mode && term_up && *term_up)
+    {
+      int total_screen_chars = (screenwidth * screenheight);
+
+      if (!rl_display_fixed || forced_display)
+	{
+	  forced_display = 0;
+
+	  /* If we have more than a screenful of material to display, then
+	     only display a screenful.  We should display the last screen,
+	     not the first.  I'll fix this in a minute. */
+	  if (out >= total_screen_chars)
+	    out = total_screen_chars - 1;
+
+	  /* Number of screen lines to display. */
+	  inv_botlin = out / screenwidth;
+
+	  /* For each line in the buffer, do the updating display. */
+	  for (linenum = 0; linenum <= inv_botlin; linenum++)
+	    update_line (linenum > vis_botlin ? ""
+			 : &visible_line[linenum * screenwidth],
+			 &invisible_line[linenum * screenwidth],
+			 linenum);
+
+	  /* We may have deleted some lines.  If so, clear the left over
+	     blank ones at the bottom out. */
+	  if (vis_botlin > inv_botlin)
+	    {
+	      char *tt;
+	      for (; linenum <= vis_botlin; linenum++)
+		{
+		  tt = &visible_line[linenum * screenwidth];
+		  move_vert (linenum);
+		  move_cursor_relative (0, tt);
+		  clear_to_eol ((linenum == vis_botlin)?
+				strlen (tt) : screenwidth);
+		}
+	    }
+	  vis_botlin = inv_botlin;
+
+	  /* Move the cursor where it should be. */
+	  move_vert (c_pos / screenwidth);
+	  move_cursor_relative (c_pos % screenwidth,
+				&invisible_line[(c_pos / screenwidth) * screenwidth]);
+	}
+    }
+  else				/* Do horizontal scrolling. */
+    {
+      int lmargin;
+
+      /* Always at top line. */
+      last_v_pos = 0;
+
+      /* If the display position of the cursor would be off the edge
+	 of the screen, start the display of this line at an offset that
+	 leaves the cursor on the screen. */
+      if (c_pos - last_lmargin > screenwidth - 2)
+	lmargin = (c_pos / (screenwidth / 3) - 2) * (screenwidth / 3);
+      else if (c_pos - last_lmargin < 1)
+	lmargin = ((c_pos - 1) / (screenwidth / 3)) * (screenwidth / 3);
+      else
+	lmargin = last_lmargin;
+
+      /* If the first character on the screen isn't the first character
+	 in the display line, indicate this with a special character. */
+      if (lmargin > 0)
+	line[lmargin] = '<';
+
+      if (lmargin + screenwidth < out)
+	line[lmargin + screenwidth - 1] = '>';
+
+      if (!rl_display_fixed || forced_display || lmargin != last_lmargin)
+	{
+	  forced_display = 0;
+	  update_line (&visible_line[last_lmargin],
+		       &invisible_line[lmargin], 0);
+
+	  move_cursor_relative (c_pos - lmargin, &invisible_line[lmargin]);
+	  last_lmargin = lmargin;
+	}
+    }
+  fflush (out_stream);
+
+  /* Swap visible and non-visible lines. */
+  {
+    char *temp = visible_line;
+    visible_line = invisible_line;
+    invisible_line = temp;
+    rl_display_fixed = 0;
+  }
+}
+
+/* PWP: update_line() is based on finding the middle difference of each
+   line on the screen; vis:
+
+			     /old first difference
+	/beginning of line   |              /old last same       /old EOL
+	v		     v              v                    v
+old:	eddie> Oh, my little gruntle-buggy is to me, as lurgid as
+new:	eddie> Oh, my little buggy says to me, as lurgid as
+	^		     ^        ^			   ^
+	\beginning of line   |        \new last same	   \new end of line
+			     \new first difference
+
+   All are character pointers for the sake of speed.  Special cases for
+   no differences, as well as for end of line additions must be handeled.
+
+   Could be made even smarter, but this works well enough */
+static
+update_line (old, new, current_line)
+     register char *old, *new;
+     int current_line;
+{
+  register char *ofd, *ols, *oe, *nfd, *nls, *ne;
+  int lendiff, wsatend;
+
+  /* Find first difference. */
+  for (ofd = old, nfd = new;
+       (ofd - old < screenwidth) && *ofd && (*ofd == *nfd);
+       ofd++, nfd++)
+    ;
+
+  /* Move to the end of the screen line. */
+  for (oe = ofd; ((oe - old) < screenwidth) && *oe; oe++);
+  for (ne = nfd; ((ne - new) < screenwidth) && *ne; ne++);
+
+  /* If no difference, continue to next line. */
+  if (ofd == oe && nfd == ne)
+    return;
+
+  wsatend = 1;			/* flag for trailing whitespace */
+  ols = oe - 1;			/* find last same */
+  nls = ne - 1;
+  while ((*ols == *nls) && (ols > ofd) && (nls > nfd))
+    {
+      if (*ols != ' ')
+	wsatend = 0;
+      ols--;
+      nls--;
+    }
+
+  if (wsatend)
+    {
+      ols = oe;
+      nls = ne;
+    }
+  else if (*ols != *nls)
+    {
+      if (*ols)			/* don't step past the NUL */
+	ols++;
+      if (*nls)
+	nls++;
+    }
+
+  move_vert (current_line);
+  move_cursor_relative (ofd - old, old);
+
+  /* if (len (new) > len (old)) */
+  lendiff = (nls - nfd) - (ols - ofd);
+
+  /* Insert (diff(len(old),len(new)) ch */
+  if (lendiff > 0)
+    {
+      if (terminal_can_insert)
+	{
+	  extern char *term_IC;
+
+	  /* Sometimes it is cheaper to print the characters rather than
+	     use the terminal's capabilities. */
+	  if ((2 * (ne - nfd)) < lendiff && !term_IC)
+	    {
+	      output_some_chars (nfd, (ne - nfd));
+	      last_c_pos += (ne - nfd);
+	    }
+	  else
+	    {
+	      if (*ols)
+		{
+		  insert_some_chars (nfd, lendiff);
+		  last_c_pos += lendiff;
+		}
+	      else
+		{
+		  /* At the end of a line the characters do not have to
+		     be "inserted".  They can just be placed on the screen. */
+		  output_some_chars (nfd, lendiff);
+		  last_c_pos += lendiff;
+		}
+	      /* Copy (new) chars to screen from first diff to last match. */
+	      if (((nls - nfd) - lendiff) > 0)
+		{
+		  output_some_chars (&nfd[lendiff], ((nls - nfd) - lendiff));
+		  last_c_pos += ((nls - nfd) - lendiff);
+		}
+	    }
+	}
+      else
+	{		/* cannot insert chars, write to EOL */
+	  output_some_chars (nfd, (ne - nfd));
+	  last_c_pos += (ne - nfd);
+	}
+    }
+  else				/* Delete characters from line. */
+    {
+      /* If possible and inexpensive to use terminal deletion, then do so. */
+      if (term_dc && (2 * (ne - nfd)) >= (-lendiff))
+	{
+	  if (lendiff)
+	    delete_chars (-lendiff); /* delete (diff) characters */
+
+	  /* Copy (new) chars to screen from first diff to last match */
+	  if ((nls - nfd) > 0)
+	    {
+	      output_some_chars (nfd, (nls - nfd));
+	      last_c_pos += (nls - nfd);
+	    }
+	}
+      /* Otherwise, print over the existing material. */
+      else
+	{
+	  output_some_chars (nfd, (ne - nfd));
+	  last_c_pos += (ne - nfd);
+	  clear_to_eol ((oe - old) - (ne - new));
+	}
+    }
+}
+
+/* (PWP) tell the update routines that we have moved onto a
+   new (empty) line. */
+rl_on_new_line ()
+{
+  if (visible_line)
+    visible_line[0] = '\0';
+
+  last_c_pos = last_v_pos = 0;
+  vis_botlin = last_lmargin = 0;
+}
+
+/* Actually update the display, period. */
+rl_forced_update_display ()
+{
+  if (visible_line)
+    {
+      register char *temp = visible_line;
+
+      while (*temp) *temp++ = '\0';
+    }
+  rl_on_new_line ();
+  forced_display++;
+  rl_redisplay ();
+}
+
+/* Move the cursor from last_c_pos to NEW, which are buffer indices.
+   DATA is the contents of the screen line of interest; i.e., where
+   the movement is being done. */
+static void
+move_cursor_relative (new, data)
+     int new;
+     char *data;
+{
+  register int i;
+
+  /* It may be faster to output a CR, and then move forwards instead
+     of moving backwards. */
+  if (new + 1 < last_c_pos - new)
+    {
+#ifdef __MSDOS__
+      putc('\r', out_stream);
+#else
+      tputs (term_cr, 1, output_character_function);
+#endif
+      last_c_pos = 0;
+    }
+
+  if (last_c_pos == new) return;
+
+  if (last_c_pos < new)
+    {
+      /* Move the cursor forward.  We do it by printing the command
+	 to move the cursor forward if there is one, else print that
+	 portion of the output buffer again.  Which is cheaper? */
+
+      /* The above comment is left here for posterity.  It is faster
+	 to print one character (non-control) than to print a control
+	 sequence telling the terminal to move forward one character.
+	 That kind of control is for people who don't know what the
+	 data is underneath the cursor. */
+#if defined (HACK_TERMCAP_MOTION)
+      extern char *term_forward_char;
+
+      if (term_forward_char)
+	for (i = last_c_pos; i < new; i++)
+	  tputs (term_forward_char, 1, output_character_function);
+      else
+	for (i = last_c_pos; i < new; i++)
+	  putc (data[i], out_stream);
+#else
+      for (i = last_c_pos; i < new; i++)
+	putc (data[i], out_stream);
+#endif				/* HACK_TERMCAP_MOTION */
+    }
+  else
+    backspace (last_c_pos - new);
+  last_c_pos = new;
+}
+
+/* PWP: move the cursor up or down. */
+move_vert (to)
+     int to;
+{
+  void output_character_function ();
+  register int delta, i;
+
+  if (last_v_pos == to) return;
+
+  if (to > screenheight)
+    return;
+
+#ifdef __GO32__
+  {
+    int cur_r, cur_c;
+    ScreenGetCursor(&cur_r, &cur_c);
+    ScreenSetCursor(cur_r+to-last_v_pos, cur_c);
+  }
+#else /* __GO32__ */
+  if ((delta = to - last_v_pos) > 0)
+    {
+      for (i = 0; i < delta; i++)
+	putc ('\n', out_stream);
+      tputs (term_cr, 1, output_character_function);
+      last_c_pos = 0;
+    }
+  else
+    {			/* delta < 0 */
+      if (term_up && *term_up)
+	for (i = 0; i < -delta; i++)
+	  tputs (term_up, 1, output_character_function);
+    }
+#endif /* __GO32__ */
+  last_v_pos = to;		/* now to is here */
+}
+
+/* Physically print C on out_stream.  This is for functions which know
+   how to optimize the display. */
+rl_show_char (c)
+     int c;
+{
+  if (c > 127)
+    {
+      fprintf (out_stream, "M-");
+      c -= 128;
+    }
+
+#if defined (DISPLAY_TABS)
+  if (c < 32 && c != '\t')
+#else
+  if (c < 32)
+#endif
+    {
+
+      c += 64;
+    }
+
+  putc (c, out_stream);
+  fflush (out_stream);
+}
+
+#if defined (DISPLAY_TABS)
+int
+rl_character_len (c, pos)
+     register int c, pos;
+{
+  if (c < ' ' || c > 126)
+    {
+      if (c == '\t')
+	return (((pos | (int)7) + 1) - pos);
+      else
+	return (3);
+    }
+  else
+    return (1);
+}
+#else
+int
+rl_character_len (c)
+     int c;
+{
+  if (c < ' ' || c > 126)
+    return (3);
+  else
+    return (1);
+}
+#endif  /* DISPLAY_TAB */
+
+/* How to print things in the "echo-area".  The prompt is treated as a
+   mini-modeline. */
+rl_message (string, arg1, arg2)
+     char *string;
+{
+  sprintf (msg_buf, string, arg1, arg2);
+  rl_display_prompt = msg_buf;
+  rl_redisplay ();
+}
+
+/* How to clear things from the "echo-area". */
+rl_clear_message ()
+{
+  rl_display_prompt = rl_prompt;
+  rl_redisplay ();
+}
+
+/* **************************************************************** */
+/*								    */
+/*			Terminal and Termcap			    */
+/*								    */
+/* **************************************************************** */
+
+static char *term_buffer = (char *)NULL;
+static char *term_string_buffer = (char *)NULL;
+
+/* Non-zero means this terminal can't really do anything. */
+int dumb_term = 0;
+
+/* On Solaris2, sys/types.h brings in sys/reg.h,
+   which screws up the Termcap variable PC, used below.  */
+
+#undef	PC	
+
+char PC;
+char *BC, *UP;
+
+/* Some strings to control terminal actions.  These are output by tputs (). */
+char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace;
+
+int screenwidth, screenheight;
+
+/* Non-zero if we determine that the terminal can do character insertion. */
+int terminal_can_insert = 0;
+
+/* How to insert characters. */
+char *term_im, *term_ei, *term_ic, *term_ip, *term_IC;
+
+/* How to delete characters. */
+char *term_dc, *term_DC;
+
+#if defined (HACK_TERMCAP_MOTION)
+char *term_forward_char;
+#endif  /* HACK_TERMCAP_MOTION */
+
+/* How to go up a line. */
+char *term_up;
+
+/* A visible bell, if the terminal can be made to flash the screen. */
+char *visible_bell;
+
+/* Re-initialize the terminal considering that the TERM/TERMCAP variable
+   has changed. */
+rl_reset_terminal (terminal_name)
+     char *terminal_name;
+{
+  init_terminal_io (terminal_name);
+}
+
+init_terminal_io (terminal_name)
+     char *terminal_name;
+{
+#ifdef __GO32__
+  screenwidth = ScreenCols();
+  screenheight = ScreenRows();
+  term_cr = "\r";
+  term_im = term_ei = term_ic = term_IC = (char *)NULL;
+  term_up = term_dc = term_DC = visible_bell = (char *)NULL;
+#if defined (HACK_TERMCAP_MOTION)
+      term_forward_char = (char *)NULL;
+#endif
+  terminal_can_insert = 0;
+  return;
+#else
+  extern char *tgetstr ();
+  char *term, *buffer;
+#if defined (TIOCGWINSZ) && !defined (TIOCGWINSZ_BROKEN)
+  struct winsize window_size;
+#endif
+  int tty;
+
+  term = terminal_name ? terminal_name : getenv ("TERM");
+
+  if (!term_string_buffer)
+    term_string_buffer = (char *)xmalloc (2048);
+
+  if (!term_buffer)
+    term_buffer = (char *)xmalloc (2048);
+
+  buffer = term_string_buffer;
+
+  term_clrpag = term_cr = term_clreol = (char *)NULL;
+
+  if (!term)
+    term = "dumb";
+
+  if (tgetent (term_buffer, term) <= 0)
+    {
+      dumb_term = 1;
+      screenwidth = 79;
+      screenheight = 24;
+      term_cr = "\r";
+      term_im = term_ei = term_ic = term_IC = (char *)NULL;
+      term_up = term_dc = term_DC = visible_bell = (char *)NULL;
+#if defined (HACK_TERMCAP_MOTION)
+      term_forward_char = (char *)NULL;
+#endif
+      terminal_can_insert = 0;
+      return;
+    }
+
+  BC = tgetstr ("pc", &buffer);
+  PC = buffer ? *buffer : 0;
+
+  term_backspace = tgetstr ("le", &buffer);
+
+  term_cr = tgetstr ("cr", &buffer);
+  term_clreol = tgetstr ("ce", &buffer);
+  term_clrpag = tgetstr ("cl", &buffer);
+
+  if (!term_cr)
+    term_cr =  "\r";
+
+#if defined (HACK_TERMCAP_MOTION)
+  term_forward_char = tgetstr ("nd", &buffer);
+#endif  /* HACK_TERMCAP_MOTION */
+
+  if (rl_instream)
+    tty = fileno (rl_instream);
+  else
+    tty = 0;
+
+  screenwidth = screenheight = 0;
+#if defined (TIOCGWINSZ) && !defined (TIOCGWINSZ_BROKEN)
+  if (ioctl (tty, TIOCGWINSZ, &window_size) == 0)
+    {
+      screenwidth = (int) window_size.ws_col;
+      screenheight = (int) window_size.ws_row;
+    }
+#endif
+
+  if (screenwidth <= 0 || screenheight <= 0)
+    {
+      screenwidth = tgetnum ("co");
+      screenheight = tgetnum ("li");
+    }
+
+  screenwidth--;
+
+  if (screenwidth <= 0)
+    screenwidth = 79;
+
+  if (screenheight <= 0)
+    screenheight = 24;
+
+  term_im = tgetstr ("im", &buffer);
+  term_ei = tgetstr ("ei", &buffer);
+  term_IC = tgetstr ("IC", &buffer);
+  term_ic = tgetstr ("ic", &buffer);
+
+  /* "An application program can assume that the terminal can do
+      character insertion if *any one of* the capabilities `IC',
+      `im', `ic' or `ip' is provided."  But we can't do anything if
+      only `ip' is provided, so... */
+  terminal_can_insert = (term_IC || term_im || term_ic);
+
+  term_up = tgetstr ("up", &buffer);
+  term_dc = tgetstr ("dc", &buffer);
+  term_DC = tgetstr ("DC", &buffer);
+
+  visible_bell = tgetstr ("vb", &buffer);
+#endif /* !__GO32__ */
+}
+
+/* A function for the use of tputs () */
+static void
+output_character_function (c)
+     int c;
+{
+  putc (c, out_stream);
+}
+
+/* Write COUNT characters from STRING to the output stream. */
+static void
+output_some_chars (string, count)
+     char *string;
+     int count;
+{
+  fwrite (string, 1, count, out_stream);
+}
+
+/* Delete COUNT characters from the display line. */
+static
+delete_chars (count)
+     int count;
+{
+#ifdef __GO32__
+  int r, c, w;
+  ScreenGetCursor(&r, &c);
+  w = ScreenCols();
+  memcpy(ScreenPrimary+r*w+c, ScreenPrimary+r*w+c+count, w-c-count);
+  memset(ScreenPrimary+r*w+w-count, 0, count*2);
+#else /* __GO32__ */
+  if (count > screenwidth)
+    return;
+
+  if (term_DC && *term_DC)
+    {
+      char *tgoto (), *buffer;
+      buffer = tgoto (term_DC, 0, count);
+      tputs (buffer, 1, output_character_function);
+    }
+  else
+    {
+      if (term_dc && *term_dc)
+	while (count--)
+	  tputs (term_dc, 1, output_character_function);
+    }
+#endif /* __GO32__ */
+}
+
+/* Insert COUNT characters from STRING to the output stream. */
+static void
+insert_some_chars (string, count)
+     char *string;
+     int count;
+{
+#ifdef __GO32__
+  int r, c, w;
+  ScreenGetCursor(&r, &c);
+  w = ScreenCols();
+  memcpy(ScreenPrimary+r*w+c+count, ScreenPrimary+r*w+c, w-c-count);
+  /* Print the text. */
+  output_some_chars (string, count);
+#else /* __GO32__ */
+  /* If IC is defined, then we do not have to "enter" insert mode. */
+  if (term_IC)
+    {
+      char *tgoto (), *buffer;
+      buffer = tgoto (term_IC, 0, count);
+      tputs (buffer, 1, output_character_function);
+      output_some_chars (string, count);
+    }
+  else
+    {
+      register int i;
+
+      /* If we have to turn on insert-mode, then do so. */
+      if (term_im && *term_im)
+	tputs (term_im, 1, output_character_function);
+
+      /* If there is a special command for inserting characters, then
+	 use that first to open up the space. */
+      if (term_ic && *term_ic)
+	{
+	  for (i = count; i--; )
+	    tputs (term_ic, 1, output_character_function);
+	}
+
+      /* Print the text. */
+      output_some_chars (string, count);
+
+      /* If there is a string to turn off insert mode, we had best use
+	 it now. */
+      if (term_ei && *term_ei)
+	tputs (term_ei, 1, output_character_function);
+    }
+#endif /* __GO32__ */
+}
+
+/* Move the cursor back. */
+backspace (count)
+     int count;
+{
+  register int i;
+
+#ifndef __GO32__
+  if (term_backspace)
+    for (i = 0; i < count; i++)
+      tputs (term_backspace, 1, output_character_function);
+  else
+#endif /* !__GO32__ */
+    for (i = 0; i < count; i++)
+      putc ('\b', out_stream);
+}
+
+/* Move to the start of the next line. */
+crlf ()
+{
+#if defined (NEW_TTY_DRIVER)
+  tputs (term_cr, 1, output_character_function);
+#endif /* NEW_TTY_DRIVER */
+  putc ('\n', out_stream);
+}
+
+/* Clear to the end of the line.  COUNT is the minimum
+   number of character spaces to clear, */
+static void
+clear_to_eol (count)
+     int count;
+{
+#ifndef __GO32__
+  if (term_clreol)
+    {
+      tputs (term_clreol, 1, output_character_function);
+    }
+  else
+#endif /* !__GO32__ */
+    {
+      register int i;
+
+      /* Do one more character space. */
+      count++;
+
+      for (i = 0; i < count; i++)
+	putc (' ', out_stream);
+
+      backspace (count);
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*		      Saving and Restoring the TTY	    	    */
+/*								    */
+/* **************************************************************** */
+
+/* Non-zero means that the terminal is in a prepped state. */
+static int terminal_prepped = 0;
+
+#if defined (NEW_TTY_DRIVER)
+
+/* Standard flags, including ECHO. */
+static int original_tty_flags = 0;
+
+/* Local mode flags, like LPASS8. */
+static int local_mode_flags = 0;
+
+/* Terminal characters.  This has C-s and C-q in it. */
+static struct tchars original_tchars;
+
+/* Local special characters.  This has the interrupt characters in it. */
+#if defined (TIOCGLTC)
+static struct ltchars original_ltchars;
+#endif
+
+/* We use this to get and set the tty_flags. */
+static struct sgttyb the_ttybuff;
+
+/* Put the terminal in CBREAK mode so that we can detect key presses. */
+static void
+rl_prep_terminal ()
+{
+#ifndef __GO32__
+  int tty = fileno (rl_instream);
+  SIGNALS_DECLARE_SAVED (saved_signals);
+
+  if (terminal_prepped)
+    return;
+
+  SIGNALS_BLOCK (SIGINT, saved_signals);
+
+  /* We always get the latest tty values.  Maybe stty changed them. */
+  ioctl (tty, TIOCGETP, &the_ttybuff);
+  original_tty_flags = the_ttybuff.sg_flags;
+
+  readline_echoing_p = (original_tty_flags & ECHO);
+
+#if defined (TIOCLGET)
+  ioctl (tty, TIOCLGET, &local_mode_flags);
+#endif
+
+#if !defined (ANYP)
+#  define ANYP (EVENP | ODDP)
+#endif
+
+  /* If this terminal doesn't care how the 8th bit is used,
+     then we can use it for the meta-key.  We check by seeing
+     if BOTH odd and even parity are allowed. */
+  if (the_ttybuff.sg_flags & ANYP)
+    {
+#if defined (PASS8)
+      the_ttybuff.sg_flags |= PASS8;
+#endif
+
+      /* Hack on local mode flags if we can. */
+#if defined (TIOCLGET) && defined (LPASS8)
+      {
+	int flags;
+	flags = local_mode_flags | LPASS8;
+	ioctl (tty, TIOCLSET, &flags);
+      }
+#endif /* TIOCLGET && LPASS8 */
+    }
+
+#if defined (TIOCGETC)
+  {
+    struct tchars temp;
+
+    ioctl (tty, TIOCGETC, &original_tchars);
+    temp = original_tchars;
+
+#if defined (USE_XON_XOFF)
+    /* Get rid of C-s and C-q.
+       We remember the value of startc (C-q) so that if the terminal is in
+       xoff state, the user can xon it by pressing that character. */
+    xon_char = temp.t_startc;
+    temp.t_stopc = -1;
+    temp.t_startc = -1;
+
+    /* If there is an XON character, bind it to restart the output. */
+    if (xon_char != -1)
+      rl_bind_key (xon_char, rl_restart_output);
+#endif /* USE_XON_XOFF */
+
+    /* If there is an EOF char, bind eof_char to it. */
+    if (temp.t_eofc != -1)
+      eof_char = temp.t_eofc;
+
+#if defined (NO_KILL_INTR)
+    /* Get rid of C-\ and C-c. */
+    temp.t_intrc = temp.t_quitc = -1;
+#endif /* NO_KILL_INTR */
+
+    ioctl (tty, TIOCSETC, &temp);
+  }
+#endif /* TIOCGETC */
+
+#if defined (TIOCGLTC)
+  {
+    struct ltchars temp;
+
+    ioctl (tty, TIOCGLTC, &original_ltchars);
+    temp = original_ltchars;
+
+    /* Make the interrupt keys go away.  Just enough to make people
+       happy. */
+    temp.t_dsuspc = -1;	/* C-y */
+    temp.t_lnextc = -1;	/* C-v */
+
+    ioctl (tty, TIOCSLTC, &temp);
+  }
+#endif /* TIOCGLTC */
+
+  the_ttybuff.sg_flags &= ~(ECHO | CRMOD);
+  the_ttybuff.sg_flags |= CBREAK;
+  ioctl (tty, TIOCSETN, &the_ttybuff);
+
+  terminal_prepped = 1;
+
+  SIGNALS_RESTORE (saved_signals);
+#endif /* !__GO32__ */
+}
+
+/* Restore the terminal to its original state. */
+static void
+rl_deprep_terminal ()
+{
+#ifndef __GO32__
+  int tty = fileno (rl_instream);
+  SIGNALS_DECLARE_SAVED (saved_signals);
+
+  if (!terminal_prepped)
+    return;
+
+  SIGNALS_BLOCK (SIGINT, saved_signals);
+
+  the_ttybuff.sg_flags = original_tty_flags;
+  ioctl (tty, TIOCSETN, &the_ttybuff);
+  readline_echoing_p = 1;
+
+#if defined (TIOCLGET)
+  ioctl (tty, TIOCLSET, &local_mode_flags);
+#endif
+
+#if defined (TIOCSLTC)
+  ioctl (tty, TIOCSLTC, &original_ltchars);
+#endif
+
+#if defined (TIOCSETC)
+  ioctl (tty, TIOCSETC, &original_tchars);
+#endif
+  terminal_prepped = 0;
+
+  SIGNALS_RESTORE (saved_signals);
+#endif /* !__GO32 */
+}
+
+#else  /* !defined (NEW_TTY_DRIVER) */
+
+#if !defined (VMIN)
+#define VMIN VEOF
+#endif
+
+#if !defined (VTIME)
+#define VTIME VEOL
+#endif
+
+#ifndef __GO32__
+#if defined (TERMIOS_TTY_DRIVER)
+static struct termios otio;
+#else
+static struct termio otio;
+#endif /* !TERMIOS_TTY_DRIVER */
+#endif /* __GO32__ */
+
+static void
+rl_prep_terminal ()
+{
+#ifndef __GO32__
+  int tty = fileno (rl_instream);
+#if defined (TERMIOS_TTY_DRIVER)
+  struct termios tio;
+#else
+  struct termio tio;
+#endif /* !TERMIOS_TTY_DRIVER */
+
+  SIGNALS_DECLARE_SAVED (saved_signals);
+
+  if (terminal_prepped)
+    return;
+
+  /* Try to keep this function from being INTerrupted.  We can do it
+     on POSIX and systems with BSD-like signal handling. */
+  SIGNALS_BLOCK (SIGINT, saved_signals);
+
+#if defined (TERMIOS_TTY_DRIVER)
+  tcgetattr (tty, &tio);
+#else
+  ioctl (tty, TCGETA, &tio);
+#endif /* !TERMIOS_TTY_DRIVER */
+
+  otio = tio;
+
+  readline_echoing_p = (tio.c_lflag & ECHO);
+
+  tio.c_lflag &= ~(ICANON|ECHO);
+
+  if (otio.c_cc[VEOF] != _POSIX_VDISABLE)
+    eof_char = otio.c_cc[VEOF];
+
+#if defined (USE_XON_XOFF)
+#if defined (IXANY)
+  tio.c_iflag &= ~(IXON|IXOFF|IXANY);
+#else
+  /* `strict' Posix systems do not define IXANY. */
+  tio.c_iflag &= ~(IXON|IXOFF);
+#endif /* IXANY */
+#endif /* USE_XON_XOFF */
+
+  /* Only turn this off if we are using all 8 bits. */
+  /* |ISTRIP|INPCK */
+  tio.c_iflag &= ~(ISTRIP | INPCK);
+
+  /* Make sure we differentiate between CR and NL on input. */
+  tio.c_iflag &= ~(ICRNL | INLCR);
+
+#if !defined (HANDLE_SIGNALS)
+  tio.c_lflag &= ~ISIG;
+#else
+  tio.c_lflag |= ISIG;
+#endif
+
+  tio.c_cc[VMIN] = 1;
+  tio.c_cc[VTIME] = 0;
+
+  /* Turn off characters that we need on Posix systems with job control,
+     just to be sure.  This includes ^Y and ^V.  This should not really
+     be necessary.  */
+#if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_JOB_CONTROL)
+
+#if defined (VLNEXT)
+  tio.c_cc[VLNEXT] = _POSIX_VDISABLE;
+#endif
+
+#if defined (VDSUSP)
+  tio.c_cc[VDSUSP] = _POSIX_VDISABLE;
+#endif
+
+#endif /* POSIX && JOB_CONTROL */
+
+#if defined (TERMIOS_TTY_DRIVER)
+  tcsetattr (tty, TCSADRAIN, &tio);
+  tcflow (tty, TCOON);		/* Simulate a ^Q. */
+#else
+  ioctl (tty, TCSETAW, &tio);
+  ioctl (tty, TCXONC, 1);	/* Simulate a ^Q. */
+#endif /* !TERMIOS_TTY_DRIVER */
+
+  terminal_prepped = 1;
+
+  SIGNALS_RESTORE (saved_signals);
+#endif /* !__GO32__ */
+}
+
+static void
+rl_deprep_terminal ()
+{
+#ifndef __GO32__ 
+  int tty = fileno (rl_instream);
+
+  /* Try to keep this function from being INTerrupted.  We can do it
+     on POSIX and systems with BSD-like signal handling. */
+  SIGNALS_DECLARE_SAVED (saved_signals);
+
+  if (!terminal_prepped)
+    return;
+
+  SIGNALS_BLOCK (SIGINT, saved_signals);
+
+#if defined (TERMIOS_TTY_DRIVER)
+  tcsetattr (tty, TCSADRAIN, &otio);
+  tcflow (tty, TCOON);		/* Simulate a ^Q. */
+#else /* TERMIOS_TTY_DRIVER */
+  ioctl (tty, TCSETAW, &otio);
+  ioctl (tty, TCXONC, 1);	/* Simulate a ^Q. */
+#endif /* !TERMIOS_TTY_DRIVER */
+
+  terminal_prepped = 0;
+
+  SIGNALS_RESTORE (saved_signals);
+#endif /* !__GO32__ */
+}
+#endif  /* NEW_TTY_DRIVER */
+
+
+/* **************************************************************** */
+/*								    */
+/*			Utility Functions			    */
+/*								    */
+/* **************************************************************** */
+
+/* Return 0 if C is not a member of the class of characters that belong
+   in words, or 1 if it is. */
+
+int allow_pathname_alphabetic_chars = 0;
+char *pathname_alphabetic_chars = "/-_=~.#$";
+
+int
+alphabetic (c)
+     int c;
+{
+  if (pure_alphabetic (c) || (numeric (c)))
+    return (1);
+
+  if (allow_pathname_alphabetic_chars)
+    return ((int)rindex (pathname_alphabetic_chars, c));
+  else
+    return (0);
+}
+
+/* Return non-zero if C is a numeric character. */
+int
+numeric (c)
+     int c;
+{
+  return (c >= '0' && c <= '9');
+}
+
+/* Ring the terminal bell. */
+int
+ding ()
+{
+  if (readline_echoing_p)
+    {
+#ifndef __GO32__
+      if (prefer_visible_bell && visible_bell)
+	tputs (visible_bell, 1, output_character_function);
+      else
+#endif /* !__GO32__ */
+	{
+	  fprintf (stderr, "\007");
+	  fflush (stderr);
+	}
+    }
+  return (-1);
+}
+
+/* How to abort things. */
+rl_abort ()
+{
+  ding ();
+  rl_clear_message ();
+  rl_init_argument ();
+  rl_pending_input = 0;
+
+  defining_kbd_macro = 0;
+  while (executing_macro)
+    pop_executing_macro ();
+
+  rl_last_func = (Function *)NULL;
+  longjmp (readline_top_level, 1);
+}
+
+/* Return a copy of the string between FROM and TO.
+   FROM is inclusive, TO is not. */
+#if defined (sun) /* Yes, that's right, some crufty function in sunview is
+		     called rl_copy (). */
+static
+#endif
+char *
+rl_copy (from, to)
+     int from, to;
+{
+  register int length;
+  char *copy;
+
+  /* Fix it if the caller is confused. */
+  if (from > to)
+    {
+      int t = from;
+      from = to;
+      to = t;
+    }
+
+  length = to - from;
+  copy = (char *)xmalloc (1 + length);
+  strncpy (copy, the_line + from, length);
+  copy[length] = '\0';
+  return (copy);
+}
+
+/* Increase the size of RL_LINE_BUFFER until it has enough space to hold
+   LEN characters. */
+void
+rl_extend_line_buffer (len)
+     int len;
+{
+  while (len >= rl_line_buffer_len)
+    rl_line_buffer =
+      (char *)xrealloc
+	(rl_line_buffer, rl_line_buffer_len += DEFAULT_BUFFER_SIZE);
+
+  the_line = rl_line_buffer;
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Insert and Delete			    */
+/*								    */
+/* **************************************************************** */
+
+/* Insert a string of text into the line at point.  This is the only
+   way that you should do insertion.  rl_insert () calls this
+   function. */
+rl_insert_text (string)
+     char *string;
+{
+  extern int doing_an_undo;
+  register int i, l = strlen (string);
+
+  if (rl_end + l >= rl_line_buffer_len)
+    rl_extend_line_buffer (rl_end + l);
+
+  for (i = rl_end; i >= rl_point; i--)
+    the_line[i + l] = the_line[i];
+  strncpy (the_line + rl_point, string, l);
+
+  /* Remember how to undo this if we aren't undoing something. */
+  if (!doing_an_undo)
+    {
+      /* If possible and desirable, concatenate the undos. */
+      if ((strlen (string) == 1) &&
+	  rl_undo_list &&
+	  (rl_undo_list->what == UNDO_INSERT) &&
+	  (rl_undo_list->end == rl_point) &&
+	  (rl_undo_list->end - rl_undo_list->start < 20))
+	rl_undo_list->end++;
+      else
+	rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
+    }
+  rl_point += l;
+  rl_end += l;
+  the_line[rl_end] = '\0';
+}
+
+/* Delete the string between FROM and TO.  FROM is
+   inclusive, TO is not. */
+rl_delete_text (from, to)
+     int from, to;
+{
+  extern int doing_an_undo;
+  register char *text;
+
+  /* Fix it if the caller is confused. */
+  if (from > to)
+    {
+      int t = from;
+      from = to;
+      to = t;
+    }
+  text = rl_copy (from, to);
+  strncpy (the_line + from, the_line + to, rl_end - to);
+
+  /* Remember how to undo this delete. */
+  if (!doing_an_undo)
+    rl_add_undo (UNDO_DELETE, from, to, text);
+  else
+    free (text);
+
+  rl_end -= (to - from);
+  the_line[rl_end] = '\0';
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Readline character functions		    */
+/*								    */
+/* **************************************************************** */
+
+/* This is not a gap editor, just a stupid line input routine.  No hair
+   is involved in writing any of the functions, and none should be. */
+
+/* Note that:
+
+   rl_end is the place in the string that we would place '\0';
+   i.e., it is always safe to place '\0' there.
+
+   rl_point is the place in the string where the cursor is.  Sometimes
+   this is the same as rl_end.
+
+   Any command that is called interactively receives two arguments.
+   The first is a count: the numeric arg pased to this command.
+   The second is the key which invoked this command.
+*/
+
+
+/* **************************************************************** */
+/*								    */
+/*			Movement Commands			    */
+/*								    */
+/* **************************************************************** */
+
+/* Note that if you `optimize' the display for these functions, you cannot
+   use said functions in other functions which do not do optimizing display.
+   I.e., you will have to update the data base for rl_redisplay, and you
+   might as well let rl_redisplay do that job. */
+
+/* Move forward COUNT characters. */
+rl_forward (count)
+     int count;
+{
+  if (count < 0)
+    rl_backward (-count);
+  else
+    while (count)
+      {
+#if defined (VI_MODE)
+	if (rl_point == (rl_end - (rl_editing_mode == vi_mode)))
+#else
+	if (rl_point == rl_end)
+#endif /* VI_MODE */
+	  {
+	    ding ();
+	    return;
+	  }
+	else
+	  rl_point++;
+	--count;
+      }
+}
+
+/* Move backward COUNT characters. */
+rl_backward (count)
+     int count;
+{
+  if (count < 0)
+    rl_forward (-count);
+  else
+    while (count)
+      {
+	if (!rl_point)
+	  {
+	    ding ();
+	    return;
+	  }
+	else
+	  --rl_point;
+	--count;
+      }
+}
+
+/* Move to the beginning of the line. */
+rl_beg_of_line ()
+{
+  rl_point = 0;
+}
+
+/* Move to the end of the line. */
+rl_end_of_line ()
+{
+  rl_point = rl_end;
+}
+
+/* Move forward a word.  We do what Emacs does. */
+rl_forward_word (count)
+     int count;
+{
+  int c;
+
+  if (count < 0)
+    {
+      rl_backward_word (-count);
+      return;
+    }
+
+  while (count)
+    {
+      if (rl_point == rl_end)
+	return;
+
+      /* If we are not in a word, move forward until we are in one.
+	 Then, move forward until we hit a non-alphabetic character. */
+      c = the_line[rl_point];
+      if (!alphabetic (c))
+	{
+	  while (++rl_point < rl_end)
+	    {
+	      c = the_line[rl_point];
+	      if (alphabetic (c)) break;
+	    }
+	}
+      if (rl_point == rl_end) return;
+      while (++rl_point < rl_end)
+	{
+	  c = the_line[rl_point];
+	  if (!alphabetic (c)) break;
+	}
+      --count;
+    }
+}
+
+/* Move backward a word.  We do what Emacs does. */
+rl_backward_word (count)
+     int count;
+{
+  int c;
+
+  if (count < 0)
+    {
+      rl_forward_word (-count);
+      return;
+    }
+
+  while (count)
+    {
+      if (!rl_point)
+	return;
+
+      /* Like rl_forward_word (), except that we look at the characters
+	 just before point. */
+
+      c = the_line[rl_point - 1];
+      if (!alphabetic (c))
+	{
+	  while (--rl_point)
+	    {
+	      c = the_line[rl_point - 1];
+	      if (alphabetic (c)) break;
+	    }
+	}
+
+      while (rl_point)
+	{
+	  c = the_line[rl_point - 1];
+	  if (!alphabetic (c))
+	    break;
+	  else --rl_point;
+	}
+      --count;
+    }
+}
+
+/* Clear the current line.  Numeric argument to C-l does this. */
+rl_refresh_line ()
+{
+  int curr_line = last_c_pos / screenwidth;
+  extern char *term_clreol;
+
+  move_vert(curr_line);
+  move_cursor_relative (0, the_line);   /* XXX is this right */
+
+#ifdef __GO32__
+  {
+  int r, c, w;
+  ScreenGetCursor(&r, &c);
+  w = ScreenCols();
+  memset(ScreenPrimary+r*w+c, 0, (w-c)*2);
+  }
+#else /* __GO32__ */
+  if (term_clreol)
+    tputs (term_clreol, 1, output_character_function);
+#endif /* __GO32__/else */
+
+  rl_forced_update_display ();
+  rl_display_fixed = 1;
+}
+
+/* C-l typed to a line without quoting clears the screen, and then reprints
+   the prompt and the current input line.  Given a numeric arg, redraw only
+   the current line. */
+rl_clear_screen ()
+{
+  extern char *term_clrpag;
+
+  if (rl_explicit_arg)
+    {
+      rl_refresh_line ();
+      return;
+    }
+
+#ifndef __GO32__
+  if (term_clrpag)
+    tputs (term_clrpag, 1, output_character_function);
+  else
+#endif /* !__GO32__ */
+    crlf ();
+
+  rl_forced_update_display ();
+  rl_display_fixed = 1;
+}
+
+rl_arrow_keys (count, c)
+     int count, c;
+{
+  int ch;
+
+  ch = rl_read_key ();
+
+  switch (to_upper (ch))
+    {
+    case 'A':
+      rl_get_previous_history (count);
+      break;
+
+    case 'B':
+      rl_get_next_history (count);
+      break;
+
+    case 'C':
+      rl_forward (count);
+      break;
+
+    case 'D':
+      rl_backward (count);
+      break;
+
+    default:
+      ding ();
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Text commands				    */
+/*								    */
+/* **************************************************************** */
+
+/* Insert the character C at the current location, moving point forward. */
+rl_insert (count, c)
+     int count, c;
+{
+  register int i;
+  char *string;
+
+  if (count <= 0)
+    return;
+
+  /* If we can optimize, then do it.  But don't let people crash
+     readline because of extra large arguments. */
+  if (count > 1 && count < 1024)
+    {
+      string = (char *)alloca (1 + count);
+
+      for (i = 0; i < count; i++)
+	string[i] = c;
+
+      string[i] = '\0';
+      rl_insert_text (string);
+      return;
+    }
+
+  if (count > 1024)
+    {
+      int decreaser;
+
+      string = (char *)alloca (1024 + 1);
+
+      for (i = 0; i < 1024; i++)
+	string[i] = c;
+
+      while (count)
+	{
+	  decreaser = (count > 1024 ? 1024 : count);
+	  string[decreaser] = '\0';
+	  rl_insert_text (string);
+	  count -= decreaser;
+	}
+      return;
+    }
+
+  /* We are inserting a single character.
+     If there is pending input, then make a string of all of the
+     pending characters that are bound to rl_insert, and insert
+     them all. */
+  if (any_typein)
+    {
+      int key = 0, t;
+
+      i = 0;
+      string = (char *)alloca (ibuffer_len + 1);
+      string[i++] = c;
+
+      while ((t = rl_get_char (&key)) &&
+	     (keymap[key].type == ISFUNC &&
+	      keymap[key].function == rl_insert))
+	string[i++] = key;
+
+      if (t)
+	rl_unget_char (key);
+
+      string[i] = '\0';
+      rl_insert_text (string);
+      return;
+    }
+  else
+    {
+      /* Inserting a single character. */
+      string = (char *)alloca (2);
+
+      string[1] = '\0';
+      string[0] = c;
+      rl_insert_text (string);
+    }
+}
+
+/* Insert the next typed character verbatim. */
+rl_quoted_insert (count)
+     int count;
+{
+  int c = rl_read_key ();
+  rl_insert (count, c);
+}
+
+/* Insert a tab character. */
+rl_tab_insert (count)
+     int count;
+{
+  rl_insert (count, '\t');
+}
+
+/* What to do when a NEWLINE is pressed.  We accept the whole line.
+   KEY is the key that invoked this command.  I guess it could have
+   meaning in the future. */
+rl_newline (count, key)
+     int count, key;
+{
+
+  rl_done = 1;
+
+#if defined (VI_MODE)
+  {
+    extern int vi_doing_insert;
+    if (vi_doing_insert)
+      {
+	rl_end_undo_group ();
+	vi_doing_insert = 0;
+      }
+  }
+#endif /* VI_MODE */
+
+  if (readline_echoing_p)
+    {
+      move_vert (vis_botlin);
+      vis_botlin = 0;
+      crlf ();
+      fflush (out_stream);
+      rl_display_fixed++;
+    }
+}
+
+rl_clean_up_for_exit ()
+{
+  if (readline_echoing_p)
+    {
+      move_vert (vis_botlin);
+      vis_botlin = 0;
+      fflush (out_stream);
+      rl_restart_output ();
+    }
+}
+
+/* What to do for some uppercase characters, like meta characters,
+   and some characters appearing in emacs_ctlx_keymap.  This function
+   is just a stub, you bind keys to it and the code in rl_dispatch ()
+   is special cased. */
+rl_do_lowercase_version (ignore1, ignore2)
+     int ignore1, ignore2;
+{
+}
+
+/* Rubout the character behind point. */
+rl_rubout (count)
+     int count;
+{
+  if (count < 0)
+    {
+      rl_delete (-count);
+      return;
+    }
+
+  if (!rl_point)
+    {
+      ding ();
+      return;
+    }
+
+  if (count > 1)
+    {
+      int orig_point = rl_point;
+      rl_backward (count);
+      rl_kill_text (orig_point, rl_point);
+    }
+  else
+    {
+      int c = the_line[--rl_point];
+      rl_delete_text (rl_point, rl_point + 1);
+
+      if (rl_point == rl_end && alphabetic (c) && last_c_pos)
+	{
+	  backspace (1);
+	  putc (' ', out_stream);
+	  backspace (1);
+	  last_c_pos--;
+	  visible_line[last_c_pos] = '\0';
+	  rl_display_fixed++;
+	}
+    }
+}
+
+/* Delete the character under the cursor.  Given a numeric argument,
+   kill that many characters instead. */
+rl_delete (count, invoking_key)
+     int count, invoking_key;
+{
+  if (count < 0)
+    {
+      rl_rubout (-count);
+      return;
+    }
+
+  if (rl_point == rl_end)
+    {
+      ding ();
+      return;
+    }
+
+  if (count > 1)
+    {
+      int orig_point = rl_point;
+      rl_forward (count);
+      rl_kill_text (orig_point, rl_point);
+      rl_point = orig_point;
+    }
+  else
+    rl_delete_text (rl_point, rl_point + 1);
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Kill commands				    */
+/*								    */
+/* **************************************************************** */
+
+/* The next two functions mimic unix line editing behaviour, except they
+   save the deleted text on the kill ring.  This is safer than not saving
+   it, and since we have a ring, nobody should get screwed. */
+
+/* This does what C-w does in Unix.  We can't prevent people from
+   using behaviour that they expect. */
+rl_unix_word_rubout ()
+{
+  if (!rl_point) ding ();
+  else {
+    int orig_point = rl_point;
+    while (rl_point && whitespace (the_line[rl_point - 1]))
+      rl_point--;
+    while (rl_point && !whitespace (the_line[rl_point - 1]))
+      rl_point--;
+    rl_kill_text (rl_point, orig_point);
+  }
+}
+
+/* Here is C-u doing what Unix does.  You don't *have* to use these
+   key-bindings.  We have a choice of killing the entire line, or
+   killing from where we are to the start of the line.  We choose the
+   latter, because if you are a Unix weenie, then you haven't backspaced
+   into the line at all, and if you aren't, then you know what you are
+   doing. */
+rl_unix_line_discard ()
+{
+  if (!rl_point) ding ();
+  else {
+    rl_kill_text (rl_point, 0);
+    rl_point = 0;
+  }
+}
+
+
+
+/* **************************************************************** */
+/*								    */
+/*			Commands For Typos			    */
+/*								    */
+/* **************************************************************** */
+
+/* Random and interesting things in here.  */
+
+/* **************************************************************** */
+/*								    */
+/*			Changing Case				    */
+/*								    */
+/* **************************************************************** */
+
+/* The three kinds of things that we know how to do. */
+#define UpCase 1
+#define DownCase 2
+#define CapCase 3
+
+/* Uppercase the word at point. */
+rl_upcase_word (count)
+     int count;
+{
+  rl_change_case (count, UpCase);
+}
+
+/* Lowercase the word at point. */
+rl_downcase_word (count)
+     int count;
+{
+  rl_change_case (count, DownCase);
+}
+
+/* Upcase the first letter, downcase the rest. */
+rl_capitalize_word (count)
+     int count;
+{
+  rl_change_case (count, CapCase);
+}
+
+/* The meaty function.
+   Change the case of COUNT words, performing OP on them.
+   OP is one of UpCase, DownCase, or CapCase.
+   If a negative argument is given, leave point where it started,
+   otherwise, leave it where it moves to. */
+rl_change_case (count, op)
+     int count, op;
+{
+  register int start = rl_point, end;
+  int state = 0;
+
+  rl_forward_word (count);
+  end = rl_point;
+
+  if (count < 0)
+    {
+      int temp = start;
+      start = end;
+      end = temp;
+    }
+
+  /* We are going to modify some text, so let's prepare to undo it. */
+  rl_modifying (start, end);
+
+  for (; start < end; start++)
+    {
+      switch (op)
+	{
+	case UpCase:
+	  the_line[start] = to_upper (the_line[start]);
+	  break;
+
+	case DownCase:
+	  the_line[start] = to_lower (the_line[start]);
+	  break;
+
+	case CapCase:
+	  if (state == 0)
+	    {
+	      the_line[start] = to_upper (the_line[start]);
+	      state = 1;
+	    }
+	  else
+	    {
+	      the_line[start] = to_lower (the_line[start]);
+	    }
+	  if (!pure_alphabetic (the_line[start]))
+	    state = 0;
+	  break;
+
+	default:
+	  abort ();
+	}
+    }
+  rl_point = end;
+}
+
+/* **************************************************************** */
+/*								    */
+/*			Transposition				    */
+/*								    */
+/* **************************************************************** */
+
+/* Transpose the words at point. */
+rl_transpose_words (count)
+     int count;
+{
+  char *word1, *word2;
+  int w1_beg, w1_end, w2_beg, w2_end;
+  int orig_point = rl_point;
+
+  if (!count) return;
+
+  /* Find the two words. */
+  rl_forward_word (count);
+  w2_end = rl_point;
+  rl_backward_word (1);
+  w2_beg = rl_point;
+  rl_backward_word (count);
+  w1_beg = rl_point;
+  rl_forward_word (1);
+  w1_end = rl_point;
+
+  /* Do some check to make sure that there really are two words. */
+  if ((w1_beg == w2_beg) || (w2_beg < w1_end))
+    {
+      ding ();
+      rl_point = orig_point;
+      return;
+    }
+
+  /* Get the text of the words. */
+  word1 = rl_copy (w1_beg, w1_end);
+  word2 = rl_copy (w2_beg, w2_end);
+
+  /* We are about to do many insertions and deletions.  Remember them
+     as one operation. */
+  rl_begin_undo_group ();
+
+  /* Do the stuff at word2 first, so that we don't have to worry
+     about word1 moving. */
+  rl_point = w2_beg;
+  rl_delete_text (w2_beg, w2_end);
+  rl_insert_text (word1);
+
+  rl_point = w1_beg;
+  rl_delete_text (w1_beg, w1_end);
+  rl_insert_text (word2);
+
+  /* This is exactly correct since the text before this point has not
+     changed in length. */
+  rl_point = w2_end;
+
+  /* I think that does it. */
+  rl_end_undo_group ();
+  free (word1); free (word2);
+}
+
+/* Transpose the characters at point.  If point is at the end of the line,
+   then transpose the characters before point. */
+rl_transpose_chars (count)
+     int count;
+{
+  if (!count)
+    return;
+
+  if (!rl_point || rl_end < 2) {
+    ding ();
+    return;
+  }
+
+  while (count)
+    {
+      if (rl_point == rl_end)
+	{
+	  int t = the_line[rl_point - 1];
+
+	  the_line[rl_point - 1] = the_line[rl_point - 2];
+	  the_line[rl_point - 2] = t;
+	}
+      else
+	{
+	  int t = the_line[rl_point];
+
+	  the_line[rl_point] = the_line[rl_point - 1];
+	  the_line[rl_point - 1] = t;
+
+	  if (count < 0 && rl_point)
+	    rl_point--;
+	  else
+	    rl_point++;
+	}
+
+      if (count < 0)
+	count++;
+      else
+	count--;
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Bogus Flow Control      		    */
+/*								    */
+/* **************************************************************** */
+
+rl_restart_output (count, key)
+     int count, key;
+{
+  int fildes = fileno (rl_outstream);
+#if defined (TIOCSTART)
+#if defined (apollo)
+  ioctl (&fildes, TIOCSTART, 0);
+#else
+  ioctl (fildes, TIOCSTART, 0);
+#endif /* apollo */
+
+#else
+#  if defined (TERMIOS_TTY_DRIVER)
+        tcflow (fildes, TCOON);
+#  else
+#    if defined (TCXONC)
+        ioctl (fildes, TCXONC, TCOON);
+#    endif /* TCXONC */
+#  endif /* !TERMIOS_TTY_DRIVER */
+#endif /* TIOCSTART */
+}
+
+rl_stop_output (count, key)
+     int count, key;
+{
+  int fildes = fileno (rl_instream);
+
+#if defined (TIOCSTOP)
+# if defined (apollo)
+  ioctl (&fildes, TIOCSTOP, 0);
+# else
+  ioctl (fildes, TIOCSTOP, 0);
+# endif /* apollo */
+#else
+# if defined (TERMIOS_TTY_DRIVER)
+  tcflow (fildes, TCOOFF);
+# else
+#   if defined (TCXONC)
+  ioctl (fildes, TCXONC, TCOON);
+#   endif /* TCXONC */
+# endif /* !TERMIOS_TTY_DRIVER */
+#endif /* TIOCSTOP */
+}
+
+/* **************************************************************** */
+/*								    */
+/*	Completion matching, from readline's point of view.	    */
+/*								    */
+/* **************************************************************** */
+
+/* Pointer to the generator function for completion_matches ().
+   NULL means to use filename_entry_function (), the default filename
+   completer. */
+Function *rl_completion_entry_function = (Function *)NULL;
+
+/* Pointer to alternative function to create matches.
+   Function is called with TEXT, START, and END.
+   START and END are indices in RL_LINE_BUFFER saying what the boundaries
+   of TEXT are.
+   If this function exists and returns NULL then call the value of
+   rl_completion_entry_function to try to match, otherwise use the
+   array of strings returned. */
+Function *rl_attempted_completion_function = (Function *)NULL;
+
+/* Local variable states what happened during the last completion attempt. */
+static int completion_changed_buffer = 0;
+
+/* Complete the word at or before point.  You have supplied the function
+   that does the initial simple matching selection algorithm (see
+   completion_matches ()).  The default is to do filename completion. */
+
+rl_complete (ignore, invoking_key)
+     int ignore, invoking_key;
+{
+  if (rl_last_func == rl_complete && !completion_changed_buffer)
+    rl_complete_internal ('?');
+  else
+    rl_complete_internal (TAB);
+}
+
+/* List the possible completions.  See description of rl_complete (). */
+rl_possible_completions ()
+{
+  rl_complete_internal ('?');
+}
+
+/* The user must press "y" or "n". Non-zero return means "y" pressed. */
+get_y_or_n ()
+{
+  int c;
+ loop:
+  c = rl_read_key ();
+  if (c == 'y' || c == 'Y') return (1);
+  if (c == 'n' || c == 'N') return (0);
+  if (c == ABORT_CHAR) rl_abort ();
+  ding (); goto loop;
+}
+
+/* Up to this many items will be displayed in response to a
+   possible-completions call.  After that, we ask the user if
+   she is sure she wants to see them all. */
+int rl_completion_query_items = 100;
+
+/* The basic list of characters that signal a break between words for the
+   completer routine.  The contents of this variable is what breaks words
+   in the shell, i.e. " \t\n\"\\'`@$><=" */
+char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(";
+
+/* The list of characters that signal a break between words for
+   rl_complete_internal.  The default list is the contents of
+   rl_basic_word_break_characters.  */
+char *rl_completer_word_break_characters = (char *)NULL;
+
+/* The list of characters which are used to quote a substring of the command
+   line.  Command completion occurs on the entire substring, and within the
+   substring rl_completer_word_break_characters are treated as any other
+   character, unless they also appear within this list. */
+char *rl_completer_quote_characters = (char *)NULL;
+
+/* List of characters that are word break characters, but should be left
+   in TEXT when it is passed to the completion function.  The shell uses
+   this to help determine what kind of completing to do. */
+char *rl_special_prefixes = (char *)NULL;
+
+/* If non-zero, then disallow duplicates in the matches. */
+int rl_ignore_completion_duplicates = 1;
+
+/* Non-zero means that the results of the matches are to be treated
+   as filenames.  This is ALWAYS zero on entry, and can only be changed
+   within a completion entry finder function. */
+int rl_filename_completion_desired = 0;
+
+/* This function, if defined, is called by the completer when real
+   filename completion is done, after all the matching names have been
+   generated. It is passed a (char**) known as matches in the code below.
+   It consists of a NULL-terminated array of pointers to potential
+   matching strings.  The 1st element (matches[0]) is the maximal
+   substring that is common to all matches. This function can re-arrange
+   the list of matches as required, but all elements of the array must be
+   free()'d if they are deleted. The main intent of this function is
+   to implement FIGNORE a la SunOS csh. */
+Function *rl_ignore_some_completions_function = (Function *)NULL;
+
+/* Complete the word at or before point.
+   WHAT_TO_DO says what to do with the completion.
+   `?' means list the possible completions.
+   TAB means do standard completion.
+   `*' means insert all of the possible completions. */
+rl_complete_internal (what_to_do)
+     int what_to_do;
+{
+  char *filename_completion_function ();
+  char **completion_matches (), **matches;
+  Function *our_func;
+  int start, scan, end, delimiter = 0;
+  char *text, *saved_line_buffer;
+  char quote_char = '\0';
+  char *replacement;
+
+  if (the_line)
+    saved_line_buffer = savestring (the_line);
+  else
+    saved_line_buffer = (char *)NULL;
+
+  if (rl_completion_entry_function)
+    our_func = rl_completion_entry_function;
+  else
+    our_func = (int (*)())filename_completion_function;
+
+  /* Only the completion entry function can change this. */
+  rl_filename_completion_desired = 0;
+
+  /* We now look backwards for the start of a filename/variable word. */
+  end = rl_point;
+
+  if (rl_point)
+    {
+      if (rl_completer_quote_characters)
+	{
+	  /* We have a list of characters which can be used in pairs to quote
+	     substrings for completion.  Try to find the start of an unclosed
+	     quoted substring.
+	     FIXME:  Doesn't yet handle '\' escapes to hid embedded quotes */
+	  for (scan = 0; scan < end; scan++)
+	    {
+	      if (quote_char != '\0')
+		{
+		  /* Ignore everything until the matching close quote char */
+		  if (the_line[scan] == quote_char)
+		    {
+		      /* Found matching close quote. Abandon this substring. */
+		      quote_char = '\0';
+		      rl_point = end;
+		    }
+		}
+	      else if (rindex (rl_completer_quote_characters, the_line[scan]))
+		{
+		  /* Found start of a quoted substring. */
+		  quote_char = the_line[scan];
+		  rl_point = scan + 1;
+		}
+	    }
+	}
+      if (rl_point == end)
+	{
+	  /* We didn't find an unclosed quoted substring upon which to do
+	     completion, so use the word break characters to find the
+	     substring on which to do completion. */
+	  while (--rl_point &&
+		 !rindex (rl_completer_word_break_characters,
+			  the_line[rl_point])) {;}
+	}
+
+      /* If we are at a word break, then advance past it. */
+      if (rindex (rl_completer_word_break_characters, the_line[rl_point]))
+	{
+	  /* If the character that caused the word break was a quoting
+	     character, then remember it as the delimiter. */
+	  if (rindex ("\"'", the_line[rl_point]) && (end - rl_point) > 1)
+	    delimiter = the_line[rl_point];
+
+	  /* If the character isn't needed to determine something special
+	     about what kind of completion to perform, then advance past it. */
+
+	  if (!rl_special_prefixes ||
+	      !rindex (rl_special_prefixes, the_line[rl_point]))
+	    rl_point++;
+	}
+    }
+
+  start = rl_point;
+  rl_point = end;
+  text = rl_copy (start, end);
+
+  /* If the user wants to TRY to complete, but then wants to give
+     up and use the default completion function, they set the
+     variable rl_attempted_completion_function. */
+  if (rl_attempted_completion_function)
+    {
+      matches =
+	(char **)(*rl_attempted_completion_function) (text, start, end);
+
+      if (matches)
+	{
+	  our_func = (Function *)NULL;
+	  goto after_usual_completion;
+	}
+    }
+
+  matches = completion_matches (text, our_func);
+
+ after_usual_completion:
+  free (text);
+
+  if (!matches)
+    ding ();
+  else
+    {
+      register int i;
+
+    some_matches:
+
+      /* It seems to me that in all the cases we handle we would like
+	 to ignore duplicate possibilities.  Scan for the text to
+	 insert being identical to the other completions. */
+      if (rl_ignore_completion_duplicates)
+	{
+	  char *lowest_common;
+	  int j, newlen = 0;
+
+	  /* Sort the items. */
+	  /* It is safe to sort this array, because the lowest common
+	     denominator found in matches[0] will remain in place. */
+	  for (i = 0; matches[i]; i++);
+	  qsort (matches, i, sizeof (char *), compare_strings);
+
+	  /* Remember the lowest common denominator for it may be unique. */
+	  lowest_common = savestring (matches[0]);
+
+	  for (i = 0; matches[i + 1]; i++)
+	    {
+	      if (strcmp (matches[i], matches[i + 1]) == 0)
+		{
+		  free (matches[i]);
+		  matches[i] = (char *)-1;
+		}
+	      else
+		newlen++;
+	    }
+
+	  /* We have marked all the dead slots with (char *)-1.
+	     Copy all the non-dead entries into a new array. */
+	  {
+	    char **temp_array =
+	      (char **)malloc ((3 + newlen) * sizeof (char *));
+
+	    for (i = 1, j = 1; matches[i]; i++)
+	      {
+		if (matches[i] != (char *)-1)
+		  temp_array[j++] = matches[i];
+	      }
+
+	    temp_array[j] = (char *)NULL;
+
+	    if (matches[0] != (char *)-1)
+	      free (matches[0]);
+
+	    free (matches);
+
+	    matches = temp_array;
+	  }
+
+	  /* Place the lowest common denominator back in [0]. */
+	  matches[0] = lowest_common;
+
+	  /* If there is one string left, and it is identical to the
+	     lowest common denominator, then the LCD is the string to
+	     insert. */
+	  if (j == 2 && strcmp (matches[0], matches[1]) == 0)
+	    {
+	      free (matches[1]);
+	      matches[1] = (char *)NULL;
+	    }
+	}
+
+      switch (what_to_do)
+	{
+	case TAB:
+	  /* If we are matching filenames, then here is our chance to
+	     do clever processing by re-examining the list.  Call the
+	     ignore function with the array as a parameter.  It can
+	     munge the array, deleting matches as it desires. */
+	  if (rl_ignore_some_completions_function &&
+	      our_func == (int (*)())filename_completion_function)
+	    (void)(*rl_ignore_some_completions_function)(matches);
+
+	  /* If we are doing completions on quoted substrings, and any matches
+	     contain any of the completer word break characters, then auto-
+	     matically prepend the substring with a quote character (just
+	     pick the first one from the list of such) if it does not already
+	     begin with a quote string.  FIXME:  Need to remove any such
+	     automatically inserted quote character when it no longer is
+	     necessary, such as if we change the string we are completing on
+	     and the new set of matches don't require a quoted substring? */
+
+	  replacement = matches[0];
+	  if (matches[0] != NULL
+	      && rl_completer_quote_characters != NULL
+	      && (quote_char == '\0'))
+	    {
+	      for (i = 1; matches[i] != NULL; i++)
+		{
+		  if (strpbrk (matches[i], rl_completer_word_break_characters))
+		    {
+		      /* Found an embedded word break character in a potential
+			 match, so need to prepend a quote character if we are
+			 replacing the completion string. */
+		      replacement = (char *)alloca (strlen (matches[0]) + 2);
+		      quote_char = *rl_completer_quote_characters;
+		      *replacement = quote_char;
+		      strcpy (replacement + 1, matches[0]);
+		      break;
+		    }
+		}
+	    }
+	  if (replacement)
+	    {
+	      rl_delete_text (start, rl_point);
+	      rl_point = start;
+	      rl_insert_text (replacement);
+	    }
+
+	  /* If there are more matches, ring the bell to indicate.
+	     If this was the only match, and we are hacking files,
+	     check the file to see if it was a directory.  If so,
+	     add a '/' to the name.  If not, and we are at the end
+	     of the line, then add a space. */
+	  if (matches[1])
+	    {
+	      ding ();		/* There are other matches remaining. */
+	    }
+	  else
+	    {
+	      char temp_string[16];
+	      int temp_index = 0;
+
+	      if (quote_char)
+		{
+		  temp_string[temp_index++] = quote_char;
+		}
+	      temp_string[temp_index++] = delimiter ? delimiter : ' ';
+	      temp_string[temp_index++] = '\0';
+
+	      if (rl_filename_completion_desired)
+		{
+		  struct stat finfo;
+		  char *filename = tilde_expand (matches[0]);
+
+		  if ((stat (filename, &finfo) == 0) &&
+		      S_ISDIR (finfo.st_mode))
+		    {
+		      if (the_line[rl_point] != '/')
+			rl_insert_text ("/");
+		    }
+		  else
+		    {
+		      if (rl_point == rl_end)
+			rl_insert_text (temp_string);
+		    }
+		  free (filename);
+		}
+	      else
+		{
+		  if (rl_point == rl_end)
+		    rl_insert_text (temp_string);
+		}
+	    }
+	  break;
+
+	case '*':
+	  {
+	    int i = 1;
+
+	    rl_delete_text (start, rl_point);
+	    rl_point = start;
+	    rl_begin_undo_group ();
+	    if (matches[1])
+	      {
+		while (matches[i])
+		  {
+		    rl_insert_text (matches[i++]);
+		    rl_insert_text (" ");
+		  }
+	      }
+	    else
+	      {
+		rl_insert_text (matches[0]);
+		rl_insert_text (" ");
+	      }
+	    rl_end_undo_group ();
+	  }
+	  break;
+
+	case '?':
+	  {
+	    int len, count, limit, max = 0;
+	    int j, k, l;
+
+	    /* Handle simple case first.  What if there is only one answer? */
+	    if (!matches[1])
+	      {
+		char *temp;
+
+		if (rl_filename_completion_desired)
+		  temp = rindex (matches[0], '/');
+		else
+		  temp = (char *)NULL;
+
+		if (!temp)
+		  temp = matches[0];
+		else
+		  temp++;
+
+		crlf ();
+		fprintf (out_stream, "%s", temp);
+		crlf ();
+		goto restart;
+	      }
+
+	    /* There is more than one answer.  Find out how many there are,
+	       and find out what the maximum printed length of a single entry
+	       is. */
+	    for (i = 1; matches[i]; i++)
+	      {
+		char *temp = (char *)NULL;
+
+		/* If we are hacking filenames, then only count the characters
+		   after the last slash in the pathname. */
+		if (rl_filename_completion_desired)
+		  temp = rindex (matches[i], '/');
+		else
+		  temp = (char *)NULL;
+
+		if (!temp)
+		  temp = matches[i];
+		else
+		  temp++;
+
+		if (strlen (temp) > max)
+		  max = strlen (temp);
+	      }
+
+	    len = i;
+
+	    /* If there are many items, then ask the user if she
+	       really wants to see them all. */
+	    if (len >= rl_completion_query_items)
+	      {
+		crlf ();
+		fprintf (out_stream,
+			 "There are %d possibilities.  Do you really", len);
+		crlf ();
+		fprintf (out_stream, "wish to see them all? (y or n)");
+		fflush (out_stream);
+		if (!get_y_or_n ())
+		  {
+		    crlf ();
+		    goto restart;
+		  }
+	      }
+	    /* How many items of MAX length can we fit in the screen window? */
+	    max += 2;
+	    limit = screenwidth / max;
+	    if (limit != 1 && (limit * max == screenwidth))
+	      limit--;
+
+	    /* Avoid a possible floating exception.  If max > screenwidth,
+	       limit will be 0 and a divide-by-zero fault will result. */
+	    if (limit == 0)
+	      limit = 1;
+
+	    /* How many iterations of the printing loop? */
+	    count = (len + (limit - 1)) / limit;
+
+	    /* Watch out for special case.  If LEN is less than LIMIT, then
+	       just do the inner printing loop. */
+	    if (len < limit) count = 1;
+
+	    /* Sort the items if they are not already sorted. */
+	    if (!rl_ignore_completion_duplicates)
+	      qsort (matches, len, sizeof (char *), compare_strings);
+
+	    /* Print the sorted items, up-and-down alphabetically, like
+	       ls might. */
+	    crlf ();
+
+	    for (i = 1; i < count + 1; i++)
+	      {
+		for (j = 0, l = i; j < limit; j++)
+		  {
+		    if (l > len || !matches[l])
+		      {
+			break;
+		      }
+		    else
+		      {
+			char *temp = (char *)NULL;
+
+			if (rl_filename_completion_desired)
+			  temp = rindex (matches[l], '/');
+			else
+			  temp = (char *)NULL;
+
+			if (!temp)
+			  temp = matches[l];
+			else
+			  temp++;
+
+			fprintf (out_stream, "%s", temp);
+			for (k = 0; k < max - strlen (temp); k++)
+			  putc (' ', out_stream);
+		      }
+		    l += count;
+		  }
+		crlf ();
+	      }
+	  restart:
+
+	    rl_on_new_line ();
+	  }
+	  break;
+
+	default:
+	  abort ();
+	}
+
+      for (i = 0; matches[i]; i++)
+	free (matches[i]);
+      free (matches);
+    }
+
+  /* Check to see if the line has changed through all of this manipulation. */
+  if (saved_line_buffer)
+    {
+      if (strcmp (the_line, saved_line_buffer) != 0)
+	completion_changed_buffer = 1;
+      else
+	completion_changed_buffer = 0;
+
+      free (saved_line_buffer);
+    }
+}
+
+/* Stupid comparison routine for qsort () ing strings. */
+static int
+compare_strings (s1, s2)
+  char **s1, **s2;
+{
+  return (strcmp (*s1, *s2));
+}
+
+/* A completion function for usernames.
+   TEXT contains a partial username preceded by a random
+   character (usually `~').  */
+char *
+username_completion_function (text, state)
+     int state;
+     char *text;
+{
+#ifdef __GO32__
+  return (char *)NULL;
+#else /* !__GO32__ */
+  static char *username = (char *)NULL;
+  static struct passwd *entry;
+  static int namelen, first_char, first_char_loc;
+
+  if (!state)
+    {
+      if (username)
+	free (username);
+
+      first_char = *text;
+
+      if (first_char == '~')
+	first_char_loc = 1;
+      else
+	first_char_loc = 0;
+
+      username = savestring (&text[first_char_loc]);
+      namelen = strlen (username);
+      setpwent ();
+    }
+
+  while (entry = getpwent ())
+    {
+      if (strncmp (username, entry->pw_name, namelen) == 0)
+	break;
+    }
+
+  if (!entry)
+    {
+      endpwent ();
+      return ((char *)NULL);
+    }
+  else
+    {
+      char *value = (char *)xmalloc (2 + strlen (entry->pw_name));
+
+      *value = *text;
+
+      strcpy (value + first_char_loc, entry->pw_name);
+
+      if (first_char == '~')
+	rl_filename_completion_desired = 1;
+
+      return (value);
+    }
+#endif /* !__GO32__ */
+}
+
+/* **************************************************************** */
+/*								    */
+/*			Undo, and Undoing			    */
+/*								    */
+/* **************************************************************** */
+
+/* Non-zero tells rl_delete_text and rl_insert_text to not add to
+   the undo list. */
+int doing_an_undo = 0;
+
+/* The current undo list for THE_LINE. */
+UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
+
+/* Remember how to undo something.  Concatenate some undos if that
+   seems right. */
+rl_add_undo (what, start, end, text)
+     enum undo_code what;
+     int start, end;
+     char *text;
+{
+  UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
+  temp->what = what;
+  temp->start = start;
+  temp->end = end;
+  temp->text = text;
+  temp->next = rl_undo_list;
+  rl_undo_list = temp;
+}
+
+/* Free the existing undo list. */
+free_undo_list ()
+{
+  while (rl_undo_list) {
+    UNDO_LIST *release = rl_undo_list;
+    rl_undo_list = rl_undo_list->next;
+
+    if (release->what == UNDO_DELETE)
+      free (release->text);
+
+    free (release);
+  }
+}
+
+/* Undo the next thing in the list.  Return 0 if there
+   is nothing to undo, or non-zero if there was. */
+int
+rl_do_undo ()
+{
+  UNDO_LIST *release;
+  int waiting_for_begin = 0;
+
+undo_thing:
+  if (!rl_undo_list)
+    return (0);
+
+  doing_an_undo = 1;
+
+  switch (rl_undo_list->what) {
+
+    /* Undoing deletes means inserting some text. */
+  case UNDO_DELETE:
+    rl_point = rl_undo_list->start;
+    rl_insert_text (rl_undo_list->text);
+    free (rl_undo_list->text);
+    break;
+
+    /* Undoing inserts means deleting some text. */
+  case UNDO_INSERT:
+    rl_delete_text (rl_undo_list->start, rl_undo_list->end);
+    rl_point = rl_undo_list->start;
+    break;
+
+    /* Undoing an END means undoing everything 'til we get to
+       a BEGIN. */
+  case UNDO_END:
+    waiting_for_begin++;
+    break;
+
+    /* Undoing a BEGIN means that we are done with this group. */
+  case UNDO_BEGIN:
+    if (waiting_for_begin)
+      waiting_for_begin--;
+    else
+      abort ();
+    break;
+  }
+
+  doing_an_undo = 0;
+
+  release = rl_undo_list;
+  rl_undo_list = rl_undo_list->next;
+  free (release);
+
+  if (waiting_for_begin)
+    goto undo_thing;
+
+  return (1);
+}
+
+/* Begin a group.  Subsequent undos are undone as an atomic operation. */
+rl_begin_undo_group ()
+{
+  rl_add_undo (UNDO_BEGIN, 0, 0, 0);
+}
+
+/* End an undo group started with rl_begin_undo_group (). */
+rl_end_undo_group ()
+{
+  rl_add_undo (UNDO_END, 0, 0, 0);
+}
+
+/* Save an undo entry for the text from START to END. */
+rl_modifying (start, end)
+     int start, end;
+{
+  if (start > end)
+    {
+      int t = start;
+      start = end;
+      end = t;
+    }
+
+  if (start != end)
+    {
+      char *temp = rl_copy (start, end);
+      rl_begin_undo_group ();
+      rl_add_undo (UNDO_DELETE, start, end, temp);
+      rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
+      rl_end_undo_group ();
+    }
+}
+
+/* Revert the current line to its previous state. */
+rl_revert_line ()
+{
+  if (!rl_undo_list) ding ();
+  else {
+    while (rl_undo_list)
+      rl_do_undo ();
+  }
+}
+
+/* Do some undoing of things that were done. */
+rl_undo_command (count)
+{
+  if (count < 0) return;	/* Nothing to do. */
+
+  while (count)
+    {
+      if (rl_do_undo ())
+	{
+	  count--;
+	}
+      else
+	{
+	  ding ();
+	  break;
+	}
+    }
+}
+
+/* **************************************************************** */
+/*								    */
+/*			History Utilities			    */
+/*								    */
+/* **************************************************************** */
+
+/* We already have a history library, and that is what we use to control
+   the history features of readline.  However, this is our local interface
+   to the history mechanism. */
+
+/* While we are editing the history, this is the saved
+   version of the original line. */
+HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
+
+/* Set the history pointer back to the last entry in the history. */
+start_using_history ()
+{
+  using_history ();
+  if (saved_line_for_history)
+    free_history_entry (saved_line_for_history);
+
+  saved_line_for_history = (HIST_ENTRY *)NULL;
+}
+
+/* Free the contents (and containing structure) of a HIST_ENTRY. */
+free_history_entry (entry)
+     HIST_ENTRY *entry;
+{
+  if (!entry) return;
+  if (entry->line)
+    free (entry->line);
+  free (entry);
+}
+
+/* Perhaps put back the current line if it has changed. */
+maybe_replace_line ()
+{
+  HIST_ENTRY *temp = current_history ();
+
+  /* If the current line has changed, save the changes. */
+  if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
+    {
+      temp = replace_history_entry (where_history (), the_line, rl_undo_list);
+      free (temp->line);
+      free (temp);
+    }
+}
+
+/* Put back the saved_line_for_history if there is one. */
+maybe_unsave_line ()
+{
+  if (saved_line_for_history)
+    {
+      int line_len;
+
+      line_len = strlen (saved_line_for_history->line);
+
+      if (line_len >= rl_line_buffer_len)
+	rl_extend_line_buffer (line_len);
+
+      strcpy (the_line, saved_line_for_history->line);
+      rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
+      free_history_entry (saved_line_for_history);
+      saved_line_for_history = (HIST_ENTRY *)NULL;
+      rl_end = rl_point = strlen (the_line);
+    }
+  else
+    ding ();
+}
+
+/* Save the current line in saved_line_for_history. */
+maybe_save_line ()
+{
+  if (!saved_line_for_history)
+    {
+      saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
+      saved_line_for_history->line = savestring (the_line);
+      saved_line_for_history->data = (char *)rl_undo_list;
+    }
+}
+
+/* **************************************************************** */
+/*								    */
+/*			History Commands			    */
+/*								    */
+/* **************************************************************** */
+
+/* Meta-< goes to the start of the history. */
+rl_beginning_of_history ()
+{
+  rl_get_previous_history (1 + where_history ());
+}
+
+/* Meta-> goes to the end of the history.  (The current line). */
+rl_end_of_history ()
+{
+  maybe_replace_line ();
+  using_history ();
+  maybe_unsave_line ();
+}
+
+/* Move down to the next history line. */
+rl_get_next_history (count)
+     int count;
+{
+  HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
+
+  if (count < 0)
+    {
+      rl_get_previous_history (-count);
+      return;
+    }
+
+  if (!count)
+    return;
+
+  maybe_replace_line ();
+
+  while (count)
+    {
+      temp = next_history ();
+      if (!temp)
+	break;
+      --count;
+    }
+
+  if (!temp)
+    maybe_unsave_line ();
+  else
+    {
+      int line_len;
+
+      line_len = strlen (temp->line);
+
+      if (line_len >= rl_line_buffer_len)
+	rl_extend_line_buffer (line_len);
+
+      strcpy (the_line, temp->line);
+      rl_undo_list = (UNDO_LIST *)temp->data;
+      rl_end = rl_point = strlen (the_line);
+#if defined (VI_MODE)
+      if (rl_editing_mode == vi_mode)
+	rl_point = 0;
+#endif /* VI_MODE */
+    }
+}
+
+/* Get the previous item out of our interactive history, making it the current
+   line.  If there is no previous history, just ding. */
+rl_get_previous_history (count)
+     int count;
+{
+  HIST_ENTRY *old_temp = (HIST_ENTRY *)NULL;
+  HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
+
+  if (count < 0)
+    {
+      rl_get_next_history (-count);
+      return;
+    }
+
+  if (!count)
+    return;
+
+  /* If we don't have a line saved, then save this one. */
+  maybe_save_line ();
+
+  /* If the current line has changed, save the changes. */
+  maybe_replace_line ();
+
+  while (count)
+    {
+      temp = previous_history ();
+      if (!temp)
+	break;
+      else
+	old_temp = temp;
+      --count;
+    }
+
+  /* If there was a large argument, and we moved back to the start of the
+     history, that is not an error.  So use the last value found. */
+  if (!temp && old_temp)
+    temp = old_temp;
+
+  if (!temp)
+    ding ();
+  else
+    {
+      int line_len;
+
+      line_len = strlen (temp->line);
+
+      if (line_len >= rl_line_buffer_len)
+	rl_extend_line_buffer (line_len);
+
+      strcpy (the_line, temp->line);
+      rl_undo_list = (UNDO_LIST *)temp->data;
+      rl_end = rl_point = line_len;
+
+#if defined (VI_MODE)
+      if (rl_editing_mode == vi_mode)
+	rl_point = 0;
+#endif /* VI_MODE */
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			I-Search and Searching			    */
+/*								    */
+/* **************************************************************** */
+
+/* Search backwards through the history looking for a string which is typed
+   interactively.  Start with the current line. */
+rl_reverse_search_history (sign, key)
+     int sign;
+     int key;
+{
+  rl_search_history (-sign, key);
+}
+
+/* Search forwards through the history looking for a string which is typed
+   interactively.  Start with the current line. */
+rl_forward_search_history (sign, key)
+     int sign;
+     int key;
+{
+  rl_search_history (sign, key);
+}
+
+/* Display the current state of the search in the echo-area.
+   SEARCH_STRING contains the string that is being searched for,
+   DIRECTION is zero for forward, or 1 for reverse,
+   WHERE is the history list number of the current line.  If it is
+   -1, then this line is the starting one. */
+rl_display_search (search_string, reverse_p, where)
+     char *search_string;
+     int reverse_p, where;
+{
+  char *message = (char *)NULL;
+
+  message =
+    (char *)alloca (1 + (search_string ? strlen (search_string) : 0) + 30);
+
+  *message = '\0';
+
+#if defined (NOTDEF)
+  if (where != -1)
+    sprintf (message, "[%d]", where + history_base);
+#endif /* NOTDEF */
+
+  strcat (message, "(");
+
+  if (reverse_p)
+    strcat (message, "reverse-");
+
+  strcat (message, "i-search)`");
+
+  if (search_string)
+    strcat (message, search_string);
+
+  strcat (message, "': ");
+  rl_message (message, 0, 0);
+  rl_redisplay ();
+}
+
+/* Search through the history looking for an interactively typed string.
+   This is analogous to i-search.  We start the search in the current line.
+   DIRECTION is which direction to search; >= 0 means forward, < 0 means
+   backwards. */
+rl_search_history (direction, invoking_key)
+     int direction;
+     int invoking_key;
+{
+  /* The string that the user types in to search for. */
+  char *search_string = (char *)alloca (128);
+
+  /* The current length of SEARCH_STRING. */
+  int search_string_index;
+
+  /* The list of lines to search through. */
+  char **lines;
+
+  /* The length of LINES. */
+  int hlen;
+
+  /* Where we get LINES from. */
+  HIST_ENTRY **hlist = history_list ();
+
+  register int i = 0;
+  int orig_point = rl_point;
+  int orig_line = where_history ();
+  int last_found_line = orig_line;
+  int c, done = 0;
+
+  /* The line currently being searched. */
+  char *sline;
+
+  /* Offset in that line. */
+  int index;
+
+  /* Non-zero if we are doing a reverse search. */
+  int reverse = (direction < 0);
+
+  /* Create an arrary of pointers to the lines that we want to search. */
+  maybe_replace_line ();
+  if (hlist)
+    for (i = 0; hlist[i]; i++);
+
+  /* Allocate space for this many lines, +1 for the current input line,
+     and remember those lines. */
+  lines = (char **)alloca ((1 + (hlen = i)) * sizeof (char *));
+  for (i = 0; i < hlen; i++)
+    lines[i] = hlist[i]->line;
+
+  if (saved_line_for_history)
+    lines[i] = saved_line_for_history->line;
+  else
+    /* So I have to type it in this way instead. */
+    {
+      char *alloced_line;
+
+      /* Keep that mips alloca happy. */
+      alloced_line = (char *)alloca (1 + strlen (the_line));
+      lines[i] = alloced_line;
+      strcpy (lines[i], &the_line[0]);
+    }
+
+  hlen++;
+
+  /* The line where we start the search. */
+  i = orig_line;
+
+  /* Initialize search parameters. */
+  *search_string = '\0';
+  search_string_index = 0;
+
+  /* Normalize DIRECTION into 1 or -1. */
+  if (direction >= 0)
+    direction = 1;
+  else
+    direction = -1;
+
+  rl_display_search (search_string, reverse, -1);
+
+  sline = the_line;
+  index = rl_point;
+
+  while (!done)
+    {
+      c = rl_read_key ();
+
+      /* Hack C to Do What I Mean. */
+      {
+	Function *f = (Function *)NULL;
+
+	if (keymap[c].type == ISFUNC)
+	  {
+	    f = keymap[c].function;
+
+	    if (f == rl_reverse_search_history)
+	      c = reverse ? -1 : -2;
+	    else if (f == rl_forward_search_history)
+	      c =  !reverse ? -1 : -2;
+	  }
+      }
+
+      switch (c)
+	{
+	case ESC:
+	  done = 1;
+	  continue;
+
+	  /* case invoking_key: */
+	case -1:
+	  goto search_again;
+
+	  /* switch directions */
+	case -2:
+	  direction = -direction;
+	  reverse = (direction < 0);
+
+	  goto do_search;
+
+	case CTRL ('G'):
+	  strcpy (the_line, lines[orig_line]);
+	  rl_point = orig_point;
+	  rl_end = strlen (the_line);
+	  rl_clear_message ();
+	  return;
+
+	default:
+	  if (c < 32 || c > 126)
+	    {
+	      rl_execute_next (c);
+	      done = 1;
+	      continue;
+	    }
+	  else
+	    {
+	      search_string[search_string_index++] = c;
+	      search_string[search_string_index] = '\0';
+	      goto do_search;
+
+	    search_again:
+
+	      if (!search_string_index)
+		continue;
+	      else
+		{
+		  if (reverse)
+		    --index;
+		  else
+		    if (index != strlen (sline))
+		      ++index;
+		    else
+		      ding ();
+		}
+	    do_search:
+
+	      while (1)
+		{
+		  if (reverse)
+		    {
+		      while (index >= 0)
+			if (strncmp
+			    (search_string, sline + index, search_string_index)
+			    == 0)
+			  goto string_found;
+			else
+			  index--;
+		    }
+		  else
+		    {
+		      register int limit =
+			(strlen (sline) - search_string_index) + 1;
+
+		      while (index < limit)
+			{
+			  if (strncmp (search_string,
+				       sline + index,
+				       search_string_index) == 0)
+			    goto string_found;
+			  index++;
+			}
+		    }
+
+		next_line:
+		  i += direction;
+
+		  /* At limit for direction? */
+		  if ((reverse && i < 0) ||
+		      (!reverse && i == hlen))
+		    goto search_failed;
+
+		  sline = lines[i];
+		  if (reverse)
+		    index = strlen (sline);
+		  else
+		    index = 0;
+
+		  /* If the search string is longer than the current
+		     line, no match. */
+		  if (search_string_index > strlen (sline))
+		    goto next_line;
+
+		  /* Start actually searching. */
+		  if (reverse)
+		    index -= search_string_index;
+		}
+
+	    search_failed:
+	      /* We cannot find the search string.  Ding the bell. */
+	      ding ();
+	      i = last_found_line;
+	      break;
+
+	    string_found:
+	      /* We have found the search string.  Just display it.  But don't
+		 actually move there in the history list until the user accepts
+		 the location. */
+	      {
+		int line_len;
+
+		line_len = strlen (lines[i]);
+
+		if (line_len >= rl_line_buffer_len)
+		  rl_extend_line_buffer (line_len);
+
+		strcpy (the_line, lines[i]);
+		rl_point = index;
+		rl_end = line_len;
+		last_found_line = i;
+		rl_display_search
+		  (search_string, reverse, (i == orig_line) ? -1 : i);
+	      }
+	    }
+	}
+      continue;
+    }
+
+  /* The searching is over.  The user may have found the string that she
+     was looking for, or else she may have exited a failing search.  If
+     INDEX is -1, then that shows that the string searched for was not
+     found.  We use this to determine where to place rl_point. */
+  {
+    int now = last_found_line;
+
+    /* First put back the original state. */
+    strcpy (the_line, lines[orig_line]);
+
+    if (now < orig_line)
+      rl_get_previous_history (orig_line - now);
+    else
+      rl_get_next_history (now - orig_line);
+
+    /* If the index of the "matched" string is less than zero, then the
+       final search string was never matched, so put point somewhere
+       reasonable. */
+    if (index < 0)
+      index = strlen (the_line);
+
+    rl_point = index;
+    rl_clear_message ();
+  }
+}
+
+/* Make C be the next command to be executed. */
+rl_execute_next (c)
+     int c;
+{
+  rl_pending_input = c;
+}
+
+/* **************************************************************** */
+/*								    */
+/*			Killing Mechanism			    */
+/*								    */
+/* **************************************************************** */
+
+/* What we assume for a max number of kills. */
+#define DEFAULT_MAX_KILLS 10
+
+/* The real variable to look at to find out when to flush kills. */
+int rl_max_kills = DEFAULT_MAX_KILLS;
+
+/* Where to store killed text. */
+char **rl_kill_ring = (char **)NULL;
+
+/* Where we are in the kill ring. */
+int rl_kill_index = 0;
+
+/* How many slots we have in the kill ring. */
+int rl_kill_ring_length = 0;
+
+/* How to say that you only want to save a certain amount
+   of kill material. */
+rl_set_retained_kills (num)
+     int num;
+{}
+
+/* The way to kill something.  This appends or prepends to the last
+   kill, if the last command was a kill command.  if FROM is less
+   than TO, then the text is appended, otherwise prepended.  If the
+   last command was not a kill command, then a new slot is made for
+   this kill. */
+rl_kill_text (from, to)
+     int from, to;
+{
+  int slot;
+  char *text = rl_copy (from, to);
+
+  /* Is there anything to kill? */
+  if (from == to)
+    {
+      free (text);
+      last_command_was_kill++;
+      return;
+    }
+
+  /* Delete the copied text from the line. */
+  rl_delete_text (from, to);
+
+  /* First, find the slot to work with. */
+  if (!last_command_was_kill)
+    {
+      /* Get a new slot.  */
+      if (!rl_kill_ring)
+	{
+	  /* If we don't have any defined, then make one. */
+	  rl_kill_ring = (char **)
+	    xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
+	  slot = 1;
+	}
+      else
+	{
+	  /* We have to add a new slot on the end, unless we have
+	     exceeded the max limit for remembering kills. */
+	  slot = rl_kill_ring_length;
+	  if (slot == rl_max_kills)
+	    {
+	      register int i;
+	      free (rl_kill_ring[0]);
+	      for (i = 0; i < slot; i++)
+		rl_kill_ring[i] = rl_kill_ring[i + 1];
+	    }
+	  else
+	    {
+	      rl_kill_ring =
+		(char **)
+		  xrealloc (rl_kill_ring,
+			    ((slot = (rl_kill_ring_length += 1)) + 1)
+			    * sizeof (char *));
+	    }
+	}
+      slot--;
+    }
+  else
+    {
+      slot = rl_kill_ring_length - 1;
+    }
+
+  /* If the last command was a kill, prepend or append. */
+  if (last_command_was_kill && rl_editing_mode != vi_mode)
+    {
+      char *old = rl_kill_ring[slot];
+      char *new = (char *)xmalloc (1 + strlen (old) + strlen (text));
+
+      if (from < to)
+	{
+	  strcpy (new, old);
+	  strcat (new, text);
+	}
+      else
+	{
+	  strcpy (new, text);
+	  strcat (new, old);
+	}
+      free (old);
+      free (text);
+      rl_kill_ring[slot] = new;
+    }
+  else
+    {
+      rl_kill_ring[slot] = text;
+    }
+  rl_kill_index = slot;
+  last_command_was_kill++;
+}
+
+/* Now REMEMBER!  In order to do prepending or appending correctly, kill
+   commands always make rl_point's original position be the FROM argument,
+   and rl_point's extent be the TO argument. */
+
+/* **************************************************************** */
+/*								    */
+/*			Killing Commands			    */
+/*								    */
+/* **************************************************************** */
+
+/* Delete the word at point, saving the text in the kill ring. */
+rl_kill_word (count)
+     int count;
+{
+  int orig_point = rl_point;
+
+  if (count < 0)
+    rl_backward_kill_word (-count);
+  else
+    {
+      rl_forward_word (count);
+
+      if (rl_point != orig_point)
+	rl_kill_text (orig_point, rl_point);
+
+      rl_point = orig_point;
+    }
+}
+
+/* Rubout the word before point, placing it on the kill ring. */
+rl_backward_kill_word (count)
+     int count;
+{
+  int orig_point = rl_point;
+
+  if (count < 0)
+    rl_kill_word (-count);
+  else
+    {
+      rl_backward_word (count);
+
+      if (rl_point != orig_point)
+	rl_kill_text (orig_point, rl_point);
+    }
+}
+
+/* Kill from here to the end of the line.  If DIRECTION is negative, kill
+   back to the line start instead. */
+rl_kill_line (direction)
+     int direction;
+{
+  int orig_point = rl_point;
+
+  if (direction < 0)
+    rl_backward_kill_line (1);
+  else
+    {
+      rl_end_of_line ();
+      if (orig_point != rl_point)
+	rl_kill_text (orig_point, rl_point);
+      rl_point = orig_point;
+    }
+}
+
+/* Kill backwards to the start of the line.  If DIRECTION is negative, kill
+   forwards to the line end instead. */
+rl_backward_kill_line (direction)
+     int direction;
+{
+  int orig_point = rl_point;
+
+  if (direction < 0)
+    rl_kill_line (1);
+  else
+    {
+      if (!rl_point)
+	ding ();
+      else
+	{
+	  rl_beg_of_line ();
+	  rl_kill_text (orig_point, rl_point);
+	}
+    }
+}
+
+/* Yank back the last killed text.  This ignores arguments. */
+rl_yank ()
+{
+  if (!rl_kill_ring) rl_abort ();
+  rl_insert_text (rl_kill_ring[rl_kill_index]);
+}
+
+/* If the last command was yank, or yank_pop, and the text just
+   before point is identical to the current kill item, then
+   delete that text from the line, rotate the index down, and
+   yank back some other text. */
+rl_yank_pop ()
+{
+  int l;
+
+  if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
+      !rl_kill_ring)
+    {
+      rl_abort ();
+    }
+
+  l = strlen (rl_kill_ring[rl_kill_index]);
+  if (((rl_point - l) >= 0) &&
+      (strncmp (the_line + (rl_point - l),
+		rl_kill_ring[rl_kill_index], l) == 0))
+    {
+      rl_delete_text ((rl_point - l), rl_point);
+      rl_point -= l;
+      rl_kill_index--;
+      if (rl_kill_index < 0)
+	rl_kill_index = rl_kill_ring_length - 1;
+      rl_yank ();
+    }
+  else
+    rl_abort ();
+
+}
+
+/* Yank the COUNTth argument from the previous history line. */
+rl_yank_nth_arg (count, ignore)
+     int count;
+{
+  register HIST_ENTRY *entry = previous_history ();
+  char *arg;
+
+  if (entry)
+    next_history ();
+  else
+    {
+      ding ();
+      return;
+    }
+
+  arg = history_arg_extract (count, count, entry->line);
+  if (!arg || !*arg)
+    {
+      ding ();
+      return;
+    }
+
+  rl_begin_undo_group ();
+
+#if defined (VI_MODE)
+  /* Vi mode always inserts a space befoe yanking the argument, and it
+     inserts it right *after* rl_point. */
+  if (rl_editing_mode == vi_mode)
+    rl_point++;
+#endif /* VI_MODE */
+
+  if (rl_point && the_line[rl_point - 1] != ' ')
+    rl_insert_text (" ");
+
+  rl_insert_text (arg);
+  free (arg);
+
+  rl_end_undo_group ();
+}
+
+/* How to toggle back and forth between editing modes. */
+rl_vi_editing_mode ()
+{
+#if defined (VI_MODE)
+  rl_editing_mode = vi_mode;
+  rl_vi_insertion_mode ();
+#endif /* VI_MODE */
+}
+
+rl_emacs_editing_mode ()
+{
+  rl_editing_mode = emacs_mode;
+  keymap = emacs_standard_keymap;
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			     Completion				    */
+/*								    */
+/* **************************************************************** */
+
+/* Non-zero means that case is not significant in completion. */
+int completion_case_fold = 0;
+
+/* Return an array of (char *) which is a list of completions for TEXT.
+   If there are no completions, return a NULL pointer.
+   The first entry in the returned array is the substitution for TEXT.
+   The remaining entries are the possible completions.
+   The array is terminated with a NULL pointer.
+
+   ENTRY_FUNCTION is a function of two args, and returns a (char *).
+     The first argument is TEXT.
+     The second is a state argument; it should be zero on the first call, and
+     non-zero on subsequent calls.  It returns a NULL pointer to the caller
+     when there are no more matches.
+ */
+char **
+completion_matches (text, entry_function)
+     char *text;
+     char *(*entry_function) ();
+{
+  /* Number of slots in match_list. */
+  int match_list_size;
+
+  /* The list of matches. */
+  char **match_list =
+    (char **)xmalloc (((match_list_size = 10) + 1) * sizeof (char *));
+
+  /* Number of matches actually found. */
+  int matches = 0;
+
+  /* Temporary string binder. */
+  char *string;
+
+  match_list[1] = (char *)NULL;
+
+  while (string = (*entry_function) (text, matches))
+    {
+      if (matches + 1 == match_list_size)
+	match_list = (char **)xrealloc
+	  (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
+
+      match_list[++matches] = string;
+      match_list[matches + 1] = (char *)NULL;
+    }
+
+  /* If there were any matches, then look through them finding out the
+     lowest common denominator.  That then becomes match_list[0]. */
+  if (matches)
+    {
+      register int i = 1;
+      int low = 100000;		/* Count of max-matched characters. */
+
+      /* If only one match, just use that. */
+      if (matches == 1)
+	{
+	  match_list[0] = match_list[1];
+	  match_list[1] = (char *)NULL;
+	}
+      else
+	{
+	  /* Otherwise, compare each member of the list with
+	     the next, finding out where they stop matching. */
+
+	  while (i < matches)
+	    {
+	      register int c1, c2, si;
+
+	      if (completion_case_fold)
+		{
+		  for (si = 0;
+		       (c1 = to_lower(match_list[i][si])) &&
+		       (c2 = to_lower(match_list[i + 1][si]));
+		       si++)
+		    if (c1 != c2) break;
+		}
+	      else
+		{
+		  for (si = 0;
+		       (c1 = match_list[i][si]) &&
+		       (c2 = match_list[i + 1][si]);
+		       si++)
+		    if (c1 != c2) break;
+		}
+
+	      if (low > si) low = si;
+	      i++;
+	    }
+	  match_list[0] = (char *)xmalloc (low + 1);
+	  strncpy (match_list[0], match_list[1], low);
+	  match_list[0][low] = '\0';
+	}
+    }
+  else				/* There were no matches. */
+    {
+      free (match_list);
+      match_list = (char **)NULL;
+    }
+  return (match_list);
+}
+
+/* Okay, now we write the entry_function for filename completion.  In the
+   general case.  Note that completion in the shell is a little different
+   because of all the pathnames that must be followed when looking up the
+   completion for a command. */
+char *
+filename_completion_function (text, state)
+     int state;
+     char *text;
+{
+  static DIR *directory;
+  static char *filename = (char *)NULL;
+  static char *dirname = (char *)NULL;
+  static char *users_dirname = (char *)NULL;
+  static int filename_len;
+
+  dirent *entry = (dirent *)NULL;
+
+  /* If we don't have any state, then do some initialization. */
+  if (!state)
+    {
+      char *temp;
+
+      if (dirname) free (dirname);
+      if (filename) free (filename);
+      if (users_dirname) free (users_dirname);
+
+      filename = savestring (text);
+      if (!*text) text = ".";
+      dirname = savestring (text);
+
+      temp = rindex (dirname, '/');
+
+      if (temp)
+	{
+	  strcpy (filename, ++temp);
+	  *temp = '\0';
+	}
+      else
+	strcpy (dirname, ".");
+
+      /* We aren't done yet.  We also support the "~user" syntax. */
+
+      /* Save the version of the directory that the user typed. */
+      users_dirname = savestring (dirname);
+      {
+	char *temp_dirname;
+
+	temp_dirname = tilde_expand (dirname);
+	free (dirname);
+	dirname = temp_dirname;
+
+	if (rl_symbolic_link_hook)
+	  (*rl_symbolic_link_hook) (&dirname);
+      }
+      directory = opendir (dirname);
+      filename_len = strlen (filename);
+
+      rl_filename_completion_desired = 1;
+    }
+
+  /* At this point we should entertain the possibility of hacking wildcarded
+     filenames, like /usr/man/man<WILD>/te<TAB>.  If the directory name
+     contains globbing characters, then build an array of directories to
+     glob on, and glob on the first one. */
+
+  /* Now that we have some state, we can read the directory. */
+
+  while (directory && (entry = readdir (directory)))
+    {
+      /* Special case for no filename.
+	 All entries except "." and ".." match. */
+      if (!filename_len)
+	{
+	  if ((strcmp (entry->d_name, ".") != 0) &&
+	      (strcmp (entry->d_name, "..") != 0))
+	    break;
+	}
+      else
+	{
+	  /* Otherwise, if these match upto the length of filename, then
+	     it is a match. */
+	    if (entry->d_name[0] == filename[0] && /* Quick test */
+		(strncmp (filename, entry->d_name, filename_len) == 0))
+	      {
+		break;
+	      }
+	}
+    }
+
+  if (!entry)
+    {
+      if (directory)
+	{
+	  closedir (directory);
+	  directory = (DIR *)NULL;
+	}
+      return (char *)NULL;
+    }
+  else
+    {
+      char *temp;
+
+      if (dirname && (strcmp (dirname, ".") != 0))
+	{
+	  temp = (char *)
+	    xmalloc (1 + strlen (users_dirname) + strlen (entry->d_name));
+	  strcpy (temp, users_dirname);
+	  strcat (temp, entry->d_name);
+	}
+      else
+	{
+	  temp = (savestring (entry->d_name));
+	}
+      return (temp);
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			Binding keys				    */
+/*								    */
+/* **************************************************************** */
+
+/* rl_add_defun (char *name, Function *function, int key)
+   Add NAME to the list of named functions.  Make FUNCTION
+   be the function that gets called.
+   If KEY is not -1, then bind it. */
+rl_add_defun (name, function, key)
+     char *name;
+     Function *function;
+     int key;
+{
+  if (key != -1)
+    rl_bind_key (key, function);
+  rl_add_funmap_entry (name, function);
+}
+
+/* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
+int
+rl_bind_key (key, function)
+     int key;
+     Function *function;
+{
+  if (key < 0)
+    return (key);
+
+  if (key > 127 && key < 256)
+    {
+      if (keymap[ESC].type == ISKMAP)
+	{
+	  Keymap escmap = (Keymap)keymap[ESC].function;
+
+	  key -= 128;
+	  escmap[key].type = ISFUNC;
+	  escmap[key].function = function;
+	  return (0);
+	}
+      return (key);
+    }
+
+  keymap[key].type = ISFUNC;
+  keymap[key].function = function;
+ return (0);
+}
+
+/* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
+   KEY. */
+int
+rl_bind_key_in_map (key, function, map)
+     int key;
+     Function *function;
+     Keymap map;
+{
+  int result;
+  Keymap oldmap = keymap;
+
+  keymap = map;
+  result = rl_bind_key (key, function);
+  keymap = oldmap;
+  return (result);
+}
+
+/* Make KEY do nothing in the currently selected keymap.
+   Returns non-zero in case of error. */
+int
+rl_unbind_key (key)
+     int key;
+{
+  return (rl_bind_key (key, (Function *)NULL));
+}
+
+/* Make KEY do nothing in MAP.
+   Returns non-zero in case of error. */
+int
+rl_unbind_key_in_map (key, map)
+     int key;
+     Keymap map;
+{
+  return (rl_bind_key_in_map (key, (Function *)NULL, map));
+}
+
+/* Bind the key sequence represented by the string KEYSEQ to
+   FUNCTION.  This makes new keymaps as necessary.  The initial
+   place to do bindings is in MAP. */
+rl_set_key (keyseq, function, map)
+     char *keyseq;
+     Function *function;
+     Keymap map;
+{
+  rl_generic_bind (ISFUNC, keyseq, function, map);
+}
+
+/* Bind the key sequence represented by the string KEYSEQ to
+   the string of characters MACRO.  This makes new keymaps as
+   necessary.  The initial place to do bindings is in MAP. */
+rl_macro_bind (keyseq, macro, map)
+     char *keyseq, *macro;
+     Keymap map;
+{
+  char *macro_keys;
+  int macro_keys_len;
+
+  macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
+
+  if (rl_translate_keyseq (macro, macro_keys, &macro_keys_len))
+    {
+      free (macro_keys);
+      return;
+    }
+  rl_generic_bind (ISMACR, keyseq, macro_keys, map);
+}
+
+/* Bind the key sequence represented by the string KEYSEQ to
+   the arbitrary pointer DATA.  TYPE says what kind of data is
+   pointed to by DATA, right now this can be a function (ISFUNC),
+   a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
+   as necessary.  The initial place to do bindings is in MAP. */
+
+static void
+rl_generic_bind (type, keyseq, data, map)
+     int type;
+     char *keyseq, *data;
+     Keymap map;
+{
+  char *keys;
+  int keys_len;
+  register int i;
+
+  /* If no keys to bind to, exit right away. */
+  if (!keyseq || !*keyseq)
+    {
+      if (type == ISMACR)
+	free (data);
+      return;
+    }
+
+  keys = (char *)alloca (1 + (2 * strlen (keyseq)));
+
+  /* Translate the ASCII representation of KEYSEQ into an array
+     of characters.  Stuff the characters into ARRAY, and the
+     length of ARRAY into LENGTH. */
+  if (rl_translate_keyseq (keyseq, keys, &keys_len))
+    return;
+
+  /* Bind keys, making new keymaps as necessary. */
+  for (i = 0; i < keys_len; i++)
+    {
+      if (i + 1 < keys_len)
+	{
+	  if (map[keys[i]].type != ISKMAP)
+	    {
+	      if (map[i].type == ISMACR)
+		free ((char *)map[i].function);
+
+	      map[keys[i]].type = ISKMAP;
+	      map[keys[i]].function = (Function *)rl_make_bare_keymap ();
+	    }
+	  map = (Keymap)map[keys[i]].function;
+	}
+      else
+	{
+	  if (map[keys[i]].type == ISMACR)
+	    free ((char *)map[keys[i]].function);
+
+	  map[keys[i]].function = (Function *)data;
+	  map[keys[i]].type = type;
+	}
+    }
+}
+
+/* Translate the ASCII representation of SEQ, stuffing the
+   values into ARRAY, an array of characters.  LEN gets the
+   final length of ARRAY.  Return non-zero if there was an
+   error parsing SEQ. */
+rl_translate_keyseq (seq, array, len)
+     char *seq, *array;
+     int *len;
+{
+  register int i, c, l = 0;
+
+  for (i = 0; c = seq[i]; i++)
+    {
+      if (c == '\\')
+	{
+	  c = seq[++i];
+
+	  if (!c)
+	    break;
+
+	  if (((c == 'C' || c == 'M') &&  seq[i + 1] == '-') ||
+	      (c == 'e'))
+	    {
+	      /* Handle special case of backwards define. */
+	      if (strncmp (&seq[i], "C-\\M-", 5) == 0)
+		{
+		  array[l++] = ESC;
+		  i += 5;
+		  array[l++] = CTRL (to_upper (seq[i]));
+		  if (!seq[i])
+		    i--;
+		  continue;
+		}
+
+	      switch (c)
+		{
+		case 'M':
+		  i++;
+		  array[l++] = ESC;
+		  break;
+
+		case 'C':
+		  i += 2;
+		  /* Special hack for C-?... */
+		  if (seq[i] == '?')
+		    array[l++] = RUBOUT;
+		  else
+		    array[l++] = CTRL (to_upper (seq[i]));
+		  break;
+
+		case 'e':
+		  array[l++] = ESC;
+		}
+
+	      continue;
+	    }
+	}
+      array[l++] = c;
+    }
+
+  *len = l;
+  array[l] = '\0';
+  return (0);
+}
+
+/* Return a pointer to the function that STRING represents.
+   If STRING doesn't have a matching function, then a NULL pointer
+   is returned. */
+Function *
+rl_named_function (string)
+     char *string;
+{
+  register int i;
+
+  for (i = 0; funmap[i]; i++)
+    if (stricmp (funmap[i]->name, string) == 0)
+      return (funmap[i]->function);
+  return ((Function *)NULL);
+}
+
+/* The last key bindings file read. */
+#ifdef __MSDOS__
+/* Don't know what to do, but this is a guess */
+static char *last_readline_init_file = "/INPUTRC";
+#else
+static char *last_readline_init_file = "~/.inputrc";
+#endif
+
+/* Re-read the current keybindings file. */
+rl_re_read_init_file (count, ignore)
+     int count, ignore;
+{
+  rl_read_init_file ((char *)NULL);
+}
+
+/* Do key bindings from a file.  If FILENAME is NULL it defaults
+   to `~/.inputrc'.  If the file existed and could be opened and
+   read, 0 is returned, otherwise errno is returned. */
+int
+rl_read_init_file (filename)
+     char *filename;
+{
+  register int i;
+  char *buffer, *openname, *line, *end;
+  struct stat finfo;
+  int file;
+
+  /* Default the filename. */
+  if (!filename)
+    filename = last_readline_init_file;
+
+  openname = tilde_expand (filename);
+
+  if (!openname || *openname == '\000')
+    return ENOENT;
+
+  if ((stat (openname, &finfo) < 0) ||
+      (file = open (openname, O_RDONLY, 0666)) < 0)
+    {
+      free (openname);
+      return (errno);
+    }
+  else
+    free (openname);
+
+  last_readline_init_file = filename;
+
+  /* Read the file into BUFFER. */
+  buffer = (char *)xmalloc (finfo.st_size + 1);
+  i = read (file, buffer, finfo.st_size);
+  close (file);
+
+  if (i != finfo.st_size)
+    return (errno);
+
+  /* Loop over the lines in the file.  Lines that start with `#' are
+     comments; all other lines are commands for readline initialization. */
+  line = buffer;
+  end = buffer + finfo.st_size;
+  while (line < end)
+    {
+      /* Find the end of this line. */
+      for (i = 0; line + i != end && line[i] != '\n'; i++);
+
+      /* Mark end of line. */
+      line[i] = '\0';
+
+      /* If the line is not a comment, then parse it. */
+      if (*line != '#')
+	rl_parse_and_bind (line);
+
+      /* Move to the next line. */
+      line += i + 1;
+    }
+  return (0);
+}
+
+/* **************************************************************** */
+/*								    */
+/*			Parser Directives       		    */
+/*								    */
+/* **************************************************************** */
+
+/* Conditionals. */
+
+/* Calling programs set this to have their argv[0]. */
+char *rl_readline_name = "other";
+
+/* Stack of previous values of parsing_conditionalized_out. */
+static unsigned char *if_stack = (unsigned char *)NULL;
+static int if_stack_depth = 0;
+static int if_stack_size = 0;
+
+/* Push parsing_conditionalized_out, and set parser state based on ARGS. */
+parser_if (args)
+     char *args;
+{
+  register int i;
+
+  /* Push parser state. */
+  if (if_stack_depth + 1 >= if_stack_size)
+    {
+      if (!if_stack)
+	if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
+      else
+	if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
+    }
+  if_stack[if_stack_depth++] = parsing_conditionalized_out;
+
+  /* If parsing is turned off, then nothing can turn it back on except
+     for finding the matching endif.  In that case, return right now. */
+  if (parsing_conditionalized_out)
+    return;
+
+  /* Isolate first argument. */
+  for (i = 0; args[i] && !whitespace (args[i]); i++);
+
+  if (args[i])
+    args[i++] = '\0';
+
+  /* Handle "if term=foo" and "if mode=emacs" constructs.  If this
+     isn't term=foo, or mode=emacs, then check to see if the first
+     word in ARGS is the same as the value stored in rl_readline_name. */
+  if (rl_terminal_name && strnicmp (args, "term=", 5) == 0)
+    {
+      char *tem, *tname;
+
+      /* Terminals like "aaa-60" are equivalent to "aaa". */
+      tname = savestring (rl_terminal_name);
+      tem = rindex (tname, '-');
+      if (tem)
+	*tem = '\0';
+
+      if (stricmp (args + 5, tname) == 0)
+	parsing_conditionalized_out = 0;
+      else
+	parsing_conditionalized_out = 1;
+
+      free (tname);
+    }
+#if defined (VI_MODE)
+  else if (strnicmp (args, "mode=", 5) == 0)
+    {
+      int mode;
+
+      if (stricmp (args + 5, "emacs") == 0)
+	mode = emacs_mode;
+      else if (stricmp (args + 5, "vi") == 0)
+	mode = vi_mode;
+      else
+	mode = no_mode;
+
+      if (mode == rl_editing_mode)
+	parsing_conditionalized_out = 0;
+      else
+	parsing_conditionalized_out = 1;
+    }
+#endif /* VI_MODE */
+  /* Check to see if the first word in ARGS is the same as the
+     value stored in rl_readline_name. */
+  else if (stricmp (args, rl_readline_name) == 0)
+    parsing_conditionalized_out = 0;
+  else
+    parsing_conditionalized_out = 1;
+}
+
+/* Invert the current parser state if there is anything on the stack. */
+parser_else (args)
+     char *args;
+{
+  register int i;
+
+  if (!if_stack_depth)
+    {
+      /* Error message? */
+      return;
+    }
+
+  /* Check the previous (n - 1) levels of the stack to make sure that
+     we haven't previously turned off parsing. */
+  for (i = 0; i < if_stack_depth - 1; i++)
+    if (if_stack[i] == 1)
+      return;
+
+  /* Invert the state of parsing if at top level. */
+  parsing_conditionalized_out = !parsing_conditionalized_out;
+}
+
+/* Terminate a conditional, popping the value of
+   parsing_conditionalized_out from the stack. */
+parser_endif (args)
+     char *args;
+{
+  if (if_stack_depth)
+    parsing_conditionalized_out = if_stack[--if_stack_depth];
+  else
+    {
+      /* *** What, no error message? *** */
+    }
+}
+
+/* Associate textual names with actual functions. */
+static struct {
+  char *name;
+  Function *function;
+} parser_directives [] = {
+  { "if", parser_if },
+  { "endif", parser_endif },
+  { "else", parser_else },
+  { (char *)0x0, (Function *)0x0 }
+};
+
+/* Handle a parser directive.  STATEMENT is the line of the directive
+   without any leading `$'. */
+static int
+handle_parser_directive (statement)
+     char *statement;
+{
+  register int i;
+  char *directive, *args;
+
+  /* Isolate the actual directive. */
+
+  /* Skip whitespace. */
+  for (i = 0; whitespace (statement[i]); i++);
+
+  directive = &statement[i];
+
+  for (; statement[i] && !whitespace (statement[i]); i++);
+
+  if (statement[i])
+    statement[i++] = '\0';
+
+  for (; statement[i] && whitespace (statement[i]); i++);
+
+  args = &statement[i];
+
+  /* Lookup the command, and act on it. */
+  for (i = 0; parser_directives[i].name; i++)
+    if (stricmp (directive, parser_directives[i].name) == 0)
+      {
+	(*parser_directives[i].function) (args);
+	return (0);
+      }
+
+  /* *** Should an error message be output? */
+  return (1);
+}
+
+/* Ugly but working hack for binding prefix meta. */
+#define PREFIX_META_HACK
+
+static int substring_member_of_array ();
+
+/* Read the binding command from STRING and perform it.
+   A key binding command looks like: Keyname: function-name\0,
+   a variable binding command looks like: set variable value.
+   A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
+rl_parse_and_bind (string)
+     char *string;
+{
+  extern char *possible_control_prefixes[], *possible_meta_prefixes[];
+  char *funname, *kname;
+  register int c;
+  int key, i;
+
+  while (string && whitespace (*string))
+    string++;
+
+  if (!string || !*string || *string == '#')
+    return;
+
+  /* If this is a parser directive, act on it. */
+  if (*string == '$')
+    {
+      handle_parser_directive (&string[1]);
+      return;
+    }
+
+  /* If we are supposed to be skipping parsing right now, then do it. */
+  if (parsing_conditionalized_out)
+    return;
+
+  i = 0;
+  /* If this keyname is a complex key expression surrounded by quotes,
+     advance to after the matching close quote. */
+  if (*string == '"')
+    {
+      for (i = 1; c = string[i]; i++)
+	{
+	  if (c == '"' && string[i - 1] != '\\')
+	    break;
+	}
+    }
+
+  /* Advance to the colon (:) or whitespace which separates the two objects. */
+  for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
+
+  /* Mark the end of the command (or keyname). */
+  if (string[i])
+    string[i++] = '\0';
+
+  /* If this is a command to set a variable, then do that. */
+  if (stricmp (string, "set") == 0)
+    {
+      char *var = string + i;
+      char *value;
+
+      /* Make VAR point to start of variable name. */
+      while (*var && whitespace (*var)) var++;
+
+      /* Make value point to start of value string. */
+      value = var;
+      while (*value && !whitespace (*value)) value++;
+      if (*value)
+	*value++ = '\0';
+      while (*value && whitespace (*value)) value++;
+
+      rl_variable_bind (var, value);
+      return;
+    }
+
+  /* Skip any whitespace between keyname and funname. */
+  for (; string[i] && whitespace (string[i]); i++);
+  funname = &string[i];
+
+  /* Now isolate funname.
+     For straight function names just look for whitespace, since
+     that will signify the end of the string.  But this could be a
+     macro definition.  In that case, the string is quoted, so skip
+     to the matching delimiter. */
+  if (*funname == '\'' || *funname == '"')
+    {
+      int delimiter = string[i++];
+
+      for (; c = string[i]; i++)
+	{
+	  if (c == delimiter && string[i - 1] != '\\')
+	    break;
+	}
+      if (c)
+	i++;
+    }
+
+  /* Advance to the end of the string.  */
+  for (; string[i] && !whitespace (string[i]); i++);
+
+  /* No extra whitespace at the end of the string. */
+  string[i] = '\0';
+
+  /* If this is a new-style key-binding, then do the binding with
+     rl_set_key ().  Otherwise, let the older code deal with it. */
+  if (*string == '"')
+    {
+      char *seq = (char *)alloca (1 + strlen (string));
+      register int j, k = 0;
+
+      for (j = 1; string[j]; j++)
+	{
+	  if (string[j] == '"' && string[j - 1] != '\\')
+	    break;
+
+	  seq[k++] = string[j];
+	}
+      seq[k] = '\0';
+
+      /* Binding macro? */
+      if (*funname == '\'' || *funname == '"')
+	{
+	  j = strlen (funname);
+
+	  if (j && funname[j - 1] == *funname)
+	    funname[j - 1] = '\0';
+
+	  rl_macro_bind (seq, &funname[1], keymap);
+	}
+      else
+	rl_set_key (seq, rl_named_function (funname), keymap);
+
+      return;
+    }
+
+  /* Get the actual character we want to deal with. */
+  kname = rindex (string, '-');
+  if (!kname)
+    kname = string;
+  else
+    kname++;
+
+  key = glean_key_from_name (kname);
+
+  /* Add in control and meta bits. */
+  if (substring_member_of_array (string, possible_control_prefixes))
+    key = CTRL (to_upper (key));
+
+  if (substring_member_of_array (string, possible_meta_prefixes))
+    key = META (key);
+
+  /* Temporary.  Handle old-style keyname with macro-binding. */
+  if (*funname == '\'' || *funname == '"')
+    {
+      char seq[2];
+      int fl = strlen (funname);
+
+      seq[0] = key; seq[1] = '\0';
+      if (fl && funname[fl - 1] == *funname)
+	funname[fl - 1] = '\0';
+
+      rl_macro_bind (seq, &funname[1], keymap);
+    }
+#if defined (PREFIX_META_HACK)
+  /* Ugly, but working hack to keep prefix-meta around. */
+  else if (stricmp (funname, "prefix-meta") == 0)
+    {
+      char seq[2];
+
+      seq[0] = key;
+      seq[1] = '\0';
+      rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, keymap);
+    }
+#endif /* PREFIX_META_HACK */
+  else
+    rl_bind_key (key, rl_named_function (funname));
+}
+
+rl_variable_bind (name, value)
+     char *name, *value;
+{
+  if (stricmp (name, "editing-mode") == 0)
+    {
+      if (strnicmp (value, "vi", 2) == 0)
+	{
+#if defined (VI_MODE)
+	  keymap = vi_insertion_keymap;
+	  rl_editing_mode = vi_mode;
+#else
+#if defined (NOTDEF)
+	  /* What state is the terminal in?  I'll tell you:
+	     non-determinate!  That means we cannot do any output. */
+	  ding ();
+#endif /* NOTDEF */
+#endif /* VI_MODE */
+	}
+      else if (strnicmp (value, "emacs", 5) == 0)
+	{
+	  keymap = emacs_standard_keymap;
+	  rl_editing_mode = emacs_mode;
+	}
+    }
+  else if (stricmp (name, "horizontal-scroll-mode") == 0)
+    {
+      if (!*value || stricmp (value, "On") == 0)
+	horizontal_scroll_mode = 1;
+      else
+	horizontal_scroll_mode = 0;
+    }
+  else if (stricmp (name, "mark-modified-lines") == 0)
+    {
+      if (!*value || stricmp (value, "On") == 0)
+	mark_modified_lines = 1;
+      else
+	mark_modified_lines = 0;
+    }
+  else if (stricmp (name, "prefer-visible-bell") == 0)
+    {
+      if (!*value || stricmp (value, "On") == 0)
+        prefer_visible_bell = 1;
+      else
+        prefer_visible_bell = 0;
+    }
+  else if (stricmp (name, "comment-begin") == 0)
+    {
+#if defined (VI_MODE)
+      extern char *rl_vi_comment_begin;
+
+      if (*value)
+	{
+	  if (rl_vi_comment_begin)
+	    free (rl_vi_comment_begin);
+
+	  rl_vi_comment_begin = savestring (value);
+	}
+#endif /* VI_MODE */
+    }
+}
+
+/* Return the character which matches NAME.
+   For example, `Space' returns ' '. */
+
+typedef struct {
+  char *name;
+  int value;
+} assoc_list;
+
+assoc_list name_key_alist[] = {
+  { "DEL", 0x7f },
+  { "ESC", '\033' },
+  { "Escape", '\033' },
+  { "LFD", '\n' },
+  { "Newline", '\n' },
+  { "RET", '\r' },
+  { "Return", '\r' },
+  { "Rubout", 0x7f },
+  { "SPC", ' ' },
+  { "Space", ' ' },
+  { "Tab", 0x09 },
+  { (char *)0x0, 0 }
+};
+
+int
+glean_key_from_name (name)
+     char *name;
+{
+  register int i;
+
+  for (i = 0; name_key_alist[i].name; i++)
+    if (stricmp (name, name_key_alist[i].name) == 0)
+      return (name_key_alist[i].value);
+
+  return (*name);
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*		  Key Binding and Function Information		    */
+/*								    */
+/* **************************************************************** */
+
+/* Each of the following functions produces information about the
+   state of keybindings and functions known to Readline.  The info
+   is always printed to rl_outstream, and in such a way that it can
+   be read back in (i.e., passed to rl_parse_and_bind (). */
+
+/* Print the names of functions known to Readline. */
+void
+rl_list_funmap_names (ignore)
+     int ignore;
+{
+  register int i;
+  char **funmap_names;
+  extern char **rl_funmap_names ();
+
+  funmap_names = rl_funmap_names ();
+
+  if (!funmap_names)
+    return;
+
+  for (i = 0; funmap_names[i]; i++)
+    fprintf (rl_outstream, "%s\n", funmap_names[i]);
+
+  free (funmap_names);
+}
+
+/* Return a NULL terminated array of strings which represent the key
+   sequences that are used to invoke FUNCTION in MAP. */
+static char **
+invoking_keyseqs_in_map (function, map)
+     Function *function;
+     Keymap map;
+{
+  register int key;
+  char **result;
+  int result_index, result_size;
+
+  result = (char **)NULL;
+  result_index = result_size = 0;
+
+  for (key = 0; key < 128; key++)
+    {
+      switch (map[key].type)
+	{
+	case ISMACR:
+	  /* Macros match, if, and only if, the pointers are identical.
+	     Thus, they are treated exactly like functions in here. */
+	case ISFUNC:
+	  /* If the function in the keymap is the one we are looking for,
+	     then add the current KEY to the list of invoking keys. */
+	  if (map[key].function == function)
+	    {
+	      char *keyname = (char *)xmalloc (5);
+
+	      if (CTRL_P (key))
+		sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key)));
+	      else if (key == RUBOUT)
+		sprintf (keyname, "\\C-?");
+	      else
+		sprintf (keyname, "%c", key);
+	      
+	      if (result_index + 2 > result_size)
+		{
+		  if (!result)
+		    result = (char **) xmalloc
+		      ((result_size = 10) * sizeof (char *));
+		  else
+		    result = (char **) xrealloc
+		      (result, (result_size += 10) * sizeof (char *));
+		}
+
+	      result[result_index++] = keyname;
+	      result[result_index] = (char *)NULL;
+	    }
+	  break;
+
+	case ISKMAP:
+	  {
+	    char **seqs = (char **)NULL;
+
+	    /* Find the list of keyseqs in this map which have FUNCTION as
+	       their target.  Add the key sequences found to RESULT. */
+	    if (map[key].function)
+	      seqs =
+		invoking_keyseqs_in_map (function, (Keymap)map[key].function);
+
+	    if (seqs)
+	      {
+		register int i;
+
+		for (i = 0; seqs[i]; i++)
+		  {
+		    char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
+
+		    if (key == ESC)
+		      sprintf (keyname, "\\e");
+		    else if (CTRL_P (key))
+		      sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key)));
+		    else if (key == RUBOUT)
+		      sprintf (keyname, "\\C-?");
+		    else
+		      sprintf (keyname, "%c", key);
+
+		    strcat (keyname, seqs[i]);
+
+		    if (result_index + 2 > result_size)
+		      {
+			if (!result)
+			  result = (char **)
+			    xmalloc ((result_size = 10) * sizeof (char *));
+			else
+			  result = (char **)
+			    xrealloc (result,
+				      (result_size += 10) * sizeof (char *));
+		      }
+
+		    result[result_index++] = keyname;
+		    result[result_index] = (char *)NULL;
+		  }
+	      }
+	  }
+	  break;
+	}
+    }
+  return (result);
+}
+
+/* Return a NULL terminated array of strings which represent the key
+   sequences that can be used to invoke FUNCTION using the current keymap. */
+char **
+rl_invoking_keyseqs (function)
+     Function *function;
+{
+  return (invoking_keyseqs_in_map (function, keymap));
+}
+
+/* Print all of the current functions and their bindings to
+   rl_outstream.  If an explicit argument is given, then print
+   the output in such a way that it can be read back in. */
+int
+rl_dump_functions (count)
+     int count;
+{
+  void rl_function_dumper ();
+
+  rl_function_dumper (rl_explicit_arg);
+  rl_on_new_line ();
+  return (0);
+}
+
+/* Print all of the functions and their bindings to rl_outstream.  If
+   PRINT_READABLY is non-zero, then print the output in such a way
+   that it can be read back in. */
+void
+rl_function_dumper (print_readably)
+     int print_readably;
+{
+  register int i;
+  char **rl_funmap_names (), **names;
+  char *name;
+
+  names = rl_funmap_names ();
+
+  fprintf (rl_outstream, "\n");
+
+  for (i = 0; name = names[i]; i++)
+    {
+      Function *function;
+      char **invokers;
+
+      function = rl_named_function (name);
+      invokers = invoking_keyseqs_in_map (function, keymap);
+
+      if (print_readably)
+	{
+	  if (!invokers)
+	    fprintf (rl_outstream, "# %s (not bound)\n", name);
+	  else
+	    {
+	      register int j;
+
+	      for (j = 0; invokers[j]; j++)
+		{
+		  fprintf (rl_outstream, "\"%s\": %s\n",
+			   invokers[j], name);
+		  free (invokers[j]);
+		}
+
+	      free (invokers);
+	    }
+	}
+      else
+	{
+	  if (!invokers)
+	    fprintf (rl_outstream, "%s is not bound to any keys\n",
+		     name);
+	  else
+	    {
+	      register int j;
+
+	      fprintf (rl_outstream, "%s can be found on ", name);
+
+	      for (j = 0; invokers[j] && j < 5; j++)
+		{
+		  fprintf (rl_outstream, "\"%s\"%s", invokers[j],
+			   invokers[j + 1] ? ", " : ".\n");
+		}
+
+	      if (j == 5 && invokers[j])
+		fprintf (rl_outstream, "...\n");
+
+	      for (j = 0; invokers[j]; j++)
+		free (invokers[j]);
+
+	      free (invokers);
+	    }
+	}
+    }
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			String Utility Functions		    */
+/*								    */
+/* **************************************************************** */
+
+static char *strindex ();
+
+/* Return pointer to first occurance in STRING1 of any character from STRING2,
+   or NULL if no occurance found. */
+static char *
+strpbrk (string1, string2)
+     char *string1, *string2;
+{
+  register char *scan;
+
+  for (; *string1 != '\0'; string1++)
+    {
+      for (scan = string2; *scan != '\0'; scan++)
+	{
+	  if (*string1 == *scan)
+	    {
+	      return (string1);
+	    }
+	}
+    }
+  return (NULL);
+}
+
+/* Return non-zero if any members of ARRAY are a substring in STRING. */
+static int
+substring_member_of_array (string, array)
+     char *string, **array;
+{
+  while (*array)
+    {
+      if (strindex (string, *array))
+	return (1);
+      array++;
+    }
+  return (0);
+}
+
+/* Whoops, Unix doesn't have strnicmp. */
+
+/* Compare at most COUNT characters from string1 to string2.  Case
+   doesn't matter. */
+static int
+strnicmp (string1, string2, count)
+     char *string1, *string2;
+{
+  register char ch1, ch2;
+
+  while (count)
+    {
+      ch1 = *string1++;
+      ch2 = *string2++;
+      if (to_upper(ch1) == to_upper(ch2))
+	count--;
+      else break;
+    }
+  return (count);
+}
+
+/* strcmp (), but caseless. */
+static int
+stricmp (string1, string2)
+     char *string1, *string2;
+{
+  register char ch1, ch2;
+
+  while (*string1 && *string2)
+    {
+      ch1 = *string1++;
+      ch2 = *string2++;
+      if (to_upper(ch1) != to_upper(ch2))
+	return (1);
+    }
+  return (*string1 | *string2);
+}
+
+/* Determine if s2 occurs in s1.  If so, return a pointer to the
+   match in s1.  The compare is case insensitive. */
+static char *
+strindex (s1, s2)
+     register char *s1, *s2;
+{
+  register int i, l = strlen (s2);
+  register int len = strlen (s1);
+
+  for (i = 0; (len - i) >= l; i++)
+    if (strnicmp (&s1[i], s2, l) == 0)
+      return (s1 + i);
+  return ((char *)NULL);
+}
+
+
+/* **************************************************************** */
+/*								    */
+/*			USG (System V) Support			    */
+/*								    */
+/* **************************************************************** */
+
+/* When compiling and running in the `Posix' environment, Ultrix does
+   not restart system calls, so this needs to do it. */
+int
+rl_getc (stream)
+     FILE *stream;
+{
+  int result;
+  unsigned char c;
+
+#ifdef __GO32__
+  if (isatty(0))
+    return getkey();
+#endif /* __GO32__ */
+
+  while (1)
+    {
+      result = read (fileno (stream), &c, sizeof (char));
+
+      if (result == sizeof (char))
+	return (c);
+
+      /* If zero characters are returned, then the file that we are
+	 reading from is empty!  Return EOF in that case. */
+      if (result == 0)
+	return (EOF);
+
+#ifndef __GO32__
+      /* If the error that we received was SIGINT, then try again,
+	 this is simply an interrupted system call to read ().
+	 Otherwise, some error ocurred, also signifying EOF. */
+      if (errno != EINTR)
+	return (EOF);
+#endif /* !__GO32__ */
+    }
+}
+
+#if defined (STATIC_MALLOC)
+
+/* **************************************************************** */
+/*								    */
+/*			xmalloc and xrealloc ()		     	    */
+/*								    */
+/* **************************************************************** */
+
+static void memory_error_and_abort ();
+
+static char *
+xmalloc (bytes)
+     int bytes;
+{
+  char *temp = (char *)malloc (bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static char *
+xrealloc (pointer, bytes)
+     char *pointer;
+     int bytes;
+{
+  char *temp;
+
+  if (!pointer)
+    temp = (char *)malloc (bytes);
+  else
+    temp = (char *)realloc (pointer, bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+
+  return (temp);
+}
+
+static void
+memory_error_and_abort ()
+{
+  fprintf (stderr, "readline: Out of virtual memory!\n");
+  abort ();
+}
+#endif /* STATIC_MALLOC */
+
+
+/* **************************************************************** */
+/*								    */
+/*			Testing Readline			    */
+/*								    */
+/* **************************************************************** */
+
+#if defined (TEST)
+
+main ()
+{
+  HIST_ENTRY **history_list ();
+  char *temp = (char *)NULL;
+  char *prompt = "readline% ";
+  int done = 0;
+
+  while (!done)
+    {
+      temp = readline (prompt);
+
+      /* Test for EOF. */
+      if (!temp)
+	exit (1);
+
+      /* If there is anything on the line, print it and remember it. */
+      if (*temp)
+	{
+	  fprintf (stderr, "%s\r\n", temp);
+	  add_history (temp);
+	}
+
+      /* Check for `command' that we handle. */
+      if (strcmp (temp, "quit") == 0)
+	done = 1;
+
+      if (strcmp (temp, "list") == 0)
+	{
+	  HIST_ENTRY **list = history_list ();
+	  register int i;
+	  if (list)
+	    {
+	      for (i = 0; list[i]; i++)
+		{
+		  fprintf (stderr, "%d: %s\r\n", i, list[i]->line);
+		  free (list[i]->line);
+		}
+	      free (list);
+	    }
+	}
+      free (temp);
+    }
+}
+
+#endif /* TEST */
+
+
+/*
+ * Local variables:
+ * compile-command: "gcc -g -traditional -I. -I.. -DTEST -o readline readline.c keymaps.o funmap.o history.o -ltermcap"
+ * end:
+ */
diff --git a/gnu/usr.bin/gdb/readline/readline.h b/gnu/usr.bin/gdb/readline/readline.h
new file mode 100644
index 00000000000..8a50708c275
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/readline.h
@@ -0,0 +1,209 @@
+/* Readline.h -- the names of functions callable from within readline. */
+/* $Id: readline.h,v 1.1 1995/10/18 08:40:15 deraadt Exp $ */
+
+#if !defined (_READLINE_H_)
+#define _READLINE_H_
+
+#include "keymaps.h"
+
+#if !defined (__FUNCTION_DEF)
+typedef int Function ();
+#define __FUNCTION_DEF
+#endif /* __FUNCTION_DEF */
+
+/* The functions for manipulating the text of the line within readline.
+Most of these functions are bound to keys by default. */
+extern int
+  rl_beg_of_line (), rl_backward (), rl_delete (), rl_end_of_line (),
+  rl_forward (), ding (), rl_backward (), rl_newline (), rl_kill_line (),
+  rl_clear_screen (), rl_get_next_history (), rl_get_previous_history (),
+  rl_quoted_insert (), rl_reverse_search_history (), rl_transpose_chars (),
+  rl_unix_line_discard (), rl_quoted_insert (), rl_unix_word_rubout (),
+  rl_yank (), rl_rubout (), rl_backward_word (), rl_kill_word (),
+  rl_forward_word (), rl_tab_insert (), rl_yank_pop (), rl_yank_nth_arg (),
+  rl_backward_kill_word (), rl_backward_kill_line (), rl_transpose_words (),
+  rl_complete (), rl_possible_completions (), rl_do_lowercase_version (),
+  rl_digit_argument (), rl_universal_argument (), rl_abort (),
+  rl_undo_command (), rl_revert_line (), rl_beginning_of_history (),
+  rl_end_of_history (), rl_forward_search_history (), rl_insert (),
+  rl_upcase_word (), rl_downcase_word (), rl_capitalize_word (),
+  rl_restart_output (), rl_re_read_init_file (), rl_dump_functions ();
+
+/* These are *both* defined even when VI_MODE is not. */
+extern int rl_vi_editing_mode (), rl_emacs_editing_mode ();
+
+#if defined (VI_MODE)
+/* Things for vi mode. */
+extern int
+  rl_vi_movement_mode (), rl_vi_insertion_mode (), rl_vi_arg_digit (),
+  rl_vi_prev_word (), rl_vi_next_word (), rl_vi_char_search (),
+  rl_vi_eof_maybe (), rl_vi_append_mode (), rl_vi_put (),
+  rl_vi_append_eol (), rl_vi_insert_beg (), rl_vi_delete (), rl_vi_comment (),
+  rl_vi_first_print (), rl_vi_fword (), rl_vi_fWord (), rl_vi_bword (),
+  rl_vi_bWord (), rl_vi_eword (), rl_vi_eWord (), rl_vi_end_word (),
+  rl_vi_change_case (), rl_vi_match (), rl_vi_bracktype (),
+  rl_vi_change_char (), rl_vi_yank_arg (), rl_vi_search (),
+  rl_vi_search_again (), rl_vi_dosearch (), rl_vi_subst (),
+  rl_vi_overstrike (), rl_vi_overstrike_delete (), rl_vi_replace(),
+  rl_vi_column (), rl_vi_delete_to (), rl_vi_change_to (), rl_vi_yank_to (),
+  rl_vi_complete (), rl_vi_fetch_history ();
+#endif /* VI_MODE */
+
+/* Keyboard macro commands. */
+extern int
+rl_start_kbd_macro (), rl_end_kbd_macro (), rl_call_last_kbd_macro ();
+
+extern int rl_arrow_keys(), rl_refresh_line ();
+
+/* Maintaining the state of undo.  We remember individual deletes and inserts
+   on a chain of things to do. */
+
+/* The actions that undo knows how to undo.  Notice that UNDO_DELETE means
+   to insert some text, and UNDO_INSERT means to delete some text.   I.e.,
+   the code tells undo what to undo, not how to undo it. */
+enum undo_code { UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END };
+
+/* What an element of THE_UNDO_LIST looks like. */
+typedef struct undo_list {
+  struct undo_list *next;
+  int start, end;		/* Where the change took place. */
+  char *text;			/* The text to insert, if undoing a delete. */
+  enum undo_code what;		/* Delete, Insert, Begin, End. */
+} UNDO_LIST;
+
+/* The current undo list for RL_LINE_BUFFER. */
+extern UNDO_LIST *rl_undo_list;
+
+/* The data structure for mapping textual names to code addresses. */
+typedef struct {
+  char *name;
+  Function *function;
+} FUNMAP;
+
+extern FUNMAP **funmap;
+
+/* **************************************************************** */
+/*								    */
+/*			Well Published Variables		    */
+/*								    */
+/* **************************************************************** */
+
+/* The name of the calling program.  You should initialize this to
+   whatever was in argv[0].  It is used when parsing conditionals. */
+extern char *rl_readline_name;
+
+/* The line buffer that is in use. */
+extern char *rl_line_buffer;
+
+/* The location of point, and end. */
+extern int rl_point, rl_end;
+
+/* The name of the terminal to use. */
+extern char *rl_terminal_name;
+
+/* The input and output streams. */
+extern FILE *rl_instream, *rl_outstream;
+
+/* The basic list of characters that signal a break between words for the
+   completer routine.  The initial contents of this variable is what
+   breaks words in the shell, i.e. "n\"\\'`@$>". */
+extern char *rl_basic_word_break_characters;
+
+/* The list of characters that signal a break between words for
+   rl_complete_internal.  The default list is the contents of
+   rl_basic_word_break_characters.  */
+extern char *rl_completer_word_break_characters;
+
+/* List of characters which are used to quote a substring of the command
+   line, upon which completion is to be performed for the entire substring.
+   Within quoted substrings, rl_completer_word_break_characters are treated
+   as normal characters, unless they also appear in this list. */
+extern char *rl_completer_quote_characters;
+
+/* List of characters that are word break characters, but should be left
+   in TEXT when it is passed to the completion function.  The shell uses
+   this to help determine what kind of completing to do. */
+extern char *rl_special_prefixes;
+
+/* Pointer to the generator function for completion_matches ().
+   NULL means to use filename_entry_function (), the default filename
+   completer. */
+extern Function *rl_completion_entry_function;
+
+/* If rl_ignore_some_completions_function is non-NULL it is the address
+   of a function to call after all of the possible matches have been
+   generated, but before the actual completion is done to the input line.
+   The function is called with one argument; a NULL terminated array
+   of (char *).  If your function removes any of the elements, they
+   must be free()'ed. */
+extern Function *rl_ignore_some_completions_function;
+
+/* Pointer to alternative function to create matches.
+   Function is called with TEXT, START, and END.
+   START and END are indices in RL_LINE_BUFFER saying what the boundaries
+   of TEXT are.
+   If this function exists and returns NULL then call the value of
+   rl_completion_entry_function to try to match, otherwise use the
+   array of strings returned. */
+extern Function *rl_attempted_completion_function;
+
+/* If non-zero, then this is the address of a function to call just
+   before readline_internal () prints the first prompt. */
+extern Function *rl_startup_hook;
+
+/* If non-zero, then this is the address of a function to call when
+   completing on a directory name.  The function is called with
+   the address of a string (the current directory name) as an arg. */
+extern Function *rl_symbolic_link_hook;
+
+/* If non-zero then this is the address of a function you want called
+   while Readline is waiting for character input.     */
+extern Function *rl_event_hook;
+
+/* Non-zero means that modified history lines are preceded
+   with an asterisk. */
+extern int rl_show_star;
+
+
+/* **************************************************************** */
+/*                                                                  */
+/*             Tilde Variables That Can be Externally Set           */
+/*                                                                  */
+/* **************************************************************** */
+
+/* If non-null, this contains the address of a function to call if the
+   standard meaning for expanding a tilde fails.  The function is called
+   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
+   which is the expansion, or a NULL pointer if there is no expansion. */
+extern Function *tilde_expansion_failure_hook;
+
+/* When non-null, this is a NULL terminated array of strings which
+   are duplicates for a tilde prefix.  Bash uses this to expand
+   `=~' and `:~'. */
+extern char **tilde_additional_prefixes;
+
+/* When non-null, this is a NULL terminated array of strings which match
+   the end of a username, instead of just "/".  Bash sets this to
+   `/' and `:'. */
+extern char **tilde_additional_suffixes;
+
+/* **************************************************************** */
+/*								    */
+/*			Well Published Functions		    */
+/*								    */
+/* **************************************************************** */
+
+/* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means none. */
+extern char *readline ();
+
+/* Return an array of strings which are the result of repeatadly calling
+   FUNC with TEXT. */
+extern char **completion_matches ();
+
+/* rl_add_defun (char *name, Function *function, int key)
+   Add NAME to the list of named functions.  Make FUNCTION
+   be the function that gets called.
+   If KEY is not -1, then bind it. */
+extern int rl_add_defun ();
+
+#endif /* _READLINE_H_ */
diff --git a/gnu/usr.bin/gdb/readline/sysdep.h b/gnu/usr.bin/gdb/readline/sysdep.h
new file mode 100644
index 00000000000..11d5416064e
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/sysdep.h
@@ -0,0 +1,38 @@
+/* System-dependent stuff, for ``normal'' systems */
+/* If you think you need to change this file, then you are wrong.  In order to
+   avoid a huge ugly mass of nested #ifdefs, you should create a new file just
+   for your system, which contains exactly those #includes and definitions that
+   your system needs, AND NOTHING MORE!  Then, add that file to the appropriate
+   place in configure.in, and viola, you are done.  sysdep-sunos4.h is a good
+   example of how to do this. */
+
+/* $Id: sysdep.h,v 1.1 1995/10/18 08:40:15 deraadt Exp $ */
+
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else
+#if defined (sparc) && defined (sun)
+#include <alloca.h>
+#endif
+#ifndef alloca				/* May be a macro, with args. */
+extern char *alloca ();
+#endif
+#endif
+
+#include <sys/types.h>			/* Needed by dirent.h */
+
+#if defined (USG) && defined (TIOCGWINSZ)
+#include <sys/stream.h>
+#if defined (USGr4) || defined (USGr3)
+#include <sys/ptem.h>
+#endif /* USGr4 */
+#endif /* USG && TIOCGWINSZ */
+
+#include <dirent.h>
+typedef struct dirent dirent;
+
+/* SVR4 systems should use <termios.h> rather than <termio.h>. */
+
+#if defined (USGr4)
+#define _POSIX_VERSION
+#endif
diff --git a/gnu/usr.bin/gdb/readline/tilde.c b/gnu/usr.bin/gdb/readline/tilde.c
new file mode 100644
index 00000000000..95b1ba162f5
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/tilde.c
@@ -0,0 +1,373 @@
+/* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */
+
+/* Copyright (C) 1988,1989, 1991 Free Software Foundation, Inc.
+
+   This file is part of GNU Readline, a library for reading lines
+   of text with interactive input and history editing.
+
+   Readline is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: tilde.c,v 1.1 1995/10/18 08:40:16 deraadt Exp $
+*/
+
+#include "sysdep.h"
+
+#ifndef __MSDOS__
+#include <pwd.h>
+#endif
+
+#ifdef __GNUC__
+#undef alloca
+#define alloca(x) __builtin_alloca(x)
+#endif
+
+#ifndef savestring
+#define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
+#endif
+
+typedef int Function ();
+#if !defined (NULL)
+#  define NULL 0x0
+#endif
+
+#if defined (TEST)
+static char *xmalloc (), *xrealloc ();
+#else
+extern char *xmalloc (), *xrealloc ();
+#endif /* TEST */
+
+/* The default value of tilde_additional_prefixes.  This is set to
+   whitespace preceding a tilde so that simple programs which do not
+   perform any word separation get desired behaviour. */
+static char *default_prefixes[] =
+  { " ~", "\t~", (char *)NULL };
+
+/* The default value of tilde_additional_suffixes.  This is set to
+   whitespace or newline so that simple programs which do not
+   perform any word separation get desired behaviour. */
+static char *default_suffixes[] =
+  { " ", "\n", (char *)NULL };
+
+/* If non-null, this contains the address of a function to call if the
+   standard meaning for expanding a tilde fails.  The function is called
+   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
+   which is the expansion, or a NULL pointer if there is no expansion. */
+Function *tilde_expansion_failure_hook = (Function *)NULL;
+
+/* When non-null, this is a NULL terminated array of strings which
+   are duplicates for a tilde prefix.  Bash uses this to expand
+   `=~' and `:~'. */
+char **tilde_additional_prefixes = default_prefixes;
+
+/* When non-null, this is a NULL terminated array of strings which match
+   the end of a username, instead of just "/".  Bash sets this to
+   `:' and `=~'. */
+char **tilde_additional_suffixes = default_suffixes;
+
+/* Find the start of a tilde expansion in STRING, and return the index of
+   the tilde which starts the expansion.  Place the length of the text
+   which identified this tilde starter in LEN, excluding the tilde itself. */
+static int
+tilde_find_prefix (string, len)
+     char *string;
+     int *len;
+{
+  register int i, j, string_len;
+  register char **prefixes = tilde_additional_prefixes;
+
+  string_len = strlen (string);
+  *len = 0;
+
+  if (!*string || *string == '~')
+    return (0);
+
+  if (prefixes)
+    {
+      for (i = 0; i < string_len; i++)
+	{
+	  for (j = 0; prefixes[j]; j++)
+	    {
+	      if (strncmp (string + i, prefixes[j], strlen (prefixes[j])) == 0)
+		{
+		  *len = strlen (prefixes[j]) - 1;
+		  return (i + *len);
+		}
+	    }
+	}
+    }
+  return (string_len);
+}
+
+/* Find the end of a tilde expansion in STRING, and return the index of
+   the character which ends the tilde definition.  */
+static int
+tilde_find_suffix (string)
+     char *string;
+{
+  register int i, j, string_len;
+  register char **suffixes = tilde_additional_suffixes;
+
+  string_len = strlen (string);
+
+  for (i = 0; i < string_len; i++)
+    {
+      if (string[i] == '/' || !string[i])
+	break;
+
+      for (j = 0; suffixes && suffixes[j]; j++)
+	{
+	  if (strncmp (string + i, suffixes[j], strlen (suffixes[j])) == 0)
+	    return (i);
+	}
+    }
+  return (i);
+}
+
+/* Return a new string which is the result of tilde expanding FILENAME. */
+char *
+tilde_expand (filename)
+     char *filename;
+{
+  char *result, *tilde_expand_word ();
+  int result_size, result_index;
+
+  result_size = result_index = 0;
+  result = (char *)NULL;
+
+  /* Scan through FILENAME expanding tildes as we come to them. */
+  while (1)
+    {
+      register int start, end;
+      char *tilde_word, *expansion;
+      int len;
+
+      /* Make START point to the tilde which starts the expansion. */
+      start = tilde_find_prefix (filename, &len);
+
+      /* Copy the skipped text into the result. */
+      /* This test is always true the first time, since result_index
+	 is 0, result_size is 0, and start is >= 0.  So we malloc here.  */
+      if ((result_index + start + 1) > result_size) {
+	result_size += (start + 20);
+	if (result == NULL)
+	  result = (char *)xmalloc  (        1 + result_size);
+	else
+	  result = (char *)xrealloc (result, 1 + result_size);
+      }
+
+      strncpy (result + result_index, filename, start);
+      result_index += start;
+
+      /* Advance FILENAME upto the starting tilde. */
+      filename += start;
+
+      /* Make END be the index of one after the last character of the
+	 username. */
+      end = tilde_find_suffix (filename);
+
+      /* If both START and END are zero, we are all done. */
+      if (!start && !end)
+	break;
+
+      /* Expand the entire tilde word, and copy it into RESULT. */
+      tilde_word = (char *)xmalloc (1 + end);
+      strncpy (tilde_word, filename, end);
+      tilde_word[end] = '\0';
+      filename += end;
+
+      expansion = tilde_expand_word (tilde_word);
+      free (tilde_word);
+
+      len = strlen (expansion);
+      if ((result_index + len + 1) > result_size)
+	result = (char *)xrealloc (result, 1 + (result_size += (len + 20)));
+
+      strcpy (result + result_index, expansion);
+      result_index += len;
+      free (expansion);
+    }
+
+  result[result_index] = '\0';
+
+  return (result);
+}
+
+/* Do the work of tilde expansion on FILENAME.  FILENAME starts with a
+   tilde.  If there is no expansion, call tilde_expansion_failure_hook. */
+char *
+tilde_expand_word (filename)
+     char *filename;
+{
+  char *dirname = filename ? savestring (filename) : (char *)NULL;
+
+  if (dirname && *dirname == '~')
+    {
+      char *temp_name;
+      if (!dirname[1] || dirname[1] == '/')
+	{
+	  /* Prepend $HOME to the rest of the string. */
+	  char *temp_home = (char *)getenv ("HOME");
+
+	  temp_name = (char *)alloca (1 + strlen (&dirname[1])
+				      + (temp_home? strlen (temp_home) : 0));
+	  temp_name[0] = '\0';
+	  if (temp_home)
+	    strcpy (temp_name, temp_home);
+	  strcat (temp_name, &dirname[1]);
+	  free (dirname);
+	  dirname = savestring (temp_name);
+	}
+      else
+	{
+#ifndef __MSDOS__
+	  struct passwd *getpwnam (), *user_entry;
+#endif
+	  char *username = (char *)alloca (257);
+	  int i, c;
+
+	  for (i = 1; c = dirname[i]; i++)
+	    {
+	      if (c == '/')
+		break;
+	      else
+		username[i - 1] = c;
+	    }
+	  username[i - 1] = '\0';
+
+#ifndef __MSDOS__
+	  if (!(user_entry = getpwnam (username)))
+	    {
+	      /* If the calling program has a special syntax for
+		 expanding tildes, and we couldn't find a standard
+		 expansion, then let them try. */
+#endif
+	      if (tilde_expansion_failure_hook)
+		{
+		  char *expansion;
+
+		  expansion =
+		    (char *)(*tilde_expansion_failure_hook) (username);
+
+		  if (expansion)
+		    {
+		      temp_name = (char *)alloca (1 + strlen (expansion)
+						  + strlen (&dirname[i]));
+		      strcpy (temp_name, expansion);
+		      strcat (temp_name, &dirname[i]);
+		      free (expansion);
+		      goto return_name;
+		    }
+		}
+	      /* We shouldn't report errors. */
+#ifndef __MSDOS__
+	    }
+	  else
+	    {
+	      temp_name = (char *)alloca (1 + strlen (user_entry->pw_dir)
+					  + strlen (&dirname[i]));
+	      strcpy (temp_name, user_entry->pw_dir);
+	      strcat (temp_name, &dirname[i]);
+#endif
+	    return_name:
+	      free (dirname);
+	      dirname = savestring (temp_name);
+#ifndef __MSDOS__
+	    }
+	    endpwent ();
+#endif
+	}
+    }
+  return (dirname);
+}
+
+#if defined (TEST)
+#undef NULL
+#include <stdio.h>
+
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  char *result, line[512];
+  int done = 0;
+
+  while (!done)
+    {
+      printf ("~expand: ");
+      fflush (stdout);
+
+      if (!gets (line))
+	strcpy (line, "done");
+
+      if ((strcmp (line, "done") == 0) ||
+	  (strcmp (line, "quit") == 0) ||
+	  (strcmp (line, "exit") == 0))
+	{
+	  done = 1;
+	  break;
+	}
+
+      result = tilde_expand (line);
+      printf ("  --> %s\n", result);
+      free (result);
+    }
+  exit (0);
+}
+
+static void memory_error_and_abort ();
+
+static char *
+xmalloc (bytes)
+     int bytes;
+{
+  char *temp = (char *)malloc (bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+  return (temp);
+}
+
+static char *
+xrealloc (pointer, bytes)
+     char *pointer;
+     int bytes;
+{
+  char *temp;
+
+  if (!pointer)
+    temp = (char *)malloc (bytes);
+  else
+    temp = (char *)realloc (pointer, bytes);
+
+  if (!temp)
+    memory_error_and_abort ();
+
+  return (temp);
+}
+
+static void
+memory_error_and_abort ()
+{
+  fprintf (stderr, "readline: Out of virtual memory!\n");
+  abort ();
+}
+
+/*
+ * Local variables:
+ * compile-command: "gcc -g -DTEST -o tilde tilde.c"
+ * end:
+ */
+#endif /* TEST */
+
diff --git a/gnu/usr.bin/gdb/readline/vi_keymap.c b/gnu/usr.bin/gdb/readline/vi_keymap.c
new file mode 100644
index 00000000000..b9126920f0f
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/vi_keymap.c
@@ -0,0 +1,471 @@
+/* vi_keymap.c -- the keymap for vi_mode in readline (). */
+
+/* Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+
+   This file is part of GNU Readline, a library for reading lines
+   of text with interactive input and history editing.
+
+   Readline is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: vi_keymap.c,v 1.1 1995/10/18 08:40:16 deraadt Exp $
+*/
+
+extern KEYMAP_ENTRY_ARRAY vi_escape_keymap;
+
+/* The keymap arrays for handling vi mode. */
+KEYMAP_ENTRY_ARRAY vi_movement_keymap = {
+
+  /* The regular control keys come first. */
+  { ISFUNC, (Function *)0x0 },		/* Control-@ */
+  { ISFUNC, (Function *)0x0 },		/* Control-a */
+  { ISFUNC, (Function *)0x0 },		/* Control-b */
+  { ISFUNC, (Function *)0x0 },		/* Control-c */
+  { ISFUNC, rl_vi_eof_maybe },		/* Control-d */
+  { ISFUNC, rl_emacs_editing_mode },	/* Control-e */
+  { ISFUNC, (Function *)0x0 },		/* Control-f */
+  { ISFUNC, rl_abort },			/* Control-g */
+  { ISFUNC, rl_rubout },		/* Control-h */
+  { ISFUNC, (Function *)0x0 },		/* Control-i */
+  { ISFUNC, rl_newline },		/* Control-j */
+  { ISFUNC, rl_kill_line },		/* Control-k */
+  { ISFUNC, rl_clear_screen },		/* Control-l */
+  { ISFUNC, rl_newline },		/* Control-m */
+  { ISFUNC, rl_get_next_history },	/* Control-n */
+  { ISFUNC, (Function *)0x0 },		/* Control-o */
+  { ISFUNC, rl_get_previous_history },	/* Control-p */
+  { ISFUNC, rl_quoted_insert },		/* Control-q */
+  { ISFUNC, rl_reverse_search_history }, /* Control-r */
+  { ISFUNC, rl_forward_search_history }, /* Control-s */
+  { ISFUNC, rl_transpose_chars },	/* Control-t */
+  { ISFUNC, rl_unix_line_discard },	/* Control-u */
+  { ISFUNC, rl_quoted_insert },		/* Control-v */
+  { ISFUNC, rl_unix_word_rubout },	/* Control-w */
+  { ISFUNC, (Function *)0x0 },		/* Control-x */
+  { ISFUNC, rl_yank },			/* Control-y */
+  { ISFUNC, (Function *)0x0 },		/* Control-z */
+
+  { ISKMAP, (Function *)vi_escape_keymap }, /* Control-[ */
+  { ISFUNC, (Function *)0x0 },		/* Control-\ */
+  { ISFUNC, (Function *)0x0 },		/* Control-] */
+  { ISFUNC, (Function *)0x0 },		/* Control-^ */
+  { ISFUNC, rl_undo_command },		/* Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, rl_forward },		/* SPACE */
+  { ISFUNC, (Function *)0x0 },		/* ! */
+  { ISFUNC, (Function *)0x0 },		/* " */
+  { ISFUNC, rl_vi_comment },		/* # */
+  { ISFUNC, rl_end_of_line },		/* $ */
+  { ISFUNC, rl_vi_match },		/* % */
+  { ISFUNC, (Function *)0x0 },		/* & */
+  { ISFUNC, (Function *)0x0 },		/* ' */
+  { ISFUNC, (Function *)0x0 },		/* ( */
+  { ISFUNC, (Function *)0x0 },		/* ) */
+  { ISFUNC, rl_vi_complete },		/* * */
+  { ISFUNC, rl_get_next_history},	/* + */
+  { ISFUNC, rl_vi_char_search },	/* , */
+  { ISFUNC, rl_get_previous_history },	/* - */
+  { ISFUNC, (Function *)0x0 },		/* . */
+  { ISFUNC, rl_vi_search },		/* / */
+
+  /* Regular digits. */
+  { ISFUNC, rl_vi_arg_digit },		/* 0 */
+  { ISFUNC, rl_vi_arg_digit },		/* 1 */
+  { ISFUNC, rl_vi_arg_digit },		/* 2 */
+  { ISFUNC, rl_vi_arg_digit },		/* 3 */
+  { ISFUNC, rl_vi_arg_digit },		/* 4 */
+  { ISFUNC, rl_vi_arg_digit },		/* 5 */
+  { ISFUNC, rl_vi_arg_digit },		/* 6 */
+  { ISFUNC, rl_vi_arg_digit },		/* 7 */
+  { ISFUNC, rl_vi_arg_digit },		/* 8 */
+  { ISFUNC, rl_vi_arg_digit },		/* 9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* : */
+  { ISFUNC, rl_vi_char_search },	/* ; */
+  { ISFUNC, (Function *)0x0 },		/* < */
+  { ISFUNC, rl_vi_complete },		/* = */
+  { ISFUNC, (Function *)0x0 },		/* > */
+  { ISFUNC, rl_vi_search },		/* ? */
+  { ISFUNC, (Function *)0x0 },		/* @ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_vi_append_eol },		/* A */
+  { ISFUNC, rl_vi_prev_word},		/* B */
+  { ISFUNC, rl_vi_change_to },		/* C */
+  { ISFUNC, rl_vi_delete_to },		/* D */
+  { ISFUNC, rl_vi_end_word },		/* E */
+  { ISFUNC, rl_vi_char_search },	/* F */
+  { ISFUNC, rl_vi_fetch_history },	/* G */
+  { ISFUNC, (Function *)0x0 },		/* H */
+  { ISFUNC, rl_vi_insert_beg },		/* I */
+  { ISFUNC, (Function *)0x0 },		/* J */
+  { ISFUNC, (Function *)0x0 },		/* K */
+  { ISFUNC, (Function *)0x0 },		/* L */
+  { ISFUNC, (Function *)0x0 },		/* M */
+  { ISFUNC, rl_vi_search_again },	/* N */
+  { ISFUNC, (Function *)0x0 },		/* O */
+  { ISFUNC, rl_vi_put },		/* P */
+  { ISFUNC, (Function *)0x0 },		/* Q */
+  { ISFUNC, rl_vi_replace },		/* R */
+  { ISFUNC, rl_vi_subst },		/* S */
+  { ISFUNC, rl_vi_char_search },	/* T */
+  { ISFUNC, rl_revert_line },		/* U */
+  { ISFUNC, (Function *)0x0 },		/* V */
+  { ISFUNC, rl_vi_next_word },		/* W */
+  { ISFUNC, rl_rubout },		/* X */
+  { ISFUNC, rl_vi_yank_to },		/* Y */
+  { ISFUNC, (Function *)0x0 },		/* Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* [ */
+  { ISFUNC, rl_vi_complete },		/* \ */
+  { ISFUNC, (Function *)0x0 },		/* ] */
+  { ISFUNC, rl_vi_first_print },	/* ^ */
+  { ISFUNC, rl_vi_yank_arg },		/* _ */
+  { ISFUNC, (Function *)0x0 },		/* ` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, rl_vi_append_mode },	/* a */
+  { ISFUNC, rl_vi_prev_word },		/* b */
+  { ISFUNC, rl_vi_change_to },		/* c */
+  { ISFUNC, rl_vi_delete_to },		/* d */
+  { ISFUNC, rl_vi_end_word },		/* e */
+  { ISFUNC, rl_vi_char_search },	/* f */
+  { ISFUNC, (Function *)0x0 },		/* g */
+  { ISFUNC, rl_backward },		/* h */
+  { ISFUNC, rl_vi_insertion_mode },	/* i */
+  { ISFUNC, rl_get_next_history },	/* j */
+  { ISFUNC, rl_get_previous_history },	/* k */
+  { ISFUNC, rl_forward },		/* l */
+  { ISFUNC, (Function *)0x0 },		/* m */
+  { ISFUNC, rl_vi_search_again },	/* n */
+  { ISFUNC, (Function *)0x0 },		/* o */
+  { ISFUNC, rl_vi_put },		/* p */
+  { ISFUNC, (Function *)0x0 },		/* q */
+  { ISFUNC, rl_vi_change_char },	/* r */
+  { ISFUNC, rl_vi_subst },		/* s */
+  { ISFUNC, rl_vi_char_search },	/* t */
+  { ISFUNC, rl_undo_command },		/* u */
+  { ISFUNC, (Function *)0x0 },		/* v */
+  { ISFUNC, rl_vi_next_word },		/* w */
+  { ISFUNC, rl_vi_delete },		/* x */
+  { ISFUNC, rl_vi_yank_to },		/* y */
+  { ISFUNC, (Function *)0x0 },		/* z */
+
+  /* Final punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* { */
+  { ISFUNC, rl_vi_column },		/* | */
+  { ISFUNC, (Function *)0x0 },		/* } */
+  { ISFUNC, rl_vi_change_case },	/* ~ */
+  { ISFUNC, rl_backward }		/* RUBOUT */
+};
+
+
+KEYMAP_ENTRY_ARRAY vi_insertion_keymap = {
+
+  /* The regular control keys come first. */
+  { ISFUNC, (Function *)0x0 },		/* Control-@ */
+  { ISFUNC, rl_insert },		/* Control-a */
+  { ISFUNC, rl_insert },		/* Control-b */
+  { ISFUNC, rl_insert },		/* Control-c */
+  { ISFUNC, rl_vi_eof_maybe },		/* Control-d */
+  { ISFUNC, rl_insert },		/* Control-e */
+  { ISFUNC, rl_insert },		/* Control-f */
+  { ISFUNC, rl_insert },		/* Control-g */
+  { ISFUNC, rl_rubout },		/* Control-h */
+  { ISFUNC, rl_complete },		/* Control-i */
+  { ISFUNC, rl_newline },		/* Control-j */
+  { ISFUNC, rl_insert },		/* Control-k */
+  { ISFUNC, rl_insert },		/* Control-l */
+  { ISFUNC, rl_newline },		/* Control-m */
+  { ISFUNC, rl_insert },		/* Control-n */
+  { ISFUNC, rl_insert },		/* Control-o */
+  { ISFUNC, rl_insert },		/* Control-p */
+  { ISFUNC, rl_insert },		/* Control-q */
+  { ISFUNC, rl_reverse_search_history }, /* Control-r */
+  { ISFUNC, rl_forward_search_history }, /* Control-s */
+  { ISFUNC, rl_transpose_chars },	/* Control-t */
+  { ISFUNC, rl_unix_line_discard },	/* Control-u */
+  { ISFUNC, rl_quoted_insert },		/* Control-v */
+  { ISFUNC, rl_unix_word_rubout },	/* Control-w */
+  { ISFUNC, rl_insert },		/* Control-x */
+  { ISFUNC, rl_yank },			/* Control-y */
+  { ISFUNC, rl_insert },		/* Control-z */
+
+  { ISFUNC, rl_vi_movement_mode },	/* Control-[ */
+  { ISFUNC, rl_insert },		/* Control-\ */
+  { ISFUNC, rl_insert },		/* Control-] */
+  { ISFUNC, rl_insert },		/* Control-^ */
+  { ISFUNC, rl_undo_command },		/* Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, rl_insert },		/* SPACE */
+  { ISFUNC, rl_insert },		/* ! */
+  { ISFUNC, rl_insert },		/* " */
+  { ISFUNC, rl_insert },		/* # */
+  { ISFUNC, rl_insert },		/* $ */
+  { ISFUNC, rl_insert },		/* % */
+  { ISFUNC, rl_insert },		/* & */
+  { ISFUNC, rl_insert },		/* ' */
+  { ISFUNC, rl_insert },		/* ( */
+  { ISFUNC, rl_insert },		/* ) */
+  { ISFUNC, rl_insert },		/* * */
+  { ISFUNC, rl_insert },		/* + */
+  { ISFUNC, rl_insert },		/* , */
+  { ISFUNC, rl_insert },		/* - */
+  { ISFUNC, rl_insert },		/* . */
+  { ISFUNC, rl_insert },		/* / */
+
+  /* Regular digits. */
+  { ISFUNC, rl_insert },		/* 0 */
+  { ISFUNC, rl_insert },		/* 1 */
+  { ISFUNC, rl_insert },		/* 2 */
+  { ISFUNC, rl_insert },		/* 3 */
+  { ISFUNC, rl_insert },		/* 4 */
+  { ISFUNC, rl_insert },		/* 5 */
+  { ISFUNC, rl_insert },		/* 6 */
+  { ISFUNC, rl_insert },		/* 7 */
+  { ISFUNC, rl_insert },		/* 8 */
+  { ISFUNC, rl_insert },		/* 9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, rl_insert },		/* : */
+  { ISFUNC, rl_insert },		/* ; */
+  { ISFUNC, rl_insert },		/* < */
+  { ISFUNC, rl_insert },		/* = */
+  { ISFUNC, rl_insert },		/* > */
+  { ISFUNC, rl_insert },		/* ? */
+  { ISFUNC, rl_insert },		/* @ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_insert },		/* A */
+  { ISFUNC, rl_insert },		/* B */
+  { ISFUNC, rl_insert },		/* C */
+  { ISFUNC, rl_insert },		/* D */
+  { ISFUNC, rl_insert },		/* E */
+  { ISFUNC, rl_insert },		/* F */
+  { ISFUNC, rl_insert },		/* G */
+  { ISFUNC, rl_insert },		/* H */
+  { ISFUNC, rl_insert },		/* I */
+  { ISFUNC, rl_insert },		/* J */
+  { ISFUNC, rl_insert },		/* K */
+  { ISFUNC, rl_insert },		/* L */
+  { ISFUNC, rl_insert },		/* M */
+  { ISFUNC, rl_insert },		/* N */
+  { ISFUNC, rl_insert },		/* O */
+  { ISFUNC, rl_insert },		/* P */
+  { ISFUNC, rl_insert },		/* Q */
+  { ISFUNC, rl_insert },		/* R */
+  { ISFUNC, rl_insert },		/* S */
+  { ISFUNC, rl_insert },		/* T */
+  { ISFUNC, rl_insert },		/* U */
+  { ISFUNC, rl_insert },		/* V */
+  { ISFUNC, rl_insert },		/* W */
+  { ISFUNC, rl_insert },		/* X */
+  { ISFUNC, rl_insert },		/* Y */
+  { ISFUNC, rl_insert },		/* Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, rl_insert },		/* [ */
+  { ISFUNC, rl_insert },		/* \ */
+  { ISFUNC, rl_insert },		/* ] */
+  { ISFUNC, rl_insert },		/* ^ */
+  { ISFUNC, rl_insert },		/* _ */
+  { ISFUNC, rl_insert },		/* ` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, rl_insert },		/* a */
+  { ISFUNC, rl_insert },		/* b */
+  { ISFUNC, rl_insert },		/* c */
+  { ISFUNC, rl_insert },		/* d */
+  { ISFUNC, rl_insert },		/* e */
+  { ISFUNC, rl_insert },		/* f */
+  { ISFUNC, rl_insert },		/* g */
+  { ISFUNC, rl_insert },		/* h */
+  { ISFUNC, rl_insert },		/* i */
+  { ISFUNC, rl_insert },		/* j */
+  { ISFUNC, rl_insert },		/* k */
+  { ISFUNC, rl_insert },		/* l */
+  { ISFUNC, rl_insert },		/* m */
+  { ISFUNC, rl_insert },		/* n */
+  { ISFUNC, rl_insert },		/* o */
+  { ISFUNC, rl_insert },		/* p */
+  { ISFUNC, rl_insert },		/* q */
+  { ISFUNC, rl_insert },		/* r */
+  { ISFUNC, rl_insert },		/* s */
+  { ISFUNC, rl_insert },		/* t */
+  { ISFUNC, rl_insert },		/* u */
+  { ISFUNC, rl_insert },		/* v */
+  { ISFUNC, rl_insert },		/* w */
+  { ISFUNC, rl_insert },		/* x */
+  { ISFUNC, rl_insert },		/* y */
+  { ISFUNC, rl_insert },		/* z */
+
+  /* Final punctuation. */
+  { ISFUNC, rl_insert },		/* { */
+  { ISFUNC, rl_insert },		/* | */
+  { ISFUNC, rl_insert },		/* } */
+  { ISFUNC, rl_insert },		/* ~ */
+  { ISFUNC, rl_rubout }			/* RUBOUT */
+};
+
+KEYMAP_ENTRY_ARRAY vi_escape_keymap = {
+
+  /* The regular control keys come first. */
+  { ISFUNC, (Function *)0x0 },		/* Control-@ */
+  { ISFUNC, (Function *)0x0 },		/* Control-a */
+  { ISFUNC, (Function *)0x0 },		/* Control-b */
+  { ISFUNC, (Function *)0x0 },		/* Control-c */
+  { ISFUNC, (Function *)0x0 },		/* Control-d */
+  { ISFUNC, (Function *)0x0 },		/* Control-e */
+  { ISFUNC, (Function *)0x0 },		/* Control-f */
+  { ISFUNC, (Function *)0x0 },		/* Control-g */
+  { ISFUNC, (Function *)0x0 },		/* Control-h */
+  { ISFUNC, rl_tab_insert},		/* Control-i */
+  { ISFUNC, rl_emacs_editing_mode},	/* Control-j */
+  { ISFUNC, rl_kill_line },		/* Control-k */
+  { ISFUNC, (Function *)0x0 },		/* Control-l */
+  { ISFUNC, rl_emacs_editing_mode},	/* Control-m */
+  { ISFUNC, (Function *)0x0 },		/* Control-n */
+  { ISFUNC, (Function *)0x0 },		/* Control-o */
+  { ISFUNC, (Function *)0x0 },		/* Control-p */
+  { ISFUNC, (Function *)0x0 },		/* Control-q */
+  { ISFUNC, (Function *)0x0 },		/* Control-r */
+  { ISFUNC, (Function *)0x0 },		/* Control-s */
+  { ISFUNC, (Function *)0x0 },		/* Control-t */
+  { ISFUNC, (Function *)0x0 },		/* Control-u */
+  { ISFUNC, (Function *)0x0 },		/* Control-v */
+  { ISFUNC, (Function *)0x0 },		/* Control-w */
+  { ISFUNC, (Function *)0x0 },		/* Control-x */
+  { ISFUNC, (Function *)0x0 },		/* Control-y */
+  { ISFUNC, (Function *)0x0 },		/* Control-z */
+
+  { ISFUNC, rl_vi_movement_mode },	/* Control-[ */
+  { ISFUNC, (Function *)0x0 },		/* Control-\ */
+  { ISFUNC, (Function *)0x0 },		/* Control-] */
+  { ISFUNC, (Function *)0x0 },		/* Control-^ */
+  { ISFUNC, rl_undo_command },		/* Control-_ */
+
+  /* The start of printing characters. */
+  { ISFUNC, (Function *)0x0 },		/* SPACE */
+  { ISFUNC, (Function *)0x0 },		/* ! */
+  { ISFUNC, (Function *)0x0 },		/* " */
+  { ISFUNC, (Function *)0x0 },		/* # */
+  { ISFUNC, (Function *)0x0 },		/* $ */
+  { ISFUNC, (Function *)0x0 },		/* % */
+  { ISFUNC, (Function *)0x0 },		/* & */
+  { ISFUNC, (Function *)0x0 },		/* ' */
+  { ISFUNC, (Function *)0x0 },		/* ( */
+  { ISFUNC, (Function *)0x0 },		/* ) */
+  { ISFUNC, (Function *)0x0 },		/* * */
+  { ISFUNC, (Function *)0x0 },		/* + */
+  { ISFUNC, (Function *)0x0 },		/* , */
+  { ISFUNC, (Function *)0x0 },		/* - */
+  { ISFUNC, (Function *)0x0 },		/* . */
+  { ISFUNC, (Function *)0x0 },		/* / */
+
+  /* Regular digits. */
+  { ISFUNC, rl_vi_arg_digit },		/* 0 */
+  { ISFUNC, rl_vi_arg_digit },		/* 1 */
+  { ISFUNC, rl_vi_arg_digit },		/* 2 */
+  { ISFUNC, rl_vi_arg_digit },		/* 3 */
+  { ISFUNC, rl_vi_arg_digit },		/* 4 */
+  { ISFUNC, rl_vi_arg_digit },		/* 5 */
+  { ISFUNC, rl_vi_arg_digit },		/* 6 */
+  { ISFUNC, rl_vi_arg_digit },		/* 7 */
+  { ISFUNC, rl_vi_arg_digit },		/* 8 */
+  { ISFUNC, rl_vi_arg_digit },		/* 9 */
+
+  /* A little more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* : */
+  { ISFUNC, (Function *)0x0 },		/* ; */
+  { ISFUNC, (Function *)0x0 },		/* < */
+  { ISFUNC, (Function *)0x0 },		/* = */
+  { ISFUNC, (Function *)0x0 },		/* > */
+  { ISFUNC, (Function *)0x0 },		/* ? */
+  { ISFUNC, (Function *)0x0 },		/* @ */
+
+  /* Uppercase alphabet. */
+  { ISFUNC, rl_do_lowercase_version },	/* A */
+  { ISFUNC, rl_do_lowercase_version },	/* B */
+  { ISFUNC, rl_do_lowercase_version },	/* C */
+  { ISFUNC, rl_do_lowercase_version },	/* D */
+  { ISFUNC, rl_do_lowercase_version },	/* E */
+  { ISFUNC, rl_do_lowercase_version },	/* F */
+  { ISFUNC, rl_do_lowercase_version },	/* G */
+  { ISFUNC, rl_do_lowercase_version },	/* H */
+  { ISFUNC, rl_do_lowercase_version },	/* I */
+  { ISFUNC, rl_do_lowercase_version },	/* J */
+  { ISFUNC, rl_do_lowercase_version },	/* K */
+  { ISFUNC, rl_do_lowercase_version },	/* L */
+  { ISFUNC, rl_do_lowercase_version },	/* M */
+  { ISFUNC, rl_do_lowercase_version },	/* N */
+  { ISFUNC, rl_do_lowercase_version },	/* O */
+  { ISFUNC, rl_do_lowercase_version },	/* P */
+  { ISFUNC, rl_do_lowercase_version },	/* Q */
+  { ISFUNC, rl_do_lowercase_version },	/* R */
+  { ISFUNC, rl_do_lowercase_version },	/* S */
+  { ISFUNC, rl_do_lowercase_version },	/* T */
+  { ISFUNC, rl_do_lowercase_version },	/* U */
+  { ISFUNC, rl_do_lowercase_version },	/* V */
+  { ISFUNC, rl_do_lowercase_version },	/* W */
+  { ISFUNC, rl_do_lowercase_version },	/* X */
+  { ISFUNC, rl_do_lowercase_version },	/* Y */
+  { ISFUNC, rl_do_lowercase_version },	/* Z */
+
+  /* Some more punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* [ */
+  { ISFUNC, (Function *)0x0 },		/* \ */
+  { ISFUNC, (Function *)0x0 },		/* ] */
+  { ISFUNC, (Function *)0x0 },		/* ^ */
+  { ISFUNC, (Function *)0x0 },		/* _ */
+  { ISFUNC, (Function *)0x0 },		/* ` */
+
+  /* Lowercase alphabet. */
+  { ISFUNC, (Function *)0x0 },		/* a */
+  { ISFUNC, (Function *)0x0 },		/* b */
+  { ISFUNC, (Function *)0x0 },		/* c */
+  { ISFUNC, (Function *)0x0 },		/* d */
+  { ISFUNC, (Function *)0x0 },		/* e */
+  { ISFUNC, (Function *)0x0 },		/* f */
+  { ISFUNC, (Function *)0x0 },		/* g */
+  { ISFUNC, (Function *)0x0 },		/* h */
+  { ISFUNC, (Function *)0x0 },		/* i */
+  { ISFUNC, (Function *)0x0 },		/* j */
+  { ISFUNC, (Function *)0x0 },		/* k */
+  { ISFUNC, (Function *)0x0 },		/* l */
+  { ISFUNC, (Function *)0x0 },		/* m */
+  { ISFUNC, (Function *)0x0 },		/* n */
+  { ISFUNC, (Function *)0x0 },		/* o */
+  { ISFUNC, (Function *)0x0 },		/* p */
+  { ISFUNC, (Function *)0x0 },		/* q */
+  { ISFUNC, (Function *)0x0 },		/* r */
+  { ISFUNC, (Function *)0x0 },		/* s */
+  { ISFUNC, (Function *)0x0 },		/* t */
+  { ISFUNC, (Function *)0x0 },		/* u */
+  { ISFUNC, (Function *)0x0 },		/* v */
+  { ISFUNC, (Function *)0x0 },		/* w */
+  { ISFUNC, (Function *)0x0 },		/* x */
+  { ISFUNC, (Function *)0x0 },		/* y */
+  { ISFUNC, (Function *)0x0 },		/* z */
+
+  /* Final punctuation. */
+  { ISFUNC, (Function *)0x0 },		/* { */
+  { ISFUNC, (Function *)0x0 },		/* | */
+  { ISFUNC, (Function *)0x0 },		/* } */
+  { ISFUNC, (Function *)0x0 },		/* ~ */
+  { ISFUNC, rl_backward_kill_word }	/* RUBOUT */
+};
diff --git a/gnu/usr.bin/gdb/readline/vi_mode.c b/gnu/usr.bin/gdb/readline/vi_mode.c
new file mode 100644
index 00000000000..08851a5a66f
--- /dev/null
+++ b/gnu/usr.bin/gdb/readline/vi_mode.c
@@ -0,0 +1,1219 @@
+/* vi_mode.c -- A vi emulation mode for Bash.
+   Derived from code written by Jeff Sparkes (jsparkes@bnr.ca).  */
+
+/* Copyright (C) 1988, 1991 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (the Library), a set of
+   routines for providing Emacs style line input to programs that ask
+   for it.
+
+   The Library is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   The Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+	$Id: vi_mode.c,v 1.1 1995/10/18 08:40:16 deraadt Exp $
+*/
+
+
+/* **************************************************************** */
+/*								    */
+/*			VI Emulation Mode			    */
+/*								    */
+/* **************************************************************** */
+#if defined (VI_MODE)
+
+/* Some standard library routines. */
+#include "sysdep.h"
+#include <stdio.h>
+#include "readline.h"
+#include "history.h"
+
+#ifndef digit
+#define digit(c)  ((c) >= '0' && (c) <= '9')
+#endif
+
+#ifndef isletter
+#define isletter(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+#endif
+
+#ifndef digit_value
+#define digit_value(c) ((c) - '0')
+#endif
+
+#ifndef member
+#define member(c, s) ((c) ? index ((s), (c)) : 0)
+#endif
+
+#ifndef isident
+#define isident(c) ((isletter(c) || digit(c) || c == '_'))
+#endif
+
+#ifndef exchange
+#define exchange(x, y) {int temp = x; x = y; y = temp;}
+#endif
+
+/* Variables imported from readline.c */
+extern int rl_point, rl_end, rl_mark, rl_done;
+extern FILE *rl_instream;
+extern int rl_line_buffer_len, rl_explicit_arg, rl_numeric_arg;
+extern Keymap keymap;
+extern char *rl_prompt;
+extern char *rl_line_buffer;
+extern int rl_arg_sign;
+
+extern char *xmalloc (), *xrealloc ();
+extern void rl_extend_line_buffer ();
+
+/* Last string searched for from `/' or `?'. */
+static char *vi_last_search = (char *)NULL;
+static int vi_histpos;
+
+/* Non-zero means enter insertion mode. */
+int vi_doing_insert = 0;
+
+/* String inserted into the line by rl_vi_comment (). */
+char *rl_vi_comment_begin = (char *)NULL;
+
+/* *** UNCLEAN *** */
+/* Command keys which do movement for xxx_to commands. */
+static char *vi_motion = " hl^$0ftFt;,%wbeWBE|";
+
+/* Keymap used for vi replace characters.  Created dynamically since
+   rarely used. */
+static Keymap vi_replace_map = (Keymap)NULL;
+
+/* The number of characters inserted in the last replace operation. */
+static int vi_replace_count = 0;
+
+/* Yank the nth arg from the previous line into this line at point. */
+rl_vi_yank_arg (count)
+     int count;
+{
+  /* Readline thinks that the first word on a line is the 0th, while vi
+     thinks the first word on a line is the 1st.  Compensate. */
+  if (rl_explicit_arg)
+    rl_yank_nth_arg (count - 1, 0);
+  else
+    rl_yank_nth_arg ('$', 0);
+}
+
+/* With an argument, move back that many history lines, else move to the
+   beginning of history. */
+rl_vi_fetch_history (count, c)
+     int count, c;
+{
+  extern int rl_explicit_arg;
+  int current = where_history ();
+
+  /* Giving an argument of n means we want the nth command in the history
+     file.  The command number is interpreted the same way that the bash
+     `history' command does it -- that is, giving an argument count of 450
+     to this command would get the command listed as number 450 in the
+     output of `history'. */
+  if (rl_explicit_arg)
+    {
+      int wanted = history_base + current - count;
+      if (wanted <= 0)
+        rl_beginning_of_history (0, 0);
+      else
+        rl_get_previous_history (wanted);
+    }
+  else
+    rl_beginning_of_history (count, 0);
+}
+
+/* Search again for the last thing searched for. */
+rl_vi_search_again (ignore, key)
+     int ignore, key;
+{
+  switch (key)
+    {
+    case 'n':
+      rl_vi_dosearch (vi_last_search, -1);
+      break;
+
+    case 'N':
+      rl_vi_dosearch (vi_last_search, 1);
+      break;
+    }
+}
+
+/* Do a vi style search. */
+rl_vi_search (count, key)
+     int count, key;
+{
+  int dir, c, save_pos;
+  char *p;
+
+  switch (key)
+    {
+    case '?':
+      dir = 1;
+      break;
+
+    case '/':
+      dir = -1;
+      break;
+
+    default:
+      ding ();
+      return;
+    }
+
+  vi_histpos = where_history ();
+  maybe_save_line ();
+  save_pos = rl_point;
+
+  /* Reuse the line input buffer to read the search string. */
+  rl_line_buffer[0] = 0;
+  rl_end = rl_point = 0;
+  p = (char *)alloca (2 + (rl_prompt ? strlen (rl_prompt) : 0));
+
+  sprintf (p, "%s%c", rl_prompt ? rl_prompt : "", key);
+
+  rl_message (p, 0, 0);
+
+  while (c = rl_read_key ())
+    {
+      switch (c)
+	{
+	case CTRL('H'):
+	case RUBOUT:
+	  if (rl_point == 0)
+	    {
+	      maybe_unsave_line ();
+	      rl_clear_message ();
+	      rl_point = save_pos;
+	      return;
+	    }
+
+	case CTRL('W'):
+	case CTRL('U'):
+	  rl_dispatch (c, keymap);
+	  break;
+
+	case ESC:
+	case RETURN:
+	case NEWLINE:
+	  goto dosearch;
+	  break;
+
+	case CTRL('C'):
+	  maybe_unsave_line ();
+	  rl_clear_message ();
+	  rl_point = 0;
+	  ding ();
+	  return;
+
+	default:
+	  rl_insert (1, c);
+	  break;
+	}
+      rl_redisplay ();
+    }
+ dosearch:
+  if (vi_last_search)
+    free (vi_last_search);
+
+  vi_last_search = savestring (rl_line_buffer);
+  rl_vi_dosearch (rl_line_buffer, dir);
+}
+
+/* Search for STRING in the history list.  DIR is < 0 for searching
+   backwards.  POS is an absolute index into the history list at
+   which point to begin searching.  If the first character of STRING
+   is `^', the string must match a prefix of a history line, otherwise
+   a full substring match is performed. */
+static int
+vi_history_search_pos (string, dir, pos)
+     char *string;
+     int dir, pos;
+{
+  int ret, old = where_history ();
+
+  history_set_pos (pos);
+
+  if (*string == '^')
+    ret = history_search_prefix (string + 1, dir);
+  else
+    ret = history_search (string, dir);
+    
+  if (ret == -1)
+    {
+      history_set_pos (old);
+      return (-1);
+    }
+
+  ret = where_history ();
+  history_set_pos (old);
+  return ret;
+}
+
+rl_vi_dosearch (string, dir)
+     char *string;
+     int dir;
+{
+  int old, save = vi_histpos;
+  HIST_ENTRY *h;
+
+  if (string == 0 || *string == 0 || vi_histpos < 0)
+    {
+      ding ();
+      return;
+    }
+
+  if ((save = vi_history_search_pos (string, dir, vi_histpos + dir)) == -1)
+    {
+      maybe_unsave_line ();
+      rl_clear_message ();
+      rl_point = 0;
+      ding ();
+      return;
+    }
+
+  vi_histpos = save;
+
+  old = where_history ();
+  history_set_pos (vi_histpos);
+  h = current_history ();
+  history_set_pos (old);
+
+  {
+    int line_len = strlen (h->line);
+
+    if (line_len >= rl_line_buffer_len)
+      rl_extend_line_buffer (line_len);
+    strcpy (rl_line_buffer, h->line);
+  }
+
+  rl_undo_list = (UNDO_LIST *)h->data;
+  rl_end = strlen (rl_line_buffer);
+  rl_point = 0;
+  rl_clear_message ();
+}
+
+/* Completion, from vi's point of view. */
+rl_vi_complete (ignore, key)
+     int ignore, key;
+{
+  if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
+    {
+      if (!whitespace (rl_line_buffer[rl_point + 1]))
+	rl_vi_end_word (1, 'E');
+      rl_point++;
+    }
+
+  if (key == '*')
+    rl_complete_internal ('*');	/* Expansion and replacement. */
+  else if (key == '=')
+    rl_complete_internal ('?');	/* List possible completions. */
+  else if (key == '\\')
+    rl_complete_internal (TAB);	/* Standard Readline completion. */
+  else
+    rl_complete (0, key);
+}
+
+/* Previous word in vi mode. */
+rl_vi_prev_word (count, key)
+     int count, key;
+{
+  if (count < 0)
+    {
+      rl_vi_next_word (-count, key);
+      return;
+    }
+
+  if (rl_point == 0)
+    {
+      ding ();
+      return;
+    }
+
+  if (uppercase_p (key))
+    rl_vi_bWord (count);
+  else
+    rl_vi_bword (count);
+}
+
+/* Next word in vi mode. */
+rl_vi_next_word (count, key)
+     int count;
+{
+  if (count < 0)
+    {
+      rl_vi_prev_word (-count, key);
+      return;
+    }
+
+  if (rl_point >= (rl_end - 1))
+    {
+      ding ();
+      return;
+    }
+
+  if (uppercase_p (key))
+    rl_vi_fWord (count);
+  else
+    rl_vi_fword (count);
+}
+
+/* Move to the end of the ?next? word. */
+rl_vi_end_word (count, key)
+     int count, key;
+{
+  if (count < 0)
+    {
+      ding ();
+      return;
+    }
+
+  if (uppercase_p (key))
+    rl_vi_eWord (count);
+  else
+    rl_vi_eword (count);
+}
+
+/* Move forward a word the way that 'W' does. */
+rl_vi_fWord (count)
+     int count;
+{
+  while (count-- && rl_point < (rl_end - 1))
+    {
+      /* Skip until whitespace. */
+      while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
+	rl_point++;
+
+      /* Now skip whitespace. */
+      while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
+	rl_point++;
+    }
+}
+
+rl_vi_bWord (count)
+     int count;
+{
+  while (count-- && rl_point > 0)
+    {
+      /* If we are at the start of a word, move back to whitespace so
+	 we will go back to the start of the previous word. */
+      if (!whitespace (rl_line_buffer[rl_point]) &&
+	  whitespace (rl_line_buffer[rl_point - 1]))
+	rl_point--;
+
+      while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
+	rl_point--;
+
+      if (rl_point > 0)
+	{
+	  while (--rl_point >= 0 && !whitespace (rl_line_buffer[rl_point]));
+	  rl_point++;
+	}
+    }
+}
+
+rl_vi_eWord (count)
+     int count;
+{
+  while (count-- && rl_point < (rl_end - 1))
+    {
+      if (!whitespace (rl_line_buffer[rl_point]))
+	rl_point++;
+
+      /* Move to the next non-whitespace character (to the start of the
+	 next word). */
+      while (++rl_point < rl_end && whitespace (rl_line_buffer[rl_point]));
+
+      if (rl_point && rl_point < rl_end)
+	{
+	  /* Skip whitespace. */
+	  while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
+	    rl_point++;
+
+	  /* Skip until whitespace. */
+	  while (rl_point < rl_end && !whitespace (rl_line_buffer[rl_point]))
+	    rl_point++;
+
+	  /* Move back to the last character of the word. */
+	  rl_point--;
+	}
+    }
+}
+
+rl_vi_fword (count)
+     int count;
+{
+  while (count-- && rl_point < (rl_end - 1))
+    {
+      /* Move to white space (really non-identifer). */
+      if (isident (rl_line_buffer[rl_point]))
+	{
+	  while (isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
+	    rl_point++;
+	}
+      else /* if (!whitespace (rl_line_buffer[rl_point])) */
+	{
+	  while (!isident (rl_line_buffer[rl_point]) &&
+		 !whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
+	    rl_point++;
+	}
+
+      /* Move past whitespace. */
+      while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
+	rl_point++;
+    }
+}
+
+rl_vi_bword (count)
+     int count;
+{
+  while (count-- && rl_point > 0)
+    {
+      int last_is_ident;
+
+      /* If we are at the start of a word, move back to whitespace
+	 so we will go back to the start of the previous word. */
+      if (!whitespace (rl_line_buffer[rl_point]) &&
+	  whitespace (rl_line_buffer[rl_point - 1]))
+	rl_point--;
+
+      /* If this character and the previous character are `opposite', move
+	 back so we don't get messed up by the rl_point++ down there in
+	 the while loop.  Without this code, words like `l;' screw up the
+	 function. */
+      last_is_ident = isident (rl_line_buffer[rl_point - 1]);
+      if ((isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
+	  (!isident (rl_line_buffer[rl_point]) && last_is_ident))
+	rl_point--;
+
+      while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
+	rl_point--;
+
+      if (rl_point > 0)
+	{
+	  if (isident (rl_line_buffer[rl_point]))
+	    while (--rl_point >= 0 && isident (rl_line_buffer[rl_point]));
+	  else
+	    while (--rl_point >= 0 && !isident (rl_line_buffer[rl_point]) &&
+		   !whitespace (rl_line_buffer[rl_point]));
+	  rl_point++;
+	}
+    }
+}
+
+rl_vi_eword (count)
+     int count;
+{
+  while (count-- && rl_point < rl_end - 1)
+    {
+      if (!whitespace (rl_line_buffer[rl_point]))
+	rl_point++;
+
+      while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
+	rl_point++;
+
+      if (rl_point < rl_end)
+	{
+	  if (isident (rl_line_buffer[rl_point]))
+	    while (++rl_point < rl_end && isident (rl_line_buffer[rl_point]));
+	  else
+	    while (++rl_point < rl_end && !isident (rl_line_buffer[rl_point])
+		   && !whitespace (rl_line_buffer[rl_point]));
+	}
+      rl_point--;
+    }
+}
+
+rl_vi_insert_beg ()
+{
+  rl_beg_of_line ();
+  rl_vi_insertion_mode ();
+  return 0;
+}
+
+rl_vi_append_mode ()
+{
+  if (rl_point < rl_end)
+    rl_point += 1;
+  rl_vi_insertion_mode ();
+  return 0;
+}
+
+rl_vi_append_eol ()
+{
+  rl_end_of_line ();
+  rl_vi_append_mode ();
+  return 0;
+}
+
+/* What to do in the case of C-d. */
+rl_vi_eof_maybe (count, c)
+     int count, c;
+{
+  rl_newline (1, '\n');
+}
+
+/* Insertion mode stuff. */
+
+/* Switching from one mode to the other really just involves
+   switching keymaps. */
+rl_vi_insertion_mode ()
+{
+  keymap = vi_insertion_keymap;
+}
+
+rl_vi_movement_mode ()
+{
+  if (rl_point > 0)
+    rl_backward (1);
+
+  keymap = vi_movement_keymap;
+  vi_done_inserting ();
+}
+
+vi_done_inserting ()
+{
+  if (vi_doing_insert)
+    {
+      rl_end_undo_group ();
+      vi_doing_insert = 0;
+    }
+}
+
+rl_vi_arg_digit (count, c)
+     int count, c;
+{
+  if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
+    rl_beg_of_line ();
+  else
+    rl_digit_argument (count, c);
+}
+
+rl_vi_change_case (count, ignore)
+     int count, ignore;
+{
+  char c = 0;
+
+  /* Don't try this on an empty line. */
+  if (rl_point >= rl_end)
+    return;
+
+  while (count-- && rl_point < rl_end)
+    {
+      if (uppercase_p (rl_line_buffer[rl_point]))
+	c = to_lower (rl_line_buffer[rl_point]);
+      else if (lowercase_p (rl_line_buffer[rl_point]))
+	c = to_upper (rl_line_buffer[rl_point]);
+
+      /* Vi is kind of strange here. */
+      if (c)
+	{
+	  rl_begin_undo_group ();
+	  rl_delete (1, c);
+	  rl_insert (1, c);
+	  rl_end_undo_group ();
+	  rl_vi_check ();
+        }
+      else
+	rl_forward (1);
+    }
+}
+
+rl_vi_put (count, key)
+     int count, key;
+{
+  if (!uppercase_p (key) && (rl_point + 1 <= rl_end))
+    rl_point++;
+
+  rl_yank ();
+  rl_backward (1);
+}
+
+rl_vi_check ()
+{
+  if (rl_point && rl_point == rl_end)
+    rl_point--;
+}
+
+rl_vi_column (count)
+{
+  if (count > rl_end)
+    rl_end_of_line ();
+  else
+    rl_point = count - 1;
+}
+
+int
+rl_vi_domove (key, nextkey)
+     int key, *nextkey;
+{
+  int c, save;
+  int old_end, added_blank;
+
+  added_blank = 0;
+
+  rl_mark = rl_point;
+  c = rl_read_key ();
+  *nextkey = c;
+
+  if (!member (c, vi_motion))
+    {
+      if (digit (c))
+	{
+	  save = rl_numeric_arg;
+	  rl_numeric_arg = digit_value (c);
+	  rl_digit_loop1 ();
+	  rl_numeric_arg *= save;
+	  c = rl_read_key ();	/* real command */
+	  *nextkey = c;
+	}
+      else if ((key == 'd' && c == 'd') ||
+	       (key == 'y' && c == 'y') ||
+	       (key == 'c' && c == 'c'))
+	{
+	  rl_mark = rl_end;
+	  rl_beg_of_line ();
+	  return (0);
+	}
+      else
+	return (-1);
+    }
+
+  /* Append a blank character temporarily so that the motion routines
+     work right at the end of the line. */
+  old_end = rl_end;
+  rl_line_buffer[rl_end++] = ' ';	/* This looks pretty bogus to me??? */
+  rl_line_buffer[rl_end] = '\0';
+  added_blank++;
+
+  rl_dispatch (c, keymap);
+
+  /* Remove the blank that we added. */
+  rl_end = old_end;
+  rl_line_buffer[rl_end] = '\0';
+  if (rl_point > rl_end)
+    rl_point = rl_end - 1;
+
+  /* No change in position means the command failed. */
+  if (rl_mark == rl_point)
+    return (-1);
+
+  /* rl_vi_f[wW]ord () leaves the cursor on the first character of the next
+     word.  If we are not at the end of the line, and we are on a
+     non-whitespace character, move back one (presumably to whitespace). */
+  if ((c == 'w' || c == 'W') && (rl_point < rl_end) &&
+      !whitespace (rl_line_buffer[rl_point]))
+    rl_point--;
+
+  /* If cw or cW, back up to the end of a word, so the behaviour of ce
+     or cE is the actual result.  Brute-force, no subtlety.  Do the same
+     thing for dw or dW. */
+  if (key == 'c' && (to_upper (c) == 'W'))
+    {
+      while (rl_point && whitespace (rl_line_buffer[rl_point]))
+	rl_point--;
+    }
+
+  if (rl_mark < rl_point)
+    exchange (rl_point, rl_mark);
+
+  return (0);
+}
+
+/* A simplified loop for vi. Don't dispatch key at end.
+   Don't recognize minus sign? */
+rl_digit_loop1 ()
+{
+  int key, c;
+
+  while (1)
+    {
+      rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg, 0);
+      key = c = rl_read_key ();
+
+      if (keymap[c].type == ISFUNC &&
+	  keymap[c].function == rl_universal_argument)
+	{
+	  rl_numeric_arg *= 4;
+	  continue;
+	}
+
+      c = UNMETA (c);
+      if (numeric (c))
+	{
+	  if (rl_explicit_arg)
+	    rl_numeric_arg = (rl_numeric_arg * 10) + digit_value (c);
+	  else
+	    rl_numeric_arg = digit_value (c);
+	  rl_explicit_arg = 1;
+	}
+      else
+	{
+	  rl_clear_message ();
+	  rl_stuff_char (key);
+	  break;
+	}
+    }
+}
+
+rl_vi_delete_to (count, key)
+     int count, key;
+{
+  int c;
+
+  if (uppercase_p (key))
+    rl_stuff_char ('$');
+
+  if (rl_vi_domove (key, &c))
+    {
+      ding ();
+      return;
+    }
+
+  if ((c != 'l') && (c != '|') && (c != 'h') && rl_mark < rl_end)
+    rl_mark++;
+
+  rl_kill_text (rl_point, rl_mark);
+}
+
+rl_vi_change_to (count, key)
+     int count, key;
+{
+  int c;
+
+  if (uppercase_p (key))
+    rl_stuff_char ('$');
+
+  if (rl_vi_domove (key, &c))
+    {
+      ding ();
+      return;
+    }
+
+  if ((c != 'l') && (c != '|') && (c != 'h') && rl_mark < rl_end)
+    rl_mark++;
+
+  rl_begin_undo_group ();
+  vi_doing_insert = 1;
+  rl_kill_text (rl_point, rl_mark);
+  rl_vi_insertion_mode ();
+}
+
+rl_vi_yank_to (count, key)
+     int count, key;
+{
+  int c, save = rl_point;
+
+  if (uppercase_p (key))
+    rl_stuff_char ('$');
+
+  if (rl_vi_domove (key, &c))
+    {
+      ding ();
+      return;
+    }
+
+  if ((c != 'l') && (c != '|') && (c != 'h') && rl_mark < rl_end)
+    rl_mark++;
+
+  rl_begin_undo_group ();
+  rl_kill_text (rl_point, rl_mark);
+  rl_end_undo_group ();
+  rl_do_undo ();
+  rl_point = save;
+}
+
+rl_vi_delete (count)
+{
+  int end;
+
+  if (rl_end == 0)
+    {
+      ding ();
+      return;
+    }
+
+  end = rl_point + count;
+
+  if (end >= rl_end)
+    end = rl_end;
+
+  rl_kill_text (rl_point, end);
+  
+  if (rl_point > 0 && rl_point == rl_end)
+    rl_backward (1);
+}
+
+/* Turn the current line into a comment in shell history.
+   A K*rn shell style function. */
+rl_vi_comment ()
+{
+  rl_beg_of_line ();
+
+  if (rl_vi_comment_begin != (char *)NULL)
+    rl_insert_text (rl_vi_comment_begin);
+  else
+    rl_insert_text (": ");	/* Default. */
+
+  rl_redisplay ();
+  rl_newline (1, '\010');
+}
+
+rl_vi_first_print ()
+{
+  rl_back_to_indent (0, 0);
+}
+
+rl_back_to_indent (ignore1, ignore2)
+     int ignore1, ignore2;
+{
+  rl_beg_of_line ();
+  while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
+    rl_point++;
+}
+
+/* NOTE: it is necessary that opposite directions are inverses */
+#define	FTO	 1		/* forward to */
+#define BTO	-1		/* backward to */
+#define FFIND	 2		/* forward find */
+#define BFIND	-2		/* backward find */
+
+rl_vi_char_search (count, key)
+     int count, key;
+{
+  static char target;
+  static int orig_dir, dir;
+  int pos;
+
+  if (key == ';' || key == ',')
+    dir = (key == ';' ? orig_dir : -orig_dir);
+  else
+    {
+      target = rl_getc (rl_instream);
+
+      switch (key)
+        {
+        case 't':
+          orig_dir = dir = FTO;
+          break;
+
+        case 'T':
+          orig_dir = dir = BTO;
+          break;
+
+        case 'f':
+          orig_dir = dir = FFIND;
+          break;
+
+        case 'F':
+          orig_dir = dir = BFIND;
+          break;
+        }
+    }
+
+  pos = rl_point;
+
+  while (count--)
+    {
+      if (dir < 0)
+	{
+	  if (pos == 0)
+	    {
+	      ding ();
+	      return;
+	    }
+
+	  pos--;
+	  do
+	    {
+	      if (rl_line_buffer[pos] == target)
+		{
+		  if (dir == BTO)
+		    rl_point = pos + 1;
+		  else
+		    rl_point = pos;
+		  break;
+		}
+	    }
+	  while (pos--);
+
+	  if (pos < 0)
+	    {
+	      ding ();
+	      return;
+	    }
+	}
+      else
+	{			/* dir > 0 */
+	  if (pos >= rl_end)
+	    {
+	      ding ();
+	      return;
+	    }
+
+	  pos++;
+	  do
+	    {
+	      if (rl_line_buffer[pos] == target)
+		{
+		  if (dir == FTO)
+		    rl_point = pos - 1;
+		  else
+		    rl_point = pos;
+		  break;
+		}
+	    }
+	  while (++pos < rl_end);
+
+	  if (pos >= (rl_end - 1))
+	    {
+	      ding ();
+	      return;
+	    }
+	}
+    }
+}
+
+/* Match brackets */
+rl_vi_match ()
+{
+  int count = 1, brack, pos;
+
+  pos = rl_point;
+  if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
+    {
+      while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0 &&
+	     rl_point < rl_end - 1)
+	rl_forward (1);
+
+      if (brack <= 0)
+	{
+	  rl_point = pos;
+	  ding ();
+	  return;
+	}
+    }
+
+  pos = rl_point;
+
+  if (brack < 0)
+    {
+      while (count)
+	{
+	  if (--pos >= 0)
+	    {
+	      int b = rl_vi_bracktype (rl_line_buffer[pos]);
+	      if (b == -brack)
+		count--;
+	      else if (b == brack)
+		count++;
+	    }
+	  else
+	    {
+	      ding ();
+	      return;
+	    }
+	}
+    }
+  else
+    {			/* brack > 0 */
+      while (count)
+	{
+	  if (++pos < rl_end)
+	    {
+	      int b = rl_vi_bracktype (rl_line_buffer[pos]);
+	      if (b == -brack)
+		count--;
+	      else if (b == brack)
+		count++;
+	    }
+	  else
+	    {
+	      ding ();
+	      return;
+	    }
+	}
+    }
+  rl_point = pos;
+}
+
+int
+rl_vi_bracktype (c)
+     int c;
+{
+  switch (c)
+    {
+    case '(': return  1;
+    case ')': return -1;
+    case '[': return  2;
+    case ']': return -2;
+    case '{': return  3;
+    case '}': return -3;
+    default:  return  0;
+    }
+}
+
+rl_vi_change_char (count, key)
+     int count, key;
+{
+  int c;
+
+  c = rl_getc (rl_instream);
+
+  if (c == '\033' || c == CTRL ('C'))
+    return;
+
+  while (count-- && rl_point < rl_end)
+    {
+      rl_begin_undo_group ();
+
+      rl_delete (1, c);
+      rl_insert (1, c);
+      if (count == 0)
+	rl_backward (1);
+
+      rl_end_undo_group ();
+    }
+}
+
+rl_vi_subst (count, key)
+     int count, key;
+{
+  rl_begin_undo_group ();
+  vi_doing_insert = 1;
+
+  if (uppercase_p (key))
+    {
+      rl_beg_of_line ();
+      rl_kill_line (1);
+    }
+  else
+    rl_delete (count, key);
+
+  rl_end_undo_group ();
+  rl_vi_insertion_mode ();
+}
+
+rl_vi_overstrike (count, key)
+     int count, key;
+{
+  int i;
+
+  if (vi_doing_insert == 0)
+    {
+      vi_doing_insert = 1;
+      rl_begin_undo_group ();
+    }
+
+  for (i = 0; i < count; i++)
+    {
+      vi_replace_count++;
+      rl_begin_undo_group ();
+
+      if (rl_point < rl_end)
+	{
+	  rl_delete (1, key);
+	  rl_insert (1, key);
+	}
+      else
+	rl_insert (1, key);
+
+      rl_end_undo_group ();
+    }
+}
+
+rl_vi_overstrike_delete (count)
+     int count;
+{
+  int i, s;
+
+  for (i = 0; i < count; i++)
+    {
+      if (vi_replace_count == 0)
+	{
+	  ding ();
+	  break;
+	}
+      s = rl_point;
+
+      if (rl_do_undo ())
+	vi_replace_count--;
+
+      if (rl_point == s)
+	rl_backward (1);
+    }
+
+  if (vi_replace_count == 0 && vi_doing_insert)
+    {
+      rl_end_undo_group ();
+      rl_do_undo ();
+      vi_doing_insert = 0;
+    }
+}
+
+rl_vi_replace (count, key)
+     int count, key;
+{
+  int i;
+
+  vi_replace_count = 0;
+
+  if (!vi_replace_map)
+    {
+      vi_replace_map = rl_make_bare_keymap ();
+
+      for (i = ' '; i < 127; i++)
+	vi_replace_map[i].function = rl_vi_overstrike;
+
+      vi_replace_map[RUBOUT].function = rl_vi_overstrike_delete;
+      vi_replace_map[ESC].function = rl_vi_movement_mode;
+      vi_replace_map[RETURN].function = rl_newline;
+      vi_replace_map[NEWLINE].function = rl_newline;
+
+      /* If the normal vi insertion keymap has ^H bound to erase, do the
+         same here.  Probably should remove the assignment to RUBOUT up
+         there, but I don't think it will make a difference in real life. */
+      if (vi_insertion_keymap[CTRL ('H')].type == ISFUNC &&
+	  vi_insertion_keymap[CTRL ('H')].function == rl_rubout)
+	vi_replace_map[CTRL ('H')].function = rl_vi_overstrike_delete;
+
+    }
+  keymap = vi_replace_map;
+}
+
+/*
+ * Try to complete the word we are standing on or the word that ends with
+ * the previous character. A space matches everything.
+ * Word delimiters are space and ;.
+ */
+rl_vi_possible_completions()
+{
+  int save_pos = rl_point;
+
+  if (!index (" ;", rl_line_buffer[rl_point]))
+    {
+      while (!index(" ;", rl_line_buffer[++rl_point]))
+	;
+    }
+  else if (rl_line_buffer[rl_point-1] == ';')
+    {
+      ding ();
+      return (0);
+    }
+
+  rl_possible_completions ();
+  rl_point = save_pos;
+
+  return (0);
+}
+
+#endif /* VI_MODE */