l. Readline now throws an error if it parses a key binding without a terminating
`:' or whitespace.
+m. The default binding for ^W in vi mode now uses word boundaries specified
+ by Posix (vi-unix-word-rubout is bindable command name).
+
+n. rl_clear_visible_line: new application-callable function; clears all
+ screen lines occupied by the current visible readline line.
+
+o. rl_tty_set_echoing: application-callable function that controls whether
+ or not readline thinks it is echoing terminal output.
+
+p. Handle >| and strings of digits preceding and following redirection
+ specifications as single tokens when tokenizing the line for history
+ expansion.
+
+q. Fixed a bug with displaying completions when the prefix display length
+ is greater than the length of the completions to be displayed.
+
+r. The :p history modifier now applies to the entire line, so any expansion
+ specifying :p causes the line to be printed instead of expanded.
+
+s. New application-callable function: rl_pending_signal(): returns the signal
+ number of any signal readline has caught but not yet handled.
+
+t. New application-settable variable: rl_persistent_signal_handlers: if set
+ to a non-zero value, readline will enable the readline-6.2 signal handler
+ behavior in callback mode: handlers are installed when
+ rl_callback_handler_install is called and removed removed when a complete
+ line has been read.
+
-------------------------------------------------------------------------------
This is a terse description of the new features added to readline-6.3 since
the release of readline-6.2.
/* bind.c -- key binding and startup file support for the readline library. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
Add NAME to the list of named functions. Make FUNCTION be the function
that gets called. If KEY is not -1, then bind it. */
int
-rl_add_defun (name, function, key)
- const char *name;
- rl_command_func_t *function;
- int key;
+rl_add_defun (const char *name, rl_command_func_t *function, int key)
{
if (key != -1)
rl_bind_key (key, function);
/* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
int
-rl_bind_key (key, function)
- int key;
- rl_command_func_t *function;
+rl_bind_key (int key, rl_command_func_t *function)
{
char keyseq[3];
int l;
/* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid
KEY. */
int
-rl_bind_key_in_map (key, function, map)
- int key;
- rl_command_func_t *function;
- Keymap map;
+rl_bind_key_in_map (int key, rl_command_func_t *function, Keymap map)
{
int result;
Keymap oldmap;
}
/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. Right
- now, this is always used to attempt to bind the arrow keys, hence the
- check for rl_vi_movement_mode. */
+ now, this is always used to attempt to bind the arrow keys. */
int
-rl_bind_key_if_unbound_in_map (key, default_func, kmap)
- int key;
- rl_command_func_t *default_func;
- Keymap kmap;
+rl_bind_key_if_unbound_in_map (int key, rl_command_func_t *default_func, Keymap kmap)
{
char keyseq[2];
}
int
-rl_bind_key_if_unbound (key, default_func)
- int key;
- rl_command_func_t *default_func;
+rl_bind_key_if_unbound (int key, rl_command_func_t *default_func)
{
char keyseq[2];
}
/* Make KEY do nothing in the currently selected keymap.
- Returns non-zero in case of error. */
+ Returns non-zero in case of error. This is not the same as self-insert;
+ this makes it a dead key. */
int
-rl_unbind_key (key)
- int key;
+rl_unbind_key (int key)
{
return (rl_bind_key (key, (rl_command_func_t *)NULL));
}
-/* Make KEY do nothing in MAP.
- Returns non-zero in case of error. */
+/* Make KEY do nothing in MAP. Returns non-zero in case of error. */
int
-rl_unbind_key_in_map (key, map)
- int key;
- Keymap map;
+rl_unbind_key_in_map (int key, Keymap map)
{
return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
}
/* Unbind all keys bound to FUNCTION in MAP. */
int
-rl_unbind_function_in_map (func, map)
- rl_command_func_t *func;
- Keymap map;
+rl_unbind_function_in_map (rl_command_func_t *func, Keymap map)
{
register int i, rval;
return rval;
}
+/* Unbind all keys bound to COMMAND, which is a bindable command name, in MAP */
int
-rl_unbind_command_in_map (command, map)
- const char *command;
- Keymap map;
+rl_unbind_command_in_map (const char *command, Keymap map)
{
rl_command_func_t *func;
FUNCTION, starting in the current keymap. This makes new
keymaps as necessary. */
int
-rl_bind_keyseq (keyseq, function)
- const char *keyseq;
- rl_command_func_t *function;
+rl_bind_keyseq (const char *keyseq, rl_command_func_t *function)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
}
FUNCTION. This makes new keymaps as necessary. The initial
place to do bindings is in MAP. */
int
-rl_bind_keyseq_in_map (keyseq, function, map)
- const char *keyseq;
- rl_command_func_t *function;
- Keymap map;
+rl_bind_keyseq_in_map (const char *keyseq, rl_command_func_t *function, Keymap map)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}
/* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
int
-rl_set_key (keyseq, function, map)
- const char *keyseq;
- rl_command_func_t *function;
- Keymap map;
+rl_set_key (const char *keyseq, rl_command_func_t *function, Keymap map)
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
}
now, this is always used to attempt to bind the arrow keys, hence the
check for rl_vi_movement_mode. */
int
-rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)
- const char *keyseq;
- rl_command_func_t *default_func;
- Keymap kmap;
+rl_bind_keyseq_if_unbound_in_map (const char *keyseq, rl_command_func_t *default_func, Keymap kmap)
{
rl_command_func_t *func;
}
int
-rl_bind_keyseq_if_unbound (keyseq, default_func)
- const char *keyseq;
- rl_command_func_t *default_func;
+rl_bind_keyseq_if_unbound (const char *keyseq, rl_command_func_t *default_func)
{
return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
}
the string of characters MACRO. This makes new keymaps as
necessary. The initial place to do bindings is in MAP. */
int
-rl_macro_bind (keyseq, macro, map)
- const char *keyseq, *macro;
- Keymap map;
+rl_macro_bind (const char *keyseq, const char *macro, Keymap map)
{
char *macro_keys;
int macro_keys_len;
a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps
as necessary. The initial place to do bindings is in MAP. */
int
-rl_generic_bind (type, keyseq, data, map)
- int type;
- const char *keyseq;
- char *data;
- Keymap map;
+rl_generic_bind (int type, const char *keyseq, char *data, Keymap map)
{
char *keys;
int keys_len;
an array of characters. LEN gets the final length of ARRAY. Return
non-zero if there was an error parsing SEQ. */
int
-rl_translate_keyseq (seq, array, len)
- const char *seq;
- char *array;
- int *len;
+rl_translate_keyseq (const char *seq, char *array, int *len)
{
register int i, c, l, temp;
c = seq[++i];
if (c == 0)
- break;
+ {
+ array[l++] = '\\'; /* preserve trailing backslash */
+ break;
+ }
/* Handle \C- and \M- prefixes. */
if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
array[l++] = ESC; /* ESC is meta-prefix */
i += 5;
array[l++] = CTRL (_rl_to_upper (seq[i]));
- if (seq[i] == '\0')
- i--;
}
else if (c == 'M')
{
/* Special hack for C-?... */
array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
}
+ if (seq[i] == '\0')
+ break;
continue;
}
}
static int
-_rl_isescape (c)
- int c;
+_rl_isescape (int c)
{
switch (c)
{
}
static int
-_rl_escchar (c)
- int c;
+_rl_escchar (int c)
{
switch (c)
{
}
char *
-rl_untranslate_keyseq (seq)
- int seq;
+rl_untranslate_keyseq (int seq)
{
static char kseq[16];
int i, c;
}
char *
-_rl_untranslate_macro_value (seq, use_escapes)
- char *seq;
- int use_escapes;
+_rl_untranslate_macro_value (char *seq, int use_escapes)
{
char *ret, *r, *s;
int c;
If STRING doesn't have a matching function, then a NULL pointer
is returned. */
rl_command_func_t *
-rl_named_function (string)
- const char *string;
+rl_named_function (const char *string)
{
register int i;
type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
or ISMACR (macro). */
rl_command_func_t *
-rl_function_of_keyseq (keyseq, map, type)
- const char *keyseq;
- Keymap map;
- int *type;
+rl_function_of_keyseq (const char *keyseq, Keymap map, int *type)
{
register int i;
The size of the buffer is returned in *SIZEP. Returns NULL if any
errors were encountered. */
static char *
-_rl_read_file (filename, sizep)
- char *filename;
- size_t *sizep;
+_rl_read_file (char *filename, size_t *sizep)
{
struct stat finfo;
size_t file_size;
/* Re-read the current keybindings file. */
int
-rl_re_read_init_file (count, ignore)
- int count, ignore;
+rl_re_read_init_file (int count, int ignore)
{
int r;
r = rl_read_init_file ((const char *)NULL);
If the file existed and could be opened and read, 0 is returned,
otherwise errno is returned. */
int
-rl_read_init_file (filename)
- const char *filename;
+rl_read_init_file (const char *filename)
{
/* Default the filename. */
if (filename == 0)
}
static int
-_rl_read_init_file (filename, include_level)
- const char *filename;
- int include_level;
+_rl_read_init_file (const char *filename, int include_level)
{
register int i;
char *buffer, *openname, *line, *end;
/* Push _rl_parsing_conditionalized_out, and set parser state based
on ARGS. */
static int
-parser_if (args)
- char *args;
+parser_if (char *args)
{
register int i;
/* Invert the current parser state if there is anything on the stack. */
static int
-parser_else (args)
- char *args;
+parser_else (char *args)
{
register int i;
/* Terminate a conditional, popping the value of
_rl_parsing_conditionalized_out from the stack. */
static int
-parser_endif (args)
- char *args;
+parser_endif (char *args)
{
if (if_stack_depth)
_rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
}
static int
-parser_include (args)
- char *args;
+parser_include (char *args)
{
const char *old_init_file;
char *e;
/* Handle a parser directive. STATEMENT is the line of the directive
without any leading `$'. */
static int
-handle_parser_directive (statement)
- char *statement;
+handle_parser_directive (char *statement)
{
register int i;
char *directive, *args;
/* Start at STRING[START] and look for DELIM. Return I where STRING[I] ==
DELIM or STRING[I] == 0. DELIM is usually a double quote. */
static int
-_rl_skip_to_delim (string, start, delim)
- char *string;
- int start, delim;
+_rl_skip_to_delim (char *string, int start, int delim)
{
int i, c, passc;
a variable binding command looks like: set variable value.
A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
int
-rl_parse_and_bind (string)
- char *string;
+rl_parse_and_bind (char *string)
{
char *funname, *kname;
register int c, i;
/* Advance to the colon (:) or whitespace which separates the two objects. */
for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
+ if (i == 0)
+ {
+ _rl_init_file_error ("`%s': invalid key binding: missing key sequence", string);
+ return 1;
+ }
+
equivalency = (c == ':' && string[i + 1] == '=');
foundsep = c != 0;
i = _rl_skip_to_delim (string, i+1, *funname);
if (string[i])
i++;
+ else
+ {
+ _rl_init_file_error ("`%s': missing closing quote for macro", funname);
+ return 1;
+ }
}
/* Advance to the end of the string. */
};
static int
-find_boolean_var (name)
- const char *name;
+find_boolean_var (const char *name)
{
register int i;
function needs to be called or another variable needs
to be changed when they're changed. */
static void
-hack_special_boolean_var (i)
- int i;
+hack_special_boolean_var (int i)
{
const char *name;
};
static int
-find_string_var (name)
- const char *name;
+find_string_var (const char *name)
{
register int i;
the value is null or empty, `on' (case-insensitive), or "1". Any other
values result in 0 (false). */
static int
-bool_to_int (value)
- const char *value;
+bool_to_int (const char *value)
{
return (value == 0 || *value == '\0' ||
(_rl_stricmp (value, "on") == 0) ||
}
char *
-rl_variable_value (name)
- const char *name;
+rl_variable_value (const char *name)
{
register int i;
}
int
-rl_variable_bind (name, value)
- const char *name, *value;
+rl_variable_bind (const char *name, const char *value)
{
register int i;
int v;
}
static int
-sv_editmode (value)
- const char *value;
+sv_editmode (const char *value)
{
if (_rl_strnicmp (value, "vi", 2) == 0)
{
}
static int
-sv_combegin (value)
- const char *value;
+sv_combegin (const char *value)
{
if (value && *value)
{
}
static int
-sv_dispprefix (value)
- const char *value;
+sv_dispprefix (const char *value)
{
int nval = 0;
}
static int
-sv_compquery (value)
- const char *value;
+sv_compquery (const char *value)
{
int nval = 100;
}
static int
-sv_compwidth (value)
- const char *value;
+sv_compwidth (const char *value)
{
int nval = -1;
}
static int
-sv_histsize (value)
- const char *value;
+sv_histsize (const char *value)
{
int nval;
}
static int
-sv_keymap (value)
- const char *value;
+sv_keymap (const char *value)
{
Keymap kmap;
}
static int
-sv_seqtimeout (value)
- const char *value;
+sv_seqtimeout (const char *value)
{
int nval;
}
static int
-sv_bell_style (value)
- const char *value;
+sv_bell_style (const char *value)
{
if (value == 0 || *value == '\0')
_rl_bell_preference = AUDIBLE_BELL;
}
static int
-sv_isrchterm (value)
- const char *value;
+sv_isrchterm (const char *value)
{
int beg, end, delim;
char *v;
extern char *_rl_emacs_mode_str;
static int
-sv_emacs_modestr (value)
- const char *value;
+sv_emacs_modestr (const char *value)
{
if (value && *value)
{
}
static int
-sv_viins_modestr (value)
- const char *value;
+sv_viins_modestr (const char *value)
{
if (value && *value)
{
}
static int
-sv_vicmd_modestr (value)
- const char *value;
+sv_vicmd_modestr (const char *value)
{
if (value && *value)
{
};
static int
-glean_key_from_name (name)
- char *name;
+glean_key_from_name (char *name)
{
register int i;
};
Keymap
-rl_get_keymap_by_name (name)
- const char *name;
+rl_get_keymap_by_name (const char *name)
{
register int i;
}
char *
-rl_get_keymap_name (map)
- Keymap map;
+rl_get_keymap_name (Keymap map)
{
register int i;
for (i = 0; keymap_names[i].name; i++)
}
void
-rl_set_keymap (map)
- Keymap map;
+rl_set_keymap (Keymap map)
{
if (map)
_rl_keymap = map;
}
Keymap
-rl_get_keymap ()
+rl_get_keymap (void)
{
return (_rl_keymap);
}
void
-rl_set_keymap_from_edit_mode ()
+rl_set_keymap_from_edit_mode (void)
{
if (rl_editing_mode == emacs_mode)
_rl_keymap = emacs_standard_keymap;
}
char *
-rl_get_keymap_name_from_edit_mode ()
+rl_get_keymap_name_from_edit_mode (void)
{
if (rl_editing_mode == emacs_mode)
return "emacs";
/* Print the names of functions known to Readline. */
void
-rl_list_funmap_names ()
+rl_list_funmap_names (void)
{
register int i;
const char **funmap_names;
}
static char *
-_rl_get_keyname (key)
- int key;
+_rl_get_keyname (int key)
{
char *keyname;
int i, c;
/* Return a NULL terminated array of strings which represent the key
sequences that are used to invoke FUNCTION in MAP. */
char **
-rl_invoking_keyseqs_in_map (function, map)
- rl_command_func_t *function;
- Keymap map;
+rl_invoking_keyseqs_in_map (rl_command_func_t *function, Keymap map)
{
register int key;
char **result;
/* Return a NULL terminated array of strings which represent the key
sequences that can be used to invoke FUNCTION using the current keymap. */
char **
-rl_invoking_keyseqs (function)
- rl_command_func_t *function;
+rl_invoking_keyseqs (rl_command_func_t *function)
{
return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}
PRINT_READABLY is non-zero, then print the output in such a way
that it can be read back in. */
void
-rl_function_dumper (print_readably)
- int print_readably;
+rl_function_dumper (int print_readably)
{
register int i;
const char **names;
rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */
int
-rl_dump_functions (count, key)
- int count, key;
+rl_dump_functions (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
}
static void
-_rl_macro_dumper_internal (print_readably, map, prefix)
- int print_readably;
- Keymap map;
- char *prefix;
+_rl_macro_dumper_internal (int print_readably, Keymap map, char *prefix)
{
register int key;
char *keyname, *out;
}
void
-rl_macro_dumper (print_readably)
- int print_readably;
+rl_macro_dumper (int print_readably)
{
_rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
}
int
-rl_dump_macros (count, key)
- int count, key;
+rl_dump_macros (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
}
static char *
-_rl_get_string_variable_value (name)
- const char *name;
+_rl_get_string_variable_value (const char *name)
{
static char numbuf[32];
char *ret;
}
void
-rl_variable_dumper (print_readably)
- int print_readably;
+rl_variable_dumper (int print_readably)
{
int i;
char *v;
rl_outstream. If an explicit argument is given, then print
the output in such a way that it can be read back in. */
int
-rl_dump_variables (count, key)
- int count, key;
+rl_dump_variables (int count, int key)
{
if (rl_dispatching)
fprintf (rl_outstream, "\r\n");
/* Return non-zero if any members of ARRAY are a substring in STRING. */
static int
-substring_member_of_array (string, array)
- const char *string;
- const char * const *array;
+substring_member_of_array (const char *string, const char * const *array)
{
while (*array)
{
/* callback.c -- functions to use readline as an X `callback' mechanism. */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* **************************************************************** */
/* */
-/* Callback Readline Functions */
+/* Callback Readline Functions */
/* */
/* **************************************************************** */
/* Make sure the terminal is set up, initialize readline, and prompt. */
static void
-_rl_callback_newline ()
+_rl_callback_newline (void)
{
rl_initialize ();
/* Install a readline handler, set up the terminal, and issue the prompt. */
void
-rl_callback_handler_install (prompt, linefunc)
- const char *prompt;
- rl_vcpfunc_t *linefunc;
+rl_callback_handler_install (const char *prompt, rl_vcpfunc_t *linefunc)
{
rl_set_prompt (prompt);
RL_SETSTATE (RL_STATE_CALLBACK);
/* Read one character, and dispatch to the handler if it ends the line. */
void
-rl_callback_read_char ()
+rl_callback_read_char (void)
{
char *line;
int eof, jcode;
/* Remove the handler, and make sure the terminal is in its normal state. */
void
-rl_callback_handler_remove ()
+rl_callback_handler_remove (void)
{
rl_linefunc = NULL;
RL_UNSETSTATE (RL_STATE_CALLBACK);
}
_rl_callback_generic_arg *
-_rl_callback_data_alloc (count)
- int count;
+_rl_callback_data_alloc (int count)
{
_rl_callback_generic_arg *arg;
}
void
-_rl_callback_data_dispose (arg)
- _rl_callback_generic_arg *arg;
+_rl_callback_data_dispose (_rl_callback_generic_arg *arg)
{
xfree (arg);
}
/* Make sure that this agrees with cases in rl_callback_read_char */
void
-rl_callback_sigcleanup ()
+rl_callback_sigcleanup (void)
{
if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
return;
Modified by Chet Ramey for Readline.
- Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2015
+ Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2015, 2017
Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
/* Output a color indicator (which may contain nulls). */
void
-_rl_put_indicator (const struct bin_str *ind) {
+_rl_put_indicator (const struct bin_str *ind)
+{
fwrite (ind->string, ind->len, 1, rl_outstream);
}
/* compat.c -- backwards compatibility functions. */
-/* Copyright (C) 2000-2009 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Provide backwards-compatible entry points for old function names. */
void
-free_undo_list ()
+free_undo_list (void)
{
rl_free_undo_list ();
}
int
-maybe_replace_line ()
+maybe_replace_line (void)
{
return rl_maybe_replace_line ();
}
int
-maybe_save_line ()
+maybe_save_line (void)
{
return rl_maybe_save_line ();
}
int
-maybe_unsave_line ()
+maybe_unsave_line (void)
{
return rl_maybe_unsave_line ();
}
int
-ding ()
+ding (void)
{
return rl_ding ();
}
int
-crlf ()
+crlf (void)
{
return rl_crlf ();
}
int
-alphabetic (c)
- int c;
+alphabetic (int c)
{
return rl_alphabetic (c);
}
char **
-completion_matches (s, f)
- const char *s;
- rl_compentry_func_t *f;
+completion_matches (const char *s, rl_compentry_func_t *f)
{
return rl_completion_matches (s, f);
}
char *
-username_completion_function (s, i)
- const char *s;
- int i;
+username_completion_function (const char *s, int i)
{
return rl_username_completion_function (s, i);
}
char *
-filename_completion_function (s, i)
- const char *s;
- int i;
+filename_completion_function (const char *s, int i)
{
return rl_filename_completion_function (s, i);
}
/* complete.c -- filename completion for readline. */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
matches. If < 0 or > _rl_screenwidth, it is ignored. */
int _rl_completion_columns = -1;
-/* Global variables available to applications using readline. */
-
-#if defined (VISIBLE_STATS)
-/* Non-zero means add an additional character to each filename displayed
- during listing completion iff rl_filename_completion_desired which helps
- to indicate the type of file being listed. */
-int rl_visible_stats = 0;
-#endif /* VISIBLE_STATS */
-
#if defined (COLOR_SUPPORT)
/* Non-zero means to use colors to indicate file type when listing possible
completions. The colors used are taken from $LS_COLORS, if set. */
cycle of possible completions instead of the last. */
int _rl_menu_complete_prefix_first = 0;
+/* Global variables available to applications using readline. */
+
+#if defined (VISIBLE_STATS)
+/* Non-zero means add an additional character to each filename displayed
+ during listing completion iff rl_filename_completion_desired which helps
+ to indicate the type of file being listed. */
+int rl_visible_stats = 0;
+#endif /* VISIBLE_STATS */
+
/* If non-zero, then this is the address of a function to call when
completing on a directory name. The function is called with
the address of a string (the current directory name) as an arg. */
that does the initial simple matching selection algorithm (see
rl_completion_matches ()). The default is to do filename completion. */
int
-rl_complete (ignore, invoking_key)
- int ignore, invoking_key;
+rl_complete (int ignore, int invoking_key)
{
rl_completion_invoking_key = invoking_key;
/* List the possible completions. See description of rl_complete (). */
int
-rl_possible_completions (ignore, invoking_key)
- int ignore, invoking_key;
+rl_possible_completions (int ignore, int invoking_key)
{
rl_completion_invoking_key = invoking_key;
return (rl_complete_internal ('?'));
}
int
-rl_insert_completions (ignore, invoking_key)
- int ignore, invoking_key;
+rl_insert_completions (int ignore, int invoking_key)
{
rl_completion_invoking_key = invoking_key;
return (rl_complete_internal ('*'));
an application-specific completion function to honor the
show-all-if-ambiguous readline variable. */
int
-rl_completion_mode (cfunc)
- rl_command_func_t *cfunc;
+rl_completion_mode (rl_command_func_t *cfunc)
{
if (rl_last_func == cfunc && !completion_changed_buffer)
return '?';
/* Reset readline state on a signal or other event. */
void
-_rl_reset_completion_state ()
+_rl_reset_completion_state (void)
{
rl_completion_found_quote = 0;
rl_completion_quote_character = 0;
}
static void
-_rl_complete_sigcleanup (sig, ptr)
- int sig;
- void *ptr;
+_rl_complete_sigcleanup (int sig, void *ptr)
{
if (sig == SIGINT) /* XXX - for now */
{
/* Set default values for readline word completion. These are the variables
that application completion functions can change or inspect. */
static void
-set_completion_defaults (what_to_do)
- int what_to_do;
+set_completion_defaults (int what_to_do)
{
/* Only the completion entry function can change these. */
rl_filename_completion_desired = 0;
/* The user must press "y" or "n". Non-zero return means "y" pressed. */
static int
-get_y_or_n (for_pager)
- int for_pager;
+get_y_or_n (int for_pager)
{
int c;
}
static int
-_rl_internal_pager (lines)
- int lines;
+_rl_internal_pager (int lines)
{
int i;
}
static int
-path_isdir (filename)
- const char *filename;
+path_isdir (const char *filename)
{
struct stat finfo;
`%' for character special devices
`#' for block special devices */
static int
-stat_char (filename)
- char *filename;
+stat_char (char *filename)
{
struct stat finfo;
int character, r;
#if defined (COLOR_SUPPORT)
static int
-colored_stat_start (filename)
- const char *filename;
+colored_stat_start (const char *filename)
{
_rl_set_normal_color ();
return (_rl_print_color_indicator (filename));
}
static void
-colored_stat_end ()
+colored_stat_end (void)
{
_rl_prep_non_filename_text ();
_rl_put_indicator (&_rl_color_indicator[C_CLR_TO_EOL]);
}
static int
-colored_prefix_start ()
+colored_prefix_start (void)
{
_rl_set_normal_color ();
return (_rl_print_prefix_color ());
}
static void
-colored_prefix_end ()
+colored_prefix_end (void)
{
colored_stat_end (); /* for now */
}
for the previous slash and return the portion following that. If
there's no previous slash, we just return what we were passed. */
static char *
-printable_part (pathname)
- char *pathname;
+printable_part (char *pathname)
{
char *temp, *x;
/* Compute width of STRING when displayed on screen by print_filename */
static int
-fnwidth (string)
- const char *string;
+fnwidth (const char *string)
{
int width, pos;
#if defined (HANDLE_MULTIBYTE)
#define ELLIPSIS_LEN 3
static int
-fnprint (to_print, prefix_bytes, real_pathname)
- const char *to_print;
- int prefix_bytes;
- const char *real_pathname;
+fnprint (const char *to_print, int prefix_bytes, const char *real_pathname)
{
int printed_len, w;
const char *s;
filenames. Return the number of characters we output. */
static int
-print_filename (to_print, full_pathname, prefix_bytes)
- char *to_print, *full_pathname;
- int prefix_bytes;
+print_filename (char *to_print, char *full_pathname, int prefix_bytes)
{
int printed_len, extension_char, slen, tlen;
char *s, c, *new_full_pathname, *dn;
slen--;
else
new_full_pathname[slen] = '/';
- new_full_pathname[slen] = '/';
strcpy (new_full_pathname + slen + 1, to_print);
#if defined (VISIBLE_STATS)
}
static char *
-rl_quote_filename (s, rtype, qcp)
- char *s;
- int rtype;
- char *qcp;
+rl_quote_filename (char *s, int rtype, char *qcp)
{
char *r;
the value of the delimiter character that caused a word break. */
char
-_rl_find_completion_word (fp, dp)
- int *fp, *dp;
+_rl_find_completion_word (int *fp, int *dp)
{
int scan, end, found_quote, delimiter, pass_next, isbrk;
char quote_char, *brkchars;
}
static char **
-gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
- char *text;
- int start, end;
- rl_compentry_func_t *our_func;
- int found_quote, quote_char;
+gen_completion_matches (char *text, int start, int end, rl_compentry_func_t *our_func, int found_quote, int quote_char)
{
char **matches;
/* Filter out duplicates in MATCHES. This frees up the strings in
MATCHES. */
static char **
-remove_duplicate_matches (matches)
- char **matches;
+remove_duplicate_matches (char **matches)
{
char *lowest_common;
int i, j, newlen;
/* Find the common prefix of the list of matches, and put it into
matches[0]. */
static int
-compute_lcd_of_matches (match_list, matches, text)
- char **match_list;
- int matches;
- const char *text;
+compute_lcd_of_matches (char **match_list, int matches, const char *text)
{
register int i, c1, c2, si;
int low; /* Count of max-matched characters. */
}
/* sort the list to get consistent answers. */
- qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
+ if (rl_sort_completion_matches)
+ qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
si = strlen (text);
lx = (si <= low) ? si : low; /* check shorter of text and matches */
}
static int
-postprocess_matches (matchesp, matching_filenames)
- char ***matchesp;
- int matching_filenames;
+postprocess_matches (char ***matchesp, int matching_filenames)
{
char *t, **matches, **temp_matches;
int nmatch, i;
}
static int
-complete_get_screenwidth ()
+complete_get_screenwidth (void)
{
int cols;
char *envcols;
of strings, in argv format, LEN is the number of strings in MATCHES,
and MAX is the length of the longest string in MATCHES. */
void
-rl_display_match_list (matches, len, max)
- char **matches;
- int len, max;
+rl_display_match_list (char **matches, int len, int max)
{
int count, limit, printed_len, lines, cols;
int i, j, k, l, common_length, sind;
and ask the user if he wants to see the list if there are more matches
than RL_COMPLETION_QUERY_ITEMS. */
static void
-display_matches (matches)
- char **matches;
+display_matches (char **matches)
{
int len, max, i;
char *temp;
rl_display_fixed = 1;
}
+/* qc == pointer to quoting character, if any */
static char *
-make_quoted_replacement (match, mtype, qc)
- char *match;
- int mtype;
- char *qc; /* Pointer to quoting character, if any */
+make_quoted_replacement (char *match, int mtype, char *qc)
{
int should_quote, do_replace;
char *replacement;
}
static void
-insert_match (match, start, mtype, qc)
- char *match;
- int start, mtype;
- char *qc;
+insert_match (char *match, int start, int mtype, char *qc)
{
char *replacement, *r;
char oqc;
value of _rl_complete_mark_symlink_dirs, but may be modified by an
application's completion function). */
static int
-append_to_match (text, delimiter, quote_char, nontrivial_match)
- char *text;
- int delimiter, quote_char, nontrivial_match;
+append_to_match (char *text, int delimiter, int quote_char, int nontrivial_match)
{
char temp_string[4], *filename, *fn;
int temp_string_index, s;
}
static void
-insert_all_matches (matches, point, qc)
- char **matches;
- int point;
- char *qc;
+insert_all_matches (char **matches, int point, char *qc)
{
int i;
char *rp;
}
void
-_rl_free_match_list (matches)
- char **matches;
+_rl_free_match_list (char **matches)
{
register int i;
`@' means to do standard completion, and list all possible completions if
there is more than one and partial completion is not possible. */
int
-rl_complete_internal (what_to_do)
- int what_to_do;
+rl_complete_internal (int what_to_do)
{
char **matches;
rl_compentry_func_t *our_func;
int start, end, delimiter, found_quote, i, nontrivial_lcd;
char *text, *saved_line_buffer;
char quote_char;
-#if 1
int tlen, mlen;
-#endif
RL_SETSTATE(RL_STATE_COMPLETING);
when there are no more matches.
*/
char **
-rl_completion_matches (text, entry_function)
- const char *text;
- rl_compentry_func_t *entry_function;
+rl_completion_matches (const char *text, rl_compentry_func_t *entry_function)
{
register int i;
TEXT contains a partial username preceded by a random
character (usually `~'). */
char *
-rl_username_completion_function (text, state)
- const char *text;
- int state;
+rl_username_completion_function (const char *text, int state)
{
#if defined (__WIN32__) || defined (__OPENNT)
return (char *)NULL;
_rl_completion_case_map is set, make `-' and `_' equivalent. CONVFN is
the possibly-converted directory entry; FILENAME is what the user typed. */
static int
-complete_fncmp (convfn, convlen, filename, filename_len)
- const char *convfn;
- int convlen;
- const char *filename;
- int filename_len;
+complete_fncmp (const char *convfn, int convlen, const char *filename, int filename_len)
{
register char *s1, *s2;
int d, len;
because of all the pathnames that must be followed when looking up the
completion for a command. */
char *
-rl_filename_completion_function (text, state)
- const char *text;
- int state;
+rl_filename_completion_function (const char *text, int state)
{
static DIR *directory = (DIR *)NULL;
static char *filename = (char *)NULL;
hit the end of the match list, we restore the original unmatched text,
ring the bell, and reset the counter to zero. */
int
-rl_old_menu_complete (count, invoking_key)
- int count, invoking_key;
+rl_old_menu_complete (int count, int invoking_key)
{
rl_compentry_func_t *our_func;
int matching_filenames, found_quote;
return (0);
}
+/* The current version of menu completion.
+ The differences between this function and the original are:
+
+1. It honors the maximum number of completions variable (completion-query-items)
+2. It appends to the word as usual if there is only one match
+3. It displays the common prefix if there is one, and makes it the first menu
+ choice if the menu-complete-display-prefix option is enabled
+*/
+
int
-rl_menu_complete (count, ignore)
- int count, ignore;
+rl_menu_complete (int count, int ignore)
{
rl_compentry_func_t *our_func;
int matching_filenames, found_quote;
}
int
-rl_backward_menu_complete (count, key)
- int count, key;
+rl_backward_menu_complete (int count, int key)
{
/* Positive arguments to backward-menu-complete translate into negative
arguments for menu-complete, and vice versa. */
/* display.c -- readline redisplay facility. */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* What YOU turn on when you have handled all redisplay yourself. */
int rl_display_fixed = 0;
-int _rl_suppress_redisplay = 0;
-int _rl_want_redisplay = 0;
-
/* The stuff that gets printed out before the actual text of the line.
This is usually pointing to rl_prompt. */
char *rl_display_prompt = (char *)NULL;
/* Pseudo-global variables declared here. */
+/* Hints for other parts of readline to give to the display engine. */
+int _rl_suppress_redisplay = 0;
+int _rl_want_redisplay = 0;
+
/* The visible cursor position. If you print some text, adjust this. */
/* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale
supporting multibyte characters, and an absolute cursor position when
int _rl_last_c_pos = 0;
int _rl_last_v_pos = 0;
+/* Number of physical lines consumed by the current line buffer currently
+ on screen minus 1. */
+int _rl_vis_botlin = 0;
+
+/* This is a hint update_line gives to rl_redisplay that it has adjusted the
+ value of _rl_last_c_pos *and* taken the presence of any invisible chars in
+ the prompt into account. rl_redisplay notes this and does not do the
+ adjustment itself. */
static int cpos_adjusted;
+
+/* The index into the line buffer corresponding to the cursor position */
static int cpos_buffer_position;
+
+/* A flag to note when we're displaying the first line of the prompt */
static int displaying_prompt_first_line;
+/* The number of multibyte characters in the prompt, if any */
static int prompt_multibyte_chars;
-/* Number of lines currently on screen minus 1. */
-int _rl_vis_botlin = 0;
-
static int _rl_inv_botlin = 0;
/* Variables used only in this file. */
static char *local_prompt, *local_prompt_prefix;
static int local_prompt_len;
-static int prompt_visible_length, prompt_prefix_length;
+static int prompt_prefix_length;
+/* Number of chars in the buffer that contribute to visible chars on the screen.
+ This might be different from the number of physical chars in the presence
+ of multibyte characters */
+static int prompt_visible_length;
/* The number of invisible characters in the line currently being
displayed on the screen. */
static int prompt_physical_chars;
+/* An array of indexes into the prompt string where we will break physical
+ screen lines. It's easier to compute in expand_prompt and use later in
+ rl_redisplay instead of having rl_redisplay try to guess about invisible
+ characters in the prompt or use heuristics about where they are. */
+static int *local_prompt_newlines;
+
/* set to a non-zero value by rl_redisplay if we are marking modified history
lines and the current line is so marked. */
static int modmark;
static char *saved_local_prompt;
static char *saved_local_prefix;
+static int *saved_local_prompt_newlines;
+
static int saved_last_invisible;
static int saved_visible_length;
static int saved_prefix_length;
/* Return a string indicating the editing mode, for use in the prompt. */
static char *
-prompt_modestr (lenp)
- int *lenp;
+prompt_modestr (int *lenp)
{
if (rl_editing_mode == emacs_mode)
{
index of the last invisible character in the returned string. NIFLP,
if non-zero, is a place to store the number of invisible characters in
the first prompt line. The previous are used as byte counts -- indexes
- into a character buffer. */
+ into a character buffer. *VLP gets the number of physical characters in
+ the expanded prompt (visible length) */
/* Current implementation:
\001 (^A) start non-visible characters
PMT_MULTILINE caller indicates that this is part of a multiline prompt
*/
+/* This approximates the number of lines the prompt will take when displayed */
+#define APPROX_DIV(n, d) (((n) < (d)) ? 1 : ((n) / (d)) + 1)
+
static char *
-expand_prompt (pmt, flags, lp, lip, niflp, vlp)
- char *pmt;
- int flags;
- int *lp, *lip, *niflp, *vlp;
+expand_prompt (char *pmt, int flags, int *lp, int *lip, int *niflp, int *vlp)
{
char *r, *ret, *p, *igstart, *nprompt, *ms;
int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
- int mlen;
+ int mlen, newlines, newlines_guess, bound;
+ int mb_cur_max;
/* We only expand the mode string for the last line of a multiline prompt
(a prompt with embedded newlines). */
else
nprompt = pmt;
- /* Short-circuit if we can. */
- if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (nprompt, RL_PROMPT_START_IGNORE) == 0)
+ mb_cur_max = MB_CUR_MAX;
+
+ if (_rl_screenwidth == 0)
+ _rl_get_screen_size (0, 0); /* avoid division by zero */
+
+ /* Short-circuit if we can. We can do this if we are treating the prompt as
+ a sequence of bytes and there are no invisible characters in the prompt
+ to deal with. Since we populate local_prompt_newlines, we have to run
+ through the rest of the function if this prompt looks like it's going to
+ be longer than one screen line. */
+ if ((mb_cur_max <= 1 || rl_byte_oriented) && strchr (nprompt, RL_PROMPT_START_IGNORE) == 0)
{
- r = (nprompt == pmt) ? savestring (pmt) : nprompt;
+ l = strlen (nprompt);
+ if (l < (_rl_screenwidth > 0 ? _rl_screenwidth : 80))
+ {
+ r = (nprompt == pmt) ? savestring (pmt) : nprompt;
+ if (lp)
+ *lp = l;
+ if (lip)
+ *lip = 0;
+ if (niflp)
+ *niflp = 0;
+ if (vlp)
+ *vlp = l;
- if (lp)
- *lp = strlen (r);
- if (lip)
- *lip = 0;
- if (niflp)
- *niflp = 0;
- if (vlp)
- *vlp = lp ? *lp : strlen (r);
- return r;
+ local_prompt_newlines = (int *) xrealloc (local_prompt_newlines, sizeof (int) * 2);
+ local_prompt_newlines[0] = 0;
+ local_prompt_newlines[1] = -1;
+
+ return r;
+ }
}
l = strlen (nprompt); /* XXX */
r = ret = (char *)xmalloc (l + 1);
+ /* Guess at how many screen lines the prompt will take to size the array that
+ keeps track of where the line wraps happen */
+ newlines_guess = (_rl_screenwidth > 0) ? APPROX_DIV(l, _rl_screenwidth) : APPROX_DIV(l, 80);
+ local_prompt_newlines = (int *) xrealloc (local_prompt_newlines, sizeof (int) * (newlines_guess + 1));
+ local_prompt_newlines[newlines = 0] = 0;
+ for (rl = 1; rl <= newlines_guess; rl++)
+ local_prompt_newlines[rl] = -1;
+
rl = physchars = 0; /* mode string now part of nprompt */
- invfl = 0; /* invisible chars in first line of prompt */
- invflset = 0; /* we only want to set invfl once */
- igstart = 0;
+ invfl = 0; /* invisible chars in first line of prompt */
+ invflset = 0; /* we only want to set invfl once */
+ igstart = 0; /* we're not ignoring any characters yet */
for (ignoring = last = ninvis = 0, p = nprompt; p && *p; p++)
{
else
{
#if defined (HANDLE_MULTIBYTE)
- if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
+ if (mb_cur_max > 1 && rl_byte_oriented == 0)
{
pind = p - nprompt;
ind = _rl_find_next_mbchar (nprompt, pind, 1, MB_FIND_NONZERO);
ninvis++; /* invisible chars byte counter */
}
- if (invflset == 0 && rl >= _rl_screenwidth)
+ if (invflset == 0 && physchars >= _rl_screenwidth)
{
invfl = ninvis;
invflset = 1;
}
+
+ if (physchars >= (bound = (newlines + 1) * _rl_screenwidth) && local_prompt_newlines[newlines+1] == -1)
+ {
+ int new;
+ if (physchars > bound) /* should rarely happen */
+ {
+#if defined (HANDLE_MULTIBYTE)
+ if (mb_cur_max > 1 && rl_byte_oriented == 0)
+ new = _rl_find_prev_mbchar (ret, r - ret, MB_FIND_ANY);
+ else
+#endif
+ new = r - ret - (physchars - bound); /* XXX */
+ }
+ else
+ new = r - ret;
+ local_prompt_newlines[++newlines] = new;
+ }
}
}
/* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
PMT and return the rest of PMT. */
char *
-_rl_strip_prompt (pmt)
- char *pmt;
+_rl_strip_prompt (char *pmt)
{
char *ret;
}
void
-_rl_reset_prompt ()
+_rl_reset_prompt (void)
{
rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
}
* prompt_visible_length = number of visible characters in local_prompt
* prompt_prefix_length = number of visible characters in local_prompt_prefix
*
+ * It also tries to keep track of the number of invisible characters in the
+ * prompt string, and where they are.
+ *
* This function is called once per call to readline(). It may also be
* called arbitrarily to expand the primary prompt.
*
* The return value is the number of visible characters on the last line
- * of the (possibly multi-line) prompt.
+ * of the (possibly multi-line) prompt. In this case, multi-line means
+ * there are embedded newlines in the prompt string itself, not that the
+ * number of physical characters exceeds the screen width and the prompt
+ * wraps.
*/
int
-rl_expand_prompt (prompt)
- char *prompt;
+rl_expand_prompt (char *prompt)
{
char *p, *t;
int c;
increased. If the lines have already been allocated, this ensures that
they can hold at least MINSIZE characters. */
static void
-init_line_structures (minsize)
- int minsize;
+init_line_structures (int minsize)
{
register int n;
line_structures_initialized = 1;
}
-/* Basic redisplay algorithm. */
+/* Basic redisplay algorithm. See comments inline. */
void
-rl_redisplay ()
+rl_redisplay (void)
{
register int in, out, c, linenum, cursor_linenum;
register char *line;
one passed to readline()), use the values we have already expanded.
If not, use what's already in rl_display_prompt. WRAP_OFFSET is the
number of non-visible characters in the prompt string. */
+ /* This is where we output the characters in the prompt before the last
+ newline, if any. If there aren't any embedded newlines, we don't
+ write anything. Copy the last line of the prompt string into the line in
+ any case */
if (rl_display_prompt == rl_prompt || local_prompt)
{
if (local_prompt_prefix && forced_display)
wrap_offset = prompt_invis_chars_first_line = 0;
}
+#if defined (HANDLE_MULTIBYTE)
#define CHECK_INV_LBREAKS() \
do { \
if (newlines >= (inv_lbsize - 2)) \
inv_lbsize *= 2; \
inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
} \
+ if (newlines >= (line_state_invisible->wbsize - 2)) \
+ { \
+ line_state_invisible->wbsize *= 2; \
+ line_state_invisible->wrapped_line = (int *)xrealloc (line_state_invisible->wrapped_line, line_state_invisible->wbsize * sizeof(int)); \
+ } \
} while (0)
+#else
+#define CHECK_INV_LBREAKS() \
+ do { \
+ if (newlines >= (inv_lbsize - 2)) \
+ { \
+ inv_lbsize *= 2; \
+ inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
+ } \
+ } while (0)
+#endif /* !HANDLE_MULTIBYTE */
#if defined (HANDLE_MULTIBYTE)
#define CHECK_LPOS() \
inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
} \
inv_lbreaks[++newlines] = out; \
- if (newlines >= (line_state_invisible->wbsize - 1)) \
+ if (newlines >= (line_state_invisible->wbsize - 2)) \
{ \
line_state_invisible->wbsize *= 2; \
line_state_invisible->wrapped_line = (int *)xrealloc (line_state_invisible->wrapped_line, line_state_invisible->wbsize * sizeof(int)); \
/* inv_lbreaks[i] is where line i starts in the buffer. */
inv_lbreaks[newlines = 0] = 0;
/* lpos is a physical cursor position, so it needs to be adjusted by the
- number of invisible characters in the prompt, per line */
+ number of invisible characters in the prompt, per line. We compute
+ the line breaks in the prompt string in expand_prompt, taking invisible
+ characters into account, and if lpos exceeds the screen width, we copy
+ the data in the loop below. */
lpos = prompt_physical_chars + modmark;
#if defined (HANDLE_MULTIBYTE)
/* prompt_invis_chars_first_line is the number of invisible characters in
the first physical line of the prompt.
- wrap_offset - prompt_invis_chars_first_line is the number of invis
- chars on the second (or, more generally, last) line. */
+ wrap_offset - prompt_invis_chars_first_line is usually the number of
+ invis chars on the second (or, more generally, last) line. */
/* This is zero-based, used to set the newlines */
prompt_lines_estimate = lpos / _rl_screenwidth;
/* what if lpos is already >= _rl_screenwidth before we start drawing the
contents of the command line? */
- while (lpos >= _rl_screenwidth)
- {
- int z, p;
- int nocorrect, wadjust;
-
- nocorrect = 0;
- /* Adjust depending on the invisible characters in the line. We use a
- heuristic based on experience: invisible characters nearly always
- appear in the first and last lines of the prompt */
- wadjust = (newlines == 0)
- ? prompt_invis_chars_first_line
- : ((newlines == prompt_lines_estimate) ? wrap_offset : prompt_invis_chars_first_line);
-
- /* fix from Darin Johnson <darin@acuson.com> for prompt string with
- invisible characters that is longer than the screen width. The
- prompt_invis_chars_first_line variable could be made into an array
- saying how many invisible characters there are per line, but that's
- probably too much work for the benefit gained. How many people have
- prompts that exceed two physical lines?
- Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
-#if defined (HANDLE_MULTIBYTE)
- if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
- {
- nocorrect = 1;
- n0 = num;
- temp = local_prompt_len;
- while (num < temp)
- {
- /* This has to take invisible characters in the prompt into
- account. */
- z = _rl_col_width (local_prompt, n0, num, 1) - wadjust;
- if (z > _rl_screenwidth)
- {
- num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
- break;
- }
- else if (z == _rl_screenwidth)
- {
- /* If we are in the middle or at the end of a multibyte
- character, we want to move to the start, then find out
- where it ends so we know where to insert the newline.
- If this isn't a multibyte character, its the same as num++ */
- p = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
- num = _rl_find_next_mbchar (local_prompt, p, 1, MB_FIND_ANY);
- break;
- }
- num++;
- }
- temp = num;
- }
- else
-#endif /* !HANDLE_MULTIBYTE */
- temp = ((newlines + 1) * _rl_screenwidth);
+ if (lpos >= _rl_screenwidth)
+ {
+ temp = 0;
- /* Now account for invisible characters in the current line. */
- /* XXX - this assumes that the invisible characters may be split, but only
- between the first and the last lines. */
- if (nocorrect == 0)
- temp += wadjust;
+ /* first copy the linebreaks array we computed in expand_prompt */
+ while (local_prompt_newlines[newlines+1] != -1)
+ {
+ temp = local_prompt_newlines[newlines+1];
+ inv_lbreaks[++newlines] = temp;
+ }
- inv_lbreaks[++newlines] = temp;
-#if defined (HANDLE_MULTIBYTE)
- /* lpos is a physical cursor position, so it needs to take the invisible
- characters into account. */
+ /* Now set lpos from the last newline */
if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
- lpos -= _rl_col_width (local_prompt, n0, num, 1) - wadjust;
+ lpos = _rl_col_width (local_prompt, temp, local_prompt_len, 1) - (wrap_offset - prompt_invis_chars_first_line);
else
-#endif
- lpos -= _rl_screenwidth; /* all physical cursor positions */
+ lpos -= (_rl_screenwidth * newlines);
}
prompt_last_screen_line = newlines;
/* Draw the rest of the line (after the prompt) into invisible_line, keeping
- track of where the cursor is (cpos_buffer_position), the number of the line containing
- the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
+ track of where the cursor is (cpos_buffer_position), the number of the
+ line containing the cursor (lb_linenum), the last line number (lb_botlin
+ and inv_botlin).
It maintains an array of line breaks for display (inv_lbreaks).
This handles expanding tabs for display and displaying meta characters. */
lb_linenum = 0;
temp = _rl_screenwidth - lpos;
CHECK_INV_LBREAKS ();
inv_lbreaks[++newlines] = out + temp;
+#if defined (HANDLE_MULTIBYTE)
+ line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
lpos = 4 - temp;
}
else
temp2 = _rl_screenwidth - lpos;
CHECK_INV_LBREAKS ();
inv_lbreaks[++newlines] = out + temp2;
+#if defined (HANDLE_MULTIBYTE)
+ line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
lpos = temp - temp2;
while (out < newout)
line[out++] = ' ';
line[out++] = '\0'; /* XXX - sentinel */
CHECK_INV_LBREAKS ();
inv_lbreaks[++newlines] = out;
+#if defined (HANDLE_MULTIBYTE)
+ line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
lpos = 0;
}
else if (CTRL_CHAR (c) || c == RUBOUT)
inv_botlin = lb_botlin = _rl_inv_botlin = newlines;
CHECK_INV_LBREAKS ();
inv_lbreaks[newlines+1] = out;
+#if defined (HANDLE_MULTIBYTE)
+ /* This should be 0 anyway */
+ line_state_invisible->wrapped_line[newlines+1] = _rl_wrapped_multicolumn;
+#endif
cursor_linenum = lb_linenum;
/* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.
/* update_line potentially changes _rl_last_c_pos, but doesn't
take invisible characters into account, since _rl_last_c_pos
- is an absolute cursor position in a multibyte locale. See
- if compensating here is the right thing, or if we have to
+ is an absolute cursor position in a multibyte locale. We
+ choose to (mostly) compensate for that here, rather than
change update_line itself. There are several cases in which
update_line adjusts _rl_last_c_pos itself (so it can pass
_rl_move_cursor_relative accurate values); it communicates
cpos_adjusted == 0 &&
_rl_last_c_pos != o_cpos &&
_rl_last_c_pos > (prompt_last_invisible - _rl_screenwidth - prompt_invis_chars_first_line))
+ /* This assumes that all the invisible characters are split
+ between the first and last lines of the prompt, if the
+ prompt consumes more than two lines. It's usually right */
_rl_last_c_pos -= (wrap_offset-prompt_invis_chars_first_line);
/* If this is the line with the prompt, we might need to
_rl_last_c_pos += wrap_offset;
}
+ /* Now we move the cursor to where it needs to be. First, make
+ sure we are on the correct line (cursor_linenum). */
+
/* We have to reprint the prompt if it contains invisible
characters, since it's not generally OK to just reprint
the characters from the current cursor position. But we
position that doesn't take invisible characters in the prompt
into account. We use a fudge factor to compensate. */
- /* Since _rl_backspace() doesn't know about invisible characters in the
- prompt, and there's no good way to tell it, we compensate for
- those characters here and call _rl_backspace() directly. */
+ /* Since _rl_backspace() doesn't know about invisible characters in
+ the prompt, and there's no good way to tell it, we compensate for
+ those characters here and call _rl_backspace() directly if
+ necessary */
if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos)
{
/* TX == new physical cursor position in multibyte locale. */
_rl_move_cursor_relative (nleft, &invisible_line[pos]);
}
}
- else /* Do horizontal scrolling. */
+ else /* Do horizontal scrolling. Much simpler */
{
#define M_OFFSET(margin, offset) ((margin) == 0 ? offset : 0)
int lmargin, ndisp, nleft, phys_c_pos, t;
Could be made even smarter, but this works well enough */
static void
-update_line (old, new, current_line, omax, nmax, inv_botlin)
- register char *old, *new;
- int current_line, omax, nmax, inv_botlin;
+update_line (char *old, char *new, int current_line, int omax, int nmax, int inv_botlin)
{
register char *ofd, *ols, *oe, *nfd, *nls, *ne;
int temp, lendiff, wsatend, od, nd, twidth, o_cpos;
if (temp == _rl_screenwidth && _rl_term_autowrap && !_rl_horizontal_scroll_mode
&& _rl_last_v_pos == current_line - 1)
{
+ /* We're going to wrap around by writing the first character of NEW to
+ the screen and dealing with changes to what's visible by modifying
+ OLD to match it. Complicated by the presence of multi-width
+ characters at the end of the line or beginning of the new one. */
#if defined (HANDLE_MULTIBYTE)
if (mb_cur_max > 1 && rl_byte_oriented == 0)
{
wchar_t wc;
mbstate_t ps;
- int tempwidth, bytes;
+ int oldwidth, newwidth;
+ int oldbytes, newbytes;
size_t ret;
/* This fixes only double-column characters, but if the wrapped
character consumes more than three columns, spaces will be
inserted in the string buffer. */
- if (current_line < line_state_visible->wbsize && line_state_visible->wrapped_line[current_line] > 0)
- _rl_clear_to_eol (line_state_visible->wrapped_line[current_line]);
+ /* XXX remember that we are working on the invisible line right now;
+ we don't swap visible and invisible until just before rl_redisplay
+ returns */
+ /* This will remove the extra placeholder space we added with
+ _rl_wrapped_multicolumn */
+ if (current_line < line_state_invisible->wbsize && line_state_invisible->wrapped_line[current_line] > 0)
+ _rl_clear_to_eol (line_state_invisible->wrapped_line[current_line]);
+
+ /* 1. how many screen positions does first char in old consume? */
+ memset (&ps, 0, sizeof (mbstate_t));
+ ret = mbrtowc (&wc, old, mb_cur_max, &ps);
+ oldbytes = ret;
+ if (MB_INVALIDCH (ret))
+ {
+ oldwidth = 1;
+ oldbytes = 1;
+ }
+ else if (MB_NULLWCH (ret))
+ oldwidth = 0;
+ else
+ oldwidth = WCWIDTH (wc);
+ /* 2. how many screen positions does the first char in new consume? */
memset (&ps, 0, sizeof (mbstate_t));
ret = mbrtowc (&wc, new, mb_cur_max, &ps);
+ newbytes = ret;
if (MB_INVALIDCH (ret))
{
- tempwidth = 1;
- ret = 1;
+ newwidth = 1;
+ newbytes = 1;
}
else if (MB_NULLWCH (ret))
- tempwidth = 0;
+ newwidth = 0;
else
- tempwidth = WCWIDTH (wc);
+ newwidth = WCWIDTH (wc);
- if (tempwidth > 0)
+ /* 3. if the new width is less than the old width, we need to keep
+ going in new until we have consumed at least that many screen
+ positions, and figure out how many bytes that will take */
+ while (newbytes < nmax && newwidth < oldwidth)
{
- int count, i;
- bytes = ret;
- for (count = 0; count < bytes; count++)
- putc (new[count], rl_outstream);
- _rl_last_c_pos = tempwidth;
+ ret = mbrtowc (&wc, new+newbytes, mb_cur_max, &ps);
+ if (MB_INVALIDCH (ret))
+ {
+ newwidth += 1;
+ newbytes += 1;
+ }
+ else if (MB_NULLWCH (ret))
+ break;
+ else
+ {
+ newwidth += WCWIDTH (wc);
+ newbytes += ret;
+ }
+ }
+ /* 4. If the new width is more than the old width, keep going in old
+ until we have consumed exactly that many screen positions, and
+ figure out how many bytes that will take. This is an optimization */
+ while (oldbytes < omax && oldwidth < newwidth)
+ {
+ ret = mbrtowc (&wc, old+oldbytes, mb_cur_max, &ps);
+ if (MB_INVALIDCH (ret))
+ {
+ oldwidth += 1;
+ oldbytes += 1;
+ }
+ else if (MB_NULLWCH (ret))
+ break;
+ else
+ {
+ oldwidth += WCWIDTH (wc);
+ oldbytes += ret;
+ }
+ }
+ /* 5. write the first newbytes of new, which takes newwidth. This is
+ where the screen wrapping takes place, and we are now writing
+ characters onto the new line. We need to fix up old so it
+ accurately reflects what is on the screen after the
+ _rl_output_some_chars below. */
+ if (newwidth > 0)
+ {
+ int count, i, j;
+ char *optr;
+
+ _rl_output_some_chars (new, newbytes);
+ _rl_last_c_pos = newwidth;
_rl_last_v_pos++;
- memset (&ps, 0, sizeof (mbstate_t));
- ret = mbrtowc (&wc, old, mb_cur_max, &ps);
- if (ret != 0 && bytes != 0)
+
+ /* 5a. If the number of screen positions doesn't match, punt
+ and do a dumb update. */
+ if (newwidth != oldwidth)
+ {
+ ne = new + nmax;
+ nd = newbytes;
+ nfd = new + nd;
+ goto dumb_update;
+ }
+ if (oldbytes != 0 && newbytes != 0)
{
- if (MB_INVALIDCH (ret))
- ret = 1;
- memmove (old+bytes, old+ret, strlen (old+ret));
- memcpy (old, new, bytes);
+ /* We have written as many bytes from new as we need to
+ consume the first character of old. Fix up `old' so it
+ reflects the new screen contents */
+ memmove (old+newbytes, old+oldbytes, strlen (old+oldbytes));
+ memcpy (old, new, newbytes);
+ j = newbytes - oldbytes;
+
+ omax += j;
/* Fix up indices if we copy data from one line to another */
- omax += bytes - ret;
for (i = current_line+1; i <= inv_botlin+1; i++)
- vis_lbreaks[i] += bytes - ret;
+ vis_lbreaks[i] += j;
}
}
else
memset (&ps_new, 0, sizeof(mbstate_t));
memset (&ps_old, 0, sizeof(mbstate_t));
+ /* Are the old and new lines the same? */
if (omax == nmax && STREQN (new, old, omax))
{
old_offset = omax;
}
else
{
+ /* Go through the line from the beginning and find the first
+ difference. */
new_offset = old_offset = 0;
for (ofd = old, nfd = new;
(ofd - old < omax) && *ofd &&
wsatend = 1; /* flag for trailing whitespace */
#if defined (HANDLE_MULTIBYTE)
+ /* Find the last character that is the same between the two lines. This
+ bounds the region that needs to change. */
if (mb_cur_max > 1 && rl_byte_oriented == 0)
{
ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
nd = lendiff;
/* Do a dumb update and return */
+dumb_update:
temp = ne - nfd;
if (temp > 0)
{
{
/* Non-zero if we're increasing the number of lines. */
int gl = current_line >= _rl_vis_botlin && inv_botlin > _rl_vis_botlin;
+
/* If col_lendiff is > 0, implying that the new string takes up more
screen real estate than the old, but lendiff is < 0, meaning that it
takes fewer bytes, we need to just output the characters starting
_rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
if (current_line == 0 && wrap_offset &&
displaying_prompt_first_line &&
- _rl_last_c_pos > wrap_offset &&
+ _rl_last_c_pos >= wrap_offset && /* XXX was > */
((nfd - new) <= prompt_last_invisible))
{
_rl_last_c_pos -= wrap_offset;
cpos_adjusted = 1;
}
+
+#if 1
+ /* If we write a non-space into the last screen column,
+ remove the note that we added a space to compensate for
+ a multibyte double-width character that didn't fit, since
+ it's only valid for what was previously there. */
+ /* XXX - watch this */
+ if (_rl_last_c_pos == _rl_screenwidth &&
+ line_state_invisible->wrapped_line[current_line+1] &&
+ nfd[bytes_to_insert-1] != ' ')
+ line_state_invisible->wrapped_line[current_line+1] = 0;
+#endif
}
else
_rl_last_c_pos += bytes_to_insert;
/* Tell the update routines that we have moved onto a new (empty) line. */
int
-rl_on_new_line ()
+rl_on_new_line (void)
{
if (visible_line)
visible_line[0] = '\0';
/* Clear all screen lines occupied by the current readline line buffer
(visible line) */
int
-rl_clear_visible_line ()
+rl_clear_visible_line (void)
{
int curr_line;
/* Tell the update routines that we have moved onto a new line with the
prompt already displayed. Code originally from the version of readline
distributed with CLISP. rl_expand_prompt must have already been called
- (explicitly or implicitly). This still doesn't work exactly right. */
+ (explicitly or implicitly). This still doesn't work exactly right; it
+ should use expand_prompt() */
int
-rl_on_new_line_with_prompt ()
+rl_on_new_line_with_prompt (void)
{
int prompt_size, i, l, real_screenwidth, newlines;
char *prompt_last_line, *lprompt;
/* Actually update the display, period. */
int
-rl_forced_update_display ()
+rl_forced_update_display (void)
{
register char *temp;
/* Redraw only the last line of a multi-line prompt. */
void
-rl_redraw_prompt_last_line ()
+rl_redraw_prompt_last_line (void)
{
char *t;
the movement is being done.
DATA is always the visible line or the invisible line */
void
-_rl_move_cursor_relative (new, data)
- int new;
- const char *data;
+_rl_move_cursor_relative (int new, const char *data)
{
register int i;
int woff; /* number of invisible chars on current line */
/* PWP: move the cursor up or down. */
void
-_rl_move_vert (to)
- int to;
+_rl_move_vert (int to)
{
register int delta, i;
/* Physically print C on rl_outstream. This is for functions which know
how to optimize the display. Return the number of characters output. */
int
-rl_show_char (c)
- int c;
+rl_show_char (int c)
{
int n = 1;
if (META_CHAR (c) && (_rl_output_meta_chars == 0))
}
int
-rl_character_len (c, pos)
- register int c, pos;
+rl_character_len (int c, int pos)
{
unsigned char uc;
/* How to clear things from the "echo-area". */
int
-rl_clear_message ()
+rl_clear_message (void)
{
rl_display_prompt = rl_prompt;
if (msg_saved_prompt)
}
int
-rl_reset_line_state ()
+rl_reset_line_state (void)
{
rl_on_new_line ();
return 0;
}
+/* Save all of the variables associated with the prompt and its display. Most
+ of the complexity is dealing with the invisible characters in the prompt
+ string and where they are. There are enough of these that I should consider
+ a struct. */
void
-rl_save_prompt ()
+rl_save_prompt (void)
{
saved_local_prompt = local_prompt;
saved_local_prefix = local_prompt_prefix;
saved_visible_length = prompt_visible_length;
saved_invis_chars_first_line = prompt_invis_chars_first_line;
saved_physical_chars = prompt_physical_chars;
+ saved_local_prompt_newlines = local_prompt_newlines;
local_prompt = local_prompt_prefix = (char *)0;
local_prompt_len = 0;
+ local_prompt_newlines = (int *)0;
+
prompt_last_invisible = prompt_visible_length = prompt_prefix_length = 0;
prompt_invis_chars_first_line = prompt_physical_chars = 0;
}
void
-rl_restore_prompt ()
+rl_restore_prompt (void)
{
FREE (local_prompt);
FREE (local_prompt_prefix);
+ FREE (local_prompt_newlines);
local_prompt = saved_local_prompt;
local_prompt_prefix = saved_local_prefix;
local_prompt_len = saved_local_length;
+ local_prompt_newlines = saved_local_prompt_newlines;
+
prompt_prefix_length = saved_prefix_length;
prompt_last_invisible = saved_last_invisible;
prompt_visible_length = saved_visible_length;
saved_local_length = 0;
saved_last_invisible = saved_visible_length = saved_prefix_length = 0;
saved_invis_chars_first_line = saved_physical_chars = 0;
+ saved_local_prompt_newlines = 0;
}
char *
-_rl_make_prompt_for_search (pchar)
- int pchar;
+_rl_make_prompt_for_search (int pchar)
{
int len;
char *pmt, *p;
/* Quick redisplay hack when erasing characters at the end of the line. */
void
-_rl_erase_at_end_of_line (l)
- int l;
+_rl_erase_at_end_of_line (int l)
{
register int i;
}
/* Clear to the end of the line. COUNT is the minimum
- number of character spaces to clear, */
+ number of character spaces to clear, but we use a terminal escape
+ sequence if available. */
void
-_rl_clear_to_eol (count)
- int count;
+_rl_clear_to_eol (int count)
{
#ifndef __MSDOS__
if (_rl_term_clreol)
/* Clear to the end of the line using spaces. COUNT is the minimum
number of character spaces to clear, */
static void
-space_to_eol (count)
- int count;
+space_to_eol (int count)
{
register int i;
for (i = 0; i < count; i++)
- putc (' ', rl_outstream);
+ putc (' ', rl_outstream);
_rl_last_c_pos += count;
}
void
-_rl_clear_screen ()
+_rl_clear_screen (void)
{
#ifndef __DJGPP__
if (_rl_term_clrpag)
/* Insert COUNT characters from STRING to the output stream at column COL. */
static void
-insert_some_chars (string, count, col)
- char *string;
- int count, col;
+insert_some_chars (char *string, int count, int col)
{
open_some_spaces (col);
_rl_output_some_chars (string, count);
ncurses documentation and use either im/ei with explicit spaces, or IC/ic
by itself. We assume there will either be ei or we don't need to use it. */
static void
-open_some_spaces (col)
- int col;
+open_some_spaces (int col)
{
#if !defined (__MSDOS__) && (!defined (__MINGW32__) || defined (NCURSES_VERSION))
char *buffer;
/* Delete COUNT characters from the display line. */
static void
-delete_chars (count)
- int count;
+delete_chars (int count)
{
if (count > _rl_screenwidth) /* XXX */
return;
}
void
-_rl_update_final ()
+_rl_update_final (void)
{
int full_lines;
/* Move to the start of the current line. */
static void
-cr ()
+cr (void)
{
if (_rl_term_cr)
{
terminal escape sequences. Called with the cursor at column 0 of the
line to draw the prompt on. */
static void
-redraw_prompt (t)
- char *t;
+redraw_prompt (char *t)
{
char *oldp;
/* Redisplay the current line after a SIGWINCH is received. */
void
-_rl_redisplay_after_sigwinch ()
+_rl_redisplay_after_sigwinch (void)
{
char *t;
}
void
-_rl_clean_up_for_exit ()
+_rl_clean_up_for_exit (void)
{
if (_rl_echoing_p)
{
}
void
-_rl_erase_entire_line ()
+_rl_erase_entire_line (void)
{
cr ();
_rl_clear_to_eol (0);
}
void
-_rl_ttyflush ()
+_rl_ttyflush (void)
{
fflush (rl_outstream);
}
/* return the `current display line' of the cursor -- the number of lines to
move up to get to the first screen line of the current readline line. */
int
-_rl_current_display_line ()
+_rl_current_display_line (void)
{
int ret, nleft;
In the case of multibyte characters with stateful encoding, we have to
scan from the beginning of the string to take the state into account. */
static int
-_rl_col_width (str, start, end, flags)
- const char *str;
- int start, end, flags;
+_rl_col_width (const char *str, int start, int end, int flags)
{
wchar_t wc;
mbstate_t ps;
.\" Case Western Reserve University
.\" chet.ramey@case.edu
.\"
-.\" Last Change: Wed Nov 30 10:06:13 PST 2016
+.\" Last Change: Fri Feb 3 16:02:47 EST 2017
.\"
-.TH READLINE 3 "2016 November 30" "GNU Readline 7.0"
+.TH READLINE 3 "2017 February 3" "GNU Readline 7.0"
.\"
.\" File Name macro. This used to be `.PN', for Path Name,
.\" but Sun doesn't seem to like that very much.
Move back to the start of the current or previous word. Words are
composed of alphanumeric characters (letters and digits).
.TP
+.B previous\-screen\-line
+Attempt to move point to the same physical screen column on the previous
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if point is not
+greater than the length of the prompt plus the screen width.
+.TP
+.B next\-screen\-line
+Attempt to move point to the same physical screen column on the next
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if the length
+of the current Readline line is not greater than the length of the prompt
+plus the screen width.
+.TP
.B clear\-screen (C\-l)
Clear the screen leaving the current line at the top of the screen.
With an argument, refresh the current line without clearing the
line is empty at that point, then @code{(char *)NULL} is returned.
Otherwise, the line is ended just as if a newline had been typed.
+Readline performs some expansion on the @var{prompt} before it is
+displayed on the screen. See the description of @code{rl_expand_prompt}
+(@pxref{Redisplay}) for additional details, especially if @var{prompt}
+will contain characters that do not consume physical screen space when
+displayed.
+
If you want the user to be able to get at the line later, (with
@key{C-p} for example), you must call @code{add_history()} to save the
line away in a @dfn{history} list of such lines.
Words are delimited by non-quoted shell metacharacters.
@end ifset
+@item previous-screen-line ()
+Attempt to move point to the same physical screen column on the previous
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if point is not
+greater than the length of the prompt plus the screen width.
+
+@item next-screen-line ()
+Attempt to move point to the same physical screen column on the next
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if the length
+of the current Readline line is not greater than the length of the prompt
+plus the screen width.
+
@item clear-screen (C-l)
Clear the screen and redraw the current line,
leaving the current line at the top of the screen.
The following function provides completions for the @code{cd} builtin.
It is a reasonably good example of what shell functions must do when
-used for completion. This function uses the word passsed as @code{$2}
+used for completion. This function uses the word passed as @code{$2}
to determine the directory name to complete. You can also use the
@code{COMP_WORDS} array variable; the current word is indexed by the
@code{COMP_CWORD} variable.
@ignore
-Copyright (C) 1988-2016 Free Software Foundation, Inc.
+Copyright (C) 1988-2017 Free Software Foundation, Inc.
@end ignore
@set EDITION 7.0
@set VERSION 7.0
-@set UPDATED 30 November 2016
-@set UPDATED-MONTH November 2016
+@set UPDATED 21 April 2017
+@set UPDATED-MONTH April 2017
-@set LASTCHANGE Wed Nov 30 10:06:36 PST 2016
+@set LASTCHANGE Fri Apr 21 15:25:17 EDT 2017
/* emacs_keymap.c -- the keymap for emacs_mode in readline (). */
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
if (vflag && isascii ((unsigned char)c) && isprint((unsigned char)c) == 0)
{
x = rl_untranslate_keyseq (c);
- if (fputs (x, stdout) != 0)
+ if (fputs (x, stdout) == EOF)
return 1;
}
else if (putchar (c) == EOF)
/* funmap.c -- attach names to functions. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
{ "menu-complete", rl_menu_complete },
{ "menu-complete-backward", rl_backward_menu_complete },
{ "next-history", rl_get_next_history },
+ { "next-screen-line", rl_next_screen_line },
{ "non-incremental-forward-search-history", rl_noninc_forward_search },
{ "non-incremental-reverse-search-history", rl_noninc_reverse_search },
{ "non-incremental-forward-search-history-again", rl_noninc_forward_search_again },
#endif
{ "possible-completions", rl_possible_completions },
{ "previous-history", rl_get_previous_history },
+ { "previous-screen-line", rl_previous_screen_line },
{ "print-last-kbd-macro", rl_print_last_kbd_macro },
{ "quoted-insert", rl_quoted_insert },
{ "re-read-init-file", rl_re_read_init_file },
};
int
-rl_add_funmap_entry (name, function)
- const char *name;
- rl_command_func_t *function;
+rl_add_funmap_entry (const char *name, rl_command_func_t *function)
{
if (funmap_entry + 2 >= funmap_size)
{
/* Make the funmap contain all of the default entries. */
void
-rl_initialize_funmap ()
+rl_initialize_funmap (void)
{
register int i;
is sorted. The array itself is allocated, but not the strings inside.
You should free () the array when you done, but not the pointers. */
const char **
-rl_funmap_names ()
+rl_funmap_names (void)
{
const char **result;
int result_size, result_index;
/* histexpand.c -- history expansion. */
-/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
This file contains the GNU History Library (History), a set of
routines for managing the text of previously typed lines.
So you might call this function like:
line = get_history_event ("!echo:p", &index, 0); */
char *
-get_history_event (string, caller_index, delimiting_quote)
- const char *string;
- int *caller_index;
- int delimiting_quote;
+get_history_event (const char *string, int *caller_index, int delimiting_quote)
{
register int i;
register char c;
to the closing single quote. FLAGS currently used to allow backslash
to escape a single quote (e.g., for bash $'...'). */
static void
-hist_string_extract_single_quoted (string, sindex, flags)
- char *string;
- int *sindex, flags;
+hist_string_extract_single_quoted (char *string, int *sindex, int flags)
{
register int i;
}
static char *
-quote_breaks (s)
- char *s;
+quote_breaks (char *s)
{
register char *p, *r;
char *ret;
}
static char *
-hist_error(s, start, current, errtype)
- char *s;
- int start, current, errtype;
+hist_error(char *s, int start, int current, int errtype)
{
char *temp;
const char *emsg;
subst_rhs is allowed to be set to the empty string. */
static char *
-get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
- char *str;
- int *iptr, delimiter, is_rhs, *lenptr;
+get_subst_pattern (char *str, int *iptr, int delimiter, int is_rhs, int *lenptr)
{
register int si, i, j, k;
char *s;
}
static void
-postproc_subst_rhs ()
+postproc_subst_rhs (void)
{
char *new;
int i, j, new_size;
if the `p' modifier was supplied and the caller should just print
the returned string. Returns the new index into string in
*END_INDEX_PTR, and the expanded specifier in *RET_STRING. */
+/* need current line for !# */
static int
-history_expand_internal (string, start, qc, end_index_ptr, ret_string, current_line)
- char *string;
- int start, qc, *end_index_ptr;
- char **ret_string;
- char *current_line; /* for !# */
+history_expand_internal (char *string, int start, int qc, int *end_index_ptr, char **ret_string, char *current_line)
{
int i, n, starting_index;
int substitute_globally, subst_bywords, want_quotes, print_only;
while (0)
int
-history_expand (hstring, output)
- char *hstring;
- char **output;
+history_expand (char *hstring, char **output)
{
register int j;
int i, r, l, passc, cc, modified, eindex, only_printing, dquote, squote, flag;
CALLER_INDEX is the offset in SPEC to start looking; it is updated
to point to just after the last character parsed. */
static char *
-get_history_word_specifier (spec, from, caller_index)
- char *spec, *from;
- int *caller_index;
+get_history_word_specifier (char *spec, char *from, int *caller_index)
{
register int i = *caller_index;
int first, last;
tokens, so that FIRST = -1 means the next to last token on the line).
If LAST is `$' the last arg from STRING is used. */
char *
-history_arg_extract (first, last, string)
- int first, last;
- const char *string;
+history_arg_extract (int first, int last, const char *string)
{
register int i, len;
char *result;
}
static int
-history_tokenize_word (string, ind)
- const char *string;
- int ind;
+history_tokenize_word (const char *string, int ind)
{
register int i, j;
int delimiter, nestdelim, delimopen;
}
static char *
-history_substring (string, start, end)
- const char *string;
- int start, end;
+history_substring (const char *string, int start, int end)
{
register int len;
register char *result;
WIND. The position in the returned array of strings is returned in
*INDP. */
static char **
-history_tokenize_internal (string, wind, indp)
- const char *string;
- int wind, *indp;
+history_tokenize_internal (const char *string, int wind, int *indp)
{
char **result;
register int i, start, result_index, size;
/* Return an array of tokens, much as the shell might. The tokens are
parsed out of STRING. */
char **
-history_tokenize (string)
- const char *string;
+history_tokenize (const char *string)
{
return (history_tokenize_internal (string, -1, (int *)NULL));
}
/* Free members of WORDS from START to an empty string */
static void
-freewords (words, start)
- char **words;
- int start;
+freewords (char **words, int start)
{
register int i;
in the history line LINE. Used to save the word matched by the
last history !?string? search. */
static char *
-history_find_word (line, ind)
- char *line;
- int ind;
+history_find_word (char *line, int ind)
{
char **words, *s;
int i, wind;
/* histfile.c - functions to manipulate the history file. */
-/* Copyright (C) 1989-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
This file contains the GNU History Library (History), a set of
routines for managing the text of previously typed lines.
filename. This only matters when you don't specify the
filename to read_history (), or write_history (). */
static char *
-history_filename (filename)
- const char *filename;
+history_filename (const char *filename)
{
char *return_val;
const char *home;
}
static char *
-history_backupfile (filename)
- const char *filename;
+history_backupfile (const char *filename)
{
const char *fn;
char *ret, linkbuf[PATH_MAX+1];
}
static char *
-history_tempfile (filename)
- const char *filename;
+history_tempfile (const char *filename)
{
const char *fn;
char *ret, linkbuf[PATH_MAX+1];
If FILENAME is NULL, then read from ~/.history. Returns 0 if
successful, or errno if not. */
int
-read_history (filename)
- const char *filename;
+read_history (const char *filename)
{
return (read_history_range (filename, 0, -1));
}
until the end of the file. If FILENAME is NULL, then read from
~/.history. Returns 0 if successful, or errno if not. */
int
-read_history_range (filename, from, to)
- const char *filename;
- int from, to;
+read_history_range (const char *filename, int from, int to)
{
register char *line_start, *line_end, *p;
char *input, *buffer, *bufend, *last_ts;
if ((file < 0) || (fstat (file, &finfo) == -1))
goto error_and_exit;
+ if (S_ISREG (finfo.st_mode) == 0)
+ {
+#ifdef EFTYPE
+ errno = EFTYPE;
+#else
+ errno = EINVAL;
+#endif
+ goto error_and_exit;
+ }
+
file_size = (size_t)finfo.st_size;
/* check for overflow on very large files */
goto error_and_exit;
}
+ if (file_size == 0)
+ {
+ free (input);
+ return 0; /* don't waste time if we don't have to */
+ }
+
#ifdef HISTORY_USE_MMAP
/* We map read/write and private so we can change newlines to NULs without
affecting the underlying object. */
/* Start at beginning of file, work to end. */
bufend = buffer + chars_read;
+ *bufend = '\0'; /* null-terminate buffer for timestamp checks */
current_line = 0;
/* Heuristic: the history comment character rarely changes, so assume we
/* Save FILENAME to BACK, handling case where FILENAME is a symlink
(e.g., ~/.bash_history -> .histfiles/.bash_history.$HOSTNAME) */
static int
-histfile_backup (filename, back)
- const char *filename;
- const char *back;
+histfile_backup (const char *filename, const char *back)
{
#if defined (HAVE_READLINK)
char linkbuf[PATH_MAX+1];
/* Restore ORIG from BACKUP handling case where ORIG is a symlink
(e.g., ~/.bash_history -> .histfiles/.bash_history.$HOSTNAME) */
static int
-histfile_restore (backup, orig)
- const char *backup;
- const char *orig;
+histfile_restore (const char *backup, const char *orig)
{
#if defined (HAVE_READLINK)
char linkbuf[PATH_MAX+1];
If FNAME is NULL, then use ~/.history. Writes a new file and renames
it to the original name. Returns 0 on success, errno on failure. */
int
-history_truncate_file (fname, lines)
- const char *fname;
- int lines;
+history_truncate_file (const char *fname, int lines)
{
char *buffer, *filename, *tempname, *bp, *bp1; /* bp1 == bp+1 */
int file, chars_read, rv, orig_lines, exists, r;
from the history list to FILENAME. OVERWRITE is non-zero if you
wish to replace FILENAME with the entries. */
static int
-history_do_write (filename, nelements, overwrite)
- const char *filename;
- int nelements, overwrite;
+history_do_write (const char *filename, int nelements, int overwrite)
{
register int i;
char *output, *tempname, *histname;
/* Append NELEMENT entries to FILENAME. The entries appended are from
the end of the list minus NELEMENTs up to the end of the list. */
int
-append_history (nelements, filename)
- int nelements;
- const char *filename;
+append_history (int nelements, const char *filename)
{
return (history_do_write (filename, nelements, HISTORY_APPEND));
}
then write the history list to ~/.history. Values returned
are as in read_history ().*/
int
-write_history (filename)
- const char *filename;
+write_history (const char *filename)
{
return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
}
/* history.c -- standalone history library */
-/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
This file contains the GNU History Library (History), a set of
routines for managing the text of previously typed lines.
/* Return the current HISTORY_STATE of the history. */
HISTORY_STATE *
-history_get_history_state ()
+history_get_history_state (void)
{
HISTORY_STATE *state;
/* Set the state of the current history array to STATE. */
void
-history_set_history_state (state)
- HISTORY_STATE *state;
+history_set_history_state (HISTORY_STATE *state)
{
the_history = state->entries;
history_offset = state->offset;
/* Begin a session in which the history functions might be used. This
initializes interactive variables. */
void
-using_history ()
+using_history (void)
{
history_offset = history_length;
}
This just adds up the lengths of the_history->lines and the associated
timestamps. */
int
-history_total_bytes ()
+history_total_bytes (void)
{
register int i, result;
/* Returns the magic number which says what history element we are
looking at now. In this implementation, it returns history_offset. */
int
-where_history ()
+where_history (void)
{
return (history_offset);
}
/* Make the current history item be the one at POS, an absolute index.
Returns zero if POS is out of range, else non-zero. */
int
-history_set_pos (pos)
- int pos;
+history_set_pos (int pos)
{
if (pos > history_length || pos < 0 || !the_history)
return (0);
is the actual array of data, and could be bashed or made corrupt easily.
The array is terminated with a NULL pointer. */
HIST_ENTRY **
-history_list ()
+history_list (void)
{
return (the_history);
}
/* Return the history entry at the current position, as determined by
history_offset. If there is no entry there, return a NULL pointer. */
HIST_ENTRY *
-current_history ()
+current_history (void)
{
return ((history_offset == history_length) || the_history == 0)
? (HIST_ENTRY *)NULL
a pointer to that entry. If there is no previous entry then return
a NULL pointer. */
HIST_ENTRY *
-previous_history ()
+previous_history (void)
{
return history_offset ? the_history[--history_offset] : (HIST_ENTRY *)NULL;
}
a pointer to that entry. If there is no next entry then return a
NULL pointer. */
HIST_ENTRY *
-next_history ()
+next_history (void)
{
return (history_offset == history_length) ? (HIST_ENTRY *)NULL : the_history[++history_offset];
}
/* Return the history entry which is logically at OFFSET in the history array.
OFFSET is relative to history_base. */
HIST_ENTRY *
-history_get (offset)
- int offset;
+history_get (int offset)
{
int local_index;
}
HIST_ENTRY *
-alloc_history_entry (string, ts)
- char *string;
- char *ts;
+alloc_history_entry (char *string, char *ts)
{
HIST_ENTRY *temp;
}
time_t
-history_get_time (hist)
- HIST_ENTRY *hist;
+history_get_time (HIST_ENTRY *hist)
{
char *ts;
time_t t;
}
static char *
-hist_inittime ()
+hist_inittime (void)
{
time_t t;
char ts[64], *ret;
/* Place STRING at the end of the history list. The data field
is set to NULL. */
void
-add_history (string)
- const char *string;
+add_history (const char *string)
{
HIST_ENTRY *temp;
int new_length;
/* Change the time stamp of the most recent history entry to STRING. */
void
-add_history_time (string)
- const char *string;
+add_history_time (const char *string)
{
HIST_ENTRY *hs;
/* Free HIST and return the data so the calling application can free it
if necessary and desired. */
histdata_t
-free_history_entry (hist)
- HIST_ENTRY *hist;
+free_history_entry (HIST_ENTRY *hist)
{
histdata_t x;
}
HIST_ENTRY *
-copy_history_entry (hist)
- HIST_ENTRY *hist;
+copy_history_entry (HIST_ENTRY *hist)
{
HIST_ENTRY *ret;
char *ts;
the old entry so you can dispose of the data. In the case of an
invalid WHICH, a NULL pointer is returned. */
HIST_ENTRY *
-replace_history_entry (which, line, data)
- int which;
- const char *line;
- histdata_t data;
+replace_history_entry (int which, const char *line, histdata_t data)
{
HIST_ENTRY *temp, *old_value;
end of the current line first. This can be used to construct multi-line
history entries while reading lines from the history file. */
void
-_hs_append_history_line (which, line)
- int which;
- const char *line;
+_hs_append_history_line (int which, const char *line)
{
HIST_ENTRY *hent;
size_t newlen, curlen, minlen;
WHICH >= 0 means to replace that particular history entry's data, as
long as it matches OLD. */
void
-_hs_replace_history_data (which, old, new)
- int which;
- histdata_t *old, *new;
+_hs_replace_history_data (int which, histdata_t *old, histdata_t *new)
{
HIST_ENTRY *entry;
register int i, last;
element is returned to you so you can free the line, data,
and containing structure. */
HIST_ENTRY *
-remove_history (which)
- int which;
+remove_history (int which)
{
HIST_ENTRY *return_value;
register int i;
}
HIST_ENTRY **
-remove_history_range (first, last)
- int first, last;
+remove_history_range (int first, int last)
{
HIST_ENTRY **return_value;
register int i;
/* Stifle the history list, remembering only MAX number of lines. */
void
-stifle_history (max)
- int max;
+stifle_history (int max)
{
register int i, j;
number of history entries. The value is positive if the history
was stifled, negative if it wasn't. */
int
-unstifle_history ()
+unstifle_history (void)
{
if (history_stifled)
{
}
int
-history_is_stifled ()
+history_is_stifled (void)
{
return (history_stifled);
}
void
-clear_history ()
+clear_history (void)
{
register int i;
/* histsearch.c -- searching the history list. */
-/* Copyright (C) 1989, 1992-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1989, 1992-2009,2017 Free Software Foundation, Inc.
This file contains the GNU History Library (History), a set of
routines for managing the text of previously typed lines.
returned. */
static int
-history_search_internal (string, direction, flags)
- const char *string;
- int direction, flags;
+history_search_internal (const char *string, int direction, int flags)
{
register int i, reverse;
register char *line;
}
int
-_hs_history_patsearch (string, direction, flags)
- const char *string;
- int direction, flags;
+_hs_history_patsearch (const char *string, int direction, int flags)
{
char *pat;
size_t len;
/* Do a non-anchored search for STRING through the history in DIRECTION. */
int
-history_search (string, direction)
- const char *string;
- int direction;
+history_search (const char *string, int direction)
{
return (history_search_internal (string, direction, NON_ANCHORED_SEARCH));
}
/* Do an anchored search for string through the history in DIRECTION. */
int
-history_search_prefix (string, direction)
- const char *string;
- int direction;
+history_search_prefix (const char *string, int direction)
{
return (history_search_internal (string, direction, ANCHORED_SEARCH));
}
backwards. POS is an absolute index into the history list at
which point to begin searching. */
int
-history_search_pos (string, dir, pos)
- const char *string;
- int dir, pos;
+history_search_pos (const char *string, int dir, int pos)
{
int ret, old;
/* input.c -- character input functions for readline. */
-/* Copyright (C) 1994-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Windows isatty returns true for every character device, including the null
device, so we need to perform additional checks. */
#if defined (_WIN32) && !defined (__CYGWIN__)
+#include <conio.h>
#include <io.h>
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#define any_typein (push_index != pop_index)
int
-_rl_any_typein ()
+_rl_any_typein (void)
{
return any_typein;
}
int
-_rl_pushed_input_available ()
+_rl_pushed_input_available (void)
{
return (push_index != pop_index);
}
/* Return the amount of space available in the buffer for stuffing
characters. */
static int
-ibuffer_space ()
+ibuffer_space (void)
{
if (pop_index > push_index)
return (pop_index - push_index - 1);
Return the key in KEY.
Result is non-zero if there was a key, or 0 if there wasn't. */
static int
-rl_get_char (key)
- int *key;
+rl_get_char (int *key)
{
if (push_index == pop_index)
return (0);
Returns non-zero if successful, zero if there is
no space left in the buffer. */
int
-_rl_unget_char (key)
- int key;
+_rl_unget_char (int key)
{
if (ibuffer_space ())
{
IBUFFER. Otherwise, just return. Returns number of characters read
(0 if none available) and -1 on error (EIO). */
static int
-rl_gather_tyi ()
+rl_gather_tyi (void)
{
int tty;
register int tem, result;
}
int
-rl_set_keyboard_input_timeout (u)
- int u;
+rl_set_keyboard_input_timeout (int u)
{
int o;
the user, it should use _rl_input_queued(timeout_value_in_microseconds)
instead. */
int
-_rl_input_available ()
+_rl_input_available (void)
{
#if defined(HAVE_SELECT)
fd_set readfds, exceptfds;
}
int
-_rl_input_queued (t)
- int t;
+_rl_input_queued (int t)
{
int old_timeout, r;
}
void
-_rl_insert_typein (c)
- int c;
+_rl_insert_typein (int c)
{
int key, t, i;
char *string;
/* Add KEY to the buffer of characters to be read. Returns 1 if the
character was stuffed correctly; 0 otherwise. */
int
-rl_stuff_char (key)
- int key;
+rl_stuff_char (int key)
{
if (ibuffer_space () == 0)
return 0;
/* Make C be the next command to be executed. */
int
-rl_execute_next (c)
- int c;
+rl_execute_next (int c)
{
rl_pending_input = c;
RL_SETSTATE (RL_STATE_INPUTPENDING);
/* Clear any pending input pushed with rl_execute_next() */
int
-rl_clear_pending_input ()
+rl_clear_pending_input (void)
{
rl_pending_input = 0;
RL_UNSETSTATE (RL_STATE_INPUTPENDING);
/* Read a key, including pending input. */
int
-rl_read_key ()
+rl_read_key (void)
{
int c, r;
if (rl_pending_input)
{
- c = rl_pending_input;
+ c = rl_pending_input; /* XXX - cast to unsigned char if > 0? */
rl_clear_pending_input ();
}
else
{
/* If input is coming from a macro, then use that. */
if (c = _rl_next_macro_key ())
- return (c);
+ return ((unsigned char)c);
/* If the user has an event function, then call it periodically. */
if (rl_event_hook)
}
int
-rl_getc (stream)
- FILE *stream;
+rl_getc (FILE *stream)
{
int result;
unsigned char c;
#if defined (HANDLE_MULTIBYTE)
/* read multibyte char */
int
-_rl_read_mbchar (mbchar, size)
- char *mbchar;
- int size;
+_rl_read_mbchar (char *mbchar, int size)
{
int mb_len, c;
size_t mbchar_bytes_length;
may be FIRST. Used by the search functions, among others. Very similar
to _rl_read_mbchar. */
int
-_rl_read_mbstring (first, mb, mlen)
- int first;
- char *mb;
- int mlen;
+_rl_read_mbstring (int first, char *mb, int mlen)
{
int i, c;
mbstate_t ps;
/* */
/* **************************************************************** */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
static char * const default_isearch_terminators = "\033\012";
_rl_search_cxt *
-_rl_scxt_alloc (type, flags)
- int type, flags;
+_rl_scxt_alloc (int type, int flags)
{
_rl_search_cxt *cxt;
}
void
-_rl_scxt_dispose (cxt, flags)
- _rl_search_cxt *cxt;
- int flags;
+_rl_scxt_dispose (_rl_search_cxt *cxt, int flags)
{
FREE (cxt->search_string);
FREE (cxt->allocated_line);
/* Search backwards through the history looking for a string which is typed
interactively. Start with the current line. */
int
-rl_reverse_search_history (sign, key)
- int sign, key;
+rl_reverse_search_history (int sign, int key)
{
return (rl_search_history (-sign, key));
}
/* Search forwards through the history looking for a string which is typed
interactively. Start with the current line. */
int
-rl_forward_search_history (sign, key)
- int sign, key;
+rl_forward_search_history (int sign, int key)
{
return (rl_search_history (sign, key));
}
WHERE is the history list number of the current line. If it is
-1, then this line is the starting one. */
static void
-rl_display_search (search_string, flags, where)
- char *search_string;
- int flags, where;
+rl_display_search (char *search_string, int flags, int where)
{
char *message;
int msglen, searchlen;
}
static _rl_search_cxt *
-_rl_isearch_init (direction)
- int direction;
+_rl_isearch_init (int direction)
{
_rl_search_cxt *cxt;
register int i;
}
static void
-_rl_isearch_fini (cxt)
- _rl_search_cxt *cxt;
+_rl_isearch_fini (_rl_search_cxt *cxt)
{
/* First put back the original state. */
strcpy (rl_line_buffer, cxt->lines[cxt->save_line]);
}
int
-_rl_search_getchar (cxt)
- _rl_search_cxt *cxt;
+_rl_search_getchar (_rl_search_cxt *cxt)
{
int c;
-1 if the caller should just free the context and return, 0 if we should
break out of the loop, and 1 if we should continue to read characters. */
int
-_rl_isearch_dispatch (cxt, c)
- _rl_search_cxt *cxt;
- int c;
+_rl_isearch_dispatch (_rl_search_cxt *cxt, int c)
{
int n, wstart, wlen, limit, cval;
rl_command_func_t *f;
}
int
-_rl_isearch_cleanup (cxt, r)
- _rl_search_cxt *cxt;
- int r;
+_rl_isearch_cleanup (_rl_search_cxt *cxt, int r)
{
if (r >= 0)
_rl_isearch_fini (cxt);
DIRECTION is which direction to search; >= 0 means forward, < 0 means
backwards. */
static int
-rl_search_history (direction, invoking_key)
- int direction, invoking_key;
+rl_search_history (int direction, int invoking_key)
{
_rl_search_cxt *cxt; /* local for now, but saved globally */
int c, r;
If _rl_isearch_dispatch finishes searching, this function is responsible
for turning off RL_STATE_ISEARCH, which it does using _rl_isearch_cleanup. */
int
-_rl_isearch_callback (cxt)
- _rl_search_cxt *cxt;
+_rl_isearch_callback (_rl_search_cxt *cxt)
{
int c, r;
/* keymaps.c -- Functions and keymaps for the GNU Readline library. */
-/* Copyright (C) 1988,1989-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1988,1989-2009,2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Return a new, empty keymap.
Free it with free() when you are done. */
Keymap
-rl_make_bare_keymap ()
+rl_make_bare_keymap (void)
{
register int i;
Keymap keymap;
/* Return a new keymap which is a copy of MAP. Just copies pointers, does
not copy text of macros or descend into child keymaps. */
Keymap
-rl_copy_keymap (map)
- Keymap map;
+rl_copy_keymap (Keymap map)
{
register int i;
Keymap temp;
the uppercase Meta characters bound to run their lowercase equivalents,
and the Meta digits bound to produce numeric arguments. */
Keymap
-rl_make_keymap ()
+rl_make_keymap (void)
{
register int i;
Keymap newmap;
/* Free the storage associated with MAP. */
void
-rl_discard_keymap (map)
- Keymap map;
+rl_discard_keymap (Keymap map)
{
int i;
/* Convenience function that discards, then frees, MAP. */
void
-rl_free_keymap (map)
- Keymap map;
+rl_free_keymap (Keymap map)
{
rl_discard_keymap (map);
xfree ((char *)map);
/* kill.c -- kill ring management. */
-/* Copyright (C) 1994-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* How to say that you only want to save a certain amount
of kill material. */
int
-rl_set_retained_kills (num)
- int num;
+rl_set_retained_kills (int num)
{
return 0;
}
non-zero, and the last command was a kill, the text is appended to the
current kill ring slot, otherwise prepended. */
static int
-_rl_copy_to_kill_ring (text, append)
- char *text;
- int append;
+_rl_copy_to_kill_ring (char *text, int append)
{
char *old, *new;
int slot;
slot = rl_kill_ring_length - 1;
/* If the last command was a kill, prepend or append. */
- if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
+ if (_rl_last_command_was_kill && rl_kill_ring[slot] && rl_editing_mode != vi_mode)
{
old = rl_kill_ring[slot];
new = (char *)xmalloc (1 + strlen (old) + strlen (text));
last command was not a kill command, then a new slot is made for
this kill. */
int
-rl_kill_text (from, to)
- int from, to;
+rl_kill_text (int from, int to)
{
char *text;
/* Delete the word at point, saving the text in the kill ring. */
int
-rl_kill_word (count, key)
- int count, key;
+rl_kill_word (int count, int key)
{
int orig_point;
/* Rubout the word before point, placing it on the kill ring. */
int
-rl_backward_kill_word (count, ignore)
- int count, ignore;
+rl_backward_kill_word (int count, int key)
{
int orig_point;
if (count < 0)
- return (rl_kill_word (-count, ignore));
+ return (rl_kill_word (-count, key));
else
{
orig_point = rl_point;
- rl_backward_word (count, ignore);
+ rl_backward_word (count, key);
if (rl_point != orig_point)
rl_kill_text (orig_point, rl_point);
/* Kill from here to the end of the line. If DIRECTION is negative, kill
back to the line start instead. */
int
-rl_kill_line (direction, ignore)
- int direction, ignore;
+rl_kill_line (int direction, int key)
{
int orig_point;
if (direction < 0)
- return (rl_backward_kill_line (1, ignore));
+ return (rl_backward_kill_line (1, key));
else
{
orig_point = rl_point;
- rl_end_of_line (1, ignore);
+ rl_end_of_line (1, key);
if (orig_point != rl_point)
rl_kill_text (orig_point, rl_point);
rl_point = orig_point;
/* Kill backwards to the start of the line. If DIRECTION is negative, kill
forwards to the line end instead. */
int
-rl_backward_kill_line (direction, ignore)
- int direction, ignore;
+rl_backward_kill_line (int direction, int key)
{
int orig_point;
if (direction < 0)
- return (rl_kill_line (1, ignore));
+ return (rl_kill_line (1, key));
else
{
if (rl_point == 0)
else
{
orig_point = rl_point;
- rl_beg_of_line (1, ignore);
+ rl_beg_of_line (1, key);
if (rl_point != orig_point)
rl_kill_text (orig_point, rl_point);
if (rl_editing_mode == emacs_mode)
/* Kill the whole line, no matter where point is. */
int
-rl_kill_full_line (count, ignore)
- int count, ignore;
+rl_kill_full_line (int count, int key)
{
rl_begin_undo_group ();
rl_point = 0;
/* This does what C-w does in Unix. We can't prevent people from
using behaviour that they expect. */
int
-rl_unix_word_rubout (count, key)
- int count, key;
+rl_unix_word_rubout (int count, int key)
{
int orig_point;
/* This deletes one filename component in a Unix pathname. That is, it
deletes backward to directory separator (`/') or whitespace. */
int
-rl_unix_filename_rubout (count, key)
- int count, key;
+rl_unix_filename_rubout (int count, int key)
{
int orig_point, c;
into the line at all, and if you aren't, then you know what you are
doing. */
int
-rl_unix_line_discard (count, key)
- int count, key;
+rl_unix_line_discard (int count, int key)
{
if (rl_point == 0)
rl_ding ();
/* Copy the text in the `region' to the kill ring. If DELETE is non-zero,
delete the text from the line as well. */
static int
-region_kill_internal (delete)
- int delete;
+region_kill_internal (int delete)
{
char *text;
/* Copy the text in the region to the kill ring. */
int
-rl_copy_region_to_kill (count, ignore)
- int count, ignore;
+rl_copy_region_to_kill (int count, int key)
{
return (region_kill_internal (0));
}
/* Kill the text between the point and mark. */
int
-rl_kill_region (count, ignore)
- int count, ignore;
+rl_kill_region (int count, int key)
{
int r, npoint;
/* Copy COUNT words to the kill ring. DIR says which direction we look
to find the words. */
static int
-_rl_copy_word_as_kill (count, dir)
- int count, dir;
+_rl_copy_word_as_kill (int count, int dir)
{
int om, op, r;
}
int
-rl_copy_forward_word (count, key)
- int count, key;
+rl_copy_forward_word (int count, int key)
{
if (count < 0)
return (rl_copy_backward_word (-count, key));
}
int
-rl_copy_backward_word (count, key)
- int count, key;
+rl_copy_backward_word (int count, int key)
{
if (count < 0)
return (rl_copy_forward_word (-count, key));
/* Yank back the last killed text. This ignores arguments. */
int
-rl_yank (count, ignore)
- int count, ignore;
+rl_yank (int count, int key)
{
if (rl_kill_ring == 0)
{
delete that text from the line, rotate the index down, and
yank back some other text. */
int
-rl_yank_pop (count, key)
- int count, key;
+rl_yank_pop (int count, int key)
{
int l, n;
#if defined (VI_MODE)
int
-rl_vi_yank_pop (count, key)
- int count, key;
+rl_vi_yank_pop (int count, int key)
{
int l, n;
/* Yank the COUNTh argument from the previous history line, skipping
HISTORY_SKIP lines before looking for the `previous line'. */
static int
-rl_yank_nth_arg_internal (count, ignore, history_skip)
- int count, ignore, history_skip;
+rl_yank_nth_arg_internal (int count, int key, int history_skip)
{
register HIST_ENTRY *entry;
char *arg;
inserts it right *after* rl_point. */
if (rl_editing_mode == vi_mode)
{
- rl_vi_append_mode (1, ignore);
+ rl_vi_append_mode (1, key);
rl_insert_text (" ");
}
#endif /* VI_MODE */
/* Yank the COUNTth argument from the previous history line. */
int
-rl_yank_nth_arg (count, ignore)
- int count, ignore;
+rl_yank_nth_arg (int count, int key)
{
- return (rl_yank_nth_arg_internal (count, ignore, 0));
+ return (rl_yank_nth_arg_internal (count, key, 0));
}
/* Yank the last argument from the previous history line. This `knows'
how rl_yank_nth_arg treats a count of `$'. With an argument, this
behaves the same as rl_yank_nth_arg. */
int
-rl_yank_last_arg (count, key)
- int count, key;
+rl_yank_last_arg (int count, int key)
{
static int history_skip = 0;
static int explicit_arg_p = 0;
closing sequence and insert the pasted text as a single unit without
interpretation. */
int
-rl_bracketed_paste_begin (count, key)
- int count, key;
+rl_bracketed_paste_begin (int count, int key)
{
int retval, c;
size_t len, cap;
return (retval);
}
-/* A special paste command for Windows users.. */
+/* A special paste command for Windows users. */
#if defined (_WIN32)
#include <windows.h>
int
-rl_paste_from_clipboard (count, key)
- int count, key;
+rl_paste_from_clipboard (int count, int key)
{
char *data, *ptr;
int len;
/* macro.c -- keyboard macros for readline. */
-/* Copyright (C) 1994-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2009,2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Set up to read subsequent input from STRING.
STRING is free ()'ed when we are done with it. */
void
-_rl_with_macro_input (string)
- char *string;
+_rl_with_macro_input (char *string)
{
if (macro_level > MAX_MACRO_LEVEL)
{
/* Return the next character available from a macro, or 0 if
there are no macro characters. */
int
-_rl_next_macro_key ()
+_rl_next_macro_key (void)
{
int c;
}
int
-_rl_peek_macro_key ()
+_rl_peek_macro_key (void)
{
if (rl_executing_macro == 0)
return (0);
}
int
-_rl_prev_macro_key ()
+_rl_prev_macro_key (void)
{
if (rl_executing_macro == 0)
return (0);
/* Save the currently executing macro on a stack of saved macros. */
void
-_rl_push_executing_macro ()
+_rl_push_executing_macro (void)
{
struct saved_macro *saver;
/* Discard the current macro, replacing it with the one
on the top of the stack of saved macros. */
void
-_rl_pop_executing_macro ()
+_rl_pop_executing_macro (void)
{
struct saved_macro *macro;
/* Add a character to the macro being built. */
void
-_rl_add_macro_char (c)
- int c;
+_rl_add_macro_char (int c)
{
if (current_macro_index + 1 >= current_macro_size)
{
}
void
-_rl_kill_kbd_macro ()
+_rl_kill_kbd_macro (void)
{
if (current_macro)
{
definition to the end of the existing macro, and start by
re-executing the existing macro. */
int
-rl_start_kbd_macro (ignore1, ignore2)
- int ignore1, ignore2;
+rl_start_kbd_macro (int ignore1, int ignore2)
{
if (RL_ISSTATE (RL_STATE_MACRODEF))
{
A numeric argument says to execute the macro right now,
that many times, counting the definition as the first time. */
int
-rl_end_kbd_macro (count, ignore)
- int count, ignore;
+rl_end_kbd_macro (int count, int ignore)
{
if (RL_ISSTATE (RL_STATE_MACRODEF) == 0)
{
/* Execute the most recently defined keyboard macro.
COUNT says how many times to execute it. */
int
-rl_call_last_kbd_macro (count, ignore)
- int count, ignore;
+rl_call_last_kbd_macro (int count, int ignore)
{
if (current_macro == 0)
_rl_abort_internal ();
}
int
-rl_print_last_kbd_macro (count, ignore)
- int count, ignore;
+rl_print_last_kbd_macro (int count, int ignore)
{
char *m;
}
void
-rl_push_macro_input (macro)
- char *macro;
+rl_push_macro_input (char *macro)
{
_rl_with_macro_input (macro);
}
/* mbutil.c -- readline multibyte character utility functions */
-/* Copyright (C) 2001-2015 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
#if defined(HANDLE_MULTIBYTE)
static int
-_rl_find_next_mbchar_internal (string, seed, count, find_non_zero)
- char *string;
- int seed, count, find_non_zero;
+_rl_find_next_mbchar_internal (char *string, int seed, int count, int find_non_zero)
{
size_t tmp, len;
mbstate_t ps;
}
/*static*/ int
-_rl_find_prev_mbchar_internal (string, seed, find_non_zero)
- char *string;
- int seed, find_non_zero;
+_rl_find_prev_mbchar_internal (char *string, int seed, int find_non_zero)
{
mbstate_t ps;
int prev, non_zero_prev, point, length;
prev = non_zero_prev = point = 0;
while (point < seed)
{
- tmp = mbrtowc (&wc, string + point, length - point, &ps);
+ if (_rl_utf8locale && UTF8_SINGLEBYTE(string[point]))
+ {
+ tmp = 1;
+ wc = (wchar_t) string[point];
+ memset(&ps, 0, sizeof(mbstate_t));
+ }
+ else
+ tmp = mbrtowc (&wc, string + point, length - point, &ps);
if (MB_INVALIDCH ((size_t)tmp))
{
/* in this case, bytes are invalid or too short to compose
if an invalid multibyte sequence was encountered. It returns (size_t)(-2)
if it couldn't parse a complete multibyte character. */
int
-_rl_get_char_len (src, ps)
- char *src;
- mbstate_t *ps;
+_rl_get_char_len (char *src, mbstate_t *ps)
{
size_t tmp;
/* compare the specified two characters. If the characters matched,
return 1. Otherwise return 0. */
int
-_rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
- char *buf1;
- int pos1;
- mbstate_t *ps1;
- char *buf2;
- int pos2;
- mbstate_t *ps2;
+_rl_compare_chars (char *buf1, int pos1, mbstate_t *ps1, char *buf2, int pos2, mbstate_t *ps2)
{
int i, w1, w2;
if point is invalied (point < 0 || more than string length),
it returns -1 */
int
-_rl_adjust_point (string, point, ps)
- char *string;
- int point;
- mbstate_t *ps;
+_rl_adjust_point (char *string, int point, mbstate_t *ps)
{
- size_t tmp = 0;
- int length;
- int pos = 0;
+ size_t tmp;
+ int length, pos;
+ tmp = 0;
+ pos = 0;
length = strlen(string);
if (point < 0)
return -1;
}
int
-_rl_is_mbchar_matched (string, seed, end, mbchar, length)
- char *string;
- int seed, end;
- char *mbchar;
- int length;
+_rl_is_mbchar_matched (char *string, int seed, int end, char *mbchar, int length)
{
int i;
}
wchar_t
-_rl_char_value (buf, ind)
- char *buf;
- int ind;
+_rl_char_value (char *buf, int ind)
{
size_t tmp;
wchar_t wc;
characters. */
#undef _rl_find_next_mbchar
int
-_rl_find_next_mbchar (string, seed, count, flags)
- char *string;
- int seed, count, flags;
+_rl_find_next_mbchar (char *string, int seed, int count, int flags)
{
#if defined (HANDLE_MULTIBYTE)
return _rl_find_next_mbchar_internal (string, seed, count, flags);
we look for non-zero-width multibyte characters. */
#undef _rl_find_prev_mbchar
int
-_rl_find_prev_mbchar (string, seed, flags)
- char *string;
- int seed, flags;
+_rl_find_prev_mbchar (char *string, int seed, int flags)
{
#if defined (HANDLE_MULTIBYTE)
return _rl_find_prev_mbchar_internal (string, seed, flags);
/* misc.c -- miscellaneous bindable readline functions. */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* **************************************************************** */
int
-_rl_arg_overflow ()
+_rl_arg_overflow (void)
{
if (rl_numeric_arg > 1000000)
{
}
void
-_rl_arg_init ()
+_rl_arg_init (void)
{
rl_save_prompt ();
_rl_argcxt = 0;
}
int
-_rl_arg_getchar ()
+_rl_arg_getchar (void)
{
int c;
argument should be aborted, 0 if we should not read any more chars, and
1 if we should continue to read chars. */
int
-_rl_arg_dispatch (cxt, c)
- _rl_arg_cxt cxt;
- int c;
+_rl_arg_dispatch (_rl_arg_cxt cxt, int c)
{
int key, r;
/* Handle C-u style numeric args, as well as M--, and M-digits. */
static int
-rl_digit_loop ()
+rl_digit_loop (void)
{
int c, r;
/* Create a default argument. */
void
-_rl_reset_argument ()
+_rl_reset_argument (void)
{
rl_numeric_arg = rl_arg_sign = 1;
rl_explicit_arg = 0;
/* Start a numeric argument with initial value KEY */
int
-rl_digit_argument (ignore, key)
- int ignore, key;
+rl_digit_argument (int ignore, int key)
{
_rl_arg_init ();
if (RL_ISSTATE (RL_STATE_CALLBACK))
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. */
int
-rl_universal_argument (count, key)
- int count, key;
+rl_universal_argument (int count, int key)
{
_rl_arg_init ();
rl_numeric_arg *= 4;
}
int
-_rl_arg_callback (cxt)
- _rl_arg_cxt cxt;
+_rl_arg_callback (_rl_arg_cxt cxt)
{
int c, r;
/* What to do when you abort reading an argument. */
int
-rl_discard_argument ()
+rl_discard_argument (void)
{
rl_ding ();
rl_clear_message ();
/* Set the history pointer back to the last entry in the history. */
void
-_rl_start_using_history ()
+_rl_start_using_history (void)
{
using_history ();
if (_rl_saved_line_for_history)
/* Free the contents (and containing structure) of a HIST_ENTRY. */
void
-_rl_free_history_entry (entry)
- HIST_ENTRY *entry;
+_rl_free_history_entry (HIST_ENTRY *entry)
{
if (entry == 0)
return;
/* Perhaps put back the current line if it has changed. */
int
-rl_maybe_replace_line ()
+rl_maybe_replace_line (void)
{
HIST_ENTRY *temp;
/* Restore the _rl_saved_line_for_history if there is one. */
int
-rl_maybe_unsave_line ()
+rl_maybe_unsave_line (void)
{
if (_rl_saved_line_for_history)
{
/* Save the current line in _rl_saved_line_for_history. */
int
-rl_maybe_save_line ()
+rl_maybe_save_line (void)
{
if (_rl_saved_line_for_history == 0)
{
}
int
-_rl_free_saved_history_line ()
+_rl_free_saved_history_line (void)
{
if (_rl_saved_line_for_history)
{
}
static void
-_rl_history_set_point ()
+_rl_history_set_point (void)
{
rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1)
? _rl_history_saved_point
}
void
-rl_replace_from_history (entry, flags)
- HIST_ENTRY *entry;
- int flags; /* currently unused */
+rl_replace_from_history (HIST_ENTRY *entry, int flags)
{
/* Can't call with `1' because rl_undo_list might point to an undo list
from a history entry, just like we're setting up here. */
intended to be called while actively editing, and the current line is
not assumed to have been added to the history list. */
void
-_rl_revert_all_lines ()
+_rl_revert_all_lines (void)
{
int hpos;
HIST_ENTRY *entry;
to an UNDO_LIST * saved as some history entry's data member. This
should not be called while editing is active. */
void
-rl_clear_history ()
+rl_clear_history (void)
{
HIST_ENTRY **hlist, *hent;
register int i;
/* Meta-< goes to the start of the history. */
int
-rl_beginning_of_history (count, key)
- int count, key;
+rl_beginning_of_history (int count, int key)
{
return (rl_get_previous_history (1 + where_history (), key));
}
/* Meta-> goes to the end of the history. (The current line). */
int
-rl_end_of_history (count, key)
- int count, key;
+rl_end_of_history (int count, int key)
{
rl_maybe_replace_line ();
using_history ();
/* Move down to the next history line. */
int
-rl_get_next_history (count, key)
- int count, key;
+rl_get_next_history (int count, int key)
{
HIST_ENTRY *temp;
/* Get the previous item out of our interactive history, making it the current
line. If there is no previous history, just ding. */
int
-rl_get_previous_history (count, key)
- int count, key;
+rl_get_previous_history (int count, int key)
{
HIST_ENTRY *old_temp, *temp;
if (count < 0)
return (rl_get_next_history (-count, key));
- if (count == 0)
+ if (count == 0 || history_list () == 0)
return 0;
/* either not saved by rl_newline or at end of line, so set appropriately. */
temp = old_temp;
if (temp == 0)
- rl_ding ();
+ {
+ rl_maybe_unsave_line ();
+ rl_ding ();
+ }
else
{
rl_replace_from_history (temp, 0);
/* **************************************************************** */
/* How to toggle back and forth between editing modes. */
int
-rl_vi_editing_mode (count, key)
- int count, key;
+rl_vi_editing_mode (int count, int key)
{
#if defined (VI_MODE)
_rl_set_insert_mode (RL_IM_INSERT, 1); /* vi mode ignores insert mode */
}
int
-rl_emacs_editing_mode (count, key)
- int count, key;
+rl_emacs_editing_mode (int count, int key)
{
rl_editing_mode = emacs_mode;
_rl_set_insert_mode (RL_IM_INSERT, 1); /* emacs mode default is insert mode */
/* Function for the rest of the library to use to set insert/overwrite mode. */
void
-_rl_set_insert_mode (im, force)
- int im, force;
+_rl_set_insert_mode (int im, int force)
{
#ifdef CURSOR_MODE
_rl_set_cursor (im, force);
/* Toggle overwrite mode. A positive explicit argument selects overwrite
mode. A negative or zero explicit argument selects insert mode. */
int
-rl_overwrite_mode (count, key)
- int count, key;
+rl_overwrite_mode (int count, int key)
{
if (rl_explicit_arg == 0)
_rl_set_insert_mode (rl_insert_mode ^ 1, 0);
/* nls.c -- skeletal internationalization code. */
-/* Copyright (C) 1996-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
static char *_rl_get_locale_var PARAMS((const char *));
static char *
-_rl_get_locale_var (v)
- const char *v;
+_rl_get_locale_var (const char *v)
{
char *lspec;
}
static int
-utf8locale (lspec)
- char *lspec;
+utf8locale (char *lspec)
{
char *cp;
size_t len;
/* Query the right environment variables and call setlocale() to initialize
the C library locale settings. */
char *
-_rl_init_locale ()
+_rl_init_locale (void)
{
char *ret, *lspec;
to decide the defaults for 8-bit character input and output. Returns
1 if we set eight-bit mode. */
int
-_rl_init_eightbit ()
+_rl_init_eightbit (void)
{
/* If we have setlocale(3), just check the current LC_CTYPE category
value, and go into eight-bit mode if it's not C or POSIX. */
#if !defined (HAVE_SETLOCALE)
static char *
-normalize_codeset (codeset)
- char *codeset;
+normalize_codeset (char *codeset)
{
size_t namelen, i;
int len, all_digits;
/* Isolate codeset portion of locale specification. */
static char *
-find_codeset (name, lenp)
- char *name;
- size_t *lenp;
+find_codeset (char *name, size_t *lenp)
{
char *cp, *language, *result;
/* parens.c -- implementation of matching parentheses feature. */
-/* Copyright (C) 1987, 1989, 1992-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987, 1989, 1992-2015, 2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Change emacs_standard_keymap to have bindings for paren matching when
ON_OR_OFF is 1, change them back to self_insert when ON_OR_OFF == 0. */
void
-_rl_enable_paren_matching (on_or_off)
- int on_or_off;
+_rl_enable_paren_matching (int on_or_off)
{
if (on_or_off)
{
}
int
-rl_set_paren_blink_timeout (u)
- int u;
+rl_set_paren_blink_timeout (int u)
{
int o;
}
int
-rl_insert_close (count, invoking_key)
- int count, invoking_key;
+rl_insert_close (int count, int invoking_key)
{
if (rl_explicit_arg || !rl_blink_matching_paren)
_rl_insert_char (count, invoking_key);
}
static int
-find_matching_open (string, from, closer)
- char *string;
- int from, closer;
+find_matching_open (char *string, int from, int closer)
{
register int i;
int opener, level, delimiter;
Modified by Chet Ramey for Readline.
- Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012 Free Software Foundation,
- Inc.
+ Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2017
+ Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
#endif /* COLOR_SUPPORT */
-void _rl_parse_colors()
+void _rl_parse_colors(void)
{
#if defined (COLOR_SUPPORT)
const char *p; /* Pointer to character being parsed */
/* readline.c -- a general facility for reading lines of input
with emacs style editing and completion. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Set up the prompt and expand it. Called from readline() and
rl_callback_handler_install (). */
int
-rl_set_prompt (prompt)
- const char *prompt;
+rl_set_prompt (const char *prompt)
{
FREE (rl_prompt);
rl_prompt = prompt ? savestring (prompt) : (char *)NULL;
/* Read a line of input. Prompt with PROMPT. An empty PROMPT means
none. A return value of NULL means that EOF was encountered. */
char *
-readline (prompt)
- const char *prompt;
+readline (const char *prompt)
{
char *value;
#if 0
#endif
STATIC_CALLBACK void
-readline_internal_setup ()
+readline_internal_setup (void)
{
char *nprompt;
#if defined (VI_MODE)
if (rl_editing_mode == vi_mode)
rl_vi_insertion_mode (1, 'i'); /* don't want to reset last */
+ else
#endif /* VI_MODE */
+ if (_rl_show_mode_in_prompt)
+ _rl_reset_prompt ();
/* If we're not echoing, we still want to at least print a prompt, because
rl_redisplay will not do it for us. If the calling application has a
}
STATIC_CALLBACK char *
-readline_internal_teardown (eof)
- int eof;
+readline_internal_teardown (int eof)
{
char *temp;
HIST_ENTRY *entry;
}
void
-_rl_internal_char_cleanup ()
+_rl_internal_char_cleanup (void)
{
#if defined (VI_MODE)
/* In vi mode, when you exit insert mode, the cursor moves back
STATIC_CALLBACK int
#if defined (READLINE_CALLBACKS)
-readline_internal_char ()
+readline_internal_char (void)
#else
-readline_internal_charloop ()
+readline_internal_charloop (void)
#endif
{
static int lastc, eof_found;
#if defined (READLINE_CALLBACKS)
static int
-readline_internal_charloop ()
+readline_internal_charloop (void)
{
int eof = 1;
the global rl_outstream.
If rl_prompt is non-null, then that is our prompt. */
static char *
-readline_internal ()
+readline_internal (void)
{
int eof;
}
void
-_rl_init_line_state ()
+_rl_init_line_state (void)
{
rl_point = rl_end = rl_mark = 0;
the_line = rl_line_buffer;
}
void
-_rl_set_the_line ()
+_rl_set_the_line (void)
{
the_line = rl_line_buffer;
}
#if defined (READLINE_CALLBACKS)
_rl_keyseq_cxt *
-_rl_keyseq_cxt_alloc ()
+_rl_keyseq_cxt_alloc (void)
{
_rl_keyseq_cxt *cxt;
}
void
-_rl_keyseq_cxt_dispose (cxt)
- _rl_keyseq_cxt *cxt;
+_rl_keyseq_cxt_dispose (_rl_keyseq_cxt *cxt)
{
xfree (cxt);
}
void
-_rl_keyseq_chain_dispose ()
+_rl_keyseq_chain_dispose (void)
{
_rl_keyseq_cxt *cxt;
#endif
static int
-_rl_subseq_getchar (key)
- int key;
+_rl_subseq_getchar (int key)
{
int k;
#if defined (READLINE_CALLBACKS)
int
-_rl_dispatch_callback (cxt)
- _rl_keyseq_cxt *cxt;
+_rl_dispatch_callback (_rl_keyseq_cxt *cxt)
{
int nkey, r;
If the associated command is really a keymap, then read
another key, and dispatch into that map. */
int
-_rl_dispatch (key, map)
- register int key;
- Keymap map;
+_rl_dispatch (register int key, Keymap map)
{
_rl_dispatching_keymap = map;
return _rl_dispatch_subseq (key, map, 0);
}
int
-_rl_dispatch_subseq (key, map, got_subseq)
- register int key;
- Keymap map;
- int got_subseq;
+_rl_dispatch_subseq (register int key, Keymap map, int got_subseq)
{
int r, newkey;
char *macro;
}
static int
-_rl_subseq_result (r, map, key, got_subseq)
- int r;
- Keymap map;
- int key, got_subseq;
+_rl_subseq_result (int r, Keymap map, int key, int got_subseq)
{
Keymap m;
int type, nt;
_rl_dispatching_keymap = map;
return -2;
}
- else if (r && got_subseq)
+ else if (r < 0 && got_subseq) /* XXX */
{
/* OK, back up the chain. */
if (RL_ISSTATE (RL_STATE_MACROINPUT))
/* Initialize readline (and terminal if not already). */
int
-rl_initialize ()
+rl_initialize (void)
{
/* If we have never been called before, initialize the
terminal and data structures. */
#if 0
#if defined (__EMX__)
static void
-_emx_build_environ ()
+_emx_build_environ (void)
{
TIB *tibp;
PIB *pibp;
/* Initialize the entire state of the world. */
static void
-readline_initialize_everything ()
+readline_initialize_everything (void)
{
#if 0
#if defined (__EMX__)
input editing characters, then bind them to their readline
equivalents, iff the characters are not bound to keymaps. */
static void
-readline_default_bindings ()
+readline_default_bindings (void)
{
if (_rl_bind_stty_chars)
rl_tty_set_default_bindings (_rl_keymap);
/* Reset the default bindings for the terminal special characters we're
interested in back to rl_insert and read the new ones. */
static void
-reset_default_bindings ()
+reset_default_bindings (void)
{
if (_rl_bind_stty_chars)
{
/* Bind some common arrow key sequences in MAP. */
static void
-bind_arrow_keys_internal (map)
- Keymap map;
+bind_arrow_keys_internal (Keymap map)
{
Keymap xkeymap;
rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line);
rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line);
+ /* Key bindings for control-arrow keys */
+ rl_bind_keyseq_if_unbound ("\033[1;5C", rl_forward_word);
+ rl_bind_keyseq_if_unbound ("\033[1;5D", rl_backward_word);
+ rl_bind_keyseq_if_unbound ("\033[3;5~", rl_kill_word);
+
+ /* Key bindings for alt-arrow keys */
+ rl_bind_keyseq_if_unbound ("\033[1;3C", rl_forward_word);
+ rl_bind_keyseq_if_unbound ("\033[1;3D", rl_backward_word);
+
#if defined (__MINGW32__)
rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history);
rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history);
the inputrc file a chance to bind them and create `real' keymaps
for the arrow key prefix. */
static void
-bind_arrow_keys ()
+bind_arrow_keys (void)
{
bind_arrow_keys_internal (emacs_standard_keymap);
}
static void
-bind_bracketed_paste_prefix ()
+bind_bracketed_paste_prefix (void)
{
Keymap xkeymap;
/* **************************************************************** */
int
-rl_save_state (sp)
- struct readline_state *sp;
+rl_save_state (struct readline_state *sp)
{
if (sp == 0)
return -1;
}
int
-rl_restore_state (sp)
- struct readline_state *sp;
+rl_restore_state (struct readline_state *sp)
{
if (sp == 0)
return -1;
extern int rl_skip_csi_sequence PARAMS((int, int));
extern int rl_arrow_keys PARAMS((int, int));
+extern int rl_previous_screen_line PARAMS((int, int));
+extern int rl_next_screen_line PARAMS((int, int));
+
/* Bindable commands for inserting and deleting text. */
extern int rl_insert PARAMS((int, int));
extern int rl_quoted_insert PARAMS((int, int));
/* The next-to-last-ditch effort file name for a user-specific init file. */
#define DEFAULT_INPUTRC "~/.inputrc"
-/* The ultimate last-ditch filenname for an init file -- system-wide. */
+/* The ultimate last-ditch filename for an init file -- system-wide. */
#define SYS_INPUTRC "/etc/inputrc"
/* If defined, expand tabs to spaces. */
#define UTF8_SINGLEBYTE(c) (1)
+#if !defined (HAVE_WCHAR_T) && !defined (wchar_t)
+# define wchar_t int
+#endif
+
#endif /* !HANDLE_MULTIBYTE */
extern int rl_byte_oriented;
/* rltty.c -- functions to prepare and restore the terminal for readline's
use. */
-/* Copyright (C) 1992-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t *));
static void
-save_tty_chars (tiop)
- TIOTYPE *tiop;
+save_tty_chars (TIOTYPE *tiop)
{
_rl_last_tty_chars = _rl_tty_chars;
}
static int
-get_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+get_tty_settings (int tty, TIOTYPE *tiop)
{
set_winsize (tty);
}
static int
-set_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+set_tty_settings (int tty, TIOTYPE *tiop)
{
if (tiop->flags & SGTTY_SET)
{
}
static void
-prepare_terminal_settings (meta_flag, oldtio, tiop)
- int meta_flag;
- TIOTYPE oldtio, *tiop;
+prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
{
_rl_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
_rl_echoctl = (oldtio.sgttyb.sg_flags & ECHOCTL);
#endif
static void
-save_tty_chars (tiop)
- TIOTYPE *tiop;
+save_tty_chars (TIOTYPE *tiop)
{
_rl_last_tty_chars = _rl_tty_chars;
#if defined (_AIX) || defined (_AIX41)
/* Currently this is only used on AIX */
static void
-rltty_warning (msg)
+rltty_warning (char *msg)
char *msg;
{
_rl_errmsg ("warning: %s", msg);
#if defined (_AIX)
void
-setopost(tp)
-TIOTYPE *tp;
+setopost (TIOTYPE *tp)
{
if ((tp->c_oflag & OPOST) == 0)
{
#endif
static int
-_get_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+_get_tty_settings (int tty, TIOTYPE *tiop)
{
int ioctl_ret;
}
static int
-get_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+get_tty_settings (int tty, TIOTYPE *tiop)
{
set_winsize (tty);
}
static int
-_set_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+_set_tty_settings (int tty, TIOTYPE *tiop)
{
while (SETATTR (tty, tiop) < 0)
{
}
static int
-set_tty_settings (tty, tiop)
- int tty;
- TIOTYPE *tiop;
+set_tty_settings (int tty, TIOTYPE *tiop)
{
if (_set_tty_settings (tty, tiop) < 0)
return -1;
}
static void
-prepare_terminal_settings (meta_flag, oldtio, tiop)
- int meta_flag;
- TIOTYPE oldtio, *tiop;
+prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
{
_rl_echoing_p = (oldtio.c_lflag & ECHO);
#if defined (ECHOCTL)
/* Put the terminal in CBREAK mode so that we can detect key presses. */
#if defined (NO_TTY_DRIVER)
void
-rl_prep_terminal (meta_flag)
- int meta_flag;
+rl_prep_terminal (int meta_flag)
{
_rl_echoing_p = 1;
}
void
-rl_deprep_terminal ()
+rl_deprep_terminal (void)
{
}
#else /* ! NO_TTY_DRIVER */
void
-rl_prep_terminal (meta_flag)
- int meta_flag;
+rl_prep_terminal (int meta_flag)
{
int tty, nprep;
TIOTYPE tio;
/* Restore the terminal's normal settings and modes. */
void
-rl_deprep_terminal ()
+rl_deprep_terminal (void)
{
int tty;
/* Set readline's idea of whether or not it is echoing output to the terminal,
returning the old value. */
int
-rl_tty_set_echoing (u)
- int u;
+rl_tty_set_echoing (int u)
{
int o;
/* **************************************************************** */
int
-rl_restart_output (count, key)
- int count, key;
+rl_restart_output (int count, int key)
{
#if defined (__MINGW32__)
return 0;
}
int
-rl_stop_output (count, key)
- int count, key;
+rl_stop_output (int count, int key)
{
#if defined (__MINGW32__)
return 0;
#elif defined (NEW_TTY_DRIVER)
static void
-set_special_char (kmap, tiop, sc, func)
- Keymap kmap;
- TIOTYPE *tiop;
- int sc;
- rl_command_func_t *func;
+set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
{
if (sc != -1 && kmap[(unsigned char)sc].type == ISFUNC)
kmap[(unsigned char)sc].function = func;
kmap[(unsigned char)c].function = rl_insert;
static void
-_rl_bind_tty_special_chars (kmap, ttybuff)
- Keymap kmap;
- TIOTYPE ttybuff;
+_rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
{
if (ttybuff.flags & SGTTY_SET)
{
#else /* !NEW_TTY_DRIVER */
static void
-set_special_char (kmap, tiop, sc, func)
- Keymap kmap;
- TIOTYPE *tiop;
- int sc;
- rl_command_func_t *func;
+set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
{
unsigned char uc;
kmap[uc].function = rl_insert;
static void
-_rl_bind_tty_special_chars (kmap, ttybuff)
- Keymap kmap;
- TIOTYPE ttybuff;
+_rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
{
SET_SPECIAL (VERASE, rl_rubout);
SET_SPECIAL (VKILL, rl_unix_line_discard);
/* Set the system's default editing characters to their readline equivalents
in KMAP. Should be static, now that we have rl_tty_set_default_bindings. */
void
-rltty_set_default_bindings (kmap)
- Keymap kmap;
+rltty_set_default_bindings (Keymap kmap)
{
#if !defined (NO_TTY_DRIVER)
TIOTYPE ttybuff;
/* New public way to set the system default editing chars to their readline
equivalents. */
void
-rl_tty_set_default_bindings (kmap)
- Keymap kmap;
+rl_tty_set_default_bindings (Keymap kmap)
{
rltty_set_default_bindings (kmap);
}
chars with save_tty_chars(). This only works on POSIX termios or termio
systems. */
void
-rl_tty_unset_default_bindings (kmap)
- Keymap kmap;
+rl_tty_unset_default_bindings (Keymap kmap)
{
/* Don't bother before we've saved the tty special chars at least once. */
if (RL_ISSTATE(RL_STATE_TTYCSAVED) == 0)
#if defined (NEW_TTY_DRIVER) || defined (NO_TTY_DRIVER)
int
-_rl_disable_tty_signals ()
+_rl_disable_tty_signals (void)
{
return 0;
}
int
-_rl_restore_tty_signals ()
+_rl_restore_tty_signals (void)
{
return 0;
}
static int tty_sigs_disabled = 0;
int
-_rl_disable_tty_signals ()
+_rl_disable_tty_signals (void)
{
if (tty_sigs_disabled)
return 0;
}
int
-_rl_restore_tty_signals ()
+_rl_restore_tty_signals (void)
{
int r;
/* savestring.c - function version of savestring for backwards compatibility */
-/* Copyright (C) 1998,2003 Free Software Foundation, Inc.
+/* Copyright (C) 1998,2003,2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Backwards compatibility, now that savestring has been removed from
all `public' readline header files. */
char *
-savestring (s)
- const char *s;
+savestring (const char *s)
{
char *ret;
/* search.c - code for non-incremental searching in emacs and vi modes. */
-/* Copyright (C) 1992-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
current line. This doesn't do anything with rl_point; the caller
must set it. */
static void
-make_history_line_current (entry)
- HIST_ENTRY *entry;
+make_history_line_current (HIST_ENTRY *entry)
{
_rl_replace_text (entry->line, 0, rl_end);
_rl_fix_point (1);
for STRING. DIR < 0 means to search backwards through the history list,
DIR >= 0 means to search forward. */
static int
-noninc_search_from_pos (string, pos, dir, flags, ncp)
- char *string;
- int pos, dir, flags;
- int *ncp;
+noninc_search_from_pos (char *string, int pos, int dir, int flags, int *ncp)
{
int ret, old, sflags;
char *s;
search is backwards through previous entries, else through subsequent
entries. Returns 1 if the search was successful, 0 otherwise. */
static int
-noninc_dosearch (string, dir, flags)
- char *string;
- int dir;
- int flags;
+noninc_dosearch (char *string, int dir, int flags)
{
int oldpos, pos;
HIST_ENTRY *entry;
}
static _rl_search_cxt *
-_rl_nsearch_init (dir, pchar)
- int dir, pchar;
+_rl_nsearch_init (int dir, int pchar)
{
_rl_search_cxt *cxt;
char *p;
}
int
-_rl_nsearch_cleanup (cxt, r)
- _rl_search_cxt *cxt;
- int r;
+_rl_nsearch_cleanup (_rl_search_cxt *cxt, int r)
{
_rl_scxt_dispose (cxt, 0);
_rl_nscxt = 0;
}
static void
-_rl_nsearch_abort (cxt)
- _rl_search_cxt *cxt;
+_rl_nsearch_abort (_rl_search_cxt *cxt)
{
rl_maybe_unsave_line ();
rl_clear_message ();
if the caller should abort the search, 0 if we should break out of the
loop, and 1 if we should continue to read characters. */
static int
-_rl_nsearch_dispatch (cxt, c)
- _rl_search_cxt *cxt;
- int c;
+_rl_nsearch_dispatch (_rl_search_cxt *cxt, int c)
{
+ if (c < 0)
+ c = CTRL ('C');
+
switch (c)
{
case CTRL('W'):
using _rl_nsearch_cleanup (). Returns 1 if the search was successful,
0 otherwise. */
static int
-_rl_nsearch_dosearch (cxt)
- _rl_search_cxt *cxt;
+_rl_nsearch_dosearch (_rl_search_cxt *cxt)
{
rl_mark = cxt->save_mark;
history list. PCHAR is the character to use for prompting when reading
the search string; if not specified (0), it defaults to `:'. */
static int
-noninc_search (dir, pchar)
- int dir;
- int pchar;
+noninc_search (int dir, int pchar)
{
_rl_search_cxt *cxt;
int c, r;
{
c = _rl_search_getchar (cxt);
+ if (c < 0)
+ {
+ _rl_nsearch_abort (cxt);
+ return 1;
+ }
+
if (c == 0)
break;
/* Search forward through the history list for a string. If the vi-mode
code calls this, KEY will be `?'. */
int
-rl_noninc_forward_search (count, key)
- int count, key;
+rl_noninc_forward_search (int count, int key)
{
return noninc_search (1, (key == '?') ? '?' : 0);
}
/* Reverse search the history list for a string. If the vi-mode code
calls this, KEY will be `/'. */
int
-rl_noninc_reverse_search (count, key)
- int count, key;
+rl_noninc_reverse_search (int count, int key)
{
return noninc_search (-1, (key == '/') ? '/' : 0);
}
for. If there is no saved search string, abort. If the vi-mode code
calls this, KEY will be `N'. */
int
-rl_noninc_forward_search_again (count, key)
- int count, key;
+rl_noninc_forward_search_again (int count, int key)
{
int r;
for. If there is no saved search string, abort. If the vi-mode code
calls this, KEY will be `n'. */
int
-rl_noninc_reverse_search_again (count, key)
- int count, key;
+rl_noninc_reverse_search_again (int count, int key)
{
int r;
#if defined (READLINE_CALLBACKS)
int
-_rl_nsearch_callback (cxt)
- _rl_search_cxt *cxt;
+_rl_nsearch_callback (_rl_search_cxt *cxt)
{
int c, r;
c = _rl_search_getchar (cxt);
+ if (c <= 0)
+ {
+ if (c < 0)
+ _rl_nsearch_abort (cxt);
+ return 1;
+ }
r = _rl_nsearch_dispatch (cxt, c);
if (r != 0)
return 1;
#endif
static int
-rl_history_search_internal (count, dir)
- int count, dir;
+rl_history_search_internal (int count, int dir)
{
HIST_ENTRY *temp;
int ret, oldpos, newcol;
}
static void
-rl_history_search_reinit (flags)
- int flags;
+rl_history_search_reinit (int flags)
{
int sind;
from the start of the line to rl_point. This is a non-incremental
search. The search is anchored to the beginning of the history line. */
int
-rl_history_search_forward (count, ignore)
- int count, ignore;
+rl_history_search_forward (int count, int ignore)
{
if (count == 0)
return (0);
from the start of the line to rl_point. This is a non-incremental
search. */
int
-rl_history_search_backward (count, ignore)
- int count, ignore;
+rl_history_search_backward (int count, int ignore)
{
if (count == 0)
return (0);
search. The search succeeds if the search string is present anywhere
in the history line. */
int
-rl_history_substr_search_forward (count, ignore)
- int count, ignore;
+rl_history_substr_search_forward (int count, int ignore)
{
if (count == 0)
return (0);
from the start of the line to rl_point. This is a non-incremental
search. */
int
-rl_history_substr_search_backward (count, ignore)
- int count, ignore;
+rl_history_substr_search_backward (int count, int ignore)
{
if (count == 0)
return (0);
/* shell.c -- readline utility functions that are normally provided by
bash when readline is linked as part of the shell. */
-/* Copyright (C) 1997-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2009,2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Does shell-like quoting using single quotes. */
char *
-sh_single_quote (string)
- char *string;
+sh_single_quote (char *string)
{
register int c;
char *result, *r, *s;
static char putenv_buf2[INT_STRLEN_BOUND (int) + 8 + 1]; /* sizeof("COLUMNS=") == 8 */
void
-sh_set_lines_and_columns (lines, cols)
- int lines, cols;
+sh_set_lines_and_columns (int lines, int cols)
{
#if defined (HAVE_SETENV)
sprintf (setenv_buf, "%d", lines);
}
char *
-sh_get_env_value (varname)
- const char *varname;
+sh_get_env_value (const char *varname)
{
return ((char *)getenv (varname));
}
char *
-sh_get_home_dir ()
+sh_get_home_dir (void)
{
static char *home_dir = (char *)NULL;
struct passwd *entry;
#endif
int
-sh_unset_nodelay_mode (fd)
- int fd;
+sh_unset_nodelay_mode (int fd)
{
#if defined (HAVE_FCNTL)
int flags, bflags;
/* signals.c -- signal handling support for readline. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Called from RL_CHECK_SIGNALS() macro */
RETSIGTYPE
-_rl_signal_handler (sig)
- int sig;
+_rl_signal_handler (int sig)
{
_rl_caught_signal = 0; /* XXX */
}
static RETSIGTYPE
-rl_signal_handler (sig)
- int sig;
+rl_signal_handler (int sig)
{
if (_rl_interrupt_immediately)
{
}
static RETSIGTYPE
-_rl_handle_signal (sig)
- int sig;
+_rl_handle_signal (int sig)
{
#if defined (HAVE_POSIX_SIGNALS)
sigset_t set;
#if defined (SIGWINCH)
static RETSIGTYPE
-rl_sigwinch_handler (sig)
- int sig;
+rl_sigwinch_handler (int sig)
{
SigHandler *oh;
#if !defined (HAVE_POSIX_SIGNALS)
static int
-rl_sigaction (sig, nh, oh)
- int sig;
- sighandler_cxt *nh, *oh;
+rl_sigaction (int sig, sighandler_cxt *nh, sighandler_cxt *oh)
{
oh->sa_handler = signal (sig, nh->sa_handler);
return 0;
information in OHANDLER. Return the old signal handler, like
signal(). */
static SigHandler *
-rl_set_sighandler (sig, handler, ohandler)
- int sig;
- SigHandler *handler;
- sighandler_cxt *ohandler;
+rl_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler)
{
sighandler_cxt old_handler;
#if defined (HAVE_POSIX_SIGNALS)
/* Set disposition of SIG to HANDLER, returning old state in OHANDLER. Don't
change disposition if OHANDLER indicates the signal was ignored. */
static void
-rl_maybe_set_sighandler (sig, handler, ohandler)
- int sig;
- SigHandler *handler;
- sighandler_cxt *ohandler;
+rl_maybe_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler)
{
sighandler_cxt dummy;
SigHandler *oh;
disposition was changed using rl_maybe_set_sighandler or for which the
SIG_IGN check was performed inline (e.g., SIGALRM below). */
static void
-rl_maybe_restore_sighandler (sig, handler)
- int sig;
- sighandler_cxt *handler;
+rl_maybe_restore_sighandler (int sig, sighandler_cxt *handler)
{
sighandler_cxt dummy;
}
int
-rl_set_signals ()
+rl_set_signals (void)
{
sighandler_cxt dummy;
SigHandler *oh;
}
int
-rl_clear_signals ()
+rl_clear_signals (void)
{
sighandler_cxt dummy;
/* Clean up the terminal and readline state after catching a signal, before
resending it to the calling application. */
void
-rl_cleanup_after_signal ()
+rl_cleanup_after_signal (void)
{
_rl_clean_up_for_exit ();
if (rl_deprep_term_function)
/* Reset the terminal and readline state after a signal handler returns. */
void
-rl_reset_after_signal ()
+rl_reset_after_signal (void)
{
if (rl_prep_term_function)
(*rl_prep_term_function) (_rl_meta_flag);
numeric arguments in process) after catching a signal, before calling
rl_cleanup_after_signal(). */
void
-rl_free_line_state ()
+rl_free_line_state (void)
{
register HIST_ENTRY *entry;
}
int
-rl_pending_signal ()
+rl_pending_signal (void)
{
return (_rl_caught_signal);
}
/* Cause SIGINT to not be delivered until the corresponding call to
release_sigint(). */
void
-_rl_block_sigint ()
+_rl_block_sigint (void)
{
if (sigint_blocked)
return;
/* Allow SIGINT to be delivered. */
void
-_rl_release_sigint ()
+_rl_release_sigint (void)
{
if (sigint_blocked == 0)
return;
/* Cause SIGWINCH to not be delivered until the corresponding call to
release_sigwinch(). */
void
-_rl_block_sigwinch ()
+_rl_block_sigwinch (void)
{
if (sigwinch_blocked)
return;
/* Allow SIGWINCH to be delivered. */
void
-_rl_release_sigwinch ()
+_rl_release_sigwinch (void)
{
if (sigwinch_blocked == 0)
return;
/* */
/* **************************************************************** */
void
-rl_echo_signal_char (sig)
- int sig;
+rl_echo_signal_char (int sig)
{
char cstr[3];
int cslen, c;
/* terminal.c -- controlling the terminal with termcap. */
-/* Copyright (C) 1996-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
char *_rl_term_dc;
char *_rl_term_DC;
+/* How to move forward a char, non-destructively */
char *_rl_term_forward_char;
/* How to go up a line. */
#if defined (__EMX__)
static void
-_emx_get_screensize (swp, shp)
- int *swp, *shp;
+_emx_get_screensize (int *swp, int *shp)
{
int sz[2];
#if defined (__MINGW32__)
static void
-_win_get_screensize (swp, shp)
- int *swp, *shp;
+_win_get_screensize (int *swp, int *shp)
{
HANDLE hConOut;
CONSOLE_SCREEN_BUFFER_INFO scr;
values of $LINES and $COLUMNS. The tests for TERM_STRING_BUFFER being
non-null serve to check whether or not we have initialized termcap. */
void
-_rl_get_screen_size (tty, ignore_env)
- int tty, ignore_env;
+_rl_get_screen_size (int tty, int ignore_env)
{
char *ss;
#if defined (TIOCGWINSZ)
}
void
-_rl_set_screen_size (rows, cols)
- int rows, cols;
+_rl_set_screen_size (int rows, int cols)
{
if (_rl_term_autowrap == -1)
_rl_init_terminal_io (rl_terminal_name);
}
void
-rl_set_screen_size (rows, cols)
- int rows, cols;
+rl_set_screen_size (int rows, int cols)
{
_rl_set_screen_size (rows, cols);
}
void
-rl_get_screen_size (rows, cols)
- int *rows, *cols;
+rl_get_screen_size (int *rows, int *cols)
{
if (rows)
*rows = _rl_screenheight;
}
void
-rl_reset_screen_size ()
+rl_reset_screen_size (void)
{
_rl_get_screen_size (fileno (rl_instream), 0);
}
void
-_rl_sigwinch_resize_terminal ()
+_rl_sigwinch_resize_terminal (void)
{
_rl_get_screen_size (fileno (rl_instream), 1);
}
void
-rl_resize_terminal ()
+rl_resize_terminal (void)
{
_rl_get_screen_size (fileno (rl_instream), 1);
if (_rl_echoing_p)
/* Read the desired terminal capability strings into BP. The capabilities
are described in the TC_STRINGS table. */
static void
-get_term_capabilities (bp)
- char **bp;
+get_term_capabilities (char **bp)
{
#if !defined (__DJGPP__) /* XXX - doesn't DJGPP have a termcap library? */
register int i;
}
int
-_rl_init_terminal_io (terminal_name)
- const char *terminal_name;
+_rl_init_terminal_io (const char *terminal_name)
{
const char *term;
char *buffer;
/* Bind the arrow key sequences from the termcap description in MAP. */
static void
-bind_termcap_arrow_keys (map)
- Keymap map;
+bind_termcap_arrow_keys (Keymap map)
{
Keymap xkeymap;
}
char *
-rl_get_termcap (cap)
- const char *cap;
+rl_get_termcap (const char *cap)
{
register int i;
/* Re-initialize the terminal considering that the TERM/TERMCAP variable
has changed. */
int
-rl_reset_terminal (terminal_name)
- const char *terminal_name;
+rl_reset_terminal (const char *terminal_name)
{
_rl_screenwidth = _rl_screenheight = 0;
_rl_init_terminal_io (terminal_name);
/* A function for the use of tputs () */
#ifdef _MINIX
void
-_rl_output_character_function (c)
- int c;
+_rl_output_character_function (int c)
{
putc (c, _rl_out_stream);
}
#else /* !_MINIX */
int
-_rl_output_character_function (c)
- int c;
+_rl_output_character_function (int c)
{
return putc (c, _rl_out_stream);
}
/* Write COUNT characters from STRING to the output stream. */
void
-_rl_output_some_chars (string, count)
- const char *string;
- int count;
+_rl_output_some_chars (const char *string, int count)
{
fwrite (string, 1, count, _rl_out_stream);
}
/* Move the cursor back. */
int
-_rl_backspace (count)
- int count;
+_rl_backspace (int count)
{
register int i;
/* Move to the start of the next line. */
int
-rl_crlf ()
+rl_crlf (void)
{
#if defined (NEW_TTY_DRIVER) || defined (__MINT__)
if (_rl_term_cr)
/* Ring the terminal bell. */
int
-rl_ding ()
+rl_ding (void)
{
if (_rl_echoing_p)
{
static int enabled_meta = 0; /* flag indicating we enabled meta mode */
void
-_rl_enable_meta_key ()
+_rl_enable_meta_key (void)
{
#if !defined (__DJGPP__)
if (term_has_meta && _rl_term_mm)
}
void
-_rl_disable_meta_key ()
+_rl_disable_meta_key (void)
{
#if !defined (__DJGPP__)
if (term_has_meta && _rl_term_mo && enabled_meta)
}
void
-_rl_control_keypad (on)
- int on;
+_rl_control_keypad (int on)
{
#if !defined (__DJGPP__)
if (on && _rl_term_ks)
cursor. Overwrite mode gets a very visible cursor. Only does
anything if we have both capabilities. */
void
-_rl_set_cursor (im, force)
- int im, force;
+_rl_set_cursor (int im, int force)
{
#ifndef __MSDOS__
if (_rl_term_ve && _rl_term_vs)
/* text.c -- text handling commands for readline. */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
way that you should do insertion. _rl_insert_char () calls this
function. Returns the number of characters inserted. */
int
-rl_insert_text (string)
- const char *string;
+rl_insert_text (const char *string)
{
register int i, l;
/* Delete the string between FROM and TO. FROM is inclusive, TO is not.
Returns the number of characters deleted. */
int
-rl_delete_text (from, to)
- int from, to;
+rl_delete_text (int from, int to)
{
register char *text;
register int diff, i;
} while (0)
void
-_rl_fix_point (fix_mark_too)
- int fix_mark_too;
+_rl_fix_point (int fix_mark_too)
{
_RL_FIX_POINT (rl_point);
if (fix_mark_too)
TEXT. The operation is undoable. To replace the entire line in an
undoable mode, use _rl_replace_text(text, 0, rl_end); */
int
-_rl_replace_text (text, start, end)
- const char *text;
- int start, end;
+_rl_replace_text (const char *text, int start, int end)
{
int n;
/* Replace the current line buffer contents with TEXT. If CLEAR_UNDO is
non-zero, we free the current undo list. */
void
-rl_replace_line (text, clear_undo)
- const char *text;
- int clear_undo;
+rl_replace_line (const char *text, int clear_undo)
{
int len;
/* Move forward COUNT bytes. */
int
-rl_forward_byte (count, key)
- int count, key;
+rl_forward_byte (int count, int key)
{
if (count < 0)
return (rl_backward_byte (-count, key));
}
int
-_rl_forward_char_internal (count)
- int count;
+_rl_forward_char_internal (int count)
{
int point;
#if defined (HANDLE_MULTIBYTE)
/* Move forward COUNT characters. */
int
-rl_forward_char (count, key)
- int count, key;
+rl_forward_char (int count, int key)
{
int point;
}
#else /* !HANDLE_MULTIBYTE */
int
-rl_forward_char (count, key)
- int count, key;
+rl_forward_char (int count, int key)
{
return (rl_forward_byte (count, key));
}
/* Backwards compatibility. */
int
-rl_forward (count, key)
- int count, key;
+rl_forward (int count, int key)
{
return (rl_forward_char (count, key));
}
/* Move backward COUNT bytes. */
int
-rl_backward_byte (count, key)
- int count, key;
+rl_backward_byte (int count, int key)
{
if (count < 0)
return (rl_forward_byte (-count, key));
#if defined (HANDLE_MULTIBYTE)
/* Move backward COUNT characters. */
int
-rl_backward_char (count, key)
- int count, key;
+rl_backward_char (int count, int key)
{
int point;
}
#else
int
-rl_backward_char (count, key)
- int count, key;
+rl_backward_char (int count, int key)
{
return (rl_backward_byte (count, key));
}
/* Backwards compatibility. */
int
-rl_backward (count, key)
- int count, key;
+rl_backward (int count, int key)
{
return (rl_backward_char (count, key));
}
/* Move to the beginning of the line. */
int
-rl_beg_of_line (count, key)
- int count, key;
+rl_beg_of_line (int count, int key)
{
rl_point = 0;
return 0;
/* Move to the end of the line. */
int
-rl_end_of_line (count, key)
- int count, key;
+rl_end_of_line (int count, int key)
{
rl_point = rl_end;
return 0;
/* Move forward a word. We do what Emacs does. Handles multibyte chars. */
int
-rl_forward_word (count, key)
- int count, key;
+rl_forward_word (int count, int key)
{
int c;
/* Move backward a word. We do what Emacs does. Handles multibyte chars. */
int
-rl_backward_word (count, key)
- int count, key;
+rl_backward_word (int count, int key)
{
int c, p;
/* Clear the current line. Numeric argument to C-l does this. */
int
-rl_refresh_line (ignore1, ignore2)
- int ignore1, ignore2;
+rl_refresh_line (int ignore1, int ignore2)
{
int curr_line;
the prompt and the current input line. Given a numeric arg, redraw only
the current line. */
int
-rl_clear_screen (count, key)
- int count, key;
+rl_clear_screen (int count, int key)
{
if (rl_explicit_arg)
{
}
int
-rl_skip_csi_sequence (count, key)
- int count, key;
+rl_previous_screen_line (int count, int key)
+{
+ int c;
+
+ c = _rl_term_autowrap ? _rl_screenwidth : (_rl_screenwidth + 1);
+ return (rl_backward_char (c, key));
+}
+
+int
+rl_next_screen_line (int count, int key)
+{
+ int c;
+
+ c = _rl_term_autowrap ? _rl_screenwidth : (_rl_screenwidth + 1);
+ return (rl_forward_char (c, key));
+}
+
+int
+rl_skip_csi_sequence (int count, int key)
{
int ch;
}
int
-rl_arrow_keys (count, c)
- int count, c;
+rl_arrow_keys (int count, int key)
{
int ch;
If C introduces a multibyte sequence, we read the whole sequence and
then insert the multibyte char into the line buffer. */
int
-_rl_insert_char (count, c)
- int count, c;
+_rl_insert_char (int count, int c)
{
register int i;
char *string;
If C introduces a multibyte character sequence, read the entire sequence
before starting the overwrite loop. */
int
-_rl_overwrite_char (count, c)
- int count, c;
+_rl_overwrite_char (int count, int c)
{
int i;
#if defined (HANDLE_MULTIBYTE)
}
int
-rl_insert (count, c)
- int count, c;
+rl_insert (int count, int c)
{
int r, n, x;
/* Insert the next typed character verbatim. */
static int
-_rl_insert_next (count)
- int count;
+_rl_insert_next (int count)
{
int c;
#if defined (READLINE_CALLBACKS)
static int
-_rl_insert_next_callback (data)
- _rl_callback_generic_arg *data;
+_rl_insert_next_callback (_rl_callback_generic_arg *data)
{
int count;
#endif
int
-rl_quoted_insert (count, key)
- int count, key;
+rl_quoted_insert (int count, int key)
{
/* Let's see...should the callback interface futz with signal handling? */
#if defined (HANDLE_SIGNALS)
/* Insert a tab character. */
int
-rl_tab_insert (count, key)
- int count, key;
+rl_tab_insert (int count, int key)
{
return (_rl_insert_char (count, '\t'));
}
KEY is the key that invoked this command. I guess it could have
meaning in the future. */
int
-rl_newline (count, key)
- int count, key;
+rl_newline (int count, int key)
{
rl_done = 1;
is just a stub, you bind keys to it and the code in _rl_dispatch ()
is special cased. */
int
-rl_do_lowercase_version (ignore1, ignore2)
- int ignore1, ignore2;
+rl_do_lowercase_version (int ignore1, int ignore2)
{
return 0;
}
rubout in overwrite mode has one oddity: it replaces a control
character that's displayed as two characters (^X) with two spaces. */
int
-_rl_overwrite_rubout (count, key)
- int count, key;
+_rl_overwrite_rubout (int count, int key)
{
int opoint;
int i, l;
/* Rubout the character behind point. */
int
-rl_rubout (count, key)
- int count, key;
+rl_rubout (int count, int key)
{
if (count < 0)
return (rl_delete (-count, key));
}
int
-_rl_rubout_char (count, key)
- int count, key;
+_rl_rubout_char (int count, int key)
{
int orig_point;
unsigned char c;
/* Delete the character under the cursor. Given a numeric argument,
kill that many characters instead. */
int
-rl_delete (count, key)
- int count, key;
+rl_delete (int count, int key)
{
int xpoint;
behind the cursor is deleted. COUNT is obeyed and may be used
to delete forward or backward that many characters. */
int
-rl_rubout_or_delete (count, key)
- int count, key;
+rl_rubout_or_delete (int count, int key)
{
if (rl_end != 0 && rl_point == rl_end)
return (_rl_rubout_char (count, key));
/* Delete all spaces and tabs around point. */
int
-rl_delete_horizontal_space (count, ignore)
- int count, ignore;
+rl_delete_horizontal_space (int count, int ignore)
{
int start;
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. */
int
-rl_delete_or_show_completions (count, key)
- int count, key;
+rl_delete_or_show_completions (int count, int key)
{
if (rl_end != 0 && rl_point == rl_end)
return (rl_possible_completions (count, key));
/* Turn the current line into a comment in shell history.
A K*rn shell style function. */
int
-rl_insert_comment (count, key)
- int count, key;
+rl_insert_comment (int count, int key)
{
char *rl_comment_text;
int rl_comment_len;
/* Uppercase the word at point. */
int
-rl_upcase_word (count, key)
- int count, key;
+rl_upcase_word (int count, int key)
{
return (rl_change_case (count, UpCase));
}
/* Lowercase the word at point. */
int
-rl_downcase_word (count, key)
- int count, key;
+rl_downcase_word (int count, int key)
{
return (rl_change_case (count, DownCase));
}
/* Upcase the first letter, downcase the rest. */
int
-rl_capitalize_word (count, key)
- int count, key;
+rl_capitalize_word (int count, int key)
{
return (rl_change_case (count, CapCase));
}
If a negative argument is given, leave point where it started,
otherwise, leave it where it moves to. */
static int
-rl_change_case (count, op)
- int count, op;
+rl_change_case (int count, int op)
{
int start, next, end;
- int inword, c, nc, nop;
+ int inword, nc, nop;
+ wchar_t c;
#if defined (HANDLE_MULTIBYTE)
wchar_t wc, nwc;
char mb[MB_LEN_MAX+1];
}
else
nop = op;
- if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii ((unsigned char)c))
+ /* Can't check isascii here; some languages (e.g, Turkish) have
+ multibyte upper and lower case equivalents of single-byte ascii
+ characters */
+ if (MB_CUR_MAX == 1 || rl_byte_oriented)
{
nc = (nop == UpCase) ? _rl_to_upper (c) : _rl_to_lower (c);
rl_line_buffer[start] = nc;
nwc = (nop == UpCase) ? _rl_to_wupper (wc) : _rl_to_wlower (wc);
if (nwc != wc) /* just skip unchanged characters */
{
+ char *s, *e;
mlen = wcrtomb (mb, nwc, &mps);
if (mlen > 0)
mb[mlen] = '\0';
- /* Assume the same width */
- strncpy (rl_line_buffer + start, mb, mlen);
+ /* what to do if m != mlen? adjust below */
+ /* m == length of old char, mlen == length of new char */
+ s = rl_line_buffer + start;
+ e = rl_line_buffer + rl_end;
+ if (m == mlen)
+ memcpy (s, mb, mlen);
+ else if (m > mlen)
+ {
+ memcpy (s, mb, mlen);
+ memmove (s + mlen, s + m, (e - s) - m);
+ next -= m - mlen; /* next char changes */
+ end -= m - mlen; /* end of word changes */
+ rl_end -= m - mlen; /* end of line changes */
+ rl_line_buffer[rl_end] = 0;
+ }
+ else if (m < mlen)
+ {
+ rl_extend_line_buffer (mlen - m + 1);
+ memmove (s + mlen, s + m, (e - s) - m);
+ memcpy (s, mb, mlen);
+ next += mlen - m; /* next char changes */
+ end += mlen - m; /* end of word changes */
+ rl_end += mlen - m; /* end of line changes */
+ rl_line_buffer[rl_end] = 0;
+ }
}
}
#endif
/* Transpose the words at point. If point is at the end of the line,
transpose the two words before point. */
int
-rl_transpose_words (count, key)
- int count, key;
+rl_transpose_words (int count, int key)
{
char *word1, *word2;
int w1_beg, w1_end, w2_beg, w2_end;
/* Transpose the characters at point. If point is at the end of the line,
then transpose the characters before point. */
int
-rl_transpose_chars (count, key)
- int count, key;
+rl_transpose_chars (int count, int key)
{
#if defined (HANDLE_MULTIBYTE)
char *dummy;
int
#if defined (HANDLE_MULTIBYTE)
-_rl_char_search_internal (count, dir, smbchar, len)
- int count, dir;
- char *smbchar;
- int len;
+_rl_char_search_internal (int count, int dir, char *smbchar, int len)
#else
-_rl_char_search_internal (count, dir, schar)
- int count, dir, schar;
+_rl_char_search_internal (int count, int dir, int schar)
#endif
{
int pos, inc;
that there are two separate versions of this function. */
#if defined (HANDLE_MULTIBYTE)
static int
-_rl_char_search (count, fdir, bdir)
- int count, fdir, bdir;
+_rl_char_search (int count, int fdir, int bdir)
{
char mbchar[MB_LEN_MAX];
int mb_len;
}
#else /* !HANDLE_MULTIBYTE */
static int
-_rl_char_search (count, fdir, bdir)
- int count, fdir, bdir;
+_rl_char_search (int count, int fdir, int bdir)
{
int c;
#endif
int
-rl_char_search (count, key)
- int count, key;
+rl_char_search (int count, int key)
{
#if defined (READLINE_CALLBACKS)
if (RL_ISSTATE (RL_STATE_CALLBACK))
}
int
-rl_backward_char_search (count, key)
- int count, key;
+rl_backward_char_search (int count, int key)
{
#if defined (READLINE_CALLBACKS)
if (RL_ISSTATE (RL_STATE_CALLBACK))
/* Set the mark at POSITION. */
int
-_rl_set_mark_at_pos (position)
- int position;
+_rl_set_mark_at_pos (int position)
{
- if (position > rl_end)
+ if (position < 0 || position > rl_end)
return 1;
rl_mark = position;
/* A bindable command to set the mark. */
int
-rl_set_mark (count, key)
- int count, key;
+rl_set_mark (int count, int key)
{
return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
}
/* Exchange the position of mark and point. */
int
-rl_exchange_point_and_mark (count, key)
- int count, key;
+rl_exchange_point_and_mark (int count, int key)
{
if (rl_mark > rl_end)
rl_mark = -1;
- if (rl_mark == -1)
+ if (rl_mark < 0)
{
rl_ding ();
+ rl_mark = 0; /* like _RL_FIX_POINT */
return 1;
}
else
/* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */
-/* Copyright (C) 1988-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1988-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
the tilde which starts the expansion. Place the length of the text
which identified this tilde starter in LEN, excluding the tilde itself. */
static int
-tilde_find_prefix (string, len)
- const char *string;
- int *len;
+tilde_find_prefix (const char *string, int *len)
{
register int i, j, string_len;
register char **prefixes;
/* Find the end of a tilde expansion in STRING, and return the index of
the character which ends the tilde definition. */
static int
-tilde_find_suffix (string)
- const char *string;
+tilde_find_suffix (const char *string)
{
register int i, j, string_len;
register char **suffixes;
/* Return a new string which is the result of tilde expanding STRING. */
char *
-tilde_expand (string)
- const char *string;
+tilde_expand (const char *string)
{
char *result;
int result_size, result_index;
non-null, the index of the end of the prefix into FNAME is returned in
the location it points to. */
static char *
-isolate_tilde_prefix (fname, lenp)
- const char *fname;
- int *lenp;
+isolate_tilde_prefix (const char *fname, int *lenp)
{
char *ret;
int i;
function. Right now, it just calls tilde_find_suffix and allocates new
memory, but it can be expanded to do different things later. */
char *
-tilde_find_word (fname, flags, lenp)
- const char *fname;
- int flags, *lenp;
+tilde_find_word (const char *fname, int flags, int *lenp)
{
int x;
char *r;
/* Return a string that is PREFIX concatenated with SUFFIX starting at
SUFFIND. */
static char *
-glue_prefix_and_suffix (prefix, suffix, suffind)
- char *prefix;
- const char *suffix;
- int suffind;
+glue_prefix_and_suffix (char *prefix, const char *suffix, int suffind)
{
char *ret;
int plen, slen;
tilde. If there is no expansion, call tilde_expansion_failure_hook.
This always returns a newly-allocated string, never static storage. */
char *
-tilde_expand_word (filename)
- const char *filename;
+tilde_expand_word (const char *filename)
{
char *dirname, *expansion, *username;
int user_len;
#undef NULL
#include <stdio.h>
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
char *result, line[512];
int done = 0;
exit (0);
}
-static void memory_error_and_abort ();
+static void memory_error_and_abort (void);
static void *
-xmalloc (bytes)
- size_t bytes;
+xmalloc (size_t bytes)
{
void *temp = (char *)malloc (bytes);
}
static void *
-xrealloc (pointer, bytes)
- void *pointer;
- int bytes;
+xrealloc (void *pointer, int bytes)
{
void *temp;
}
static void
-memory_error_and_abort ()
+memory_error_and_abort (void)
{
fprintf (stderr, "readline: out of virtual memory\n");
abort ();
/* undo.c - manage list of changes to lines, offering opportunity to undo them */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* **************************************************************** */
static UNDO_LIST *
-alloc_undo_entry (what, start, end, text)
- enum undo_code what;
- int start, end;
- char *text;
+alloc_undo_entry (enum undo_code what, int start, int end, char *text)
{
UNDO_LIST *temp;
/* Remember how to undo something. Concatenate some undos if that
seems right. */
void
-rl_add_undo (what, start, end, text)
- enum undo_code what;
- int start, end;
- char *text;
+rl_add_undo (enum undo_code what, int start, int end, char *text)
{
UNDO_LIST *temp;
/* Free an UNDO_LIST */
void
-_rl_free_undo_list (ul)
- UNDO_LIST *ul;
+_rl_free_undo_list (UNDO_LIST *ul)
{
UNDO_LIST *release;
/* Free the existing undo list. */
void
-rl_free_undo_list ()
+rl_free_undo_list (void)
{
UNDO_LIST *release, *orig_list;
}
UNDO_LIST *
-_rl_copy_undo_entry (entry)
- UNDO_LIST *entry;
+_rl_copy_undo_entry (UNDO_LIST *entry)
{
UNDO_LIST *new;
}
UNDO_LIST *
-_rl_copy_undo_list (head)
- UNDO_LIST *head;
+_rl_copy_undo_list (UNDO_LIST *head)
{
UNDO_LIST *list, *new, *roving, *c;
/* Undo the next thing in the list. Return 0 if there
is nothing to undo, or non-zero if there was. */
int
-rl_do_undo ()
+rl_do_undo (void)
{
UNDO_LIST *release;
int waiting_for_begin, start, end;
#undef TRANS
int
-_rl_fix_last_undo_of_type (type, start, end)
- int type, start, end;
+_rl_fix_last_undo_of_type (int type, int start, int end)
{
UNDO_LIST *rl;
/* Begin a group. Subsequent undos are undone as an atomic operation. */
int
-rl_begin_undo_group ()
+rl_begin_undo_group (void)
{
rl_add_undo (UNDO_BEGIN, 0, 0, 0);
_rl_undo_group_level++;
/* End an undo group started with rl_begin_undo_group (). */
int
-rl_end_undo_group ()
+rl_end_undo_group (void)
{
rl_add_undo (UNDO_END, 0, 0, 0);
_rl_undo_group_level--;
/* Save an undo entry for the text from START to END. */
int
-rl_modifying (start, end)
- int start, end;
+rl_modifying (int start, int end)
{
if (start > end)
{
/* Revert the current line to its previous state. */
int
-rl_revert_line (count, key)
- int count, key;
+rl_revert_line (int count, int key)
{
if (rl_undo_list == 0)
rl_ding ();
/* Do some undoing of things that were done. */
int
-rl_undo_command (count, key)
- int count, key;
+rl_undo_command (int count, int key)
{
if (count < 0)
return 0; /* Nothing to do. */
/* util.c -- readline utility functions */
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
static const char * const pathname_alphabetic_chars = "/-_=~.#$";
int
-rl_alphabetic (c)
- int c;
+rl_alphabetic (int c)
{
if (ALPHABETIC (c))
return (1);
/* How to abort things. */
int
-_rl_abort_internal ()
+_rl_abort_internal (void)
{
rl_ding ();
rl_clear_message ();
}
int
-rl_abort (count, key)
- int count, key;
+rl_abort (int count, int key)
{
return (_rl_abort_internal ());
}
int
-_rl_null_function (count, key)
- int count, key;
+_rl_null_function (int count, int key)
{
return 0;
}
int
-rl_tty_status (count, key)
- int count, key;
+rl_tty_status (int count, int key)
{
#if defined (TIOCSTAT)
ioctl (1, TIOCSTAT, (char *)0);
/* Return a copy of the string between FROM and TO.
FROM is inclusive, TO is not. */
char *
-rl_copy_text (from, to)
- int from, to;
+rl_copy_text (int from, int to)
{
register int length;
char *copy;
/* Increase the size of RL_LINE_BUFFER until it has enough space to hold
LEN characters. */
void
-rl_extend_line_buffer (len)
- int len;
+rl_extend_line_buffer (int len)
{
while (len >= rl_line_buffer_len)
{
/* A function for simple tilde expansion. */
int
-rl_tilde_expand (ignore, key)
- int ignore, key;
+rl_tilde_expand (int ignore, int key)
{
register int start, end;
char *homedir, *temp;
/* Determine if s2 occurs in s1. If so, return a pointer to the
match in s1. The compare is case insensitive. */
char *
-_rl_strindex (s1, s2)
- register const char *s1, *s2;
+_rl_strindex (const char *s1, const char *s2)
{
register int i, l, len;
/* Find the first occurrence in STRING1 of any character from STRING2.
Return a pointer to the character in STRING1. */
char *
-_rl_strpbrk (string1, string2)
- const char *string1, *string2;
+_rl_strpbrk (const char *string1, const char *string2)
{
register const char *scan;
#if defined (HANDLE_MULTIBYTE)
/* Compare at most COUNT characters from string1 to string2. Case
doesn't matter (strncasecmp). */
int
-_rl_strnicmp (string1, string2, count)
- const char *string1;
- const char *string2;
- int count;
+_rl_strnicmp (const char *string1, const char *string2, int count)
{
register const char *s1;
register const char *s2;
/* strcmp (), but caseless (strcasecmp). */
int
-_rl_stricmp (string1, string2)
- const char *string1;
- const char *string2;
+_rl_stricmp (const char *string1, const char *string2)
{
register const char *s1;
register const char *s2;
/* Stupid comparison routine for qsort () ing strings. */
int
-_rl_qsort_string_compare (s1, s2)
- char **s1, **s2;
+_rl_qsort_string_compare (char **s1, char **s2)
{
#if defined (HAVE_STRCOLL)
return (strcoll (*s1, *s2));
}
/* Function equivalents for the macros defined in chardefs.h. */
-#define FUNCTION_FOR_MACRO(f) int (f) (c) int c; { return f (c); }
+#define FUNCTION_FOR_MACRO(f) int (f) (int c) { return f (c); }
FUNCTION_FOR_MACRO (_rl_digit_p)
FUNCTION_FOR_MACRO (_rl_digit_value)
/* A convenience function, to force memory deallocation to be performed
by readline. DLLs on Windows apparently require this. */
void
-rl_free (mem)
- void *mem;
+rl_free (void *mem)
{
if (mem)
free (mem);
all `public' readline header files. */
#undef _rl_savestring
char *
-_rl_savestring (s)
- const char *s;
+_rl_savestring (const char *s)
{
return (strcpy ((char *)xmalloc (1 + (int)strlen (s)), (s)));
}
}
int
-_rl_tropen ()
+_rl_tropen (void)
{
char fnbuf[128], *x;
#else
x = "/var/tmp";
#endif
- sprintf (fnbuf, "%s/rltrace.%ld", x, (long)getpid());
+ snprintf (fnbuf, sizeof (fnbuf), "%s/rltrace.%ld", x, (long)getpid());
unlink(fnbuf);
_rl_tracefp = fopen (fnbuf, "w+");
return _rl_tracefp != 0;
}
int
-_rl_trclose ()
+_rl_trclose (void)
{
int r;
}
void
-_rl_settracefp (fp)
- FILE *fp;
+_rl_settracefp (FILE *fp)
{
_rl_tracefp = fp;
}
/* Report STRING to the audit system. */
void
-_rl_audit_tty (string)
- char *string;
+_rl_audit_tty (char *string)
{
struct audit_message req;
struct sockaddr_nl addr;
/* vi_keymap.c -- the keymap for vi_mode in readline (). */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* vi_mode.c -- A vi emulation mode for Bash.
Derived from code written by Jeff Sparkes (jsparkes@bnr.ca). */
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
#define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
#endif
+/* This is global so other parts of the code can check whether the last
+ command was a text modification command. */
int _rl_vi_last_command = 'i'; /* default `.' puts you in insert mode */
_rl_vimotion_cxt *_rl_vimvcxt = 0;
static int vidomove_dispatch PARAMS((_rl_vimotion_cxt *));
void
-_rl_vi_initialize_line ()
+_rl_vi_initialize_line (void)
{
register int i, n;
}
void
-_rl_vi_reset_last ()
+_rl_vi_reset_last (void)
{
_rl_vi_last_command = 'i';
_rl_vi_last_repeat = 1;
}
void
-_rl_vi_set_last (key, repeat, sign)
- int key, repeat, sign;
+_rl_vi_set_last (int key, int repeat, int sign)
{
_rl_vi_last_command = key;
_rl_vi_last_repeat = repeat;
/* A convenience function that calls _rl_vi_set_last to save the last command
information and enters insertion mode. */
void
-rl_vi_start_inserting (key, repeat, sign)
- int key, repeat, sign;
+rl_vi_start_inserting (int key, int repeat, int sign)
{
_rl_vi_set_last (key, repeat, sign);
rl_vi_insertion_mode (1, key);
/* Is the command C a VI mode text modification command? */
int
-_rl_vi_textmod_command (c)
- int c;
+_rl_vi_textmod_command (int c)
{
return (member (c, vi_textmod));
}
int
-_rl_vi_motion_command (c)
- int c;
+_rl_vi_motion_command (int c)
{
return (member (c, vi_motion));
}
static void
-_rl_vi_replace_insert (count)
- int count;
+_rl_vi_replace_insert (int count)
{
int nchars;
}
static void
-_rl_vi_stuff_insert (count)
- int count;
+_rl_vi_stuff_insert (int count)
{
rl_begin_undo_group ();
while (count--)
redo a text modification command. The default for _rl_vi_last_command
puts you back into insert mode. */
int
-rl_vi_redo (count, c)
- int count, c;
+rl_vi_redo (int count, int c)
{
int r;
/* A placeholder for further expansion. */
int
-rl_vi_undo (count, key)
- int count, key;
+rl_vi_undo (int count, int key)
{
return (rl_undo_command (count, key));
}
/* Yank the nth arg from the previous line into this line at point. */
int
-rl_vi_yank_arg (count, key)
- int count, key;
+rl_vi_yank_arg (int count, int key)
{
/* Readline thinks that the first word on a line is the 0th, while vi
thinks the first word on a line is the 1st. Compensate. */
/* With an argument, move back that many history lines, else move to the
beginning of history. */
int
-rl_vi_fetch_history (count, c)
- int count, c;
+rl_vi_fetch_history (int count, int c)
{
int wanted;
/* Search again for the last thing searched for. */
int
-rl_vi_search_again (count, key)
- int count, key;
+rl_vi_search_again (int count, int key)
{
switch (key)
{
/* Do a vi style search. */
int
-rl_vi_search (count, key)
- int count, key;
+rl_vi_search (int count, int key)
{
switch (key)
{
/* Completion, from vi's point of view. */
int
-rl_vi_complete (ignore, key)
- int ignore, key;
+rl_vi_complete (int ignore, int key)
{
if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
{
/* Tilde expansion for vi mode. */
int
-rl_vi_tilde_expand (ignore, key)
- int ignore, key;
+rl_vi_tilde_expand (int ignore, int key)
{
rl_tilde_expand (0, key);
rl_vi_start_inserting (key, 1, rl_arg_sign);
/* Previous word in vi mode. */
int
-rl_vi_prev_word (count, key)
- int count, key;
+rl_vi_prev_word (int count, int key)
{
if (count < 0)
return (rl_vi_next_word (-count, key));
/* Next word in vi mode. */
int
-rl_vi_next_word (count, key)
- int count, key;
+rl_vi_next_word (int count, int key)
{
if (count < 0)
return (rl_vi_prev_word (-count, key));
/* Move to the end of the ?next? word. */
int
-rl_vi_end_word (count, key)
- int count, key;
+rl_vi_end_word (int count, int key)
{
if (count < 0)
{
/* Move forward a word the way that 'W' does. */
int
-rl_vi_fWord (count, ignore)
- int count, ignore;
+rl_vi_fWord (int count, int ignore)
{
while (count-- && rl_point < (rl_end - 1))
{
}
int
-rl_vi_bWord (count, ignore)
- int count, ignore;
+rl_vi_bWord (int count, int ignore)
{
while (count-- && rl_point > 0)
{
}
int
-rl_vi_eWord (count, ignore)
- int count, ignore;
+rl_vi_eWord (int count, int ignore)
{
while (count-- && rl_point < (rl_end - 1))
{
}
int
-rl_vi_fword (count, ignore)
- int count, ignore;
+rl_vi_fword (int count, int ignore)
{
while (count-- && rl_point < (rl_end - 1))
{
}
int
-rl_vi_bword (count, ignore)
- int count, ignore;
+rl_vi_bword (int count, int ignore)
{
while (count-- && rl_point > 0)
{
so we will go back to the start of the previous word. */
if (!whitespace (rl_line_buffer[rl_point]) &&
whitespace (rl_line_buffer[rl_point - 1]))
- rl_point--;
+ if (--rl_point == 0)
+ break;
/* If this character and the previous character are `opposite', move
back so we don't get messed up by the rl_point++ down there in
}
int
-rl_vi_eword (count, ignore)
- int count, ignore;
+rl_vi_eword (int count, int ignore)
{
while (count-- && rl_point < rl_end - 1)
{
}
int
-rl_vi_insert_beg (count, key)
- int count, key;
+rl_vi_insert_beg (int count, int key)
{
rl_beg_of_line (1, key);
rl_vi_insert_mode (1, key);
}
static void
-_rl_vi_append_forward (key)
- int key;
+_rl_vi_append_forward (int key)
{
int point;
}
int
-rl_vi_append_mode (count, key)
- int count, key;
+rl_vi_append_mode (int count, int key)
{
_rl_vi_append_forward (key);
rl_vi_start_inserting (key, 1, rl_arg_sign);
}
int
-rl_vi_append_eol (count, key)
- int count, key;
+rl_vi_append_eol (int count, int key)
{
rl_end_of_line (1, key);
rl_vi_append_mode (1, key);
/* What to do in the case of C-d. */
int
-rl_vi_eof_maybe (count, c)
- int count, c;
+rl_vi_eof_maybe (int count, int c)
{
return (rl_newline (1, '\n'));
}
/* Switching from one mode to the other really just involves
switching keymaps. */
int
-rl_vi_insertion_mode (count, key)
- int count, key;
+rl_vi_insertion_mode (int count, int key)
{
_rl_keymap = vi_insertion_keymap;
_rl_vi_last_key_before_insert = key;
}
int
-rl_vi_insert_mode (count, key)
- int count, key;
+rl_vi_insert_mode (int count, int key)
{
rl_vi_start_inserting (key, 1, rl_arg_sign);
return (0);
}
static void
-vi_save_insert_buffer (start, len)
- int start, len;
+vi_save_insert_buffer (int start, int len)
{
/* Same code as _rl_vi_save_insert below */
if (len >= vi_insert_buffer_size)
}
static void
-_rl_vi_save_replace ()
+_rl_vi_save_replace (void)
{
int len, start, end;
UNDO_LIST *up;
}
static void
-_rl_vi_save_insert (up)
- UNDO_LIST *up;
+_rl_vi_save_insert (UNDO_LIST *up)
{
int len, start, end;
}
void
-_rl_vi_done_inserting ()
+_rl_vi_done_inserting (void)
{
if (_rl_vi_doing_insert)
{
}
int
-rl_vi_movement_mode (count, key)
- int count, key;
+rl_vi_movement_mode (int count, int key)
{
if (rl_point > 0)
rl_backward_char (1, key);
}
int
-rl_vi_arg_digit (count, c)
- int count, c;
+rl_vi_arg_digit (int count, int c)
{
if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
return (rl_beg_of_line (1, c));
/* Change the case of the next COUNT characters. */
#if defined (HANDLE_MULTIBYTE)
static int
-_rl_vi_change_mbchar_case (count)
- int count;
+_rl_vi_change_mbchar_case (int count)
{
wchar_t wc;
char mb[MB_LEN_MAX+1];
#endif
int
-rl_vi_change_case (count, ignore)
- int count, ignore;
+rl_vi_change_case (int count, int ignore)
{
int c, p;
}
int
-rl_vi_put (count, key)
- int count, key;
+rl_vi_put (int count, int key)
{
if (!_rl_uppercase_p (key) && (rl_point + 1 <= rl_end))
rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
return (0);
}
+/* Move the cursor back one character. */
static void
-_rl_vi_backup ()
+_rl_vi_backup (void)
{
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
rl_point--;
}
+/* Move the cursor back one character if you're at the end of the line */
int
-rl_vi_check ()
+rl_vi_check (void)
{
if (rl_point && rl_point == rl_end)
{
return (0);
}
+/* Move to the character position specified by COUNT */
int
-rl_vi_column (count, key)
- int count, key;
+rl_vi_column (int count, int key)
{
if (count > rl_end)
rl_end_of_line (1, key);
argument should be aborted, 0 if we should not read any more chars, and
1 if we should continue to read chars. */
static int
-_rl_vi_arg_dispatch (c)
- int c;
+_rl_vi_arg_dispatch (int c)
{
int key;
Don't recognize minus sign?
Should this do rl_save_prompt/rl_restore_prompt? */
static int
-rl_digit_loop1 ()
+rl_digit_loop1 (void)
{
int c, r;
return (0);
}
+/* This set of functions is basically to handle the commands that take a
+ motion argument while in callback mode: read the command, read the motion
+ command modifier, find the extent of the text to affect, and dispatch the
+ command for execution. */
static void
-_rl_mvcxt_init (m, op, key)
- _rl_vimotion_cxt *m;
- int op, key;
+_rl_mvcxt_init (_rl_vimotion_cxt *m, int op, int key)
{
m->op = op;
m->state = m->flags = 0;
}
static _rl_vimotion_cxt *
-_rl_mvcxt_alloc (op, key)
- int op, key;
+_rl_mvcxt_alloc (int op, int key)
{
_rl_vimotion_cxt *m;
}
static void
-_rl_mvcxt_dispose (m)
- _rl_vimotion_cxt *m;
+_rl_mvcxt_dispose (_rl_vimotion_cxt *m)
{
xfree (m);
}
static int
-rl_domove_motion_callback (m)
- _rl_vimotion_cxt *m;
+rl_domove_motion_callback (_rl_vimotion_cxt *m)
{
int c;
}
int
-_rl_vi_domove_motion_cleanup (c, m)
- int c;
- _rl_vimotion_cxt *m;
+_rl_vi_domove_motion_cleanup (int c, _rl_vimotion_cxt *m)
{
int r;
#define RL_VIMOVENUMARG() (RL_ISSTATE (RL_STATE_VIMOTION) && RL_ISSTATE (RL_STATE_NUMERICARG))
static int
-rl_domove_read_callback (m)
- _rl_vimotion_cxt *m;
+rl_domove_read_callback (_rl_vimotion_cxt *m)
{
int c, save;
}
static int
-rl_vi_domove_getchar (m)
- _rl_vimotion_cxt *m;
+rl_vi_domove_getchar (_rl_vimotion_cxt *m)
{
int c;
#if defined (READLINE_CALLBACKS)
int
-_rl_vi_domove_callback (m)
- _rl_vimotion_cxt *m;
+_rl_vi_domove_callback (_rl_vimotion_cxt *m)
{
int c, r;
}
#endif
-/* This code path taken when not in callback mode. */
+/* This code path is taken when not in callback mode. */
int
-rl_vi_domove (x, ignore)
- int x, *ignore;
+rl_vi_domove (int x, int *ignore)
{
int r;
_rl_vimotion_cxt *m;
}
static int
-vi_delete_dispatch (m)
- _rl_vimotion_cxt *m;
+vi_delete_dispatch (_rl_vimotion_cxt *m)
{
/* These are the motion commands that do not require adjusting the
mark. */
}
int
-rl_vi_delete_to (count, key)
- int count, key;
+rl_vi_delete_to (int count, int key)
{
int c, r;
}
static int
-vi_change_dispatch (m)
- _rl_vimotion_cxt *m;
+vi_change_dispatch (_rl_vimotion_cxt *m)
{
/* These are the motion commands that do not require adjusting the
mark. c[wW] are handled by special-case code in rl_vi_domove(),
}
int
-rl_vi_change_to (count, key)
- int count, key;
+rl_vi_change_to (int count, int key)
{
int c, r;
}
static int
-vi_yank_dispatch (m)
- _rl_vimotion_cxt *m;
+vi_yank_dispatch (_rl_vimotion_cxt *m)
{
/* These are the motion commands that do not require adjusting the
mark. */
}
int
-rl_vi_yank_to (count, key)
- int count, key;
+rl_vi_yank_to (int count, int key)
{
int c, r;
}
static int
-vidomove_dispatch (m)
- _rl_vimotion_cxt *m;
+vidomove_dispatch (_rl_vimotion_cxt *m)
{
int r;
}
int
-rl_vi_rubout (count, key)
- int count, key;
+rl_vi_rubout (int count, int key)
{
int opoint;
}
int
-rl_vi_delete (count, key)
- int count, key;
+rl_vi_delete (int count, int key)
{
int end;
#define vi_unix_word_boundary(c) (whitespace(c) || ispunct(c))
int
-rl_vi_unix_word_rubout (count, key)
- int count, key;
+rl_vi_unix_word_rubout (int count, int key)
{
int orig_point;
int
-rl_vi_back_to_indent (count, key)
- int count, key;
+rl_vi_back_to_indent (int count, int key)
{
rl_beg_of_line (1, key);
while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
}
int
-rl_vi_first_print (count, key)
- int count, key;
+rl_vi_first_print (int count, int key)
{
return (rl_vi_back_to_indent (1, key));
}
#if defined (READLINE_CALLBACKS)
static int
-_rl_vi_callback_char_search (data)
- _rl_callback_generic_arg *data;
+_rl_vi_callback_char_search (_rl_callback_generic_arg *data)
{
int c;
#if defined (HANDLE_MULTIBYTE)
#endif
int
-rl_vi_char_search (count, key)
- int count, key;
+rl_vi_char_search (int count, int key)
{
int c;
#if defined (HANDLE_MULTIBYTE)
/* Match brackets */
int
-rl_vi_match (ignore, key)
- int ignore, key;
+rl_vi_match (int ignore, int key)
{
int count = 1, brack, pos, tmp, pre;
}
int
-rl_vi_bracktype (c)
- int c;
+rl_vi_bracktype (int c)
{
switch (c)
{
}
static int
-_rl_vi_change_char (count, c, mb)
- int count, c;
- char *mb;
+_rl_vi_change_char (int count, int c, char *mb)
{
int p;
}
static int
-_rl_vi_callback_getchar (mb, mlen)
- char *mb;
- int mlen;
+_rl_vi_callback_getchar (char *mb, int mlen)
{
int c;
#if defined (READLINE_CALLBACKS)
static int
-_rl_vi_callback_change_char (data)
- _rl_callback_generic_arg *data;
+_rl_vi_callback_change_char (_rl_callback_generic_arg *data)
{
int c;
char mb[MB_LEN_MAX];
#endif
int
-rl_vi_change_char (count, key)
- int count, key;
+rl_vi_change_char (int count, int key)
{
int c;
char mb[MB_LEN_MAX];
}
int
-rl_vi_subst (count, key)
- int count, key;
+rl_vi_subst (int count, int key)
{
/* If we are redoing, rl_vi_change_to will stuff the last motion char */
if (_rl_vi_redoing == 0)
}
int
-rl_vi_overstrike (count, key)
- int count, key;
+rl_vi_overstrike (int count, int key)
{
if (_rl_vi_doing_insert == 0)
{
}
int
-rl_vi_overstrike_delete (count, key)
- int count, key;
+rl_vi_overstrike_delete (int count, int key)
{
int i, s;
}
int
-rl_vi_replace (count, key)
- int count, key;
+rl_vi_replace (int count, int key)
{
int i;
the previous character. A space matches everything. Word delimiters are
space and ;. */
int
-rl_vi_possible_completions()
+rl_vi_possible_completions (void)
{
int save_pos = rl_point;
/* Functions to save and restore marks. */
static int
-_rl_vi_set_mark ()
+_rl_vi_set_mark (void)
{
int ch;
#if defined (READLINE_CALLBACKS)
static int
-_rl_vi_callback_set_mark (data)
- _rl_callback_generic_arg *data;
+_rl_vi_callback_set_mark (_rl_callback_generic_arg *data)
{
_rl_callback_func = 0;
_rl_want_redisplay = 1;
#endif
int
-rl_vi_set_mark (count, key)
- int count, key;
+rl_vi_set_mark (int count, int key)
{
#if defined (READLINE_CALLBACKS)
if (RL_ISSTATE (RL_STATE_CALLBACK))
}
static int
-_rl_vi_goto_mark ()
+_rl_vi_goto_mark (void)
{
int ch;
#if defined (READLINE_CALLBACKS)
static int
-_rl_vi_callback_goto_mark (data)
- _rl_callback_generic_arg *data;
+_rl_vi_callback_goto_mark (_rl_callback_generic_arg *data)
{
_rl_callback_func = 0;
_rl_want_redisplay = 1;
#endif
int
-rl_vi_goto_mark (count, key)
- int count, key;
+rl_vi_goto_mark (int count, int key)
{
#if defined (READLINE_CALLBACKS)
if (RL_ISSTATE (RL_STATE_CALLBACK))
/* xfree.c -- safe version of free that ignores attempts to free NUL */
-/* Copyright (C) 1991-2010 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2010,2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* Use this as the function to call when adding unwind protects so we
don't need to know what free() returns. */
void
-xfree (string)
- PTR_T string;
+xfree (PTR_T string)
{
if (string)
free (string);
/* xmalloc.c -- safe versions of malloc and realloc */
-/* Copyright (C) 1991-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
This file is part of the GNU Readline Library (Readline), a library
for reading lines of text with interactive input and history editing.
/* **************************************************************** */
static void
-memory_error_and_abort (fname)
- char *fname;
+memory_error_and_abort (char *fname)
{
fprintf (stderr, "%s: out of virtual memory\n", fname);
exit (2);
to hold BYTES number of bytes. If the memory cannot be allocated,
print an error message and abort. */
PTR_T
-xmalloc (bytes)
- size_t bytes;
+xmalloc (size_t bytes)
{
PTR_T temp;
}
PTR_T
-xrealloc (pointer, bytes)
- PTR_T pointer;
- size_t bytes;
+xrealloc (PTR_T pointer, size_t bytes)
{
PTR_T temp;
projects / thirdparty / readline.git / commitdiff
