/* readline.c -- a general facility for reading lines of input
|
/* readline.c -- a general facility for reading lines of input
|
with emacs style editing and completion. */
|
with emacs style editing and completion. */
|
|
|
/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
|
/* Copyright (C) 1987, 1989, 1992 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 1, or
|
as published by the Free Software Foundation; either version 1, 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,
|
675 Mass Ave, Cambridge, MA 02139, USA. */
|
675 Mass Ave, Cambridge, MA 02139, USA. */
|
#define READLINE_LIBRARY
|
#define READLINE_LIBRARY
|
|
|
#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>
|
#include "posixstat.h"
|
#include "posixstat.h"
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#if defined (HAVE_SYS_FILE_H)
|
#if defined (HAVE_SYS_FILE_H)
|
# include <sys/file.h>
|
# include <sys/file.h>
|
#endif /* HAVE_SYS_FILE_H */
|
#endif /* HAVE_SYS_FILE_H */
|
|
|
#if defined (HAVE_UNISTD_H)
|
#if defined (HAVE_UNISTD_H)
|
# include <unistd.h>
|
# include <unistd.h>
|
#endif /* HAVE_UNISTD_H */
|
#endif /* HAVE_UNISTD_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_LOCALE_H)
|
#if defined (HAVE_LOCALE_H)
|
# include <locale.h>
|
# include <locale.h>
|
#endif
|
#endif
|
|
|
#include <signal.h>
|
#include <signal.h>
|
#include <stdio.h>
|
#include <stdio.h>
|
#include "posixjmp.h"
|
#include "posixjmp.h"
|
|
|
/* System-specific feature definitions and include files. */
|
/* System-specific feature definitions and include files. */
|
#include "rldefs.h"
|
#include "rldefs.h"
|
|
|
#if defined (__EMX__)
|
#if defined (__EMX__)
|
# define INCL_DOSPROCESS
|
# define INCL_DOSPROCESS
|
# include <os2.h>
|
# include <os2.h>
|
#endif /* __EMX__ */
|
#endif /* __EMX__ */
|
|
|
/* Some standard library routines. */
|
/* Some standard library routines. */
|
#include "readline.h"
|
#include "readline.h"
|
#include "history.h"
|
#include "history.h"
|
|
|
#ifndef RL_LIBRARY_VERSION
|
#ifndef RL_LIBRARY_VERSION
|
# define RL_LIBRARY_VERSION "4.0"
|
# define RL_LIBRARY_VERSION "4.0"
|
#endif
|
#endif
|
|
|
/* Evaluates its arguments multiple times. */
|
/* Evaluates its arguments multiple times. */
|
#define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0)
|
#define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0)
|
|
|
/* NOTE: Functions and variables prefixed with `_rl_' are
|
/* NOTE: Functions and variables prefixed with `_rl_' are
|
pseudo-global: they are global so they can be shared
|
pseudo-global: they are global so they can be shared
|
between files in the readline library, but are not intended
|
between files in the readline library, but are not intended
|
to be visible to readline callers. */
|
to be visible to readline callers. */
|
|
|
/* Variables and functions imported from terminal.c */
|
/* Variables and functions imported from terminal.c */
|
extern int _rl_init_terminal_io ();
|
extern int _rl_init_terminal_io ();
|
extern void _rl_enable_meta_key ();
|
extern void _rl_enable_meta_key ();
|
#ifdef _MINIX
|
#ifdef _MINIX
|
extern void _rl_output_character_function ();
|
extern void _rl_output_character_function ();
|
#else
|
#else
|
extern int _rl_output_character_function ();
|
extern int _rl_output_character_function ();
|
#endif
|
#endif
|
|
|
extern int _rl_enable_meta;
|
extern int _rl_enable_meta;
|
extern int _rl_term_autowrap;
|
extern int _rl_term_autowrap;
|
extern int screenwidth, screenheight, screenchars;
|
extern int screenwidth, screenheight, screenchars;
|
|
|
/* Variables and functions imported from rltty.c. */
|
/* Variables and functions imported from rltty.c. */
|
extern void rl_prep_terminal (), rl_deprep_terminal ();
|
extern void rl_prep_terminal (), rl_deprep_terminal ();
|
extern void rltty_set_default_bindings ();
|
extern void rltty_set_default_bindings ();
|
|
|
/* Functions imported from util.c. */
|
/* Functions imported from util.c. */
|
extern void _rl_abort_internal ();
|
extern void _rl_abort_internal ();
|
extern void rl_extend_line_buffer ();
|
extern void rl_extend_line_buffer ();
|
extern int alphabetic ();
|
extern int alphabetic ();
|
|
|
/* Functions imported from bind.c. */
|
/* Functions imported from bind.c. */
|
extern void _rl_bind_if_unbound ();
|
extern void _rl_bind_if_unbound ();
|
|
|
/* Functions imported from input.c. */
|
/* Functions imported from input.c. */
|
extern int _rl_any_typein ();
|
extern int _rl_any_typein ();
|
extern void _rl_insert_typein ();
|
extern void _rl_insert_typein ();
|
extern int rl_read_key ();
|
extern int rl_read_key ();
|
|
|
/* Functions imported from nls.c */
|
/* Functions imported from nls.c */
|
extern int _rl_init_eightbit ();
|
extern int _rl_init_eightbit ();
|
|
|
/* Functions imported from shell.c */
|
/* Functions imported from shell.c */
|
extern char *get_env_value ();
|
extern char *get_env_value ();
|
|
|
/* External redisplay functions and variables from display.c */
|
/* External redisplay functions and variables from display.c */
|
extern void _rl_move_vert ();
|
extern void _rl_move_vert ();
|
extern void _rl_update_final ();
|
extern void _rl_update_final ();
|
extern void _rl_clear_to_eol ();
|
extern void _rl_clear_to_eol ();
|
extern void _rl_clear_screen ();
|
extern void _rl_clear_screen ();
|
extern void _rl_erase_entire_line ();
|
extern void _rl_erase_entire_line ();
|
|
|
extern void _rl_erase_at_end_of_line ();
|
extern void _rl_erase_at_end_of_line ();
|
extern void _rl_move_cursor_relative ();
|
extern void _rl_move_cursor_relative ();
|
|
|
extern int _rl_vis_botlin;
|
extern int _rl_vis_botlin;
|
extern int _rl_last_c_pos;
|
extern int _rl_last_c_pos;
|
extern int _rl_horizontal_scroll_mode;
|
extern int _rl_horizontal_scroll_mode;
|
extern int rl_display_fixed;
|
extern int rl_display_fixed;
|
extern int _rl_suppress_redisplay;
|
extern int _rl_suppress_redisplay;
|
extern char *rl_display_prompt;
|
extern char *rl_display_prompt;
|
|
|
/* Variables imported from complete.c. */
|
/* Variables imported from complete.c. */
|
extern char *rl_completer_word_break_characters;
|
extern char *rl_completer_word_break_characters;
|
extern char *rl_basic_word_break_characters;
|
extern char *rl_basic_word_break_characters;
|
extern int rl_completion_query_items;
|
extern int rl_completion_query_items;
|
extern int rl_complete_with_tilde_expansion;
|
extern int rl_complete_with_tilde_expansion;
|
|
|
/* Variables and functions from macro.c. */
|
/* Variables and functions from macro.c. */
|
extern void _rl_add_macro_char ();
|
extern void _rl_add_macro_char ();
|
extern void _rl_with_macro_input ();
|
extern void _rl_with_macro_input ();
|
extern int _rl_next_macro_key ();
|
extern int _rl_next_macro_key ();
|
extern int _rl_defining_kbd_macro;
|
extern int _rl_defining_kbd_macro;
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
/* Functions imported from vi_mode.c. */
|
/* Functions imported from vi_mode.c. */
|
extern void _rl_vi_set_last ();
|
extern void _rl_vi_set_last ();
|
extern void _rl_vi_reset_last ();
|
extern void _rl_vi_reset_last ();
|
extern void _rl_vi_done_inserting ();
|
extern void _rl_vi_done_inserting ();
|
extern int _rl_vi_textmod_command ();
|
extern int _rl_vi_textmod_command ();
|
extern void _rl_vi_initialize_line ();
|
extern void _rl_vi_initialize_line ();
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
|
|
extern UNDO_LIST *rl_undo_list;
|
extern UNDO_LIST *rl_undo_list;
|
extern int _rl_doing_an_undo;
|
extern int _rl_doing_an_undo;
|
|
|
/* Forward declarations used in this file. */
|
/* Forward declarations used in this file. */
|
void _rl_free_history_entry ();
|
void _rl_free_history_entry ();
|
|
|
int _rl_dispatch ();
|
int _rl_dispatch ();
|
int _rl_init_argument ();
|
int _rl_init_argument ();
|
|
|
static char *readline_internal ();
|
static char *readline_internal ();
|
static void readline_initialize_everything ();
|
static void readline_initialize_everything ();
|
static void start_using_history ();
|
static void start_using_history ();
|
static void bind_arrow_keys ();
|
static void bind_arrow_keys ();
|
|
|
#if !defined (__GO32__) || defined (HAVE_TERMIOS_H)
|
#if !defined (__GO32__) || defined (HAVE_TERMIOS_H)
|
static void readline_default_bindings ();
|
static void readline_default_bindings ();
|
#endif /* !__GO32__ */
|
#endif /* !__GO32__ */
|
|
|
#if defined (__GO32__)
|
#if defined (__GO32__)
|
# include <go32.h>
|
# include <go32.h>
|
# include <pc.h>
|
# include <pc.h>
|
# if !defined (__DJGPP__)
|
# if !defined (__DJGPP__)
|
# undef HANDLE_SIGNALS
|
# undef HANDLE_SIGNALS
|
# endif /* !__DJGPP__ */
|
# endif /* !__DJGPP__ */
|
#endif /* __GO32__ */
|
#endif /* __GO32__ */
|
|
|
extern char *xmalloc (), *xrealloc ();
|
extern char *xmalloc (), *xrealloc ();
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Line editing input utility */
|
/* Line editing input utility */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
char *rl_library_version = RL_LIBRARY_VERSION;
|
char *rl_library_version = RL_LIBRARY_VERSION;
|
|
|
/* A pointer to the keymap that is currently in use.
|
/* A pointer to the keymap that is currently in use.
|
By default, it is the standard emacs keymap. */
|
By default, it is the standard emacs keymap. */
|
Keymap _rl_keymap = emacs_standard_keymap;
|
Keymap _rl_keymap = emacs_standard_keymap;
|
|
|
/* The current style of editing. */
|
/* The current style of editing. */
|
int rl_editing_mode = emacs_mode;
|
int rl_editing_mode = emacs_mode;
|
|
|
/* Non-zero if we called this function from _rl_dispatch(). It's present
|
/* Non-zero if we called this function from _rl_dispatch(). It's present
|
so functions can find out whether they were called from a key binding
|
so functions can find out whether they were called from a key binding
|
or directly from an application. */
|
or directly from an application. */
|
int rl_dispatching;
|
int rl_dispatching;
|
|
|
/* Non-zero if the previous command was a kill command. */
|
/* Non-zero if the previous command was a kill command. */
|
int _rl_last_command_was_kill = 0;
|
int _rl_last_command_was_kill = 0;
|
|
|
/* The current value of the numeric argument specified by the user. */
|
/* The current value of the numeric argument specified by the user. */
|
int rl_numeric_arg = 1;
|
int rl_numeric_arg = 1;
|
|
|
/* Non-zero if an argument was typed. */
|
/* Non-zero if an argument was typed. */
|
int rl_explicit_arg = 0;
|
int rl_explicit_arg = 0;
|
|
|
/* Temporary value used while generating the argument. */
|
/* Temporary value used while generating the argument. */
|
int rl_arg_sign = 1;
|
int rl_arg_sign = 1;
|
|
|
/* Non-zero means we have been called at least once before. */
|
/* Non-zero means we have been called at least once before. */
|
static int rl_initialized;
|
static int rl_initialized;
|
|
|
/* If non-zero, this program is running in an EMACS buffer. */
|
/* If non-zero, this program is running in an EMACS buffer. */
|
static int running_in_emacs;
|
static int running_in_emacs;
|
|
|
/* The current offset in the current input line. */
|
/* The current offset in the current input line. */
|
int rl_point;
|
int rl_point;
|
|
|
/* Mark in the current input line. */
|
/* Mark in the current input line. */
|
int rl_mark;
|
int rl_mark;
|
|
|
/* Length of the current input line. */
|
/* Length of the current input line. */
|
int rl_end;
|
int rl_end;
|
|
|
/* Make this non-zero to return the current input_line. */
|
/* Make this non-zero to return the current input_line. */
|
int rl_done;
|
int rl_done;
|
|
|
/* The last function executed by readline. */
|
/* The last function executed by readline. */
|
Function *rl_last_func = (Function *)NULL;
|
Function *rl_last_func = (Function *)NULL;
|
|
|
/* Top level environment for readline_internal (). */
|
/* Top level environment for readline_internal (). */
|
procenv_t readline_top_level;
|
procenv_t readline_top_level;
|
|
|
/* The streams we interact with. */
|
/* The streams we interact with. */
|
FILE *_rl_in_stream, *_rl_out_stream;
|
FILE *_rl_in_stream, *_rl_out_stream;
|
|
|
/* The names of the streams that we do input and output to. */
|
/* The names of the streams that we do input and output to. */
|
FILE *rl_instream = (FILE *)NULL;
|
FILE *rl_instream = (FILE *)NULL;
|
FILE *rl_outstream = (FILE *)NULL;
|
FILE *rl_outstream = (FILE *)NULL;
|
|
|
/* Non-zero means echo characters as they are read. */
|
/* Non-zero means echo characters as they are read. */
|
int readline_echoing_p = 1;
|
int readline_echoing_p = 1;
|
|
|
/* Current prompt. */
|
/* Current prompt. */
|
char *rl_prompt;
|
char *rl_prompt;
|
int rl_visible_prompt_length = 0;
|
int rl_visible_prompt_length = 0;
|
|
|
/* The number of characters read in order to type this complete command. */
|
/* The number of characters read in order to type this complete command. */
|
int rl_key_sequence_length = 0;
|
int rl_key_sequence_length = 0;
|
|
|
/* If non-zero, then this is the address of a function to call just
|
/* If non-zero, then this is the address of a function to call just
|
before readline_internal_setup () prints the first prompt. */
|
before readline_internal_setup () prints the first prompt. */
|
Function *rl_startup_hook = (Function *)NULL;
|
Function *rl_startup_hook = (Function *)NULL;
|
|
|
/* If non-zero, this is the address of a function to call just before
|
/* If non-zero, this is the address of a function to call just before
|
readline_internal_setup () returns and readline_internal starts
|
readline_internal_setup () returns and readline_internal starts
|
reading input characters. */
|
reading input characters. */
|
Function *rl_pre_input_hook = (Function *)NULL;
|
Function *rl_pre_input_hook = (Function *)NULL;
|
|
|
/* What we use internally. You should always refer to RL_LINE_BUFFER. */
|
/* What we use internally. You should always refer to RL_LINE_BUFFER. */
|
static char *the_line;
|
static char *the_line;
|
|
|
/* The character that can generate an EOF. Really read from
|
/* The character that can generate an EOF. Really read from
|
the terminal driver... just defaulted here. */
|
the terminal driver... just defaulted here. */
|
int _rl_eof_char = CTRL ('D');
|
int _rl_eof_char = CTRL ('D');
|
|
|
/* Non-zero makes this the next keystroke to read. */
|
/* Non-zero makes this the next keystroke to read. */
|
int rl_pending_input = 0;
|
int rl_pending_input = 0;
|
|
|
/* Pointer to a useful terminal name. */
|
/* Pointer to a useful terminal name. */
|
char *rl_terminal_name = (char *)NULL;
|
char *rl_terminal_name = (char *)NULL;
|
|
|
/* Non-zero means to always use horizontal scrolling in line display. */
|
/* Non-zero means to always use horizontal scrolling in line display. */
|
int _rl_horizontal_scroll_mode = 0;
|
int _rl_horizontal_scroll_mode = 0;
|
|
|
/* Non-zero means to display an asterisk at the starts of history lines
|
/* Non-zero means to display an asterisk at the starts of history lines
|
which have been modified. */
|
which have been modified. */
|
int _rl_mark_modified_lines = 0;
|
int _rl_mark_modified_lines = 0;
|
|
|
/* The style of `bell' notification preferred. This can be set to NO_BELL,
|
/* The style of `bell' notification preferred. This can be set to NO_BELL,
|
AUDIBLE_BELL, or VISIBLE_BELL. */
|
AUDIBLE_BELL, or VISIBLE_BELL. */
|
int _rl_bell_preference = AUDIBLE_BELL;
|
int _rl_bell_preference = AUDIBLE_BELL;
|
|
|
/* String inserted into the line by rl_insert_comment (). */
|
/* String inserted into the line by rl_insert_comment (). */
|
char *_rl_comment_begin;
|
char *_rl_comment_begin;
|
|
|
/* Keymap holding the function currently being executed. */
|
/* Keymap holding the function currently being executed. */
|
Keymap rl_executing_keymap;
|
Keymap rl_executing_keymap;
|
|
|
/* Non-zero means to erase entire line, including prompt, on empty input lines. */
|
/* Non-zero means to erase entire line, including prompt, on empty input lines. */
|
int rl_erase_empty_line = 0;
|
int rl_erase_empty_line = 0;
|
|
|
/* Line buffer and maintenence. */
|
/* Line buffer and maintenence. */
|
char *rl_line_buffer = (char *)NULL;
|
char *rl_line_buffer = (char *)NULL;
|
int rl_line_buffer_len = 0;
|
int rl_line_buffer_len = 0;
|
|
|
/* Forward declarations used by the display and termcap code. */
|
/* Forward declarations used by the display and termcap code. */
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* `Forward' declarations */
|
/* `Forward' declarations */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Non-zero means do not parse any lines other than comments and
|
/* Non-zero means do not parse any lines other than comments and
|
parser directives. */
|
parser directives. */
|
unsigned char _rl_parsing_conditionalized_out = 0;
|
unsigned char _rl_parsing_conditionalized_out = 0;
|
|
|
/* Non-zero means to convert characters with the meta bit set to
|
/* Non-zero means to convert characters with the meta bit set to
|
escape-prefixed characters so we can indirect through
|
escape-prefixed characters so we can indirect through
|
emacs_meta_keymap or vi_escape_keymap. */
|
emacs_meta_keymap or vi_escape_keymap. */
|
int _rl_convert_meta_chars_to_ascii = 1;
|
int _rl_convert_meta_chars_to_ascii = 1;
|
|
|
/* Non-zero means to output characters with the meta bit set directly
|
/* Non-zero means to output characters with the meta bit set directly
|
rather than as a meta-prefixed escape sequence. */
|
rather than as a meta-prefixed escape sequence. */
|
int _rl_output_meta_chars = 0;
|
int _rl_output_meta_chars = 0;
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Top Level Functions */
|
/* Top Level Functions */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Non-zero means treat 0200 bit in terminal input as Meta bit. */
|
/* Non-zero means treat 0200 bit in terminal input as Meta bit. */
|
int _rl_meta_flag = 0; /* Forward declaration */
|
int _rl_meta_flag = 0; /* Forward declaration */
|
|
|
/* Read a line of input. Prompt with PROMPT. An empty PROMPT means
|
/* Read a line of input. Prompt with PROMPT. An empty PROMPT means
|
none. A return value of NULL means that EOF was encountered. */
|
none. A return value of NULL means that EOF was encountered. */
|
char *
|
char *
|
readline (prompt)
|
readline (prompt)
|
char *prompt;
|
char *prompt;
|
{
|
{
|
char *value;
|
char *value;
|
|
|
rl_prompt = prompt;
|
rl_prompt = prompt;
|
|
|
/* If we are at EOF return a NULL string. */
|
/* If we are at EOF return a NULL string. */
|
if (rl_pending_input == EOF)
|
if (rl_pending_input == EOF)
|
{
|
{
|
rl_pending_input = 0;
|
rl_pending_input = 0;
|
return ((char *)NULL);
|
return ((char *)NULL);
|
}
|
}
|
|
|
rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
|
rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
|
|
|
rl_initialize ();
|
rl_initialize ();
|
(*rl_prep_term_function) (_rl_meta_flag);
|
(*rl_prep_term_function) (_rl_meta_flag);
|
|
|
#if defined (HANDLE_SIGNALS)
|
#if defined (HANDLE_SIGNALS)
|
rl_set_signals ();
|
rl_set_signals ();
|
#endif
|
#endif
|
|
|
value = readline_internal ();
|
value = readline_internal ();
|
(*rl_deprep_term_function) ();
|
(*rl_deprep_term_function) ();
|
|
|
#if defined (HANDLE_SIGNALS)
|
#if defined (HANDLE_SIGNALS)
|
rl_clear_signals ();
|
rl_clear_signals ();
|
#endif
|
#endif
|
|
|
return (value);
|
return (value);
|
}
|
}
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
# define STATIC_CALLBACK
|
# define STATIC_CALLBACK
|
#else
|
#else
|
# define STATIC_CALLBACK static
|
# define STATIC_CALLBACK static
|
#endif
|
#endif
|
|
|
STATIC_CALLBACK void
|
STATIC_CALLBACK void
|
readline_internal_setup ()
|
readline_internal_setup ()
|
{
|
{
|
_rl_in_stream = rl_instream;
|
_rl_in_stream = rl_instream;
|
_rl_out_stream = rl_outstream;
|
_rl_out_stream = rl_outstream;
|
|
|
if (rl_startup_hook)
|
if (rl_startup_hook)
|
(*rl_startup_hook) ();
|
(*rl_startup_hook) ();
|
|
|
if (readline_echoing_p == 0)
|
if (readline_echoing_p == 0)
|
{
|
{
|
if (rl_prompt)
|
if (rl_prompt)
|
{
|
{
|
fprintf (_rl_out_stream, "%s", rl_prompt);
|
fprintf (_rl_out_stream, "%s", rl_prompt);
|
fflush (_rl_out_stream);
|
fflush (_rl_out_stream);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
rl_on_new_line ();
|
rl_on_new_line ();
|
(*rl_redisplay_function) ();
|
(*rl_redisplay_function) ();
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode)
|
if (rl_editing_mode == vi_mode)
|
rl_vi_insertion_mode (1, 0);
|
rl_vi_insertion_mode (1, 0);
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
}
|
}
|
|
|
if (rl_pre_input_hook)
|
if (rl_pre_input_hook)
|
(*rl_pre_input_hook) ();
|
(*rl_pre_input_hook) ();
|
}
|
}
|
|
|
STATIC_CALLBACK char *
|
STATIC_CALLBACK char *
|
readline_internal_teardown (eof)
|
readline_internal_teardown (eof)
|
int eof;
|
int eof;
|
{
|
{
|
char *temp;
|
char *temp;
|
HIST_ENTRY *entry;
|
HIST_ENTRY *entry;
|
|
|
/* Restore the original of this history line, iff the line that we
|
/* Restore the original of this history line, iff the line that we
|
are editing was originally in the history, AND the line has changed. */
|
are editing was originally in the history, AND the line has changed. */
|
entry = current_history ();
|
entry = current_history ();
|
|
|
if (entry && rl_undo_list)
|
if (entry && rl_undo_list)
|
{
|
{
|
temp = savestring (the_line);
|
temp = savestring (the_line);
|
rl_revert_line (1, 0);
|
rl_revert_line (1, 0);
|
entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);
|
entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);
|
_rl_free_history_entry (entry);
|
_rl_free_history_entry (entry);
|
|
|
strcpy (the_line, temp);
|
strcpy (the_line, temp);
|
free (temp);
|
free (temp);
|
}
|
}
|
|
|
/* At any rate, it is highly likely that this line has an undo list. Get
|
/* At any rate, it is highly likely that this line has an undo list. Get
|
rid of it now. */
|
rid of it now. */
|
if (rl_undo_list)
|
if (rl_undo_list)
|
free_undo_list ();
|
free_undo_list ();
|
|
|
return (eof ? (char *)NULL : savestring (the_line));
|
return (eof ? (char *)NULL : savestring (the_line));
|
}
|
}
|
|
|
STATIC_CALLBACK int
|
STATIC_CALLBACK int
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
readline_internal_char ()
|
readline_internal_char ()
|
#else
|
#else
|
readline_internal_charloop ()
|
readline_internal_charloop ()
|
#endif
|
#endif
|
{
|
{
|
static int lastc, eof_found;
|
static int lastc, eof_found;
|
int c, code, lk;
|
int c, code, lk;
|
|
|
lastc = -1;
|
lastc = -1;
|
eof_found = 0;
|
eof_found = 0;
|
|
|
#if !defined (READLINE_CALLBACKS)
|
#if !defined (READLINE_CALLBACKS)
|
while (rl_done == 0)
|
while (rl_done == 0)
|
{
|
{
|
#endif
|
#endif
|
lk = _rl_last_command_was_kill;
|
lk = _rl_last_command_was_kill;
|
|
|
code = setjmp (readline_top_level);
|
code = setjmp (readline_top_level);
|
|
|
if (code)
|
if (code)
|
(*rl_redisplay_function) ();
|
(*rl_redisplay_function) ();
|
|
|
if (rl_pending_input == 0)
|
if (rl_pending_input == 0)
|
{
|
{
|
/* Then initialize the argument and number of keys read. */
|
/* Then initialize the argument and number of keys read. */
|
_rl_init_argument ();
|
_rl_init_argument ();
|
rl_key_sequence_length = 0;
|
rl_key_sequence_length = 0;
|
}
|
}
|
|
|
c = rl_read_key ();
|
c = rl_read_key ();
|
|
|
/* EOF typed to a non-blank line is a <NL>. */
|
/* EOF typed to a non-blank line is a <NL>. */
|
if (c == EOF && rl_end)
|
if (c == EOF && rl_end)
|
c = NEWLINE;
|
c = NEWLINE;
|
|
|
/* The character _rl_eof_char typed to blank line, and not as the
|
/* The character _rl_eof_char typed to blank line, and not as the
|
previous character is interpreted as EOF. */
|
previous character is interpreted as EOF. */
|
if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
|
if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)
|
{
|
{
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
return (rl_done = 1);
|
return (rl_done = 1);
|
#else
|
#else
|
eof_found = 1;
|
eof_found = 1;
|
break;
|
break;
|
#endif
|
#endif
|
}
|
}
|
|
|
lastc = c;
|
lastc = c;
|
_rl_dispatch (c, _rl_keymap);
|
_rl_dispatch (c, _rl_keymap);
|
|
|
/* If there was no change in _rl_last_command_was_kill, then no kill
|
/* If there was no change in _rl_last_command_was_kill, then no kill
|
has taken place. Note that if input is pending we are reading
|
has taken place. Note that if input is pending we are reading
|
a prefix command, so nothing has changed yet. */
|
a prefix command, so nothing has changed yet. */
|
if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)
|
if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)
|
_rl_last_command_was_kill = 0;
|
_rl_last_command_was_kill = 0;
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
/* In vi mode, when you exit insert mode, the cursor moves back
|
/* In vi mode, when you exit insert mode, the cursor moves back
|
over the previous character. We explicitly check for that here. */
|
over the previous character. We explicitly check for that here. */
|
if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
|
if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)
|
rl_vi_check ();
|
rl_vi_check ();
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
|
|
if (rl_done == 0)
|
if (rl_done == 0)
|
(*rl_redisplay_function) ();
|
(*rl_redisplay_function) ();
|
|
|
/* If the application writer has told us to erase the entire line if
|
/* If the application writer has told us to erase the entire line if
|
the only character typed was something bound to rl_newline, do so. */
|
the only character typed was something bound to rl_newline, do so. */
|
if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&
|
if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&
|
rl_point == 0 && rl_end == 0)
|
rl_point == 0 && rl_end == 0)
|
_rl_erase_entire_line ();
|
_rl_erase_entire_line ();
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
return 0;
|
return 0;
|
#else
|
#else
|
}
|
}
|
|
|
return (eof_found);
|
return (eof_found);
|
#endif
|
#endif
|
}
|
}
|
|
|
#if defined (READLINE_CALLBACKS)
|
#if defined (READLINE_CALLBACKS)
|
static int
|
static int
|
readline_internal_charloop ()
|
readline_internal_charloop ()
|
{
|
{
|
int eof = 1;
|
int eof = 1;
|
|
|
while (rl_done == 0)
|
while (rl_done == 0)
|
eof = readline_internal_char ();
|
eof = readline_internal_char ();
|
return (eof);
|
return (eof);
|
}
|
}
|
#endif /* READLINE_CALLBACKS */
|
#endif /* READLINE_CALLBACKS */
|
|
|
/* Read a line of input from the global rl_instream, doing output on
|
/* Read a line of input from the global rl_instream, doing output on
|
the global rl_outstream.
|
the global rl_outstream.
|
If rl_prompt is non-null, then that is our prompt. */
|
If rl_prompt is non-null, then that is our prompt. */
|
static char *
|
static char *
|
readline_internal ()
|
readline_internal ()
|
{
|
{
|
int eof;
|
int eof;
|
|
|
readline_internal_setup ();
|
readline_internal_setup ();
|
eof = readline_internal_charloop ();
|
eof = readline_internal_charloop ();
|
return (readline_internal_teardown (eof));
|
return (readline_internal_teardown (eof));
|
}
|
}
|
|
|
void
|
void
|
_rl_init_line_state ()
|
_rl_init_line_state ()
|
{
|
{
|
rl_point = rl_end = 0;
|
rl_point = rl_end = 0;
|
the_line = rl_line_buffer;
|
the_line = rl_line_buffer;
|
the_line[0] = 0;
|
the_line[0] = 0;
|
}
|
}
|
|
|
void
|
void
|
_rl_set_the_line ()
|
_rl_set_the_line ()
|
{
|
{
|
the_line = rl_line_buffer;
|
the_line = rl_line_buffer;
|
}
|
}
|
|
|
/* Do the command associated with KEY in MAP.
|
/* Do the command associated with KEY in MAP.
|
If the associated command is really a keymap, then read
|
If the associated command is really a keymap, then read
|
another key, and dispatch into that map. */
|
another key, and dispatch into that map. */
|
int
|
int
|
_rl_dispatch (key, map)
|
_rl_dispatch (key, map)
|
register int key;
|
register int key;
|
Keymap map;
|
Keymap map;
|
{
|
{
|
int r, newkey;
|
int r, newkey;
|
char *macro;
|
char *macro;
|
Function *func;
|
Function *func;
|
|
|
if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
|
if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)
|
{
|
{
|
if (map[ESC].type == ISKMAP)
|
if (map[ESC].type == ISKMAP)
|
{
|
{
|
if (_rl_defining_kbd_macro)
|
if (_rl_defining_kbd_macro)
|
_rl_add_macro_char (ESC);
|
_rl_add_macro_char (ESC);
|
map = FUNCTION_TO_KEYMAP (map, ESC);
|
map = FUNCTION_TO_KEYMAP (map, ESC);
|
key = UNMETA (key);
|
key = UNMETA (key);
|
rl_key_sequence_length += 2;
|
rl_key_sequence_length += 2;
|
return (_rl_dispatch (key, map));
|
return (_rl_dispatch (key, map));
|
}
|
}
|
else
|
else
|
ding ();
|
ding ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (_rl_defining_kbd_macro)
|
if (_rl_defining_kbd_macro)
|
_rl_add_macro_char (key);
|
_rl_add_macro_char (key);
|
|
|
r = 0;
|
r = 0;
|
switch (map[key].type)
|
switch (map[key].type)
|
{
|
{
|
case ISFUNC:
|
case ISFUNC:
|
func = map[key].function;
|
func = map[key].function;
|
if (func != (Function *)NULL)
|
if (func != (Function *)NULL)
|
{
|
{
|
/* Special case rl_do_lowercase_version (). */
|
/* Special case rl_do_lowercase_version (). */
|
if (func == rl_do_lowercase_version)
|
if (func == rl_do_lowercase_version)
|
return (_rl_dispatch (_rl_to_lower (key), map));
|
return (_rl_dispatch (_rl_to_lower (key), map));
|
|
|
rl_executing_keymap = map;
|
rl_executing_keymap = map;
|
|
|
#if 0
|
#if 0
|
_rl_suppress_redisplay = (map[key].function == rl_insert) && _rl_input_available ();
|
_rl_suppress_redisplay = (map[key].function == rl_insert) && _rl_input_available ();
|
#endif
|
#endif
|
|
|
rl_dispatching = 1;
|
rl_dispatching = 1;
|
r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
|
r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
|
rl_dispatching = 0;
|
rl_dispatching = 0;
|
|
|
/* If we have input pending, then the last command was a prefix
|
/* If we have input pending, then the last command was a prefix
|
command. Don't change the state of rl_last_func. Otherwise,
|
command. Don't change the state of rl_last_func. Otherwise,
|
remember the last command executed in this variable. */
|
remember the last command executed in this variable. */
|
if (!rl_pending_input && map[key].function != rl_digit_argument)
|
if (!rl_pending_input && map[key].function != rl_digit_argument)
|
rl_last_func = map[key].function;
|
rl_last_func = map[key].function;
|
}
|
}
|
else
|
else
|
{
|
{
|
_rl_abort_internal ();
|
_rl_abort_internal ();
|
return -1;
|
return -1;
|
}
|
}
|
break;
|
break;
|
|
|
case ISKMAP:
|
case ISKMAP:
|
if (map[key].function != (Function *)NULL)
|
if (map[key].function != (Function *)NULL)
|
{
|
{
|
rl_key_sequence_length++;
|
rl_key_sequence_length++;
|
newkey = rl_read_key ();
|
newkey = rl_read_key ();
|
r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));
|
r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));
|
}
|
}
|
else
|
else
|
{
|
{
|
_rl_abort_internal ();
|
_rl_abort_internal ();
|
return -1;
|
return -1;
|
}
|
}
|
break;
|
break;
|
|
|
case ISMACR:
|
case ISMACR:
|
if (map[key].function != (Function *)NULL)
|
if (map[key].function != (Function *)NULL)
|
{
|
{
|
macro = savestring ((char *)map[key].function);
|
macro = savestring ((char *)map[key].function);
|
_rl_with_macro_input (macro);
|
_rl_with_macro_input (macro);
|
return 0;
|
return 0;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
|
if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&
|
_rl_vi_textmod_command (key))
|
_rl_vi_textmod_command (key))
|
_rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
|
_rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);
|
#endif
|
#endif
|
return (r);
|
return (r);
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Initializations */
|
/* Initializations */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Initialize readline (and terminal if not already). */
|
/* Initialize readline (and terminal if not already). */
|
int
|
int
|
rl_initialize ()
|
rl_initialize ()
|
{
|
{
|
/* If we have never been called before, initialize the
|
/* If we have never been called before, initialize the
|
terminal and data structures. */
|
terminal and data structures. */
|
if (!rl_initialized)
|
if (!rl_initialized)
|
{
|
{
|
readline_initialize_everything ();
|
readline_initialize_everything ();
|
rl_initialized++;
|
rl_initialized++;
|
}
|
}
|
|
|
/* Initalize the current line information. */
|
/* Initalize the current line information. */
|
_rl_init_line_state ();
|
_rl_init_line_state ();
|
|
|
/* We aren't done yet. We haven't even gotten started yet! */
|
/* We aren't done yet. We haven't even gotten started yet! */
|
rl_done = 0;
|
rl_done = 0;
|
|
|
/* Tell the history routines what is going on. */
|
/* Tell the history routines what is going on. */
|
start_using_history ();
|
start_using_history ();
|
|
|
/* Make the display buffer match the state of the line. */
|
/* Make the display buffer match the state of the line. */
|
rl_reset_line_state ();
|
rl_reset_line_state ();
|
|
|
/* No such function typed yet. */
|
/* No such function typed yet. */
|
rl_last_func = (Function *)NULL;
|
rl_last_func = (Function *)NULL;
|
|
|
/* Parsing of key-bindings begins in an enabled state. */
|
/* Parsing of key-bindings begins in an enabled state. */
|
_rl_parsing_conditionalized_out = 0;
|
_rl_parsing_conditionalized_out = 0;
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode)
|
if (rl_editing_mode == vi_mode)
|
_rl_vi_initialize_line ();
|
_rl_vi_initialize_line ();
|
#endif
|
#endif
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if defined (__EMX__)
|
#if defined (__EMX__)
|
static void
|
static void
|
_emx_build_environ ()
|
_emx_build_environ ()
|
{
|
{
|
TIB *tibp;
|
TIB *tibp;
|
PIB *pibp;
|
PIB *pibp;
|
char *t, **tp;
|
char *t, **tp;
|
int c;
|
int c;
|
|
|
DosGetInfoBlocks (&tibp, &pibp);
|
DosGetInfoBlocks (&tibp, &pibp);
|
t = pibp->pib_pchenv;
|
t = pibp->pib_pchenv;
|
for (c = 1; *t; c++)
|
for (c = 1; *t; c++)
|
t += strlen (t) + 1;
|
t += strlen (t) + 1;
|
tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));
|
tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));
|
t = pibp->pib_pchenv;
|
t = pibp->pib_pchenv;
|
while (*t)
|
while (*t)
|
{
|
{
|
*tp++ = t;
|
*tp++ = t;
|
t += strlen (t) + 1;
|
t += strlen (t) + 1;
|
}
|
}
|
*tp = 0;
|
*tp = 0;
|
}
|
}
|
#endif /* __EMX__ */
|
#endif /* __EMX__ */
|
|
|
/* Initialize the entire state of the world. */
|
/* Initialize the entire state of the world. */
|
static void
|
static void
|
readline_initialize_everything ()
|
readline_initialize_everything ()
|
{
|
{
|
#if defined (__EMX__)
|
#if defined (__EMX__)
|
if (environ == 0)
|
if (environ == 0)
|
_emx_build_environ ();
|
_emx_build_environ ();
|
#endif
|
#endif
|
|
|
/* Find out if we are running in Emacs. */
|
/* Find out if we are running in Emacs. */
|
running_in_emacs = get_env_value ("EMACS") != (char *)0;
|
running_in_emacs = get_env_value ("EMACS") != (char *)0;
|
|
|
/* Set up input and output if they are not already set up. */
|
/* Set up input and output if they are not already set up. */
|
if (!rl_instream)
|
if (!rl_instream)
|
rl_instream = stdin;
|
rl_instream = stdin;
|
|
|
if (!rl_outstream)
|
if (!rl_outstream)
|
rl_outstream = stdout;
|
rl_outstream = stdout;
|
|
|
/* Bind _rl_in_stream and _rl_out_stream immediately. These values
|
/* Bind _rl_in_stream and _rl_out_stream immediately. These values
|
may change, but they may also be used before readline_internal ()
|
may change, but they may also be used before readline_internal ()
|
is called. */
|
is called. */
|
_rl_in_stream = rl_instream;
|
_rl_in_stream = rl_instream;
|
_rl_out_stream = rl_outstream;
|
_rl_out_stream = rl_outstream;
|
|
|
/* Allocate data structures. */
|
/* Allocate data structures. */
|
if (rl_line_buffer == 0)
|
if (rl_line_buffer == 0)
|
rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
|
rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
|
|
|
/* Initialize the terminal interface. */
|
/* Initialize the terminal interface. */
|
_rl_init_terminal_io ((char *)NULL);
|
_rl_init_terminal_io ((char *)NULL);
|
|
|
#if !defined (__GO32__) || defined (HAVE_TERMIOS_H)
|
#if !defined (__GO32__) || defined (HAVE_TERMIOS_H)
|
/* Bind tty characters to readline functions. */
|
/* Bind tty characters to readline functions. */
|
readline_default_bindings ();
|
readline_default_bindings ();
|
#endif /* !__GO32__ || HAVE_TERMIOS_H */
|
#endif /* !__GO32__ || HAVE_TERMIOS_H */
|
|
|
/* Initialize the function names. */
|
/* Initialize the function names. */
|
rl_initialize_funmap ();
|
rl_initialize_funmap ();
|
|
|
/* Decide whether we should automatically go into eight-bit mode. */
|
/* Decide whether we should automatically go into eight-bit mode. */
|
_rl_init_eightbit ();
|
_rl_init_eightbit ();
|
|
|
/* Read in the init file. */
|
/* Read in the init file. */
|
rl_read_init_file ((char *)NULL);
|
rl_read_init_file ((char *)NULL);
|
|
|
/* XXX */
|
/* XXX */
|
if (_rl_horizontal_scroll_mode && _rl_term_autowrap)
|
if (_rl_horizontal_scroll_mode && _rl_term_autowrap)
|
{
|
{
|
screenwidth--;
|
screenwidth--;
|
screenchars -= screenheight;
|
screenchars -= screenheight;
|
}
|
}
|
|
|
/* Override the effect of any `set keymap' assignments in the
|
/* Override the effect of any `set keymap' assignments in the
|
inputrc file. */
|
inputrc file. */
|
rl_set_keymap_from_edit_mode ();
|
rl_set_keymap_from_edit_mode ();
|
|
|
/* Try to bind a common arrow key prefix, if not already bound. */
|
/* Try to bind a common arrow key prefix, if not already bound. */
|
bind_arrow_keys ();
|
bind_arrow_keys ();
|
|
|
/* Enable the meta key, if this terminal has one. */
|
/* Enable the meta key, if this terminal has one. */
|
if (_rl_enable_meta)
|
if (_rl_enable_meta)
|
_rl_enable_meta_key ();
|
_rl_enable_meta_key ();
|
|
|
/* If the completion parser's default word break characters haven't
|
/* If the completion parser's default word break characters haven't
|
been set yet, then do so now. */
|
been set yet, then do so now. */
|
if (rl_completer_word_break_characters == (char *)NULL)
|
if (rl_completer_word_break_characters == (char *)NULL)
|
rl_completer_word_break_characters = rl_basic_word_break_characters;
|
rl_completer_word_break_characters = rl_basic_word_break_characters;
|
}
|
}
|
|
|
/* If this system allows us to look at the values of the regular
|
/* If this system allows us to look at the values of the regular
|
input editing characters, then bind them to their readline
|
input editing characters, then bind them to their readline
|
equivalents, iff the characters are not bound to keymaps. */
|
equivalents, iff the characters are not bound to keymaps. */
|
static void
|
static void
|
readline_default_bindings ()
|
readline_default_bindings ()
|
{
|
{
|
rltty_set_default_bindings (_rl_keymap);
|
rltty_set_default_bindings (_rl_keymap);
|
}
|
}
|
|
|
static void
|
static void
|
bind_arrow_keys_internal ()
|
bind_arrow_keys_internal ()
|
{
|
{
|
Function *f;
|
Function *f;
|
|
|
f = rl_function_of_keyseq ("\033[A", _rl_keymap, (int *)NULL);
|
f = rl_function_of_keyseq ("\033[A", _rl_keymap, (int *)NULL);
|
if (!f || f == rl_do_lowercase_version)
|
if (!f || f == rl_do_lowercase_version)
|
{
|
{
|
_rl_bind_if_unbound ("\033[A", rl_get_previous_history);
|
_rl_bind_if_unbound ("\033[A", rl_get_previous_history);
|
_rl_bind_if_unbound ("\033[B", rl_get_next_history);
|
_rl_bind_if_unbound ("\033[B", rl_get_next_history);
|
_rl_bind_if_unbound ("\033[C", rl_forward);
|
_rl_bind_if_unbound ("\033[C", rl_forward);
|
_rl_bind_if_unbound ("\033[D", rl_backward);
|
_rl_bind_if_unbound ("\033[D", rl_backward);
|
}
|
}
|
|
|
f = rl_function_of_keyseq ("\033OA", _rl_keymap, (int *)NULL);
|
f = rl_function_of_keyseq ("\033OA", _rl_keymap, (int *)NULL);
|
if (!f || f == rl_do_lowercase_version)
|
if (!f || f == rl_do_lowercase_version)
|
{
|
{
|
_rl_bind_if_unbound ("\033OA", rl_get_previous_history);
|
_rl_bind_if_unbound ("\033OA", rl_get_previous_history);
|
_rl_bind_if_unbound ("\033OB", rl_get_next_history);
|
_rl_bind_if_unbound ("\033OB", rl_get_next_history);
|
_rl_bind_if_unbound ("\033OC", rl_forward);
|
_rl_bind_if_unbound ("\033OC", rl_forward);
|
_rl_bind_if_unbound ("\033OD", rl_backward);
|
_rl_bind_if_unbound ("\033OD", rl_backward);
|
}
|
}
|
}
|
}
|
|
|
/* Try and bind the common arrow key prefix after giving termcap and
|
/* Try and bind the common arrow key prefix after giving termcap and
|
the inputrc file a chance to bind them and create `real' keymaps
|
the inputrc file a chance to bind them and create `real' keymaps
|
for the arrow key prefix. */
|
for the arrow key prefix. */
|
static void
|
static void
|
bind_arrow_keys ()
|
bind_arrow_keys ()
|
{
|
{
|
Keymap xkeymap;
|
Keymap xkeymap;
|
|
|
xkeymap = _rl_keymap;
|
xkeymap = _rl_keymap;
|
|
|
_rl_keymap = emacs_standard_keymap;
|
_rl_keymap = emacs_standard_keymap;
|
bind_arrow_keys_internal ();
|
bind_arrow_keys_internal ();
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
_rl_keymap = vi_movement_keymap;
|
_rl_keymap = vi_movement_keymap;
|
bind_arrow_keys_internal ();
|
bind_arrow_keys_internal ();
|
#endif
|
#endif
|
|
|
_rl_keymap = xkeymap;
|
_rl_keymap = xkeymap;
|
}
|
}
|
|
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Numeric Arguments */
|
/* Numeric Arguments */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Handle C-u style numeric args, as well as M--, and M-digits. */
|
/* Handle C-u style numeric args, as well as M--, and M-digits. */
|
static int
|
static int
|
rl_digit_loop ()
|
rl_digit_loop ()
|
{
|
{
|
int key, c, sawminus, sawdigits;
|
int key, c, sawminus, sawdigits;
|
|
|
rl_save_prompt ();
|
rl_save_prompt ();
|
|
|
sawminus = sawdigits = 0;
|
sawminus = sawdigits = 0;
|
while (1)
|
while (1)
|
{
|
{
|
if (rl_numeric_arg > 1000000)
|
if (rl_numeric_arg > 1000000)
|
{
|
{
|
sawdigits = rl_explicit_arg = rl_numeric_arg = 0;
|
sawdigits = rl_explicit_arg = rl_numeric_arg = 0;
|
ding ();
|
ding ();
|
rl_restore_prompt ();
|
rl_restore_prompt ();
|
rl_clear_message ();
|
rl_clear_message ();
|
return 1;
|
return 1;
|
}
|
}
|
rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
|
rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
|
key = c = rl_read_key ();
|
key = c = rl_read_key ();
|
|
|
/* If we see a key bound to `universal-argument' after seeing digits,
|
/* If we see a key bound to `universal-argument' after seeing digits,
|
it ends the argument but is otherwise ignored. */
|
it ends the argument but is otherwise ignored. */
|
if (_rl_keymap[c].type == ISFUNC &&
|
if (_rl_keymap[c].type == ISFUNC &&
|
_rl_keymap[c].function == rl_universal_argument)
|
_rl_keymap[c].function == rl_universal_argument)
|
{
|
{
|
if (sawdigits == 0)
|
if (sawdigits == 0)
|
{
|
{
|
rl_numeric_arg *= 4;
|
rl_numeric_arg *= 4;
|
continue;
|
continue;
|
}
|
}
|
else
|
else
|
{
|
{
|
key = rl_read_key ();
|
key = rl_read_key ();
|
rl_restore_prompt ();
|
rl_restore_prompt ();
|
rl_clear_message ();
|
rl_clear_message ();
|
return (_rl_dispatch (key, _rl_keymap));
|
return (_rl_dispatch (key, _rl_keymap));
|
}
|
}
|
}
|
}
|
|
|
c = UNMETA (c);
|
c = UNMETA (c);
|
|
|
if (_rl_digit_p (c))
|
if (_rl_digit_p (c))
|
{
|
{
|
rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + c - '0' : c - '0';
|
rl_numeric_arg = rl_explicit_arg ? (rl_numeric_arg * 10) + c - '0' : c - '0';
|
sawdigits = rl_explicit_arg = 1;
|
sawdigits = rl_explicit_arg = 1;
|
}
|
}
|
else if (c == '-' && rl_explicit_arg == 0)
|
else if (c == '-' && rl_explicit_arg == 0)
|
{
|
{
|
rl_numeric_arg = sawminus = 1;
|
rl_numeric_arg = sawminus = 1;
|
rl_arg_sign = -1;
|
rl_arg_sign = -1;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Make M-- command equivalent to M--1 command. */
|
/* Make M-- command equivalent to M--1 command. */
|
if (sawminus && rl_numeric_arg == 1 && rl_explicit_arg == 0)
|
if (sawminus && rl_numeric_arg == 1 && rl_explicit_arg == 0)
|
rl_explicit_arg = 1;
|
rl_explicit_arg = 1;
|
rl_restore_prompt ();
|
rl_restore_prompt ();
|
rl_clear_message ();
|
rl_clear_message ();
|
return (_rl_dispatch (key, _rl_keymap));
|
return (_rl_dispatch (key, _rl_keymap));
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Add the current digit to the argument in progress. */
|
/* Add the current digit to the argument in progress. */
|
int
|
int
|
rl_digit_argument (ignore, key)
|
rl_digit_argument (ignore, key)
|
int ignore, key;
|
int ignore, key;
|
{
|
{
|
rl_pending_input = key;
|
rl_pending_input = key;
|
return (rl_digit_loop ());
|
return (rl_digit_loop ());
|
}
|
}
|
|
|
/* What to do when you abort reading an argument. */
|
/* What to do when you abort reading an argument. */
|
int
|
int
|
rl_discard_argument ()
|
rl_discard_argument ()
|
{
|
{
|
ding ();
|
ding ();
|
rl_clear_message ();
|
rl_clear_message ();
|
_rl_init_argument ();
|
_rl_init_argument ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Create a default argument. */
|
/* Create a default argument. */
|
int
|
int
|
_rl_init_argument ()
|
_rl_init_argument ()
|
{
|
{
|
rl_numeric_arg = rl_arg_sign = 1;
|
rl_numeric_arg = rl_arg_sign = 1;
|
rl_explicit_arg = 0;
|
rl_explicit_arg = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* C-u, universal argument. Multiply the current argument by 4.
|
/* C-u, universal argument. Multiply the current argument by 4.
|
Read a key. If the key has nothing to do with arguments, then
|
Read a key. If the key has nothing to do with arguments, then
|
dispatch on it. If the key is the abort character then abort. */
|
dispatch on it. If the key is the abort character then abort. */
|
int
|
int
|
rl_universal_argument (count, key)
|
rl_universal_argument (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_numeric_arg *= 4;
|
rl_numeric_arg *= 4;
|
return (rl_digit_loop ());
|
return (rl_digit_loop ());
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Insert and Delete */
|
/* Insert and Delete */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Insert a string of text into the line at point. This is the only
|
/* Insert a string of text into the line at point. This is the only
|
way that you should do insertion. rl_insert () calls this
|
way that you should do insertion. rl_insert () calls this
|
function. */
|
function. */
|
int
|
int
|
rl_insert_text (string)
|
rl_insert_text (string)
|
char *string;
|
char *string;
|
{
|
{
|
register int i, l = strlen (string);
|
register int i, l = strlen (string);
|
|
|
if (rl_end + l >= rl_line_buffer_len)
|
if (rl_end + l >= rl_line_buffer_len)
|
rl_extend_line_buffer (rl_end + l);
|
rl_extend_line_buffer (rl_end + l);
|
|
|
for (i = rl_end; i >= rl_point; i--)
|
for (i = rl_end; i >= rl_point; i--)
|
the_line[i + l] = the_line[i];
|
the_line[i + l] = the_line[i];
|
strncpy (the_line + rl_point, string, l);
|
strncpy (the_line + rl_point, string, l);
|
|
|
/* Remember how to undo this if we aren't undoing something. */
|
/* Remember how to undo this if we aren't undoing something. */
|
if (!_rl_doing_an_undo)
|
if (!_rl_doing_an_undo)
|
{
|
{
|
/* If possible and desirable, concatenate the undos. */
|
/* If possible and desirable, concatenate the undos. */
|
if ((l == 1) &&
|
if ((l == 1) &&
|
rl_undo_list &&
|
rl_undo_list &&
|
(rl_undo_list->what == UNDO_INSERT) &&
|
(rl_undo_list->what == UNDO_INSERT) &&
|
(rl_undo_list->end == rl_point) &&
|
(rl_undo_list->end == rl_point) &&
|
(rl_undo_list->end - rl_undo_list->start < 20))
|
(rl_undo_list->end - rl_undo_list->start < 20))
|
rl_undo_list->end++;
|
rl_undo_list->end++;
|
else
|
else
|
rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
|
rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
|
}
|
}
|
rl_point += l;
|
rl_point += l;
|
rl_end += l;
|
rl_end += l;
|
the_line[rl_end] = '\0';
|
the_line[rl_end] = '\0';
|
return l;
|
return l;
|
}
|
}
|
|
|
/* Delete the string between FROM and TO. FROM is
|
/* Delete the string between FROM and TO. FROM is
|
inclusive, TO is not. */
|
inclusive, TO is not. */
|
int
|
int
|
rl_delete_text (from, to)
|
rl_delete_text (from, to)
|
int from, to;
|
int from, to;
|
{
|
{
|
register char *text;
|
register char *text;
|
register int diff, i;
|
register int diff, i;
|
|
|
/* Fix it if the caller is confused. */
|
/* Fix it if the caller is confused. */
|
if (from > to)
|
if (from > to)
|
SWAP (from, to);
|
SWAP (from, to);
|
|
|
/* fix boundaries */
|
/* fix boundaries */
|
if (to > rl_end)
|
if (to > rl_end)
|
{
|
{
|
to = rl_end;
|
to = rl_end;
|
if (from > to)
|
if (from > to)
|
from = to;
|
from = to;
|
}
|
}
|
|
|
text = rl_copy_text (from, to);
|
text = rl_copy_text (from, to);
|
|
|
/* Some versions of strncpy() can't handle overlapping arguments. */
|
/* Some versions of strncpy() can't handle overlapping arguments. */
|
diff = to - from;
|
diff = to - from;
|
for (i = from; i < rl_end - diff; i++)
|
for (i = from; i < rl_end - diff; i++)
|
the_line[i] = the_line[i + diff];
|
the_line[i] = the_line[i + diff];
|
|
|
/* Remember how to undo this delete. */
|
/* Remember how to undo this delete. */
|
if (_rl_doing_an_undo == 0)
|
if (_rl_doing_an_undo == 0)
|
rl_add_undo (UNDO_DELETE, from, to, text);
|
rl_add_undo (UNDO_DELETE, from, to, text);
|
else
|
else
|
free (text);
|
free (text);
|
|
|
rl_end -= diff;
|
rl_end -= diff;
|
the_line[rl_end] = '\0';
|
the_line[rl_end] = '\0';
|
return (diff);
|
return (diff);
|
}
|
}
|
|
|
/* Fix up point so that it is within the line boundaries after killing
|
/* Fix up point so that it is within the line boundaries after killing
|
text. If FIX_MARK_TOO is non-zero, the mark is forced within line
|
text. If FIX_MARK_TOO is non-zero, the mark is forced within line
|
boundaries also. */
|
boundaries also. */
|
|
|
#define _RL_FIX_POINT(x) \
|
#define _RL_FIX_POINT(x) \
|
do { \
|
do { \
|
if (x > rl_end) \
|
if (x > rl_end) \
|
x = rl_end; \
|
x = rl_end; \
|
else if (x < 0) \
|
else if (x < 0) \
|
x = 0; \
|
x = 0; \
|
} while (0)
|
} while (0)
|
|
|
void
|
void
|
_rl_fix_point (fix_mark_too)
|
_rl_fix_point (fix_mark_too)
|
int fix_mark_too;
|
int fix_mark_too;
|
{
|
{
|
_RL_FIX_POINT (rl_point);
|
_RL_FIX_POINT (rl_point);
|
if (fix_mark_too)
|
if (fix_mark_too)
|
_RL_FIX_POINT (rl_mark);
|
_RL_FIX_POINT (rl_mark);
|
}
|
}
|
#undef _RL_FIX_POINT
|
#undef _RL_FIX_POINT
|
|
|
void
|
void
|
_rl_replace_text (text, start, end)
|
_rl_replace_text (text, start, end)
|
char *text;
|
char *text;
|
int start, end;
|
int start, end;
|
{
|
{
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
rl_delete_text (start, end + 1);
|
rl_delete_text (start, end + 1);
|
rl_point = start;
|
rl_point = start;
|
rl_insert_text (text);
|
rl_insert_text (text);
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Readline character functions */
|
/* Readline character functions */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* This is not a gap editor, just a stupid line input routine. No hair
|
/* This is not a gap editor, just a stupid line input routine. No hair
|
is involved in writing any of the functions, and none should be. */
|
is involved in writing any of the functions, and none should be. */
|
|
|
/* Note that:
|
/* Note that:
|
|
|
rl_end is the place in the string that we would place '\0';
|
rl_end is the place in the string that we would place '\0';
|
i.e., it is always safe to place '\0' there.
|
i.e., it is always safe to place '\0' there.
|
|
|
rl_point is the place in the string where the cursor is. Sometimes
|
rl_point is the place in the string where the cursor is. Sometimes
|
this is the same as rl_end.
|
this is the same as rl_end.
|
|
|
Any command that is called interactively receives two arguments.
|
Any command that is called interactively receives two arguments.
|
The first is a count: the numeric arg pased to this command.
|
The first is a count: the numeric arg pased to this command.
|
The second is the key which invoked this command.
|
The second is the key which invoked this command.
|
*/
|
*/
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Movement Commands */
|
/* Movement Commands */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Note that if you `optimize' the display for these functions, you cannot
|
/* Note that if you `optimize' the display for these functions, you cannot
|
use said functions in other functions which do not do optimizing display.
|
use said functions in other functions which do not do optimizing display.
|
I.e., you will have to update the data base for rl_redisplay, and you
|
I.e., you will have to update the data base for rl_redisplay, and you
|
might as well let rl_redisplay do that job. */
|
might as well let rl_redisplay do that job. */
|
|
|
/* Move forward COUNT characters. */
|
/* Move forward COUNT characters. */
|
int
|
int
|
rl_forward (count, key)
|
rl_forward (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
rl_backward (-count, key);
|
rl_backward (-count, key);
|
else if (count > 0)
|
else if (count > 0)
|
{
|
{
|
int end = rl_point + count;
|
int end = rl_point + count;
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
int lend = rl_end - (rl_editing_mode == vi_mode);
|
int lend = rl_end - (rl_editing_mode == vi_mode);
|
#else
|
#else
|
int lend = rl_end;
|
int lend = rl_end;
|
#endif
|
#endif
|
|
|
if (end > lend)
|
if (end > lend)
|
{
|
{
|
rl_point = lend;
|
rl_point = lend;
|
ding ();
|
ding ();
|
}
|
}
|
else
|
else
|
rl_point = end;
|
rl_point = end;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move backward COUNT characters. */
|
/* Move backward COUNT characters. */
|
int
|
int
|
rl_backward (count, key)
|
rl_backward (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
rl_forward (-count, key);
|
rl_forward (-count, key);
|
else if (count > 0)
|
else if (count > 0)
|
{
|
{
|
if (rl_point < count)
|
if (rl_point < count)
|
{
|
{
|
rl_point = 0;
|
rl_point = 0;
|
ding ();
|
ding ();
|
}
|
}
|
else
|
else
|
rl_point -= count;
|
rl_point -= count;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move to the beginning of the line. */
|
/* Move to the beginning of the line. */
|
int
|
int
|
rl_beg_of_line (count, key)
|
rl_beg_of_line (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_point = 0;
|
rl_point = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move to the end of the line. */
|
/* Move to the end of the line. */
|
int
|
int
|
rl_end_of_line (count, key)
|
rl_end_of_line (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_point = rl_end;
|
rl_point = rl_end;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move forward a word. We do what Emacs does. */
|
/* Move forward a word. We do what Emacs does. */
|
int
|
int
|
rl_forward_word (count, key)
|
rl_forward_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c;
|
int c;
|
|
|
if (count < 0)
|
if (count < 0)
|
{
|
{
|
rl_backward_word (-count, key);
|
rl_backward_word (-count, key);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
while (count)
|
while (count)
|
{
|
{
|
if (rl_point == rl_end)
|
if (rl_point == rl_end)
|
return 0;
|
return 0;
|
|
|
/* If we are not in a word, move forward until we are in one.
|
/* If we are not in a word, move forward until we are in one.
|
Then, move forward until we hit a non-alphabetic character. */
|
Then, move forward until we hit a non-alphabetic character. */
|
c = the_line[rl_point];
|
c = the_line[rl_point];
|
if (alphabetic (c) == 0)
|
if (alphabetic (c) == 0)
|
{
|
{
|
while (++rl_point < rl_end)
|
while (++rl_point < rl_end)
|
{
|
{
|
c = the_line[rl_point];
|
c = the_line[rl_point];
|
if (alphabetic (c))
|
if (alphabetic (c))
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (rl_point == rl_end)
|
if (rl_point == rl_end)
|
return 0;
|
return 0;
|
while (++rl_point < rl_end)
|
while (++rl_point < rl_end)
|
{
|
{
|
c = the_line[rl_point];
|
c = the_line[rl_point];
|
if (alphabetic (c) == 0)
|
if (alphabetic (c) == 0)
|
break;
|
break;
|
}
|
}
|
--count;
|
--count;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move backward a word. We do what Emacs does. */
|
/* Move backward a word. We do what Emacs does. */
|
int
|
int
|
rl_backward_word (count, key)
|
rl_backward_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c;
|
int c;
|
|
|
if (count < 0)
|
if (count < 0)
|
{
|
{
|
rl_forward_word (-count, key);
|
rl_forward_word (-count, key);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
while (count)
|
while (count)
|
{
|
{
|
if (!rl_point)
|
if (!rl_point)
|
return 0;
|
return 0;
|
|
|
/* Like rl_forward_word (), except that we look at the characters
|
/* Like rl_forward_word (), except that we look at the characters
|
just before point. */
|
just before point. */
|
|
|
c = the_line[rl_point - 1];
|
c = the_line[rl_point - 1];
|
if (alphabetic (c) == 0)
|
if (alphabetic (c) == 0)
|
{
|
{
|
while (--rl_point)
|
while (--rl_point)
|
{
|
{
|
c = the_line[rl_point - 1];
|
c = the_line[rl_point - 1];
|
if (alphabetic (c))
|
if (alphabetic (c))
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
while (rl_point)
|
while (rl_point)
|
{
|
{
|
c = the_line[rl_point - 1];
|
c = the_line[rl_point - 1];
|
if (alphabetic (c) == 0)
|
if (alphabetic (c) == 0)
|
break;
|
break;
|
else
|
else
|
--rl_point;
|
--rl_point;
|
}
|
}
|
--count;
|
--count;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Clear the current line. Numeric argument to C-l does this. */
|
/* Clear the current line. Numeric argument to C-l does this. */
|
int
|
int
|
rl_refresh_line (ignore1, ignore2)
|
rl_refresh_line (ignore1, ignore2)
|
int ignore1, ignore2;
|
int ignore1, ignore2;
|
{
|
{
|
int curr_line, nleft;
|
int curr_line, nleft;
|
|
|
/* Find out whether or not there might be invisible characters in the
|
/* Find out whether or not there might be invisible characters in the
|
editing buffer. */
|
editing buffer. */
|
if (rl_display_prompt == rl_prompt)
|
if (rl_display_prompt == rl_prompt)
|
nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length;
|
nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length;
|
else
|
else
|
nleft = _rl_last_c_pos - screenwidth;
|
nleft = _rl_last_c_pos - screenwidth;
|
|
|
if (nleft > 0)
|
if (nleft > 0)
|
curr_line = 1 + nleft / screenwidth;
|
curr_line = 1 + nleft / screenwidth;
|
else
|
else
|
curr_line = 0;
|
curr_line = 0;
|
|
|
_rl_move_vert (curr_line);
|
_rl_move_vert (curr_line);
|
_rl_move_cursor_relative (0, the_line); /* XXX is this right */
|
_rl_move_cursor_relative (0, the_line); /* XXX is this right */
|
|
|
#if defined (__GO32__) && !defined (__DJGPP__)
|
#if defined (__GO32__) && !defined (__DJGPP__)
|
{
|
{
|
int row, col, width, row_start;
|
int row, col, width, row_start;
|
|
|
ScreenGetCursor (&row, &col);
|
ScreenGetCursor (&row, &col);
|
width = ScreenCols ();
|
width = ScreenCols ();
|
row_start = ScreenPrimary + (row * width);
|
row_start = ScreenPrimary + (row * width);
|
memset (row_start + col, 0, (width - col) * 2);
|
memset (row_start + col, 0, (width - col) * 2);
|
}
|
}
|
#else /* !__GO32__ || __DJGPP__ */
|
#else /* !__GO32__ || __DJGPP__ */
|
_rl_clear_to_eol (0); /* arg of 0 means to not use spaces */
|
_rl_clear_to_eol (0); /* arg of 0 means to not use spaces */
|
#endif /* !__GO32__ || __DJGPP__ */
|
#endif /* !__GO32__ || __DJGPP__ */
|
|
|
rl_forced_update_display ();
|
rl_forced_update_display ();
|
rl_display_fixed = 1;
|
rl_display_fixed = 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* C-l typed to a line without quoting clears the screen, and then reprints
|
/* C-l typed to a line without quoting clears the screen, and then reprints
|
the prompt and the current input line. Given a numeric arg, redraw only
|
the prompt and the current input line. Given a numeric arg, redraw only
|
the current line. */
|
the current line. */
|
int
|
int
|
rl_clear_screen (count, key)
|
rl_clear_screen (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_explicit_arg)
|
if (rl_explicit_arg)
|
{
|
{
|
rl_refresh_line (count, key);
|
rl_refresh_line (count, key);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
_rl_clear_screen (); /* calls termcap function to clear screen */
|
_rl_clear_screen (); /* calls termcap function to clear screen */
|
rl_forced_update_display ();
|
rl_forced_update_display ();
|
rl_display_fixed = 1;
|
rl_display_fixed = 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
rl_arrow_keys (count, c)
|
rl_arrow_keys (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
int ch;
|
int ch;
|
|
|
ch = rl_read_key ();
|
ch = rl_read_key ();
|
|
|
switch (_rl_to_upper (ch))
|
switch (_rl_to_upper (ch))
|
{
|
{
|
case 'A':
|
case 'A':
|
rl_get_previous_history (count, ch);
|
rl_get_previous_history (count, ch);
|
break;
|
break;
|
|
|
case 'B':
|
case 'B':
|
rl_get_next_history (count, ch);
|
rl_get_next_history (count, ch);
|
break;
|
break;
|
|
|
case 'C':
|
case 'C':
|
rl_forward (count, ch);
|
rl_forward (count, ch);
|
break;
|
break;
|
|
|
case 'D':
|
case 'D':
|
rl_backward (count, ch);
|
rl_backward (count, ch);
|
break;
|
break;
|
|
|
default:
|
default:
|
ding ();
|
ding ();
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Text commands */
|
/* Text commands */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Insert the character C at the current location, moving point forward. */
|
/* Insert the character C at the current location, moving point forward. */
|
int
|
int
|
rl_insert (count, c)
|
rl_insert (count, c)
|
int count, c;
|
int count, c;
|
{
|
{
|
register int i;
|
register int i;
|
char *string;
|
char *string;
|
|
|
if (count <= 0)
|
if (count <= 0)
|
return 0;
|
return 0;
|
|
|
/* If we can optimize, then do it. But don't let people crash
|
/* If we can optimize, then do it. But don't let people crash
|
readline because of extra large arguments. */
|
readline because of extra large arguments. */
|
if (count > 1 && count <= 1024)
|
if (count > 1 && count <= 1024)
|
{
|
{
|
string = xmalloc (1 + count);
|
string = xmalloc (1 + count);
|
|
|
for (i = 0; i < count; i++)
|
for (i = 0; i < count; i++)
|
string[i] = c;
|
string[i] = c;
|
|
|
string[i] = '\0';
|
string[i] = '\0';
|
rl_insert_text (string);
|
rl_insert_text (string);
|
free (string);
|
free (string);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (count > 1024)
|
if (count > 1024)
|
{
|
{
|
int decreaser;
|
int decreaser;
|
char str[1024+1];
|
char str[1024+1];
|
|
|
for (i = 0; i < 1024; i++)
|
for (i = 0; i < 1024; i++)
|
str[i] = c;
|
str[i] = c;
|
|
|
while (count)
|
while (count)
|
{
|
{
|
decreaser = (count > 1024 ? 1024 : count);
|
decreaser = (count > 1024 ? 1024 : count);
|
str[decreaser] = '\0';
|
str[decreaser] = '\0';
|
rl_insert_text (str);
|
rl_insert_text (str);
|
count -= decreaser;
|
count -= decreaser;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* We are inserting a single character.
|
/* We are inserting a single character.
|
If there is pending input, then make a string of all of the
|
If there is pending input, then make a string of all of the
|
pending characters that are bound to rl_insert, and insert
|
pending characters that are bound to rl_insert, and insert
|
them all. */
|
them all. */
|
if (_rl_any_typein ())
|
if (_rl_any_typein ())
|
_rl_insert_typein (c);
|
_rl_insert_typein (c);
|
else
|
else
|
{
|
{
|
/* Inserting a single character. */
|
/* Inserting a single character. */
|
char str[2];
|
char str[2];
|
|
|
str[1] = '\0';
|
str[1] = '\0';
|
str[0] = c;
|
str[0] = c;
|
rl_insert_text (str);
|
rl_insert_text (str);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Insert the next typed character verbatim. */
|
/* Insert the next typed character verbatim. */
|
int
|
int
|
rl_quoted_insert (count, key)
|
rl_quoted_insert (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
int c;
|
int c;
|
|
|
c = rl_read_key ();
|
c = rl_read_key ();
|
return (rl_insert (count, c));
|
return (rl_insert (count, c));
|
}
|
}
|
|
|
/* Insert a tab character. */
|
/* Insert a tab character. */
|
int
|
int
|
rl_tab_insert (count, key)
|
rl_tab_insert (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_insert (count, '\t'));
|
return (rl_insert (count, '\t'));
|
}
|
}
|
|
|
/* What to do when a NEWLINE is pressed. We accept the whole line.
|
/* What to do when a NEWLINE is pressed. We accept the whole line.
|
KEY is the key that invoked this command. I guess it could have
|
KEY is the key that invoked this command. I guess it could have
|
meaning in the future. */
|
meaning in the future. */
|
int
|
int
|
rl_newline (count, key)
|
rl_newline (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_done = 1;
|
rl_done = 1;
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode)
|
if (rl_editing_mode == vi_mode)
|
{
|
{
|
_rl_vi_done_inserting ();
|
_rl_vi_done_inserting ();
|
_rl_vi_reset_last ();
|
_rl_vi_reset_last ();
|
}
|
}
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
|
|
/* If we've been asked to erase empty lines, suppress the final update,
|
/* If we've been asked to erase empty lines, suppress the final update,
|
since _rl_update_final calls crlf(). */
|
since _rl_update_final calls crlf(). */
|
if (rl_erase_empty_line && rl_point == 0 && rl_end == 0)
|
if (rl_erase_empty_line && rl_point == 0 && rl_end == 0)
|
return 0;
|
return 0;
|
|
|
if (readline_echoing_p)
|
if (readline_echoing_p)
|
_rl_update_final ();
|
_rl_update_final ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* What to do for some uppercase characters, like meta characters,
|
/* What to do for some uppercase characters, like meta characters,
|
and some characters appearing in emacs_ctlx_keymap. This function
|
and some characters appearing in emacs_ctlx_keymap. This function
|
is just a stub, you bind keys to it and the code in _rl_dispatch ()
|
is just a stub, you bind keys to it and the code in _rl_dispatch ()
|
is special cased. */
|
is special cased. */
|
int
|
int
|
rl_do_lowercase_version (ignore1, ignore2)
|
rl_do_lowercase_version (ignore1, ignore2)
|
int ignore1, ignore2;
|
int ignore1, ignore2;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Rubout the character behind point. */
|
/* Rubout the character behind point. */
|
int
|
int
|
rl_rubout (count, key)
|
rl_rubout (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
{
|
{
|
rl_delete (-count, key);
|
rl_delete (-count, key);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (!rl_point)
|
if (!rl_point)
|
{
|
{
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (count > 1 || rl_explicit_arg)
|
if (count > 1 || rl_explicit_arg)
|
{
|
{
|
int orig_point = rl_point;
|
int orig_point = rl_point;
|
rl_backward (count, key);
|
rl_backward (count, key);
|
rl_kill_text (orig_point, rl_point);
|
rl_kill_text (orig_point, rl_point);
|
}
|
}
|
else
|
else
|
{
|
{
|
int c = the_line[--rl_point];
|
int c = the_line[--rl_point];
|
rl_delete_text (rl_point, rl_point + 1);
|
rl_delete_text (rl_point, rl_point + 1);
|
|
|
if (rl_point == rl_end && isprint (c) && _rl_last_c_pos)
|
if (rl_point == rl_end && isprint (c) && _rl_last_c_pos)
|
{
|
{
|
int l;
|
int l;
|
l = rl_character_len (c, rl_point);
|
l = rl_character_len (c, rl_point);
|
_rl_erase_at_end_of_line (l);
|
_rl_erase_at_end_of_line (l);
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Delete the character under the cursor. Given a numeric argument,
|
/* Delete the character under the cursor. Given a numeric argument,
|
kill that many characters instead. */
|
kill that many characters instead. */
|
int
|
int
|
rl_delete (count, key)
|
rl_delete (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (count < 0)
|
if (count < 0)
|
return (rl_rubout (-count, key));
|
return (rl_rubout (-count, key));
|
|
|
if (rl_point == rl_end)
|
if (rl_point == rl_end)
|
{
|
{
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (count > 1 || rl_explicit_arg)
|
if (count > 1 || rl_explicit_arg)
|
{
|
{
|
int orig_point = rl_point;
|
int orig_point = rl_point;
|
rl_forward (count, key);
|
rl_forward (count, key);
|
rl_kill_text (orig_point, rl_point);
|
rl_kill_text (orig_point, rl_point);
|
rl_point = orig_point;
|
rl_point = orig_point;
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return (rl_delete_text (rl_point, rl_point + 1));
|
return (rl_delete_text (rl_point, rl_point + 1));
|
}
|
}
|
|
|
/* Delete the character under the cursor, unless the insertion
|
/* Delete the character under the cursor, unless the insertion
|
point is at the end of the line, in which case the character
|
point is at the end of the line, in which case the character
|
behind the cursor is deleted. COUNT is obeyed and may be used
|
behind the cursor is deleted. COUNT is obeyed and may be used
|
to delete forward or backward that many characters. */
|
to delete forward or backward that many characters. */
|
int
|
int
|
rl_rubout_or_delete (count, key)
|
rl_rubout_or_delete (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_end != 0 && rl_point == rl_end)
|
if (rl_end != 0 && rl_point == rl_end)
|
return (rl_rubout (count, key));
|
return (rl_rubout (count, key));
|
else
|
else
|
return (rl_delete (count, key));
|
return (rl_delete (count, key));
|
}
|
}
|
|
|
/* Delete all spaces and tabs around point. */
|
/* Delete all spaces and tabs around point. */
|
int
|
int
|
rl_delete_horizontal_space (count, ignore)
|
rl_delete_horizontal_space (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
int start = rl_point;
|
int start = rl_point;
|
|
|
while (rl_point && whitespace (the_line[rl_point - 1]))
|
while (rl_point && whitespace (the_line[rl_point - 1]))
|
rl_point--;
|
rl_point--;
|
|
|
start = rl_point;
|
start = rl_point;
|
|
|
while (rl_point < rl_end && whitespace (the_line[rl_point]))
|
while (rl_point < rl_end && whitespace (the_line[rl_point]))
|
rl_point++;
|
rl_point++;
|
|
|
if (start != rl_point)
|
if (start != rl_point)
|
{
|
{
|
rl_delete_text (start, rl_point);
|
rl_delete_text (start, rl_point);
|
rl_point = start;
|
rl_point = start;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Like the tcsh editing function delete-char-or-list. The eof character
|
/* Like the tcsh editing function delete-char-or-list. The eof character
|
is caught before this is invoked, so this really does the same thing as
|
is caught before this is invoked, so this really does the same thing as
|
delete-char-or-list-or-eof, as long as it's bound to the eof character. */
|
delete-char-or-list-or-eof, as long as it's bound to the eof character. */
|
int
|
int
|
rl_delete_or_show_completions (count, key)
|
rl_delete_or_show_completions (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_end != 0 && rl_point == rl_end)
|
if (rl_end != 0 && rl_point == rl_end)
|
return (rl_possible_completions (count, key));
|
return (rl_possible_completions (count, key));
|
else
|
else
|
return (rl_delete (count, key));
|
return (rl_delete (count, key));
|
}
|
}
|
|
|
#ifndef RL_COMMENT_BEGIN_DEFAULT
|
#ifndef RL_COMMENT_BEGIN_DEFAULT
|
#define RL_COMMENT_BEGIN_DEFAULT "#"
|
#define RL_COMMENT_BEGIN_DEFAULT "#"
|
#endif
|
#endif
|
|
|
/* Turn the current line into a comment in shell history.
|
/* Turn the current line into a comment in shell history.
|
A K*rn shell style function. */
|
A K*rn shell style function. */
|
int
|
int
|
rl_insert_comment (count, key)
|
rl_insert_comment (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_beg_of_line (1, key);
|
rl_beg_of_line (1, key);
|
rl_insert_text (_rl_comment_begin ? _rl_comment_begin
|
rl_insert_text (_rl_comment_begin ? _rl_comment_begin
|
: RL_COMMENT_BEGIN_DEFAULT);
|
: RL_COMMENT_BEGIN_DEFAULT);
|
(*rl_redisplay_function) ();
|
(*rl_redisplay_function) ();
|
rl_newline (1, '\n');
|
rl_newline (1, '\n');
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Changing Case */
|
/* Changing Case */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* The three kinds of things that we know how to do. */
|
/* The three kinds of things that we know how to do. */
|
#define UpCase 1
|
#define UpCase 1
|
#define DownCase 2
|
#define DownCase 2
|
#define CapCase 3
|
#define CapCase 3
|
|
|
static int rl_change_case ();
|
static int rl_change_case ();
|
|
|
/* Uppercase the word at point. */
|
/* Uppercase the word at point. */
|
int
|
int
|
rl_upcase_word (count, key)
|
rl_upcase_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_change_case (count, UpCase));
|
return (rl_change_case (count, UpCase));
|
}
|
}
|
|
|
/* Lowercase the word at point. */
|
/* Lowercase the word at point. */
|
int
|
int
|
rl_downcase_word (count, key)
|
rl_downcase_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_change_case (count, DownCase));
|
return (rl_change_case (count, DownCase));
|
}
|
}
|
|
|
/* Upcase the first letter, downcase the rest. */
|
/* Upcase the first letter, downcase the rest. */
|
int
|
int
|
rl_capitalize_word (count, key)
|
rl_capitalize_word (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_change_case (count, CapCase));
|
return (rl_change_case (count, CapCase));
|
}
|
}
|
|
|
/* The meaty function.
|
/* The meaty function.
|
Change the case of COUNT words, performing OP on them.
|
Change the case of COUNT words, performing OP on them.
|
OP is one of UpCase, DownCase, or CapCase.
|
OP is one of UpCase, DownCase, or CapCase.
|
If a negative argument is given, leave point where it started,
|
If a negative argument is given, leave point where it started,
|
otherwise, leave it where it moves to. */
|
otherwise, leave it where it moves to. */
|
static int
|
static int
|
rl_change_case (count, op)
|
rl_change_case (count, op)
|
int count, op;
|
int count, op;
|
{
|
{
|
register int start, end;
|
register int start, end;
|
int inword, c;
|
int inword, c;
|
|
|
start = rl_point;
|
start = rl_point;
|
rl_forward_word (count, 0);
|
rl_forward_word (count, 0);
|
end = rl_point;
|
end = rl_point;
|
|
|
if (count < 0)
|
if (count < 0)
|
SWAP (start, end);
|
SWAP (start, end);
|
|
|
/* We are going to modify some text, so let's prepare to undo it. */
|
/* We are going to modify some text, so let's prepare to undo it. */
|
rl_modifying (start, end);
|
rl_modifying (start, end);
|
|
|
for (inword = 0; start < end; start++)
|
for (inword = 0; start < end; start++)
|
{
|
{
|
c = the_line[start];
|
c = the_line[start];
|
switch (op)
|
switch (op)
|
{
|
{
|
case UpCase:
|
case UpCase:
|
the_line[start] = _rl_to_upper (c);
|
the_line[start] = _rl_to_upper (c);
|
break;
|
break;
|
|
|
case DownCase:
|
case DownCase:
|
the_line[start] = _rl_to_lower (c);
|
the_line[start] = _rl_to_lower (c);
|
break;
|
break;
|
|
|
case CapCase:
|
case CapCase:
|
the_line[start] = (inword == 0) ? _rl_to_upper (c) : _rl_to_lower (c);
|
the_line[start] = (inword == 0) ? _rl_to_upper (c) : _rl_to_lower (c);
|
inword = alphabetic (the_line[start]);
|
inword = alphabetic (the_line[start]);
|
break;
|
break;
|
|
|
default:
|
default:
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
rl_point = end;
|
rl_point = end;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Transposition */
|
/* Transposition */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Transpose the words at point. */
|
/* Transpose the words at point. */
|
int
|
int
|
rl_transpose_words (count, key)
|
rl_transpose_words (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
char *word1, *word2;
|
char *word1, *word2;
|
int w1_beg, w1_end, w2_beg, w2_end;
|
int w1_beg, w1_end, w2_beg, w2_end;
|
int orig_point = rl_point;
|
int orig_point = rl_point;
|
|
|
if (!count)
|
if (!count)
|
return 0;
|
return 0;
|
|
|
/* Find the two words. */
|
/* Find the two words. */
|
rl_forward_word (count, key);
|
rl_forward_word (count, key);
|
w2_end = rl_point;
|
w2_end = rl_point;
|
rl_backward_word (1, key);
|
rl_backward_word (1, key);
|
w2_beg = rl_point;
|
w2_beg = rl_point;
|
rl_backward_word (count, key);
|
rl_backward_word (count, key);
|
w1_beg = rl_point;
|
w1_beg = rl_point;
|
rl_forward_word (1, key);
|
rl_forward_word (1, key);
|
w1_end = rl_point;
|
w1_end = rl_point;
|
|
|
/* Do some check to make sure that there really are two words. */
|
/* Do some check to make sure that there really are two words. */
|
if ((w1_beg == w2_beg) || (w2_beg < w1_end))
|
if ((w1_beg == w2_beg) || (w2_beg < w1_end))
|
{
|
{
|
ding ();
|
ding ();
|
rl_point = orig_point;
|
rl_point = orig_point;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* Get the text of the words. */
|
/* Get the text of the words. */
|
word1 = rl_copy_text (w1_beg, w1_end);
|
word1 = rl_copy_text (w1_beg, w1_end);
|
word2 = rl_copy_text (w2_beg, w2_end);
|
word2 = rl_copy_text (w2_beg, w2_end);
|
|
|
/* We are about to do many insertions and deletions. Remember them
|
/* We are about to do many insertions and deletions. Remember them
|
as one operation. */
|
as one operation. */
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
|
|
/* Do the stuff at word2 first, so that we don't have to worry
|
/* Do the stuff at word2 first, so that we don't have to worry
|
about word1 moving. */
|
about word1 moving. */
|
rl_point = w2_beg;
|
rl_point = w2_beg;
|
rl_delete_text (w2_beg, w2_end);
|
rl_delete_text (w2_beg, w2_end);
|
rl_insert_text (word1);
|
rl_insert_text (word1);
|
|
|
rl_point = w1_beg;
|
rl_point = w1_beg;
|
rl_delete_text (w1_beg, w1_end);
|
rl_delete_text (w1_beg, w1_end);
|
rl_insert_text (word2);
|
rl_insert_text (word2);
|
|
|
/* This is exactly correct since the text before this point has not
|
/* This is exactly correct since the text before this point has not
|
changed in length. */
|
changed in length. */
|
rl_point = w2_end;
|
rl_point = w2_end;
|
|
|
/* I think that does it. */
|
/* I think that does it. */
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
free (word1);
|
free (word1);
|
free (word2);
|
free (word2);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Transpose the characters at point. If point is at the end of the line,
|
/* Transpose the characters at point. If point is at the end of the line,
|
then transpose the characters before point. */
|
then transpose the characters before point. */
|
int
|
int
|
rl_transpose_chars (count, key)
|
rl_transpose_chars (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
char dummy[2];
|
char dummy[2];
|
|
|
if (!count)
|
if (!count)
|
return 0;
|
return 0;
|
|
|
if (!rl_point || rl_end < 2)
|
if (!rl_point || rl_end < 2)
|
{
|
{
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
|
|
if (rl_point == rl_end)
|
if (rl_point == rl_end)
|
{
|
{
|
--rl_point;
|
--rl_point;
|
count = 1;
|
count = 1;
|
}
|
}
|
rl_point--;
|
rl_point--;
|
|
|
dummy[0] = the_line[rl_point];
|
dummy[0] = the_line[rl_point];
|
dummy[1] = '\0';
|
dummy[1] = '\0';
|
|
|
rl_delete_text (rl_point, rl_point + 1);
|
rl_delete_text (rl_point, rl_point + 1);
|
|
|
rl_point += count;
|
rl_point += count;
|
_rl_fix_point (0);
|
_rl_fix_point (0);
|
rl_insert_text (dummy);
|
rl_insert_text (dummy);
|
|
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Character Searching */
|
/* Character Searching */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
int
|
int
|
_rl_char_search_internal (count, dir, schar)
|
_rl_char_search_internal (count, dir, schar)
|
int count, dir, schar;
|
int count, dir, schar;
|
{
|
{
|
int pos, inc;
|
int pos, inc;
|
|
|
pos = rl_point;
|
pos = rl_point;
|
inc = (dir < 0) ? -1 : 1;
|
inc = (dir < 0) ? -1 : 1;
|
while (count)
|
while (count)
|
{
|
{
|
if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
|
if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
|
{
|
{
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
pos += inc;
|
pos += inc;
|
do
|
do
|
{
|
{
|
if (rl_line_buffer[pos] == schar)
|
if (rl_line_buffer[pos] == schar)
|
{
|
{
|
count--;
|
count--;
|
if (dir < 0)
|
if (dir < 0)
|
rl_point = (dir == BTO) ? pos + 1 : pos;
|
rl_point = (dir == BTO) ? pos + 1 : pos;
|
else
|
else
|
rl_point = (dir == FTO) ? pos - 1 : pos;
|
rl_point = (dir == FTO) ? pos - 1 : pos;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
while ((dir < 0) ? pos-- : ++pos < rl_end);
|
while ((dir < 0) ? pos-- : ++pos < rl_end);
|
}
|
}
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Search COUNT times for a character read from the current input stream.
|
/* Search COUNT times for a character read from the current input stream.
|
FDIR is the direction to search if COUNT is non-negative; otherwise
|
FDIR is the direction to search if COUNT is non-negative; otherwise
|
the search goes in BDIR. */
|
the search goes in BDIR. */
|
static int
|
static int
|
_rl_char_search (count, fdir, bdir)
|
_rl_char_search (count, fdir, bdir)
|
int count, fdir, bdir;
|
int count, fdir, bdir;
|
{
|
{
|
int c;
|
int c;
|
|
|
c = rl_read_key ();
|
c = rl_read_key ();
|
if (count < 0)
|
if (count < 0)
|
return (_rl_char_search_internal (-count, bdir, c));
|
return (_rl_char_search_internal (-count, bdir, c));
|
else
|
else
|
return (_rl_char_search_internal (count, fdir, c));
|
return (_rl_char_search_internal (count, fdir, c));
|
}
|
}
|
|
|
int
|
int
|
rl_char_search (count, key)
|
rl_char_search (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (_rl_char_search (count, FFIND, BFIND));
|
return (_rl_char_search (count, FFIND, BFIND));
|
}
|
}
|
|
|
int
|
int
|
rl_backward_char_search (count, key)
|
rl_backward_char_search (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (_rl_char_search (count, BFIND, FFIND));
|
return (_rl_char_search (count, BFIND, FFIND));
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* History Utilities */
|
/* History Utilities */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* We already have a history library, and that is what we use to control
|
/* We already have a history library, and that is what we use to control
|
the history features of readline. This is our local interface to
|
the history features of readline. This is our local interface to
|
the history mechanism. */
|
the history mechanism. */
|
|
|
/* While we are editing the history, this is the saved
|
/* While we are editing the history, this is the saved
|
version of the original line. */
|
version of the original line. */
|
HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
|
HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
|
|
|
/* Set the history pointer back to the last entry in the history. */
|
/* Set the history pointer back to the last entry in the history. */
|
static void
|
static void
|
start_using_history ()
|
start_using_history ()
|
{
|
{
|
using_history ();
|
using_history ();
|
if (saved_line_for_history)
|
if (saved_line_for_history)
|
_rl_free_history_entry (saved_line_for_history);
|
_rl_free_history_entry (saved_line_for_history);
|
|
|
saved_line_for_history = (HIST_ENTRY *)NULL;
|
saved_line_for_history = (HIST_ENTRY *)NULL;
|
}
|
}
|
|
|
/* Free the contents (and containing structure) of a HIST_ENTRY. */
|
/* Free the contents (and containing structure) of a HIST_ENTRY. */
|
void
|
void
|
_rl_free_history_entry (entry)
|
_rl_free_history_entry (entry)
|
HIST_ENTRY *entry;
|
HIST_ENTRY *entry;
|
{
|
{
|
if (entry == 0)
|
if (entry == 0)
|
return;
|
return;
|
if (entry->line)
|
if (entry->line)
|
free (entry->line);
|
free (entry->line);
|
free (entry);
|
free (entry);
|
}
|
}
|
|
|
/* Perhaps put back the current line if it has changed. */
|
/* Perhaps put back the current line if it has changed. */
|
int
|
int
|
maybe_replace_line ()
|
maybe_replace_line ()
|
{
|
{
|
HIST_ENTRY *temp;
|
HIST_ENTRY *temp;
|
|
|
temp = current_history ();
|
temp = current_history ();
|
/* If the current line has changed, save the changes. */
|
/* If the current line has changed, save the changes. */
|
if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
|
if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
|
{
|
{
|
temp = replace_history_entry (where_history (), the_line, (histdata_t)rl_undo_list);
|
temp = replace_history_entry (where_history (), the_line, (histdata_t)rl_undo_list);
|
free (temp->line);
|
free (temp->line);
|
free (temp);
|
free (temp);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Put back the saved_line_for_history if there is one. */
|
/* Put back the saved_line_for_history if there is one. */
|
int
|
int
|
maybe_unsave_line ()
|
maybe_unsave_line ()
|
{
|
{
|
int line_len;
|
int line_len;
|
|
|
if (saved_line_for_history)
|
if (saved_line_for_history)
|
{
|
{
|
line_len = strlen (saved_line_for_history->line);
|
line_len = strlen (saved_line_for_history->line);
|
|
|
if (line_len >= rl_line_buffer_len)
|
if (line_len >= rl_line_buffer_len)
|
rl_extend_line_buffer (line_len);
|
rl_extend_line_buffer (line_len);
|
|
|
strcpy (the_line, saved_line_for_history->line);
|
strcpy (the_line, saved_line_for_history->line);
|
rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
|
rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
|
_rl_free_history_entry (saved_line_for_history);
|
_rl_free_history_entry (saved_line_for_history);
|
saved_line_for_history = (HIST_ENTRY *)NULL;
|
saved_line_for_history = (HIST_ENTRY *)NULL;
|
rl_end = rl_point = strlen (the_line);
|
rl_end = rl_point = strlen (the_line);
|
}
|
}
|
else
|
else
|
ding ();
|
ding ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Save the current line in saved_line_for_history. */
|
/* Save the current line in saved_line_for_history. */
|
int
|
int
|
maybe_save_line ()
|
maybe_save_line ()
|
{
|
{
|
if (saved_line_for_history == 0)
|
if (saved_line_for_history == 0)
|
{
|
{
|
saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
|
saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
|
saved_line_for_history->line = savestring (the_line);
|
saved_line_for_history->line = savestring (the_line);
|
saved_line_for_history->data = (char *)rl_undo_list;
|
saved_line_for_history->data = (char *)rl_undo_list;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* History Commands */
|
/* History Commands */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Meta-< goes to the start of the history. */
|
/* Meta-< goes to the start of the history. */
|
int
|
int
|
rl_beginning_of_history (count, key)
|
rl_beginning_of_history (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (rl_get_previous_history (1 + where_history (), key));
|
return (rl_get_previous_history (1 + where_history (), key));
|
}
|
}
|
|
|
/* Meta-> goes to the end of the history. (The current line). */
|
/* Meta-> goes to the end of the history. (The current line). */
|
int
|
int
|
rl_end_of_history (count, key)
|
rl_end_of_history (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
maybe_replace_line ();
|
maybe_replace_line ();
|
using_history ();
|
using_history ();
|
maybe_unsave_line ();
|
maybe_unsave_line ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Move down to the next history line. */
|
/* Move down to the next history line. */
|
int
|
int
|
rl_get_next_history (count, key)
|
rl_get_next_history (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
HIST_ENTRY *temp;
|
HIST_ENTRY *temp;
|
int line_len;
|
int line_len;
|
|
|
if (count < 0)
|
if (count < 0)
|
return (rl_get_previous_history (-count, key));
|
return (rl_get_previous_history (-count, key));
|
|
|
if (count == 0)
|
if (count == 0)
|
return 0;
|
return 0;
|
|
|
maybe_replace_line ();
|
maybe_replace_line ();
|
|
|
temp = (HIST_ENTRY *)NULL;
|
temp = (HIST_ENTRY *)NULL;
|
while (count)
|
while (count)
|
{
|
{
|
temp = next_history ();
|
temp = next_history ();
|
if (!temp)
|
if (!temp)
|
break;
|
break;
|
--count;
|
--count;
|
}
|
}
|
|
|
if (temp == 0)
|
if (temp == 0)
|
maybe_unsave_line ();
|
maybe_unsave_line ();
|
else
|
else
|
{
|
{
|
line_len = strlen (temp->line);
|
line_len = strlen (temp->line);
|
|
|
if (line_len >= rl_line_buffer_len)
|
if (line_len >= rl_line_buffer_len)
|
rl_extend_line_buffer (line_len);
|
rl_extend_line_buffer (line_len);
|
|
|
strcpy (the_line, temp->line);
|
strcpy (the_line, temp->line);
|
rl_undo_list = (UNDO_LIST *)temp->data;
|
rl_undo_list = (UNDO_LIST *)temp->data;
|
rl_end = rl_point = strlen (the_line);
|
rl_end = rl_point = strlen (the_line);
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode)
|
if (rl_editing_mode == vi_mode)
|
rl_point = 0;
|
rl_point = 0;
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Get the previous item out of our interactive history, making it the current
|
/* Get the previous item out of our interactive history, making it the current
|
line. If there is no previous history, just ding. */
|
line. If there is no previous history, just ding. */
|
int
|
int
|
rl_get_previous_history (count, key)
|
rl_get_previous_history (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
HIST_ENTRY *old_temp, *temp;
|
HIST_ENTRY *old_temp, *temp;
|
int line_len;
|
int line_len;
|
|
|
if (count < 0)
|
if (count < 0)
|
return (rl_get_next_history (-count, key));
|
return (rl_get_next_history (-count, key));
|
|
|
if (count == 0)
|
if (count == 0)
|
return 0;
|
return 0;
|
|
|
/* If we don't have a line saved, then save this one. */
|
/* If we don't have a line saved, then save this one. */
|
maybe_save_line ();
|
maybe_save_line ();
|
|
|
/* If the current line has changed, save the changes. */
|
/* If the current line has changed, save the changes. */
|
maybe_replace_line ();
|
maybe_replace_line ();
|
|
|
temp = old_temp = (HIST_ENTRY *)NULL;
|
temp = old_temp = (HIST_ENTRY *)NULL;
|
while (count)
|
while (count)
|
{
|
{
|
temp = previous_history ();
|
temp = previous_history ();
|
if (temp == 0)
|
if (temp == 0)
|
break;
|
break;
|
|
|
old_temp = temp;
|
old_temp = temp;
|
--count;
|
--count;
|
}
|
}
|
|
|
/* If there was a large argument, and we moved back to the start of the
|
/* If there was a large argument, and we moved back to the start of the
|
history, that is not an error. So use the last value found. */
|
history, that is not an error. So use the last value found. */
|
if (!temp && old_temp)
|
if (!temp && old_temp)
|
temp = old_temp;
|
temp = old_temp;
|
|
|
if (temp == 0)
|
if (temp == 0)
|
ding ();
|
ding ();
|
else
|
else
|
{
|
{
|
line_len = strlen (temp->line);
|
line_len = strlen (temp->line);
|
|
|
if (line_len >= rl_line_buffer_len)
|
if (line_len >= rl_line_buffer_len)
|
rl_extend_line_buffer (line_len);
|
rl_extend_line_buffer (line_len);
|
|
|
strcpy (the_line, temp->line);
|
strcpy (the_line, temp->line);
|
rl_undo_list = (UNDO_LIST *)temp->data;
|
rl_undo_list = (UNDO_LIST *)temp->data;
|
rl_end = rl_point = line_len;
|
rl_end = rl_point = line_len;
|
|
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
if (rl_editing_mode == vi_mode)
|
if (rl_editing_mode == vi_mode)
|
rl_point = 0;
|
rl_point = 0;
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* The Mark and the Region. */
|
/* The Mark and the Region. */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Set the mark at POSITION. */
|
/* Set the mark at POSITION. */
|
int
|
int
|
_rl_set_mark_at_pos (position)
|
_rl_set_mark_at_pos (position)
|
int position;
|
int position;
|
{
|
{
|
if (position > rl_end)
|
if (position > rl_end)
|
return -1;
|
return -1;
|
|
|
rl_mark = position;
|
rl_mark = position;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* A bindable command to set the mark. */
|
/* A bindable command to set the mark. */
|
int
|
int
|
rl_set_mark (count, key)
|
rl_set_mark (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
|
return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
|
}
|
}
|
|
|
/* Exchange the position of mark and point. */
|
/* Exchange the position of mark and point. */
|
int
|
int
|
rl_exchange_point_and_mark (count, key)
|
rl_exchange_point_and_mark (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
if (rl_mark > rl_end)
|
if (rl_mark > rl_end)
|
rl_mark = -1;
|
rl_mark = -1;
|
|
|
if (rl_mark == -1)
|
if (rl_mark == -1)
|
{
|
{
|
ding ();
|
ding ();
|
return -1;
|
return -1;
|
}
|
}
|
else
|
else
|
SWAP (rl_point, rl_mark);
|
SWAP (rl_point, rl_mark);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Editing Modes */
|
/* Editing Modes */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* How to toggle back and forth between editing modes. */
|
/* How to toggle back and forth between editing modes. */
|
int
|
int
|
rl_vi_editing_mode (count, key)
|
rl_vi_editing_mode (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
#if defined (VI_MODE)
|
#if defined (VI_MODE)
|
rl_editing_mode = vi_mode;
|
rl_editing_mode = vi_mode;
|
rl_vi_insertion_mode (1, key);
|
rl_vi_insertion_mode (1, key);
|
#endif /* VI_MODE */
|
#endif /* VI_MODE */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
rl_emacs_editing_mode (count, key)
|
rl_emacs_editing_mode (count, key)
|
int count, key;
|
int count, key;
|
{
|
{
|
rl_editing_mode = emacs_mode;
|
rl_editing_mode = emacs_mode;
|
_rl_keymap = emacs_standard_keymap;
|
_rl_keymap = emacs_standard_keymap;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
