/* vi_mode.c -- A vi emulation mode for Bash.
+ Derived from code written by Jeff Sparkes (jsparkes@bnr.ca). */
- Derived from code written by Jeff Sparkes (jeff1@????).
- */
+/* 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 1, 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.
+
+ The GNU General Public License is often shipped with GNU software, and
+ is generally kept in a file called COPYING or LICENSE. If you do not
+ have a copy of the license, write to the Free Software Foundation,
+ 675 Mass Ave, Cambridge, MA 02139, USA. */
\f
/* **************************************************************** */
/* */
/* VI Emulation Mode */
/* */
/* **************************************************************** */
+#if defined (VI_MODE)
+
+#include <stdio.h>
+
+#if defined (__GNUC__)
+# define alloca __builtin_alloca
+#else
+# if defined (sparc) || defined (HAVE_ALLOCA_H)
+# include <alloca.h>
+# endif
+#endif
+
+/* 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
+
+/* 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;
/* 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|";
static Keymap vi_replace_map = (Keymap)NULL;
/* The number of characters inserted in the last replace operation. */
-static vi_replace_count = 0;
+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;
{
- rl_yank_nth_arg (count, 0);
+ /* 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. */
save_pos = rl_point;
/* Reuse the line input buffer to read the search string. */
- the_line[0] = 0;
+ rl_line_buffer[0] = 0;
rl_end = rl_point = 0;
p = (char *)alloca (2 + (rl_prompt ? strlen (rl_prompt) : 0));
if (vi_last_search)
free (vi_last_search);
- vi_last_search = savestring (the_line);
- rl_vi_dosearch (the_line, dir);
+ 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)
return;
}
- if ((save = history_search_pos (string, dir, vi_histpos + dir)) == -1)
+ if ((save = vi_history_search_pos (string, dir, vi_histpos + dir)) == -1)
{
maybe_unsave_line ();
rl_clear_message ();
h = current_history ();
history_set_pos (old);
- strcpy (the_line, h->line);
+ {
+ 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 (the_line);
+ rl_end = strlen (rl_line_buffer);
rl_point = 0;
rl_clear_message ();
}
rl_vi_complete (ignore, key)
int ignore, key;
{
- if (!whitespace (the_line[rl_point]))
+ if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
{
- if (!whitespace (the_line[rl_point + 1]))
+ if (!whitespace (rl_line_buffer[rl_point + 1]))
rl_vi_end_word (1, 'E');
rl_point++;
}
if (key == '*')
- rl_complete_internal ('*');
+ 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);
-
- rl_vi_insertion_mode ();
}
/* Previous word in vi mode. */
return;
}
+ if (rl_point == 0)
+ {
+ ding ();
+ return;
+ }
+
if (uppercase_p (key))
rl_vi_bWord (count);
else
return;
}
+ if (rl_point >= (rl_end - 1))
+ {
+ ding ();
+ return;
+ }
+
if (uppercase_p (key))
rl_vi_fWord (count);
else
while (count-- && rl_point < (rl_end - 1))
{
/* Skip until whitespace. */
- while (!whitespace (the_line[rl_point]) && rl_point < rl_end)
+ while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
rl_point++;
/* Now skip whitespace. */
- while (whitespace (the_line[rl_point]) && rl_point < rl_end)
+ while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
rl_point++;
}
}
{
while (count-- && rl_point > 0)
{
- while (rl_point-- >= 0 && whitespace (the_line[rl_point]));
- while (rl_point >= 0 && !whitespace (the_line[rl_point]))
+ /* 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--;
- 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))
+ while (count-- && rl_point < (rl_end - 1))
{
- while (rl_point++ < rl_end && whitespace (the_line[rl_point]));
- while (rl_point++ < rl_end && !whitespace (the_line[rl_point]));
- rl_point--;
+ 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))
+ while (count-- && rl_point < (rl_end - 1))
{
- if (isident (the_line[rl_point]))
+ /* Move to white space (really non-identifer). */
+ if (isident (rl_line_buffer[rl_point]))
{
- while (isident (the_line[rl_point]) && rl_point < rl_end)
- rl_point += 1;
+ while (isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
+ rl_point++;
}
- else if (!whitespace (the_line[rl_point]))
+ else /* if (!whitespace (rl_line_buffer[rl_point])) */
{
- while (!isident (the_line[rl_point]) &&
- !whitespace (the_line[rl_point]) && rl_point < rl_end)
- rl_point += 1;
+ while (!isident (rl_line_buffer[rl_point]) &&
+ !whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
+ rl_point++;
}
- while (whitespace (the_line[rl_point]) && rl_point < rl_end)
+ /* 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)
+ while (count-- && rl_point > 0)
{
- while (--rl_point > 0 && whitespace (the_line[rl_point]));
+ 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 (the_line[rl_point]))
- while (--rl_point >= 0 && isident (the_line[rl_point]));
+ if (isident (rl_line_buffer[rl_point]))
+ while (--rl_point >= 0 && isident (rl_line_buffer[rl_point]));
else
- while (--rl_point >= 0 && !isident (the_line[rl_point]) &&
- !whitespace (the_line[rl_point]));
+ 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)
+ while (count-- && rl_point < rl_end - 1)
{
- while (++rl_point < rl_end && whitespace (the_line[rl_point]));
+ 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 (the_line[rl_point]))
- while (++rl_point < rl_end && isident (the_line[rl_point]));
+ 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 (the_line[rl_point])
- && !whitespace (the_line[rl_point]));
- rl_point--;
+ while (++rl_point < rl_end && !isident (rl_line_buffer[rl_point])
+ && !whitespace (rl_line_buffer[rl_point]));
}
+ rl_point--;
}
}
rl_digit_argument (count, c);
}
-/* Doesn't take an arg count in vi */
-rl_vi_change_case (ignore1, ignore2)
- int ignore1, ignore2;
+rl_vi_change_case (count, ignore)
+ int count, ignore;
{
char c = 0;
- if (uppercase_p (the_line[rl_point]))
- c = to_lower (the_line[rl_point]);
- else if (lowercase_p (the_line[rl_point]))
- c = to_upper (the_line[rl_point]);
+ /* Don't try this on an empty line. */
+ if (rl_point >= rl_end)
+ return;
- /* Vi is kind of strange here. */
- if (c)
+ while (count-- && rl_point < rl_end)
{
- rl_begin_undo_group ();
- rl_delete (1, c);
- rl_insert (1, c);
- rl_end_undo_group ();
- rl_vi_check ();
+ 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);
}
- else
- rl_forward (1);
}
rl_vi_put (count, key)
int count, key;
{
- if (!uppercase_p (key))
- rl_forward (1);
+ if (!uppercase_p (key) && (rl_point + 1 <= rl_end))
+ rl_point++;
rl_yank ();
rl_backward (1);
int key, *nextkey;
{
int c, save;
+ int old_end, added_blank;
+
+ added_blank = 0;
rl_mark = rl_point;
c = rl_read_key ();
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;
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);
- if ((c == 'w' || c == 'W') && rl_point < rl_end)
+ /* 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);
while (1)
{
- rl_message ("(arg: %d) ", arg_sign * rl_numeric_arg, 0);
+ rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg, 0);
key = c = rl_read_key ();
if (keymap[c].type == ISFUNC &&
rl_numeric_arg *= 4;
continue;
}
+
c = UNMETA (c);
if (numeric (c))
{
if (rl_explicit_arg)
- rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0');
+ rl_numeric_arg = (rl_numeric_arg * 10) + digit_value (c);
else
- rl_numeric_arg = (c - '0');
+ rl_numeric_arg = digit_value (c);
rl_explicit_arg = 1;
}
else
{
rl_clear_message ();
rl_stuff_char (key);
+ break;
}
}
}
return;
}
- if ((c != '|') && (c != 'h') && rl_mark < rl_end)
+ if ((c != 'l') && (c != '|') && (c != 'h') && rl_mark < rl_end)
rl_mark++;
rl_kill_text (rl_point, rl_mark);
return;
}
- if ((c != '|') && (c != 'h') && rl_mark < rl_end)
+ if ((c != 'l') && (c != '|') && (c != 'h') && rl_mark < rl_end)
rl_mark++;
rl_begin_undo_group ();
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_vi_delete (count)
{
- if (rl_point >= rl_end - 1)
+ int end;
+
+ if (rl_end == 0)
{
- rl_delete (count, 0);
- if (rl_point > 0)
- rl_backward (1);
+ ding ();
+ return;
}
- else
- rl_delete (count, 0);
+
+ 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 ksh function */
+/* Turn the current line into a comment in shell history.
+ A K*rn shell style function. */
rl_vi_comment ()
{
rl_beg_of_line ();
- rl_insert_text (": "); /* # doesn't work in interactive mode */
+
+ 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');
}
int ignore1, ignore2;
{
rl_beg_of_line ();
- while (rl_point < rl_end && whitespace (the_line[rl_point]))
+ while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
rl_point++;
}
dir = (key == ';' ? orig_dir : -orig_dir);
else
{
- target = rl_getc (in_stream);
+ 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;
- }
+ {
+ 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;
- if (dir < 0)
+ while (count--)
{
- pos--;
- do
+ if (dir < 0)
{
- if (the_line[pos] == target)
+ if (pos == 0)
{
- if (dir == BTO)
- rl_point = pos + 1;
- else
- rl_point = pos;
+ ding ();
return;
}
- }
- while (pos--);
- if (pos < 0)
- {
- ding ();
- return;
- }
- }
- else
- { /* dir > 0 */
- pos++;
- do
- {
- if (the_line[pos] == target)
+ pos--;
+ do
{
- if (dir == FTO)
- rl_point = pos - 1;
- else
- rl_point = pos;
+ 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;
}
}
- while (++pos < rl_end);
+ else
+ { /* dir > 0 */
+ if (pos >= rl_end)
+ {
+ ding ();
+ return;
+ }
- if (pos >= (rl_end - 1))
- ding ();
+ 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;
+ }
+ }
}
}
int count = 1, brack, pos;
pos = rl_point;
- if ((brack = rl_vi_bracktype (the_line[rl_point])) == 0)
+ if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
{
- while ((brack = rl_vi_bracktype (the_line[rl_point])) == 0 &&
+ while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0 &&
rl_point < rl_end - 1)
rl_forward (1);
{
if (--pos >= 0)
{
- int b = rl_vi_bracktype (the_line[pos]);
+ int b = rl_vi_bracktype (rl_line_buffer[pos]);
if (b == -brack)
count--;
else if (b == brack)
{
if (++pos < rl_end)
{
- int b = rl_vi_bracktype (the_line[pos]);
+ int b = rl_vi_bracktype (rl_line_buffer[pos]);
if (b == -brack)
count--;
else if (b == brack)
}
}
-rl_vi_change_char ()
+rl_vi_change_char (count, key)
+ int count, key;
{
int c;
- c = rl_getc (in_stream);
+ c = rl_getc (rl_instream);
- switch (c)
- {
- case '\033':
- case CTRL('C'):
- return;
+ if (c == '\033' || c == CTRL ('C'))
+ return;
- default:
+ 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 ();
- break;
}
}
rl_kill_line (1);
}
else
- rl_delete (1, key);
+ rl_delete (count, key);
rl_vi_insertion_mode ();
}
}
}
-rl_vi_replace ()
+rl_vi_replace (count, key)
+ int count, key;
{
int i;
vi_replace_count = 0;
- vi_replace_map = rl_make_bare_keymap ();
+ if (!vi_replace_map)
+ {
+ vi_replace_map = rl_make_bare_keymap ();
- for (i = ' '; i < 127; i++)
- vi_replace_map[i].function = rl_vi_overstrike;
+ 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;
+ 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;
}
{
int save_pos = rl_point;
- if (!index (" ;", the_line[rl_point]))
+ if (!index (" ;", rl_line_buffer[rl_point]))
{
- while (!index(" ;", the_line[++rl_point]))
+ while (!index(" ;", rl_line_buffer[++rl_point]))
;
}
- else if (the_line[rl_point-1] == ';')
+ else if (rl_line_buffer[rl_point-1] == ';')
{
ding ();
return (0);
return (0);
}
+
+#endif /* VI_MODE */
projects / deliverable / binutils-gdb.git / blobdiff