/* vi_mode.c -- A vi emulation mode for Bash.
|
/* 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 (jsparkes@bnr.ca). */
|
|
|
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
|
|
This file is part of the GNU Readline Library, a library for
|
This file is part of the GNU Readline Library, a library for
|
reading lines of text with interactive input and history editing.
|
reading lines of text with interactive input and history editing.
|
|
|
The GNU Readline Library is free software; you can redistribute it
|
The GNU Readline Library is free software; you can redistribute it
|
and/or modify it under the terms of the GNU General Public License
|
and/or modify it under the terms of the GNU General Public License
|
as published by the Free Software Foundation; either version 2, or
|
as published by the Free Software Foundation; either version 2, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
The GNU Readline Library is distributed in the hope that it will be
|
The GNU Readline Library is distributed in the hope that it will be
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
The GNU General Public License is often shipped with GNU software, and
|
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
|
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,
|
have a copy of the license, write to the Free Software Foundation,
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
#define READLINE_LIBRARY
|
#define READLINE_LIBRARY
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* VI Emulation Mode */
|
/* VI Emulation Mode */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
#include "rlconf.h"
|
#include "rlconf.h"
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
|
|
#if defined (HAVE_CONFIG_H)
|
#if defined (HAVE_CONFIG_H)
|
# include <config.h>
|
# include <config.h>
|
#endif
|
#endif
|
|
|
#include <sys/types.h>
|
#include <sys/types.h>
|
|
|
#if defined (HAVE_STDLIB_H)
|
#if defined (HAVE_STDLIB_H)
|
# include <stdlib.h>
|
# include <stdlib.h>
|
#else
|
#else
|
# include "ansi_stdlib.h"
|
# include "ansi_stdlib.h"
|
#endif /* HAVE_STDLIB_H */
|
#endif /* HAVE_STDLIB_H */
|
|
|
#if defined (HAVE_UNISTD_H)
|
#if defined (HAVE_UNISTD_H)
|
# include <unistd.h>
|
# include <unistd.h>
|
#endif
|
#endif
|
|
|
#include <stdio.h>
|
#include <stdio.h>
|
|
|
/* Some standard library routines. */
|
/* Some standard library routines. */
|
#include "rldefs.h"
|
#include "rldefs.h"
|
#include "rlmbutil.h"
|
#include "rlmbutil.h"
|
|
|
#include "readline.h"
|
#include "readline.h"
|
#include "history.h"
|
#include "history.h"
|
|
|
#include "rlprivate.h"
|
#include "rlprivate.h"
|
#include "xmalloc.h"
|
#include "xmalloc.h"
|
|
|
#ifndef member
|
#ifndef member
|
#define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
|
#define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
|
#endif
|
#endif
|
|
|
int _rl_vi_last_command = 'i'; /* default `.' puts you in insert mode */
|
int _rl_vi_last_command = 'i'; /* default `.' puts you in insert mode */
|
|
|
/* Non-zero means enter insertion mode. */
|
/* Non-zero means enter insertion mode. */
|
static int _rl_vi_doing_insert;
|
static int _rl_vi_doing_insert;
|
|
|
/* Command keys which do movement for xxx_to commands. */
|
/* Command keys which do movement for xxx_to commands. */
|
static const char *vi_motion = " hl^$0ftFT;,%wbeWBE|";
|
static const char *vi_motion = " hl^$0ftFT;,%wbeWBE|";
|
|
|
/* Keymap used for vi replace characters. Created dynamically since
|
/* Keymap used for vi replace characters. Created dynamically since
|
rarely used. */
|
rarely used. */
|
static Keymap vi_replace_map;
|
static Keymap vi_replace_map;
|
|
|
/* The number of characters inserted in the last replace operation. */
|
/* The number of characters inserted in the last replace operation. */
|
static int vi_replace_count;
|
static int vi_replace_count;
|
|
|
/* If non-zero, we have text inserted after a c[motion] command that put
|
/* If non-zero, we have text inserted after a c[motion] command that put
|
us implicitly into insert mode. Some people want this text to be
|
us implicitly into insert mode. Some people want this text to be
|
attached to the command so that it is `redoable' with `.'. */
|
attached to the command so that it is `redoable' with `.'. */
|
static int vi_continued_command;
|
static int vi_continued_command;
|
static char *vi_insert_buffer;
|
static char *vi_insert_buffer;
|
static int vi_insert_buffer_size;
|
static int vi_insert_buffer_size;
|
|
|
static int _rl_vi_last_repeat = 1;
|
static int _rl_vi_last_repeat = 1;
|
static int _rl_vi_last_arg_sign = 1;
|
static int _rl_vi_last_arg_sign = 1;
|
static int _rl_vi_last_motion;
|
static int _rl_vi_last_motion;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
static char _rl_vi_last_search_mbchar[MB_LEN_MAX];
|
static char _rl_vi_last_search_mbchar[MB_LEN_MAX];
|
static int _rl_vi_last_search_mblen;
|
static int _rl_vi_last_search_mblen;
|
#else
|
#else
|
static int _rl_vi_last_search_char;
|
static int _rl_vi_last_search_char;
|
#endif
|
#endif
|
static int _rl_vi_last_replacement;
|
static int _rl_vi_last_replacement;
|
|
|
static int _rl_vi_last_key_before_insert;
|
static int _rl_vi_last_key_before_insert;
|
|
|
static int vi_redoing;
|
static int vi_redoing;
|
|
|
/* Text modification commands. These are the `redoable' commands. */
|
/* Text modification commands. These are the `redoable' commands. */
|
static const char *vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~";
|
static const char *vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~";
|
|
|
/* Arrays for the saved marks. */
|
/* Arrays for the saved marks. */
|
static int vi_mark_chars['z' - 'a' + 1];
|
static int vi_mark_chars['z' - 'a' + 1];
|
|
|
static void _rl_vi_stuff_insert PARAMS((int));
|
static void _rl_vi_stuff_insert PARAMS((int));
|
static void _rl_vi_save_insert PARAMS((UNDO_LIST *));
|
static void _rl_vi_save_insert PARAMS((UNDO_LIST *));
|
|
|
static int _rl_vi_arg_dispatch PARAMS((int));
|
static int _rl_vi_arg_dispatch PARAMS((int));
|
static int rl_digit_loop1 PARAMS((void));
|
static int rl_digit_loop1 PARAMS((void));
|
|
|
static int _rl_vi_set_mark PARAMS((void));
|
static int _rl_vi_set_mark PARAMS((void));
|
static int _rl_vi_goto_mark PARAMS((void));
|
static int _rl_vi_goto_mark PARAMS((void));
|
|
|
static int _rl_vi_callback_getchar PARAMS((char *, int));
|
static int _rl_vi_callback_getchar PARAMS((char *, int));
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int _rl_vi_callback_set_mark PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_set_mark PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_goto_mark PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_goto_mark PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_change_char PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_change_char PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_char_search PARAMS((_rl_callback_generic_arg *));
|
static int _rl_vi_callback_char_search PARAMS((_rl_callback_generic_arg *));
|
#endif
|
#endif
|
|
|
void
|
void
|
_rl_vi_initialize_line ()
|
_rl_vi_initialize_line ()
|
{
|
{
|
register int i;
|
register int i;
|
|
|
for (i = 0; i < sizeof (vi_mark_chars) / sizeof (int); i++)
|
for (i = 0; i < sizeof (vi_mark_chars) / sizeof (int); i++)
|
vi_mark_chars[i] = -1;
|
vi_mark_chars[i] = -1;
|
|
|
RL_UNSETSTATE(RL_STATE_VICMDONCE);
|
RL_UNSETSTATE(RL_STATE_VICMDONCE);
|
}
|
}
|
|
|
void
|
void
|
_rl_vi_reset_last ()
|
_rl_vi_reset_last ()
|
{
|
{
|
_rl_vi_last_command = 'i';
|
_rl_vi_last_command = 'i';
|
_rl_vi_last_repeat = 1;
|
_rl_vi_last_repeat = 1;
|
_rl_vi_last_arg_sign = 1;
|
_rl_vi_last_arg_sign = 1;
|
_rl_vi_last_motion = 0;
|
_rl_vi_last_motion = 0;
|
}
|
}
|
|
|
void
|
void
|
_rl_vi_set_last (key, repeat, sign)
|
_rl_vi_set_last (key, repeat, sign)
|
int key, repeat, sign;
|
int key, repeat, sign;
|
{
|
{
|
_rl_vi_last_command = key;
|
_rl_vi_last_command = key;
|
_rl_vi_last_repeat = repeat;
|
_rl_vi_last_repeat = repeat;
|
_rl_vi_last_arg_sign = sign;
|
_rl_vi_last_arg_sign = sign;
|
}
|
}
|
|
|
/* A convenience function that calls _rl_vi_set_last to save the last command
|
/* A convenience function that calls _rl_vi_set_last to save the last command
|
information and enters insertion mode. */
|
information and enters insertion mode. */
|
void
|
void
|
rl_vi_start_inserting (key, repeat, sign)
|
rl_vi_start_inserting (key, repeat, sign)
|
int key, repeat, sign;
|
int key, repeat, sign;
|
{
|
{
|
_rl_vi_set_last (key, repeat, sign);
|
_rl_vi_set_last (key, repeat, sign);
|
rl_vi_insertion_mode (1, key);
|
rl_vi_insertion_mode (1, key);
|
}
|
}
|
|
|
/* Is the command C a VI mode text modification command? */
|
/* Is the command C a VI mode text modification command? */
|
int
|
int
|
_rl_vi_textmod_command (c)
|
_rl_vi_textmod_command (c)
|
int c;
|
int c;
|
{
|
{
|
return (member (c, vi_textmod));
|
return (member (c, vi_textmod));
|
}
|
}
|
|
|
static void
|
static void
|
_rl_vi_stuff_insert (count)
|
_rl_vi_stuff_insert (count)
|
int count;
|
int count;
|
{
|
{
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
while (count--)
|
while (count--)
|
rl_insert_text (vi_insert_buffer);
|
rl_insert_text (vi_insert_buffer);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
}
|
}
|
|
|
/* Bound to `.'. Called from command mode, so we know that we have to
|
/* Bound to `.'. Called from command mode, so we know that we have to
|
redo a text modification command. The default for _rl_vi_last_command
|
redo a text modification command. The default for _rl_vi_last_command
|
puts you back into insert mode. */
|
puts you back into insert mode. */
|
int
|
int
|
rl_vi_redo (count, c)
|
rl_vi_redo (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
int r;
|
int r;
|
|
|
if (!rl_explicit_arg)
|
if (!rl_explicit_arg)
|
{
|
{
|
rl_numeric_arg = _rl_vi_last_repeat;
|
rl_numeric_arg = _rl_vi_last_repeat;
|
rl_arg_sign = _rl_vi_last_arg_sign;
|
rl_arg_sign = _rl_vi_last_arg_sign;
|
}
|
}
|
|
|
r = 0;
|
r = 0;
|
vi_redoing = 1;
|
vi_redoing = 1;
|
/* If we're redoing an insert with `i', stuff in the inserted text
|
/* If we're redoing an insert with `i', stuff in the inserted text
|
and do not go into insertion mode. */
|
and do not go into insertion mode. */
|
if (_rl_vi_last_command == 'i' && vi_insert_buffer && *vi_insert_buffer)
|
if (_rl_vi_last_command == 'i' && vi_insert_buffer && *vi_insert_buffer)
|
{
|
{
|
_rl_vi_stuff_insert (count);
|
_rl_vi_stuff_insert (count);
|
/* And back up point over the last character inserted. */
|
/* And back up point over the last character inserted. */
|
if (rl_point > 0)
|
if (rl_point > 0)
|
rl_point--;
|
rl_point--;
|
}
|
}
|
else
|
else
|
r = _rl_dispatch (_rl_vi_last_command, _rl_keymap);
|
r = _rl_dispatch (_rl_vi_last_command, _rl_keymap);
|
vi_redoing = 0;
|
vi_redoing = 0;
|
|
|
return (r);
|
return (r);
|
}
|
}
|
|
|
/* A placeholder for further expansion. */
|
/* A placeholder for further expansion. */
|
int
|
int
|
rl_vi_undo (count, key)
|
rl_vi_undo (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_undo_command (count, key));
|
return (rl_undo_command (count, key));
|
}
|
}
|
|
|
/* Yank the nth arg from the previous line into this line at point. */
|
/* Yank the nth arg from the previous line into this line at point. */
|
int
|
int
|
rl_vi_yank_arg (count, key)
|
rl_vi_yank_arg (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
/* Readline thinks that the first word on a line is the 0th, while vi
|
/* 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. */
|
thinks the first word on a line is the 1st. Compensate. */
|
if (rl_explicit_arg)
|
if (rl_explicit_arg)
|
rl_yank_nth_arg (count - 1, 0);
|
rl_yank_nth_arg (count - 1, 0);
|
else
|
else
|
rl_yank_nth_arg ('$', 0);
|
rl_yank_nth_arg ('$', 0);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* With an argument, move back that many history lines, else move to the
|
/* With an argument, move back that many history lines, else move to the
|
beginning of history. */
|
beginning of history. */
|
int
|
int
|
rl_vi_fetch_history (count, c)
|
rl_vi_fetch_history (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
int wanted;
|
int wanted;
|
|
|
/* Giving an argument of n means we want the nth command in the 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
|
file. The command number is interpreted the same way that the bash
|
`history' command does it -- that is, giving an argument count of 450
|
`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
|
to this command would get the command listed as number 450 in the
|
output of `history'. */
|
output of `history'. */
|
if (rl_explicit_arg)
|
if (rl_explicit_arg)
|
{
|
{
|
wanted = history_base + where_history () - count;
|
wanted = history_base + where_history () - count;
|
if (wanted <= 0)
|
if (wanted <= 0)
|
rl_beginning_of_history (0, 0);
|
rl_beginning_of_history (0, 0);
|
else
|
else
|
rl_get_previous_history (wanted, c);
|
rl_get_previous_history (wanted, c);
|
}
|
}
|
else
|
else
|
rl_beginning_of_history (count, 0);
|
rl_beginning_of_history (count, 0);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Search again for the last thing searched for. */
|
/* Search again for the last thing searched for. */
|
int
|
int
|
rl_vi_search_again (count, key)
|
rl_vi_search_again (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
switch (key)
|
switch (key)
|
{
|
{
|
case 'n':
|
case 'n':
|
rl_noninc_reverse_search_again (count, key);
|
rl_noninc_reverse_search_again (count, key);
|
break;
|
break;
|
|
|
case 'N':
|
case 'N':
|
rl_noninc_forward_search_again (count, key);
|
rl_noninc_forward_search_again (count, key);
|
break;
|
break;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Do a vi style search. */
|
/* Do a vi style search. */
|
int
|
int
|
rl_vi_search (count, key)
|
rl_vi_search (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
switch (key)
|
switch (key)
|
{
|
{
|
case '?':
|
case '?':
|
_rl_free_saved_history_line ();
|
_rl_free_saved_history_line ();
|
rl_noninc_forward_search (count, key);
|
rl_noninc_forward_search (count, key);
|
break;
|
break;
|
|
|
case '/':
|
case '/':
|
_rl_free_saved_history_line ();
|
_rl_free_saved_history_line ();
|
rl_noninc_reverse_search (count, key);
|
rl_noninc_reverse_search (count, key);
|
break;
|
break;
|
|
|
default:
|
default:
|
rl_ding ();
|
rl_ding ();
|
break;
|
break;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Completion, from vi's point of view. */
|
/* Completion, from vi's point of view. */
|
int
|
int
|
rl_vi_complete (ignore, key)
|
rl_vi_complete (ignore, key)
|
int ignore, key;
|
int ignore, key;
|
{
|
{
|
if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
|
if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
|
{
|
{
|
if (!whitespace (rl_line_buffer[rl_point + 1]))
|
if (!whitespace (rl_line_buffer[rl_point + 1]))
|
rl_vi_end_word (1, 'E');
|
rl_vi_end_word (1, 'E');
|
rl_point++;
|
rl_point++;
|
}
|
}
|
|
|
if (key == '*')
|
if (key == '*')
|
rl_complete_internal ('*'); /* Expansion and replacement. */
|
rl_complete_internal ('*'); /* Expansion and replacement. */
|
else if (key == '=')
|
else if (key == '=')
|
rl_complete_internal ('?'); /* List possible completions. */
|
rl_complete_internal ('?'); /* List possible completions. */
|
else if (key == '\\')
|
else if (key == '\\')
|
rl_complete_internal (TAB); /* Standard Readline completion. */
|
rl_complete_internal (TAB); /* Standard Readline completion. */
|
else
|
else
|
rl_complete (0, key);
|
rl_complete (0, key);
|
|
|
if (key == '*' || key == '\\')
|
if (key == '*' || key == '\\')
|
rl_vi_start_inserting (key, 1, rl_arg_sign);
|
rl_vi_start_inserting (key, 1, rl_arg_sign);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Tilde expansion for vi mode. */
|
/* Tilde expansion for vi mode. */
|
int
|
int
|
rl_vi_tilde_expand (ignore, key)
|
rl_vi_tilde_expand (ignore, key)
|
int ignore, key;
|
int ignore, key;
|
{
|
{
|
rl_tilde_expand (0, key);
|
rl_tilde_expand (0, key);
|
rl_vi_start_inserting (key, 1, rl_arg_sign);
|
rl_vi_start_inserting (key, 1, rl_arg_sign);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Previous word in vi mode. */
|
/* Previous word in vi mode. */
|
int
|
int
|
rl_vi_prev_word (count, key)
|
rl_vi_prev_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
return (rl_vi_next_word (-count, key));
|
return (rl_vi_next_word (-count, key));
|
|
|
if (rl_point == 0)
|
if (rl_point == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_vi_bWord (count, key);
|
rl_vi_bWord (count, key);
|
else
|
else
|
rl_vi_bword (count, key);
|
rl_vi_bword (count, key);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Next word in vi mode. */
|
/* Next word in vi mode. */
|
int
|
int
|
rl_vi_next_word (count, key)
|
rl_vi_next_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
return (rl_vi_prev_word (-count, key));
|
return (rl_vi_prev_word (-count, key));
|
|
|
if (rl_point >= (rl_end - 1))
|
if (rl_point >= (rl_end - 1))
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_vi_fWord (count, key);
|
rl_vi_fWord (count, key);
|
else
|
else
|
rl_vi_fword (count, key);
|
rl_vi_fword (count, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Move to the end of the ?next? word. */
|
/* Move to the end of the ?next? word. */
|
int
|
int
|
rl_vi_end_word (count, key)
|
rl_vi_end_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_vi_eWord (count, key);
|
rl_vi_eWord (count, key);
|
else
|
else
|
rl_vi_eword (count, key);
|
rl_vi_eword (count, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Move forward a word the way that 'W' does. */
|
/* Move forward a word the way that 'W' does. */
|
int
|
int
|
rl_vi_fWord (count, ignore)
|
rl_vi_fWord (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point < (rl_end - 1))
|
while (count-- && rl_point < (rl_end - 1))
|
{
|
{
|
/* Skip until whitespace. */
|
/* Skip until whitespace. */
|
while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
rl_point++;
|
rl_point++;
|
|
|
/* Now skip whitespace. */
|
/* Now skip whitespace. */
|
while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
rl_point++;
|
rl_point++;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_bWord (count, ignore)
|
rl_vi_bWord (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point > 0)
|
while (count-- && rl_point > 0)
|
{
|
{
|
/* If we are at the start of a word, move back to whitespace so
|
/* 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. */
|
we will go back to the start of the previous word. */
|
if (!whitespace (rl_line_buffer[rl_point]) &&
|
if (!whitespace (rl_line_buffer[rl_point]) &&
|
whitespace (rl_line_buffer[rl_point - 1]))
|
whitespace (rl_line_buffer[rl_point - 1]))
|
rl_point--;
|
rl_point--;
|
|
|
while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
|
rl_point--;
|
rl_point--;
|
|
|
if (rl_point > 0)
|
if (rl_point > 0)
|
{
|
{
|
while (--rl_point >= 0 && !whitespace (rl_line_buffer[rl_point]));
|
while (--rl_point >= 0 && !whitespace (rl_line_buffer[rl_point]));
|
rl_point++;
|
rl_point++;
|
}
|
}
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_eWord (count, ignore)
|
rl_vi_eWord (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point < (rl_end - 1))
|
while (count-- && rl_point < (rl_end - 1))
|
{
|
{
|
if (!whitespace (rl_line_buffer[rl_point]))
|
if (!whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
/* Move to the next non-whitespace character (to the start of the
|
/* Move to the next non-whitespace character (to the start of the
|
next word). */
|
next word). */
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
if (rl_point && rl_point < rl_end)
|
if (rl_point && rl_point < rl_end)
|
{
|
{
|
/* Skip whitespace. */
|
/* Skip whitespace. */
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
/* Skip until whitespace. */
|
/* Skip until whitespace. */
|
while (rl_point < rl_end && !whitespace (rl_line_buffer[rl_point]))
|
while (rl_point < rl_end && !whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
/* Move back to the last character of the word. */
|
/* Move back to the last character of the word. */
|
rl_point--;
|
rl_point--;
|
}
|
}
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_fword (count, ignore)
|
rl_vi_fword (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point < (rl_end - 1))
|
while (count-- && rl_point < (rl_end - 1))
|
{
|
{
|
/* Move to white space (really non-identifer). */
|
/* Move to white space (really non-identifer). */
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
{
|
{
|
while (_rl_isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
while (_rl_isident (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
rl_point++;
|
rl_point++;
|
}
|
}
|
else /* if (!whitespace (rl_line_buffer[rl_point])) */
|
else /* if (!whitespace (rl_line_buffer[rl_point])) */
|
{
|
{
|
while (!_rl_isident (rl_line_buffer[rl_point]) &&
|
while (!_rl_isident (rl_line_buffer[rl_point]) &&
|
!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
rl_point++;
|
rl_point++;
|
}
|
}
|
|
|
/* Move past whitespace. */
|
/* Move past whitespace. */
|
while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end)
|
rl_point++;
|
rl_point++;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_bword (count, ignore)
|
rl_vi_bword (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point > 0)
|
while (count-- && rl_point > 0)
|
{
|
{
|
int last_is_ident;
|
int last_is_ident;
|
|
|
/* If we are at the start of a word, move back to whitespace
|
/* 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. */
|
so we will go back to the start of the previous word. */
|
if (!whitespace (rl_line_buffer[rl_point]) &&
|
if (!whitespace (rl_line_buffer[rl_point]) &&
|
whitespace (rl_line_buffer[rl_point - 1]))
|
whitespace (rl_line_buffer[rl_point - 1]))
|
rl_point--;
|
rl_point--;
|
|
|
/* If this character and the previous character are `opposite', move
|
/* 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
|
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
|
the while loop. Without this code, words like `l;' screw up the
|
function. */
|
function. */
|
last_is_ident = _rl_isident (rl_line_buffer[rl_point - 1]);
|
last_is_ident = _rl_isident (rl_line_buffer[rl_point - 1]);
|
if ((_rl_isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
|
if ((_rl_isident (rl_line_buffer[rl_point]) && !last_is_ident) ||
|
(!_rl_isident (rl_line_buffer[rl_point]) && last_is_ident))
|
(!_rl_isident (rl_line_buffer[rl_point]) && last_is_ident))
|
rl_point--;
|
rl_point--;
|
|
|
while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point > 0 && whitespace (rl_line_buffer[rl_point]))
|
rl_point--;
|
rl_point--;
|
|
|
if (rl_point > 0)
|
if (rl_point > 0)
|
{
|
{
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
while (--rl_point >= 0 && _rl_isident (rl_line_buffer[rl_point]));
|
while (--rl_point >= 0 && _rl_isident (rl_line_buffer[rl_point]));
|
else
|
else
|
while (--rl_point >= 0 && !_rl_isident (rl_line_buffer[rl_point]) &&
|
while (--rl_point >= 0 && !_rl_isident (rl_line_buffer[rl_point]) &&
|
!whitespace (rl_line_buffer[rl_point]));
|
!whitespace (rl_line_buffer[rl_point]));
|
rl_point++;
|
rl_point++;
|
}
|
}
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_eword (count, ignore)
|
rl_vi_eword (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
while (count-- && rl_point < rl_end - 1)
|
while (count-- && rl_point < rl_end - 1)
|
{
|
{
|
if (!whitespace (rl_line_buffer[rl_point]))
|
if (!whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
if (rl_point < rl_end)
|
if (rl_point < rl_end)
|
{
|
{
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
if (_rl_isident (rl_line_buffer[rl_point]))
|
while (++rl_point < rl_end && _rl_isident (rl_line_buffer[rl_point]));
|
while (++rl_point < rl_end && _rl_isident (rl_line_buffer[rl_point]));
|
else
|
else
|
while (++rl_point < rl_end && !_rl_isident (rl_line_buffer[rl_point])
|
while (++rl_point < rl_end && !_rl_isident (rl_line_buffer[rl_point])
|
&& !whitespace (rl_line_buffer[rl_point]));
|
&& !whitespace (rl_line_buffer[rl_point]));
|
}
|
}
|
rl_point--;
|
rl_point--;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_insert_beg (count, key)
|
rl_vi_insert_beg (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_beg_of_line (1, key);
|
rl_beg_of_line (1, key);
|
rl_vi_insertion_mode (1, key);
|
rl_vi_insertion_mode (1, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_append_mode (count, key)
|
rl_vi_append_mode (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_point < rl_end)
|
if (rl_point < rl_end)
|
{
|
{
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
rl_point++;
|
rl_point++;
|
else
|
else
|
{
|
{
|
int point = rl_point;
|
int point = rl_point;
|
rl_forward_char (1, key);
|
rl_forward_char (1, key);
|
if (point == rl_point)
|
if (point == rl_point)
|
rl_point = rl_end;
|
rl_point = rl_end;
|
}
|
}
|
}
|
}
|
rl_vi_insertion_mode (1, key);
|
rl_vi_insertion_mode (1, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_append_eol (count, key)
|
rl_vi_append_eol (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_end_of_line (1, key);
|
rl_end_of_line (1, key);
|
rl_vi_append_mode (1, key);
|
rl_vi_append_mode (1, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* What to do in the case of C-d. */
|
/* What to do in the case of C-d. */
|
int
|
int
|
rl_vi_eof_maybe (count, c)
|
rl_vi_eof_maybe (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
return (rl_newline (1, '\n'));
|
return (rl_newline (1, '\n'));
|
}
|
}
|
|
|
/* Insertion mode stuff. */
|
/* Insertion mode stuff. */
|
|
|
/* Switching from one mode to the other really just involves
|
/* Switching from one mode to the other really just involves
|
switching keymaps. */
|
switching keymaps. */
|
int
|
int
|
rl_vi_insertion_mode (count, key)
|
rl_vi_insertion_mode (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
_rl_keymap = vi_insertion_keymap;
|
_rl_keymap = vi_insertion_keymap;
|
_rl_vi_last_key_before_insert = key;
|
_rl_vi_last_key_before_insert = key;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
static void
|
static void
|
_rl_vi_save_insert (up)
|
_rl_vi_save_insert (up)
|
UNDO_LIST *up;
|
UNDO_LIST *up;
|
{
|
{
|
int len, start, end;
|
int len, start, end;
|
|
|
if (up == 0)
|
if (up == 0)
|
{
|
{
|
if (vi_insert_buffer_size >= 1)
|
if (vi_insert_buffer_size >= 1)
|
vi_insert_buffer[0] = '\0';
|
vi_insert_buffer[0] = '\0';
|
return;
|
return;
|
}
|
}
|
|
|
start = up->start;
|
start = up->start;
|
end = up->end;
|
end = up->end;
|
len = end - start + 1;
|
len = end - start + 1;
|
if (len >= vi_insert_buffer_size)
|
if (len >= vi_insert_buffer_size)
|
{
|
{
|
vi_insert_buffer_size += (len + 32) - (len % 32);
|
vi_insert_buffer_size += (len + 32) - (len % 32);
|
vi_insert_buffer = (char *)xrealloc (vi_insert_buffer, vi_insert_buffer_size);
|
vi_insert_buffer = (char *)xrealloc (vi_insert_buffer, vi_insert_buffer_size);
|
}
|
}
|
strncpy (vi_insert_buffer, rl_line_buffer + start, len - 1);
|
strncpy (vi_insert_buffer, rl_line_buffer + start, len - 1);
|
vi_insert_buffer[len-1] = '\0';
|
vi_insert_buffer[len-1] = '\0';
|
}
|
}
|
|
|
void
|
void
|
_rl_vi_done_inserting ()
|
_rl_vi_done_inserting ()
|
{
|
{
|
if (_rl_vi_doing_insert)
|
if (_rl_vi_doing_insert)
|
{
|
{
|
/* The `C', `s', and `S' commands set this. */
|
/* The `C', `s', and `S' commands set this. */
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
/* Now, the text between rl_undo_list->next->start and
|
/* Now, the text between rl_undo_list->next->start and
|
rl_undo_list->next->end is what was inserted while in insert
|
rl_undo_list->next->end is what was inserted while in insert
|
mode. It gets copied to VI_INSERT_BUFFER because it depends
|
mode. It gets copied to VI_INSERT_BUFFER because it depends
|
on absolute indices into the line which may change (though they
|
on absolute indices into the line which may change (though they
|
probably will not). */
|
probably will not). */
|
_rl_vi_doing_insert = 0;
|
_rl_vi_doing_insert = 0;
|
_rl_vi_save_insert (rl_undo_list->next);
|
_rl_vi_save_insert (rl_undo_list->next);
|
vi_continued_command = 1;
|
vi_continued_command = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
if ((_rl_vi_last_key_before_insert == 'i' || _rl_vi_last_key_before_insert == 'a') && rl_undo_list)
|
if ((_rl_vi_last_key_before_insert == 'i' || _rl_vi_last_key_before_insert == 'a') && rl_undo_list)
|
_rl_vi_save_insert (rl_undo_list);
|
_rl_vi_save_insert (rl_undo_list);
|
/* XXX - Other keys probably need to be checked. */
|
/* XXX - Other keys probably need to be checked. */
|
else if (_rl_vi_last_key_before_insert == 'C')
|
else if (_rl_vi_last_key_before_insert == 'C')
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
while (_rl_undo_group_level > 0)
|
while (_rl_undo_group_level > 0)
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
vi_continued_command = 0;
|
vi_continued_command = 0;
|
}
|
}
|
}
|
}
|
|
|
int
|
int
|
rl_vi_movement_mode (count, key)
|
rl_vi_movement_mode (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_point > 0)
|
if (rl_point > 0)
|
rl_backward_char (1, key);
|
rl_backward_char (1, key);
|
|
|
_rl_keymap = vi_movement_keymap;
|
_rl_keymap = vi_movement_keymap;
|
_rl_vi_done_inserting ();
|
_rl_vi_done_inserting ();
|
|
|
/* This is how POSIX.2 says `U' should behave -- everything up until the
|
/* This is how POSIX.2 says `U' should behave -- everything up until the
|
first time you go into command mode should not be undone. */
|
first time you go into command mode should not be undone. */
|
if (RL_ISSTATE (RL_STATE_VICMDONCE) == 0)
|
if (RL_ISSTATE (RL_STATE_VICMDONCE) == 0)
|
rl_free_undo_list ();
|
rl_free_undo_list ();
|
|
|
RL_SETSTATE (RL_STATE_VICMDONCE);
|
RL_SETSTATE (RL_STATE_VICMDONCE);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_arg_digit (count, c)
|
rl_vi_arg_digit (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
|
if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
|
return (rl_beg_of_line (1, c));
|
return (rl_beg_of_line (1, c));
|
else
|
else
|
return (rl_digit_argument (count, c));
|
return (rl_digit_argument (count, c));
|
}
|
}
|
|
|
/* Change the case of the next COUNT characters. */
|
/* Change the case of the next COUNT characters. */
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
static int
|
static int
|
_rl_vi_change_mbchar_case (count)
|
_rl_vi_change_mbchar_case (count)
|
int count;
|
int count;
|
{
|
{
|
wchar_t wc;
|
wchar_t wc;
|
char mb[MB_LEN_MAX+1];
|
char mb[MB_LEN_MAX+1];
|
int mblen, p;
|
int mblen, p;
|
mbstate_t ps;
|
mbstate_t ps;
|
|
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
if (_rl_adjust_point (rl_line_buffer, rl_point, &ps) > 0)
|
if (_rl_adjust_point (rl_line_buffer, rl_point, &ps) > 0)
|
count--;
|
count--;
|
while (count-- && rl_point < rl_end)
|
while (count-- && rl_point < rl_end)
|
{
|
{
|
mbrtowc (&wc, rl_line_buffer + rl_point, rl_end - rl_point, &ps);
|
mbrtowc (&wc, rl_line_buffer + rl_point, rl_end - rl_point, &ps);
|
if (iswupper (wc))
|
if (iswupper (wc))
|
wc = towlower (wc);
|
wc = towlower (wc);
|
else if (iswlower (wc))
|
else if (iswlower (wc))
|
wc = towupper (wc);
|
wc = towupper (wc);
|
else
|
else
|
{
|
{
|
/* Just skip over chars neither upper nor lower case */
|
/* Just skip over chars neither upper nor lower case */
|
rl_forward_char (1, 0);
|
rl_forward_char (1, 0);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Vi is kind of strange here. */
|
/* Vi is kind of strange here. */
|
if (wc)
|
if (wc)
|
{
|
{
|
p = rl_point;
|
p = rl_point;
|
mblen = wcrtomb (mb, wc, &ps);
|
mblen = wcrtomb (mb, wc, &ps);
|
if (mblen >= 0)
|
if (mblen >= 0)
|
mb[mblen] = '\0';
|
mb[mblen] = '\0';
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
rl_vi_delete (1, 0);
|
rl_vi_delete (1, 0);
|
if (rl_point < p) /* Did we retreat at EOL? */
|
if (rl_point < p) /* Did we retreat at EOL? */
|
rl_point++; /* XXX - should we advance more than 1 for mbchar? */
|
rl_point++; /* XXX - should we advance more than 1 for mbchar? */
|
rl_insert_text (mb);
|
rl_insert_text (mb);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
rl_vi_check ();
|
rl_vi_check ();
|
}
|
}
|
else
|
else
|
rl_forward_char (1, 0);
|
rl_forward_char (1, 0);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
rl_vi_change_case (count, ignore)
|
rl_vi_change_case (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
int c, p;
|
int c, p;
|
|
|
/* Don't try this on an empty line. */
|
/* Don't try this on an empty line. */
|
if (rl_point >= rl_end)
|
if (rl_point >= rl_end)
|
return (0);
|
return (0);
|
|
|
c = 0;
|
c = 0;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
return (_rl_vi_change_mbchar_case (count));
|
return (_rl_vi_change_mbchar_case (count));
|
#endif
|
#endif
|
|
|
while (count-- && rl_point < rl_end)
|
while (count-- && rl_point < rl_end)
|
{
|
{
|
if (_rl_uppercase_p (rl_line_buffer[rl_point]))
|
if (_rl_uppercase_p (rl_line_buffer[rl_point]))
|
c = _rl_to_lower (rl_line_buffer[rl_point]);
|
c = _rl_to_lower (rl_line_buffer[rl_point]);
|
else if (_rl_lowercase_p (rl_line_buffer[rl_point]))
|
else if (_rl_lowercase_p (rl_line_buffer[rl_point]))
|
c = _rl_to_upper (rl_line_buffer[rl_point]);
|
c = _rl_to_upper (rl_line_buffer[rl_point]);
|
else
|
else
|
{
|
{
|
/* Just skip over characters neither upper nor lower case. */
|
/* Just skip over characters neither upper nor lower case. */
|
rl_forward_char (1, c);
|
rl_forward_char (1, c);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Vi is kind of strange here. */
|
/* Vi is kind of strange here. */
|
if (c)
|
if (c)
|
{
|
{
|
p = rl_point;
|
p = rl_point;
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
rl_vi_delete (1, c);
|
rl_vi_delete (1, c);
|
if (rl_point < p) /* Did we retreat at EOL? */
|
if (rl_point < p) /* Did we retreat at EOL? */
|
rl_point++;
|
rl_point++;
|
_rl_insert_char (1, c);
|
_rl_insert_char (1, c);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
rl_vi_check ();
|
rl_vi_check ();
|
}
|
}
|
else
|
else
|
rl_forward_char (1, c);
|
rl_forward_char (1, c);
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_put (count, key)
|
rl_vi_put (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (!_rl_uppercase_p (key) && (rl_point + 1 <= rl_end))
|
if (!_rl_uppercase_p (key) && (rl_point + 1 <= rl_end))
|
rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
|
rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
|
|
|
while (count--)
|
while (count--)
|
rl_yank (1, key);
|
rl_yank (1, key);
|
|
|
rl_backward_char (1, key);
|
rl_backward_char (1, key);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_check ()
|
rl_vi_check ()
|
{
|
{
|
if (rl_point && rl_point == rl_end)
|
if (rl_point && rl_point == rl_end)
|
{
|
{
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
|
rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
|
else
|
else
|
rl_point--;
|
rl_point--;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_column (count, key)
|
rl_vi_column (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count > rl_end)
|
if (count > rl_end)
|
rl_end_of_line (1, key);
|
rl_end_of_line (1, key);
|
else
|
else
|
rl_point = count - 1;
|
rl_point = count - 1;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_domove (key, nextkey)
|
rl_vi_domove (key, nextkey)
|
int key, *nextkey;
|
int key, *nextkey;
|
{
|
{
|
int c, save;
|
int c, save;
|
int old_end;
|
int old_end;
|
|
|
rl_mark = rl_point;
|
rl_mark = rl_point;
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
c = rl_read_key ();
|
c = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
*nextkey = c;
|
*nextkey = c;
|
|
|
if (!member (c, vi_motion))
|
if (!member (c, vi_motion))
|
{
|
{
|
if (_rl_digit_p (c))
|
if (_rl_digit_p (c))
|
{
|
{
|
save = rl_numeric_arg;
|
save = rl_numeric_arg;
|
rl_numeric_arg = _rl_digit_value (c);
|
rl_numeric_arg = _rl_digit_value (c);
|
rl_explicit_arg = 1;
|
rl_explicit_arg = 1;
|
RL_SETSTATE (RL_STATE_NUMERICARG|RL_STATE_VIMOTION);
|
RL_SETSTATE (RL_STATE_NUMERICARG|RL_STATE_VIMOTION);
|
rl_digit_loop1 ();
|
rl_digit_loop1 ();
|
RL_UNSETSTATE (RL_STATE_VIMOTION);
|
RL_UNSETSTATE (RL_STATE_VIMOTION);
|
rl_numeric_arg *= save;
|
rl_numeric_arg *= save;
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
c = rl_read_key (); /* real command */
|
c = rl_read_key (); /* real command */
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
*nextkey = c;
|
*nextkey = c;
|
}
|
}
|
else if (key == c && (key == 'd' || key == 'y' || key == 'c'))
|
else if (key == c && (key == 'd' || key == 'y' || key == 'c'))
|
{
|
{
|
rl_mark = rl_end;
|
rl_mark = rl_end;
|
rl_beg_of_line (1, c);
|
rl_beg_of_line (1, c);
|
_rl_vi_last_motion = c;
|
_rl_vi_last_motion = c;
|
return (0);
|
return (0);
|
}
|
}
|
else
|
else
|
return (-1);
|
return (-1);
|
}
|
}
|
|
|
_rl_vi_last_motion = c;
|
_rl_vi_last_motion = c;
|
|
|
/* Append a blank character temporarily so that the motion routines
|
/* Append a blank character temporarily so that the motion routines
|
work right at the end of the line. */
|
work right at the end of the line. */
|
old_end = rl_end;
|
old_end = rl_end;
|
rl_line_buffer[rl_end++] = ' ';
|
rl_line_buffer[rl_end++] = ' ';
|
rl_line_buffer[rl_end] = '\0';
|
rl_line_buffer[rl_end] = '\0';
|
|
|
_rl_dispatch (c, _rl_keymap);
|
_rl_dispatch (c, _rl_keymap);
|
|
|
/* Remove the blank that we added. */
|
/* Remove the blank that we added. */
|
rl_end = old_end;
|
rl_end = old_end;
|
rl_line_buffer[rl_end] = '\0';
|
rl_line_buffer[rl_end] = '\0';
|
if (rl_point > rl_end)
|
if (rl_point > rl_end)
|
rl_point = rl_end;
|
rl_point = rl_end;
|
|
|
/* No change in position means the command failed. */
|
/* No change in position means the command failed. */
|
if (rl_mark == rl_point)
|
if (rl_mark == rl_point)
|
return (-1);
|
return (-1);
|
|
|
/* rl_vi_f[wW]ord () leaves the cursor on the first character of the next
|
/* 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
|
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). */
|
non-whitespace character, move back one (presumably to whitespace). */
|
if ((_rl_to_upper (c) == 'W') && rl_point < rl_end && rl_point > rl_mark &&
|
if ((_rl_to_upper (c) == 'W') && rl_point < rl_end && rl_point > rl_mark &&
|
!whitespace (rl_line_buffer[rl_point]))
|
!whitespace (rl_line_buffer[rl_point]))
|
rl_point--;
|
rl_point--;
|
|
|
/* If cw or cW, back up to the end of a word, so the behaviour of ce
|
/* 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. */
|
or cE is the actual result. Brute-force, no subtlety. */
|
if (key == 'c' && rl_point >= rl_mark && (_rl_to_upper (c) == 'W'))
|
if (key == 'c' && rl_point >= rl_mark && (_rl_to_upper (c) == 'W'))
|
{
|
{
|
/* Don't move farther back than where we started. */
|
/* Don't move farther back than where we started. */
|
while (rl_point > rl_mark && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point > rl_mark && whitespace (rl_line_buffer[rl_point]))
|
rl_point--;
|
rl_point--;
|
|
|
/* Posix.2 says that if cw or cW moves the cursor towards the end of
|
/* Posix.2 says that if cw or cW moves the cursor towards the end of
|
the line, the character under the cursor should be deleted. */
|
the line, the character under the cursor should be deleted. */
|
if (rl_point == rl_mark)
|
if (rl_point == rl_mark)
|
rl_point++;
|
rl_point++;
|
else
|
else
|
{
|
{
|
/* Move past the end of the word so that the kill doesn't
|
/* Move past the end of the word so that the kill doesn't
|
remove the last letter of the previous word. Only do this
|
remove the last letter of the previous word. Only do this
|
if we are not at the end of the line. */
|
if we are not at the end of the line. */
|
if (rl_point >= 0 && rl_point < (rl_end - 1) && !whitespace (rl_line_buffer[rl_point]))
|
if (rl_point >= 0 && rl_point < (rl_end - 1) && !whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
}
|
}
|
}
|
}
|
|
|
if (rl_mark < rl_point)
|
if (rl_mark < rl_point)
|
SWAP (rl_point, rl_mark);
|
SWAP (rl_point, rl_mark);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Process C as part of the current numeric argument. Return -1 if the
|
/* Process C as part of the current numeric argument. Return -1 if the
|
argument should be aborted, 0 if we should not read any more chars, and
|
argument should be aborted, 0 if we should not read any more chars, and
|
1 if we should continue to read chars. */
|
1 if we should continue to read chars. */
|
static int
|
static int
|
_rl_vi_arg_dispatch (c)
|
_rl_vi_arg_dispatch (c)
|
int c;
|
int c;
|
{
|
{
|
int key;
|
int key;
|
|
|
key = c;
|
key = c;
|
if (c >= 0 && _rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument)
|
if (c >= 0 && _rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument)
|
{
|
{
|
rl_numeric_arg *= 4;
|
rl_numeric_arg *= 4;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
c = UNMETA (c);
|
c = UNMETA (c);
|
|
|
if (_rl_digit_p (c))
|
if (_rl_digit_p (c))
|
{
|
{
|
if (rl_explicit_arg)
|
if (rl_explicit_arg)
|
rl_numeric_arg = (rl_numeric_arg * 10) + _rl_digit_value (c);
|
rl_numeric_arg = (rl_numeric_arg * 10) + _rl_digit_value (c);
|
else
|
else
|
rl_numeric_arg = _rl_digit_value (c);
|
rl_numeric_arg = _rl_digit_value (c);
|
rl_explicit_arg = 1;
|
rl_explicit_arg = 1;
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
rl_clear_message ();
|
rl_clear_message ();
|
rl_stuff_char (key);
|
rl_stuff_char (key);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* A simplified loop for vi. Don't dispatch key at end.
|
/* A simplified loop for vi. Don't dispatch key at end.
|
Don't recognize minus sign?
|
Don't recognize minus sign?
|
Should this do rl_save_prompt/rl_restore_prompt? */
|
Should this do rl_save_prompt/rl_restore_prompt? */
|
static int
|
static int
|
rl_digit_loop1 ()
|
rl_digit_loop1 ()
|
{
|
{
|
int c, r;
|
int c, r;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
if (_rl_arg_overflow ())
|
if (_rl_arg_overflow ())
|
return 1;
|
return 1;
|
|
|
c = _rl_arg_getchar ();
|
c = _rl_arg_getchar ();
|
|
|
r = _rl_vi_arg_dispatch (c);
|
r = _rl_vi_arg_dispatch (c);
|
if (r <= 0)
|
if (r <= 0)
|
break;
|
break;
|
}
|
}
|
|
|
RL_UNSETSTATE(RL_STATE_NUMERICARG);
|
RL_UNSETSTATE(RL_STATE_NUMERICARG);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_delete_to (count, key)
|
rl_vi_delete_to (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c;
|
int c;
|
|
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_stuff_char ('$');
|
rl_stuff_char ('$');
|
else if (vi_redoing)
|
else if (vi_redoing)
|
rl_stuff_char (_rl_vi_last_motion);
|
rl_stuff_char (_rl_vi_last_motion);
|
|
|
if (rl_vi_domove (key, &c))
|
if (rl_vi_domove (key, &c))
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* These are the motion commands that do not require adjusting the
|
/* These are the motion commands that do not require adjusting the
|
mark. */
|
mark. */
|
if ((strchr (" l|h^0bB", c) == 0) && (rl_mark < rl_end))
|
if ((strchr (" l|h^0bB", c) == 0) && (rl_mark < rl_end))
|
rl_mark++;
|
rl_mark++;
|
|
|
rl_kill_text (rl_point, rl_mark);
|
rl_kill_text (rl_point, rl_mark);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_change_to (count, key)
|
rl_vi_change_to (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c, start_pos;
|
int c, start_pos;
|
|
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_stuff_char ('$');
|
rl_stuff_char ('$');
|
else if (vi_redoing)
|
else if (vi_redoing)
|
rl_stuff_char (_rl_vi_last_motion);
|
rl_stuff_char (_rl_vi_last_motion);
|
|
|
start_pos = rl_point;
|
start_pos = rl_point;
|
|
|
if (rl_vi_domove (key, &c))
|
if (rl_vi_domove (key, &c))
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* These are the motion commands that do not require adjusting the
|
/* These are the motion commands that do not require adjusting the
|
mark. c[wW] are handled by special-case code in rl_vi_domove(),
|
mark. c[wW] are handled by special-case code in rl_vi_domove(),
|
and already leave the mark at the correct location. */
|
and already leave the mark at the correct location. */
|
if ((strchr (" l|hwW^0bB", c) == 0) && (rl_mark < rl_end))
|
if ((strchr (" l|hwW^0bB", c) == 0) && (rl_mark < rl_end))
|
rl_mark++;
|
rl_mark++;
|
|
|
/* The cursor never moves with c[wW]. */
|
/* The cursor never moves with c[wW]. */
|
if ((_rl_to_upper (c) == 'W') && rl_point < start_pos)
|
if ((_rl_to_upper (c) == 'W') && rl_point < start_pos)
|
rl_point = start_pos;
|
rl_point = start_pos;
|
|
|
if (vi_redoing)
|
if (vi_redoing)
|
{
|
{
|
if (vi_insert_buffer && *vi_insert_buffer)
|
if (vi_insert_buffer && *vi_insert_buffer)
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
rl_delete_text (rl_point, rl_mark);
|
rl_delete_text (rl_point, rl_mark);
|
if (vi_insert_buffer && *vi_insert_buffer)
|
if (vi_insert_buffer && *vi_insert_buffer)
|
{
|
{
|
rl_insert_text (vi_insert_buffer);
|
rl_insert_text (vi_insert_buffer);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
rl_begin_undo_group (); /* to make the `u' command work */
|
rl_begin_undo_group (); /* to make the `u' command work */
|
rl_kill_text (rl_point, rl_mark);
|
rl_kill_text (rl_point, rl_mark);
|
/* `C' does not save the text inserted for undoing or redoing. */
|
/* `C' does not save the text inserted for undoing or redoing. */
|
if (_rl_uppercase_p (key) == 0)
|
if (_rl_uppercase_p (key) == 0)
|
_rl_vi_doing_insert = 1;
|
_rl_vi_doing_insert = 1;
|
rl_vi_start_inserting (key, rl_numeric_arg, rl_arg_sign);
|
rl_vi_start_inserting (key, rl_numeric_arg, rl_arg_sign);
|
}
|
}
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_yank_to (count, key)
|
rl_vi_yank_to (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c, save;
|
int c, save;
|
|
|
save = rl_point;
|
save = rl_point;
|
if (_rl_uppercase_p (key))
|
if (_rl_uppercase_p (key))
|
rl_stuff_char ('$');
|
rl_stuff_char ('$');
|
|
|
if (rl_vi_domove (key, &c))
|
if (rl_vi_domove (key, &c))
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* These are the motion commands that do not require adjusting the
|
/* These are the motion commands that do not require adjusting the
|
mark. */
|
mark. */
|
if ((strchr (" l|h^0%bB", c) == 0) && (rl_mark < rl_end))
|
if ((strchr (" l|h^0%bB", c) == 0) && (rl_mark < rl_end))
|
rl_mark++;
|
rl_mark++;
|
|
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
rl_kill_text (rl_point, rl_mark);
|
rl_kill_text (rl_point, rl_mark);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
rl_do_undo ();
|
rl_do_undo ();
|
rl_point = save;
|
rl_point = save;
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_rubout (count, key)
|
rl_vi_rubout (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int p, opoint;
|
int p, opoint;
|
|
|
if (count < 0)
|
if (count < 0)
|
return (rl_vi_delete (-count, key));
|
return (rl_vi_delete (-count, key));
|
|
|
if (rl_point == 0)
|
if (rl_point == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
opoint = rl_point;
|
opoint = rl_point;
|
if (count > 1 && MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (count > 1 && MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
rl_backward_char (count, key);
|
rl_backward_char (count, key);
|
else if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
else if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
|
rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
|
else
|
else
|
rl_point -= count;
|
rl_point -= count;
|
|
|
if (rl_point < 0)
|
if (rl_point < 0)
|
rl_point = 0;
|
rl_point = 0;
|
|
|
rl_kill_text (rl_point, opoint);
|
rl_kill_text (rl_point, opoint);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_delete (count, key)
|
rl_vi_delete (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int end;
|
int end;
|
|
|
if (count < 0)
|
if (count < 0)
|
return (rl_vi_rubout (-count, key));
|
return (rl_vi_rubout (-count, key));
|
|
|
if (rl_end == 0)
|
if (rl_end == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
end = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
|
end = _rl_find_next_mbchar (rl_line_buffer, rl_point, count, MB_FIND_NONZERO);
|
else
|
else
|
end = rl_point + count;
|
end = rl_point + count;
|
|
|
if (end >= rl_end)
|
if (end >= rl_end)
|
end = rl_end;
|
end = rl_end;
|
|
|
rl_kill_text (rl_point, end);
|
rl_kill_text (rl_point, end);
|
|
|
if (rl_point > 0 && rl_point == rl_end)
|
if (rl_point > 0 && rl_point == rl_end)
|
rl_backward_char (1, key);
|
rl_backward_char (1, key);
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_back_to_indent (count, key)
|
rl_vi_back_to_indent (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_beg_of_line (1, key);
|
rl_beg_of_line (1, key);
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
|
rl_point++;
|
rl_point++;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_first_print (count, key)
|
rl_vi_first_print (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_vi_back_to_indent (1, key));
|
return (rl_vi_back_to_indent (1, key));
|
}
|
}
|
|
|
static int _rl_cs_dir, _rl_cs_orig_dir;
|
static int _rl_cs_dir, _rl_cs_orig_dir;
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int
|
static int
|
_rl_vi_callback_char_search (data)
|
_rl_vi_callback_char_search (data)
|
_rl_callback_generic_arg *data;
|
_rl_callback_generic_arg *data;
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
_rl_vi_last_search_mblen = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
|
_rl_vi_last_search_mblen = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
|
#else
|
#else
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
_rl_vi_last_search_char = rl_read_key ();
|
_rl_vi_last_search_char = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
#endif
|
#endif
|
|
|
_rl_callback_func = 0;
|
_rl_callback_func = 0;
|
_rl_want_redisplay = 1;
|
_rl_want_redisplay = 1;
|
|
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_mbchar, _rl_vi_last_search_mblen));
|
return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_mbchar, _rl_vi_last_search_mblen));
|
#else
|
#else
|
return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_char));
|
return (_rl_char_search_internal (data->count, _rl_cs_dir, _rl_vi_last_search_char));
|
#endif
|
#endif
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
rl_vi_char_search (count, key)
|
rl_vi_char_search (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
static char *target;
|
static char *target;
|
static int tlen;
|
static int tlen;
|
#else
|
#else
|
static char target;
|
static char target;
|
#endif
|
#endif
|
|
|
if (key == ';' || key == ',')
|
if (key == ';' || key == ',')
|
_rl_cs_dir = (key == ';') ? _rl_cs_orig_dir : -_rl_cs_orig_dir;
|
_rl_cs_dir = (key == ';') ? _rl_cs_orig_dir : -_rl_cs_orig_dir;
|
else
|
else
|
{
|
{
|
switch (key)
|
switch (key)
|
{
|
{
|
case 't':
|
case 't':
|
_rl_cs_orig_dir = _rl_cs_dir = FTO;
|
_rl_cs_orig_dir = _rl_cs_dir = FTO;
|
break;
|
break;
|
|
|
case 'T':
|
case 'T':
|
_rl_cs_orig_dir = _rl_cs_dir = BTO;
|
_rl_cs_orig_dir = _rl_cs_dir = BTO;
|
break;
|
break;
|
|
|
case 'f':
|
case 'f':
|
_rl_cs_orig_dir = _rl_cs_dir = FFIND;
|
_rl_cs_orig_dir = _rl_cs_dir = FFIND;
|
break;
|
break;
|
|
|
case 'F':
|
case 'F':
|
_rl_cs_orig_dir = _rl_cs_dir = BFIND;
|
_rl_cs_orig_dir = _rl_cs_dir = BFIND;
|
break;
|
break;
|
}
|
}
|
|
|
if (vi_redoing)
|
if (vi_redoing)
|
{
|
{
|
/* set target and tlen below */
|
/* set target and tlen below */
|
}
|
}
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
else if (RL_ISSTATE (RL_STATE_CALLBACK))
|
else if (RL_ISSTATE (RL_STATE_CALLBACK))
|
{
|
{
|
_rl_callback_data = _rl_callback_data_alloc (count);
|
_rl_callback_data = _rl_callback_data_alloc (count);
|
_rl_callback_data->i1 = _rl_cs_dir;
|
_rl_callback_data->i1 = _rl_cs_dir;
|
_rl_callback_func = _rl_vi_callback_char_search;
|
_rl_callback_func = _rl_vi_callback_char_search;
|
return (0);
|
return (0);
|
}
|
}
|
#endif
|
#endif
|
else
|
else
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
_rl_vi_last_search_mblen = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
|
_rl_vi_last_search_mblen = _rl_read_mbchar (_rl_vi_last_search_mbchar, MB_LEN_MAX);
|
#else
|
#else
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
_rl_vi_last_search_char = rl_read_key ();
|
_rl_vi_last_search_char = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
|
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
target = _rl_vi_last_search_mbchar;
|
target = _rl_vi_last_search_mbchar;
|
tlen = _rl_vi_last_search_mblen;
|
tlen = _rl_vi_last_search_mblen;
|
#else
|
#else
|
target = _rl_vi_last_search_char;
|
target = _rl_vi_last_search_char;
|
#endif
|
#endif
|
|
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
return (_rl_char_search_internal (count, _rl_cs_dir, target, tlen));
|
return (_rl_char_search_internal (count, _rl_cs_dir, target, tlen));
|
#else
|
#else
|
return (_rl_char_search_internal (count, _rl_cs_dir, target));
|
return (_rl_char_search_internal (count, _rl_cs_dir, target));
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Match brackets */
|
/* Match brackets */
|
int
|
int
|
rl_vi_match (ignore, key)
|
rl_vi_match (ignore, key)
|
int ignore, key;
|
int ignore, key;
|
{
|
{
|
int count = 1, brack, pos, tmp, pre;
|
int count = 1, brack, pos, tmp, pre;
|
|
|
pos = rl_point;
|
pos = rl_point;
|
if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
|
if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
|
{
|
{
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
{
|
{
|
while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
|
while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0)
|
{
|
{
|
pre = rl_point;
|
pre = rl_point;
|
rl_forward_char (1, key);
|
rl_forward_char (1, key);
|
if (pre == rl_point)
|
if (pre == rl_point)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
else
|
else
|
while ((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_point < rl_end - 1)
|
rl_forward_char (1, key);
|
rl_forward_char (1, key);
|
|
|
if (brack <= 0)
|
if (brack <= 0)
|
{
|
{
|
rl_point = pos;
|
rl_point = pos;
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
pos = rl_point;
|
pos = rl_point;
|
|
|
if (brack < 0)
|
if (brack < 0)
|
{
|
{
|
while (count)
|
while (count)
|
{
|
{
|
tmp = pos;
|
tmp = pos;
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
pos--;
|
pos--;
|
else
|
else
|
{
|
{
|
pos = _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY);
|
pos = _rl_find_prev_mbchar (rl_line_buffer, pos, MB_FIND_ANY);
|
if (tmp == pos)
|
if (tmp == pos)
|
pos--;
|
pos--;
|
}
|
}
|
if (pos >= 0)
|
if (pos >= 0)
|
{
|
{
|
int b = rl_vi_bracktype (rl_line_buffer[pos]);
|
int b = rl_vi_bracktype (rl_line_buffer[pos]);
|
if (b == -brack)
|
if (b == -brack)
|
count--;
|
count--;
|
else if (b == brack)
|
else if (b == brack)
|
count++;
|
count++;
|
}
|
}
|
else
|
else
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{ /* brack > 0 */
|
{ /* brack > 0 */
|
while (count)
|
while (count)
|
{
|
{
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
if (MB_CUR_MAX == 1 || rl_byte_oriented)
|
pos++;
|
pos++;
|
else
|
else
|
pos = _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY);
|
pos = _rl_find_next_mbchar (rl_line_buffer, pos, 1, MB_FIND_ANY);
|
|
|
if (pos < rl_end)
|
if (pos < rl_end)
|
{
|
{
|
int b = rl_vi_bracktype (rl_line_buffer[pos]);
|
int b = rl_vi_bracktype (rl_line_buffer[pos]);
|
if (b == -brack)
|
if (b == -brack)
|
count--;
|
count--;
|
else if (b == brack)
|
else if (b == brack)
|
count++;
|
count++;
|
}
|
}
|
else
|
else
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
}
|
}
|
rl_point = pos;
|
rl_point = pos;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_bracktype (c)
|
rl_vi_bracktype (c)
|
int c;
|
int c;
|
{
|
{
|
switch (c)
|
switch (c)
|
{
|
{
|
case '(': return 1;
|
case '(': return 1;
|
case ')': return -1;
|
case ')': return -1;
|
case '[': return 2;
|
case '[': return 2;
|
case ']': return -2;
|
case ']': return -2;
|
case '{': return 3;
|
case '{': return 3;
|
case '}': return -3;
|
case '}': return -3;
|
default: return 0;
|
default: return 0;
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
_rl_vi_change_char (count, c, mb)
|
_rl_vi_change_char (count, c, mb)
|
int count, c;
|
int count, c;
|
char *mb;
|
char *mb;
|
{
|
{
|
int p;
|
int p;
|
|
|
if (c == '\033' || c == CTRL ('C'))
|
if (c == '\033' || c == CTRL ('C'))
|
return -1;
|
return -1;
|
|
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
while (count-- && rl_point < rl_end)
|
while (count-- && rl_point < rl_end)
|
{
|
{
|
p = rl_point;
|
p = rl_point;
|
rl_vi_delete (1, c);
|
rl_vi_delete (1, c);
|
if (rl_point < p) /* Did we retreat at EOL? */
|
if (rl_point < p) /* Did we retreat at EOL? */
|
rl_point++;
|
rl_point++;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
rl_insert_text (mb);
|
rl_insert_text (mb);
|
else
|
else
|
#endif
|
#endif
|
_rl_insert_char (1, c);
|
_rl_insert_char (1, c);
|
}
|
}
|
|
|
/* The cursor shall be left on the last character changed. */
|
/* The cursor shall be left on the last character changed. */
|
rl_backward_char (1, c);
|
rl_backward_char (1, c);
|
|
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
static int
|
static int
|
_rl_vi_callback_getchar (mb, mblen)
|
_rl_vi_callback_getchar (mb, mblen)
|
char *mb;
|
char *mb;
|
int mblen;
|
int mblen;
|
{
|
{
|
int c;
|
int c;
|
|
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
c = rl_read_key ();
|
c = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
|
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
c = _rl_read_mbstring (c, mb, mblen);
|
c = _rl_read_mbstring (c, mb, mblen);
|
#endif
|
#endif
|
|
|
return c;
|
return c;
|
}
|
}
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int
|
static int
|
_rl_vi_callback_change_char (data)
|
_rl_vi_callback_change_char (data)
|
_rl_callback_generic_arg *data;
|
_rl_callback_generic_arg *data;
|
{
|
{
|
int c;
|
int c;
|
char mb[MB_LEN_MAX];
|
char mb[MB_LEN_MAX];
|
|
|
_rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
|
_rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
|
|
|
_rl_callback_func = 0;
|
_rl_callback_func = 0;
|
_rl_want_redisplay = 1;
|
_rl_want_redisplay = 1;
|
|
|
return (_rl_vi_change_char (data->count, c, mb));
|
return (_rl_vi_change_char (data->count, c, mb));
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
rl_vi_change_char (count, key)
|
rl_vi_change_char (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c;
|
int c;
|
char mb[MB_LEN_MAX];
|
char mb[MB_LEN_MAX];
|
|
|
if (vi_redoing)
|
if (vi_redoing)
|
{
|
{
|
c = _rl_vi_last_replacement;
|
c = _rl_vi_last_replacement;
|
mb[0] = c;
|
mb[0] = c;
|
mb[1] = '\0';
|
mb[1] = '\0';
|
}
|
}
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
else if (RL_ISSTATE (RL_STATE_CALLBACK))
|
else if (RL_ISSTATE (RL_STATE_CALLBACK))
|
{
|
{
|
_rl_callback_data = _rl_callback_data_alloc (count);
|
_rl_callback_data = _rl_callback_data_alloc (count);
|
_rl_callback_func = _rl_vi_callback_change_char;
|
_rl_callback_func = _rl_vi_callback_change_char;
|
return (0);
|
return (0);
|
}
|
}
|
#endif
|
#endif
|
else
|
else
|
_rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
|
_rl_vi_last_replacement = c = _rl_vi_callback_getchar (mb, MB_LEN_MAX);
|
|
|
return (_rl_vi_change_char (count, c, mb));
|
return (_rl_vi_change_char (count, c, mb));
|
}
|
}
|
|
|
int
|
int
|
rl_vi_subst (count, key)
|
rl_vi_subst (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
/* If we are redoing, rl_vi_change_to will stuff the last motion char */
|
/* If we are redoing, rl_vi_change_to will stuff the last motion char */
|
if (vi_redoing == 0)
|
if (vi_redoing == 0)
|
rl_stuff_char ((key == 'S') ? 'c' : 'l'); /* `S' == `cc', `s' == `cl' */
|
rl_stuff_char ((key == 'S') ? 'c' : 'l'); /* `S' == `cc', `s' == `cl' */
|
|
|
return (rl_vi_change_to (count, 'c'));
|
return (rl_vi_change_to (count, 'c'));
|
}
|
}
|
|
|
int
|
int
|
rl_vi_overstrike (count, key)
|
rl_vi_overstrike (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (_rl_vi_doing_insert == 0)
|
if (_rl_vi_doing_insert == 0)
|
{
|
{
|
_rl_vi_doing_insert = 1;
|
_rl_vi_doing_insert = 1;
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
}
|
}
|
|
|
if (count > 0)
|
if (count > 0)
|
{
|
{
|
_rl_overwrite_char (count, key);
|
_rl_overwrite_char (count, key);
|
vi_replace_count += count;
|
vi_replace_count += count;
|
}
|
}
|
|
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_overstrike_delete (count, key)
|
rl_vi_overstrike_delete (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int i, s;
|
int i, s;
|
|
|
for (i = 0; i < count; i++)
|
for (i = 0; i < count; i++)
|
{
|
{
|
if (vi_replace_count == 0)
|
if (vi_replace_count == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
break;
|
break;
|
}
|
}
|
s = rl_point;
|
s = rl_point;
|
|
|
if (rl_do_undo ())
|
if (rl_do_undo ())
|
vi_replace_count--;
|
vi_replace_count--;
|
|
|
if (rl_point == s)
|
if (rl_point == s)
|
rl_backward_char (1, key);
|
rl_backward_char (1, key);
|
}
|
}
|
|
|
if (vi_replace_count == 0 && _rl_vi_doing_insert)
|
if (vi_replace_count == 0 && _rl_vi_doing_insert)
|
{
|
{
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
rl_do_undo ();
|
rl_do_undo ();
|
_rl_vi_doing_insert = 0;
|
_rl_vi_doing_insert = 0;
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
int
|
int
|
rl_vi_replace (count, key)
|
rl_vi_replace (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int i;
|
int i;
|
|
|
vi_replace_count = 0;
|
vi_replace_count = 0;
|
|
|
if (!vi_replace_map)
|
if (!vi_replace_map)
|
{
|
{
|
vi_replace_map = rl_make_bare_keymap ();
|
vi_replace_map = rl_make_bare_keymap ();
|
|
|
for (i = ' '; i < KEYMAP_SIZE; i++)
|
for (i = ' '; i < KEYMAP_SIZE; i++)
|
vi_replace_map[i].function = rl_vi_overstrike;
|
vi_replace_map[i].function = rl_vi_overstrike;
|
|
|
vi_replace_map[RUBOUT].function = rl_vi_overstrike_delete;
|
vi_replace_map[RUBOUT].function = rl_vi_overstrike_delete;
|
vi_replace_map[ESC].function = rl_vi_movement_mode;
|
vi_replace_map[ESC].function = rl_vi_movement_mode;
|
vi_replace_map[RETURN].function = rl_newline;
|
vi_replace_map[RETURN].function = rl_newline;
|
vi_replace_map[NEWLINE].function = rl_newline;
|
vi_replace_map[NEWLINE].function = rl_newline;
|
|
|
/* If the normal vi insertion keymap has ^H bound to erase, do the
|
/* If the normal vi insertion keymap has ^H bound to erase, do the
|
same here. Probably should remove the assignment to RUBOUT up
|
same here. Probably should remove the assignment to RUBOUT up
|
there, but I don't think it will make a difference in real life. */
|
there, but I don't think it will make a difference in real life. */
|
if (vi_insertion_keymap[CTRL ('H')].type == ISFUNC &&
|
if (vi_insertion_keymap[CTRL ('H')].type == ISFUNC &&
|
vi_insertion_keymap[CTRL ('H')].function == rl_rubout)
|
vi_insertion_keymap[CTRL ('H')].function == rl_rubout)
|
vi_replace_map[CTRL ('H')].function = rl_vi_overstrike_delete;
|
vi_replace_map[CTRL ('H')].function = rl_vi_overstrike_delete;
|
|
|
}
|
}
|
_rl_keymap = vi_replace_map;
|
_rl_keymap = vi_replace_map;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/* Try to complete the word we are standing on or the word that ends with
|
/* 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
|
the previous character. A space matches everything. Word delimiters are
|
space and ;. */
|
space and ;. */
|
int
|
int
|
rl_vi_possible_completions()
|
rl_vi_possible_completions()
|
{
|
{
|
int save_pos = rl_point;
|
int save_pos = rl_point;
|
|
|
if (rl_line_buffer[rl_point] != ' ' && rl_line_buffer[rl_point] != ';')
|
if (rl_line_buffer[rl_point] != ' ' && rl_line_buffer[rl_point] != ';')
|
{
|
{
|
while (rl_point < rl_end && rl_line_buffer[rl_point] != ' ' &&
|
while (rl_point < rl_end && rl_line_buffer[rl_point] != ' ' &&
|
rl_line_buffer[rl_point] != ';')
|
rl_line_buffer[rl_point] != ';')
|
rl_point++;
|
rl_point++;
|
}
|
}
|
else if (rl_line_buffer[rl_point - 1] == ';')
|
else if (rl_line_buffer[rl_point - 1] == ';')
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return (0);
|
return (0);
|
}
|
}
|
|
|
rl_possible_completions ();
|
rl_possible_completions ();
|
rl_point = save_pos;
|
rl_point = save_pos;
|
|
|
return (0);
|
return (0);
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Functions to save and restore marks. */
|
/* Functions to save and restore marks. */
|
static int
|
static int
|
_rl_vi_set_mark ()
|
_rl_vi_set_mark ()
|
{
|
{
|
int ch;
|
int ch;
|
|
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
ch = rl_read_key ();
|
ch = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
|
|
if (ch < 'a' || ch > 'z')
|
if (ch < 'a' || ch > 'z')
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
ch -= 'a';
|
ch -= 'a';
|
vi_mark_chars[ch] = rl_point;
|
vi_mark_chars[ch] = rl_point;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int
|
static int
|
_rl_vi_callback_set_mark (data)
|
_rl_vi_callback_set_mark (data)
|
_rl_callback_generic_arg *data;
|
_rl_callback_generic_arg *data;
|
{
|
{
|
_rl_callback_func = 0;
|
_rl_callback_func = 0;
|
_rl_want_redisplay = 1;
|
_rl_want_redisplay = 1;
|
|
|
return (_rl_vi_set_mark ());
|
return (_rl_vi_set_mark ());
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
rl_vi_set_mark (count, key)
|
rl_vi_set_mark (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
if (RL_ISSTATE (RL_STATE_CALLBACK))
|
if (RL_ISSTATE (RL_STATE_CALLBACK))
|
{
|
{
|
_rl_callback_data = 0;
|
_rl_callback_data = 0;
|
_rl_callback_func = _rl_vi_callback_set_mark;
|
_rl_callback_func = _rl_vi_callback_set_mark;
|
return (0);
|
return (0);
|
}
|
}
|
#endif
|
#endif
|
|
|
return (_rl_vi_set_mark ());
|
return (_rl_vi_set_mark ());
|
}
|
}
|
|
|
static int
|
static int
|
_rl_vi_goto_mark ()
|
_rl_vi_goto_mark ()
|
{
|
{
|
int ch;
|
int ch;
|
|
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
ch = rl_read_key ();
|
ch = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
|
|
if (ch == '`')
|
if (ch == '`')
|
{
|
{
|
rl_point = rl_mark;
|
rl_point = rl_mark;
|
return 0;
|
return 0;
|
}
|
}
|
else if (ch < 'a' || ch > 'z')
|
else if (ch < 'a' || ch > 'z')
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
ch -= 'a';
|
ch -= 'a';
|
if (vi_mark_chars[ch] == -1)
|
if (vi_mark_chars[ch] == -1)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
return -1;
|
return -1;
|
}
|
}
|
rl_point = vi_mark_chars[ch];
|
rl_point = vi_mark_chars[ch];
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int
|
static int
|
_rl_vi_callback_goto_mark (data)
|
_rl_vi_callback_goto_mark (data)
|
_rl_callback_generic_arg *data;
|
_rl_callback_generic_arg *data;
|
{
|
{
|
_rl_callback_func = 0;
|
_rl_callback_func = 0;
|
_rl_want_redisplay = 1;
|
_rl_want_redisplay = 1;
|
|
|
return (_rl_vi_goto_mark ());
|
return (_rl_vi_goto_mark ());
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
rl_vi_goto_mark (count, key)
|
rl_vi_goto_mark (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
if (RL_ISSTATE (RL_STATE_CALLBACK))
|
if (RL_ISSTATE (RL_STATE_CALLBACK))
|
{
|
{
|
_rl_callback_data = 0;
|
_rl_callback_data = 0;
|
_rl_callback_func = _rl_vi_callback_goto_mark;
|
_rl_callback_func = _rl_vi_callback_goto_mark;
|
return (0);
|
return (0);
|
}
|
}
|
#endif
|
#endif
|
|
|
return (_rl_vi_goto_mark ());
|
return (_rl_vi_goto_mark ());
|
}
|
}
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
|
|
