/* Variables exported by this file. */
Keymap rl_binding_keymap;
-static int _rl_read_init_file __P((char *, int));
+static int _rl_read_init_file __P((const char *, int));
static int glean_key_from_name __P((char *));
-static int substring_member_of_array __P((char *, char **));
+static int substring_member_of_array __P((char *, const char **));
static int currently_reading_init_file;
/* */
/* **************************************************************** */
-/* rl_add_defun (char *name, Function *function, int key)
+/* rl_add_defun (char *name, rl_command_func_t *function, int key)
Add NAME to the list of named functions. Make FUNCTION be the function
that gets called. If KEY is not -1, then bind it. */
int
rl_add_defun (name, function, key)
- char *name;
- Function *function;
+ const char *name;
+ rl_command_func_t *function;
int key;
{
if (key != -1)
int
rl_bind_key (key, function)
int key;
- Function *function;
+ rl_command_func_t *function;
{
if (key < 0)
return (key);
int
rl_bind_key_in_map (key, function, map)
int key;
- Function *function;
+ rl_command_func_t *function;
Keymap map;
{
int result;
rl_unbind_key (key)
int key;
{
- return (rl_bind_key (key, (Function *)NULL));
+ return (rl_bind_key (key, (rl_command_func_t *)NULL));
}
/* Make KEY do nothing in MAP.
int key;
Keymap map;
{
- return (rl_bind_key_in_map (key, (Function *)NULL, 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)
- Function *func;
+ rl_command_func_t *func;
Keymap map;
{
register int i, rval;
{
if (map[i].type == ISFUNC && map[i].function == func)
{
- map[i].function = (Function *)NULL;
+ map[i].function = (rl_command_func_t *)NULL;
rval = 1;
}
}
int
rl_unbind_command_in_map (command, map)
- char *command;
+ const char *command;
Keymap map;
{
- Function *func;
+ rl_command_func_t *func;
func = rl_named_function (command);
if (func == 0)
place to do bindings is in MAP. */
int
rl_set_key (keyseq, function, map)
- char *keyseq;
- Function *function;
+ const char *keyseq;
+ rl_command_func_t *function;
Keymap map;
{
return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
necessary. The initial place to do bindings is in MAP. */
int
rl_macro_bind (keyseq, macro, map)
- char *keyseq, *macro;
+ const char *keyseq, *macro;
Keymap map;
{
char *macro_keys;
int
rl_generic_bind (type, keyseq, data, map)
int type;
- char *keyseq, *data;
+ const char *keyseq;
+ char *data;
Keymap map;
{
char *keys;
non-zero if there was an error parsing SEQ. */
int
rl_translate_keyseq (seq, array, len)
- char *seq, *array;
+ const char *seq;
+ char *array;
int *len;
{
register int i, c, l, temp;
/* Return a pointer to the function that STRING represents.
If STRING doesn't have a matching function, then a NULL pointer
is returned. */
-Function *
+rl_command_func_t *
rl_named_function (string)
- char *string;
+ const char *string;
{
register int i;
for (i = 0; funmap[i]; i++)
if (_rl_stricmp (funmap[i]->name, string) == 0)
return (funmap[i]->function);
- return ((Function *)NULL);
+ return ((rl_command_func_t *)NULL);
}
/* Return the function (or macro) definition which would be invoked via
used. TYPE, if non-NULL, is a pointer to an int which will receive the
type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap),
or ISMACR (macro). */
-Function *
+rl_command_func_t *
rl_function_of_keyseq (keyseq, map, type)
- char *keyseq;
+ const char *keyseq;
Keymap map;
int *type;
{
return (map[ic].function);
}
}
- return ((Function *) NULL);
+ return ((rl_command_func_t *) NULL);
}
/* The last key bindings file read. */
static char *last_readline_init_file = (char *)NULL;
/* The file we're currently reading key bindings from. */
-static char *current_readline_init_file;
+static const char *current_readline_init_file;
static int current_readline_init_include_level;
static int current_readline_init_lineno;
int count, ignore;
{
int r;
- r = rl_read_init_file ((char *)NULL);
+ r = rl_read_init_file ((const char *)NULL);
rl_set_keymap_from_edit_mode ();
return r;
}
otherwise errno is returned. */
int
rl_read_init_file (filename)
- char *filename;
+ const char *filename;
{
/* Default the filename. */
if (filename == 0)
{
filename = last_readline_init_file;
if (filename == 0)
- filename = get_env_value ("INPUTRC");
+ filename = sh_get_env_value ("INPUTRC");
if (filename == 0)
filename = DEFAULT_INPUTRC;
}
static int
_rl_read_init_file (filename, include_level)
- char *filename;
+ const char *filename;
int include_level;
{
register int i;
/* Find the end of this line. */
for (i = 0; line + i != end && line[i] != '\n'; i++);
-#if defined (__CYGWIN32__)
+#if defined (__CYGWIN__)
/* ``Be liberal in what you accept.'' */
if (line[i] == '\n' && line[i-1] == '\r')
line[i - 1] = '\0';
/* */
/* **************************************************************** */
+typedef int _rl_parser_func_t __P((char *));
+
+/* Things that mean `Control'. */
+const char *_rl_possible_control_prefixes[] = {
+ "Control-", "C-", "CTRL-", (const char *)NULL
+};
+
+const char *_rl_possible_meta_prefixes[] = {
+ "Meta", "M-", (const char *)NULL
+};
+
/* Conditionals. */
/* Calling programs set this to have their argv[0]. */
-char *rl_readline_name = "other";
+const char *rl_readline_name = "other";
/* Stack of previous values of parsing_conditionalized_out. */
static unsigned char *if_stack = (unsigned char *)NULL;
parser_include (args)
char *args;
{
- char *old_init_file, *e;
+ const char *old_init_file;
+ char *e;
int old_line_number, old_include_level, r;
if (_rl_parsing_conditionalized_out)
e = strchr (args, '\n');
if (e)
*e = '\0';
- r = _rl_read_init_file (args, old_include_level + 1);
+ r = _rl_read_init_file ((const char *)args, old_include_level + 1);
current_readline_init_file = old_init_file;
current_readline_init_lineno = old_line_number;
/* Associate textual names with actual functions. */
static struct {
- char *name;
- Function *function;
+ const char *name;
+ _rl_parser_func_t *function;
} parser_directives [] = {
{ "if", parser_if },
{ "endif", parser_endif },
{ "else", parser_else },
{ "include", parser_include },
- { (char *)0x0, (Function *)0x0 }
+ { (char *)0x0, (_rl_parser_func_t *)0x0 }
};
/* Handle a parser directive. STATEMENT is the line of the directive
key = glean_key_from_name (kname);
/* Add in control and meta bits. */
- if (substring_member_of_array (string, possible_control_prefixes))
+ if (substring_member_of_array (string, _rl_possible_control_prefixes))
key = CTRL (_rl_to_upper (key));
- if (substring_member_of_array (string, possible_meta_prefixes))
+ if (substring_member_of_array (string, _rl_possible_meta_prefixes))
key = META (key);
/* Temporary. Handle old-style keyname with macro-binding. */
#define V_SPECIAL 0x1
static struct {
- char *name;
+ const char *name;
int *value;
int flags;
} boolean_varlist [] = {
hack_special_boolean_var (i)
int i;
{
- char *name;
+ const char *name;
name = boolean_varlist[i].name;
}
}
+typedef int _rl_sv_func_t __P((const char *));
+
/* These *must* correspond to the array indices for the appropriate
string variable. (Though they're not used right now.) */
#define V_BELLSTYLE 0
#define V_INT 2
/* Forward declarations */
-static int sv_bell_style __P((char *));
-static int sv_combegin __P((char *));
-static int sv_compquery __P((char *));
-static int sv_editmode __P((char *));
-static int sv_isrchterm __P((char *));
-static int sv_keymap __P((char *));
+static int sv_bell_style __P((const char *));
+static int sv_combegin __P((const char *));
+static int sv_compquery __P((const char *));
+static int sv_editmode __P((const char *));
+static int sv_isrchterm __P((const char *));
+static int sv_keymap __P((const char *));
static struct {
- char *name;
+ const char *name;
int flags;
- Function *set_func;
+ _rl_sv_func_t *set_func;
} string_varlist[] = {
{ "bell-style", V_STRING, sv_bell_style },
{ "comment-begin", V_STRING, sv_combegin },
int
rl_variable_bind (name, value)
- char *name, *value;
+ const char *name, *value;
{
register int i;
int v;
static int
sv_editmode (value)
- char *value;
+ const char *value;
{
if (_rl_strnicmp (value, "vi", 2) == 0)
{
static int
sv_combegin (value)
- char *value;
+ const char *value;
{
if (value && *value)
{
static int
sv_compquery (value)
- char *value;
+ const char *value;
{
int nval = 100;
static int
sv_keymap (value)
- char *value;
+ const char *value;
{
Keymap kmap;
static int
sv_bell_style (value)
- char *value;
+ const char *value;
{
if (value == 0 || *value == '\0')
_SET_BELL (AUDIBLE_BELL);
static int
sv_isrchterm (value)
- char *value;
+ const char *value;
{
int beg, end, delim;
char *v;
For example, `Space' returns ' '. */
typedef struct {
- char *name;
+ const char *name;
int value;
} assoc_list;
/* Auxiliary functions to manage keymaps. */
static struct {
- char *name;
+ const char *name;
Keymap map;
} keymap_names[] = {
{ "emacs", emacs_standard_keymap },
Keymap
rl_get_keymap_by_name (name)
- char *name;
+ const char *name;
{
register int i;
for (i = 0; keymap_names[i].name; i++)
- if (strcmp (name, keymap_names[i].name) == 0)
+ if (_rl_stricmp (name, keymap_names[i].name) == 0)
return (keymap_names[i].map);
return ((Keymap) NULL);
}
register int i;
for (i = 0; keymap_names[i].name; i++)
if (map == keymap_names[i].map)
- return (keymap_names[i].name);
+ return ((char *)keymap_names[i].name);
return ((char *)NULL);
}
rl_list_funmap_names ()
{
register int i;
- char **funmap_names;
+ const char **funmap_names;
funmap_names = rl_funmap_names ();
sequences that are used to invoke FUNCTION in MAP. */
char **
rl_invoking_keyseqs_in_map (function, map)
- Function *function;
+ rl_command_func_t *function;
Keymap map;
{
register int key;
sequences that can be used to invoke FUNCTION using the current keymap. */
char **
rl_invoking_keyseqs (function)
- Function *function;
+ rl_command_func_t *function;
{
return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
}
int print_readably;
{
register int i;
- char **names;
- char *name;
+ const char **names;
+ const char *name;
names = rl_funmap_names ();
for (i = 0; name = names[i]; i++)
{
- Function *function;
+ rl_command_func_t *function;
char **invokers;
function = rl_named_function (name);
int print_readably;
{
int i;
- char *kname;
+ const char *kname;
for (i = 0; boolean_varlist[i].name; i++)
{
/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. */
void
_rl_bind_if_unbound (keyseq, default_func)
- char *keyseq;
- Function *default_func;
+ const char *keyseq;
+ rl_command_func_t *default_func;
{
- Function *func;
+ rl_command_func_t *func;
if (keyseq)
{
/* Return non-zero if any members of ARRAY are a substring in STRING. */
static int
substring_member_of_array (string, array)
- char *string, **array;
+ char *string;
+ const char **array;
{
while (*array)
{
projects / thirdparty / bash.git / blobdiff