/* Variables exported by this file. */
Keymap rl_binding_keymap;
-static int _rl_read_init_file __P((char *, int));
-static int glean_key_from_name __P((char *));
-static int substring_member_of_array __P((char *, char **));
+static char *_rl_read_file PARAMS((char *, size_t *));
+static void _rl_init_file_error PARAMS((const char *));
+static int _rl_read_init_file PARAMS((const char *, int));
+static int glean_key_from_name PARAMS((char *));
+static int substring_member_of_array PARAMS((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;
int keys_len;
register int i;
+ KEYMAP_ENTRY k;
+
+ k.function = 0;
/* If no keys to bind to, exit right away. */
if (!keyseq || !*keyseq)
return -1;
}
- keys = xmalloc (1 + (2 * strlen (keyseq)));
+ keys = (char *)xmalloc (1 + (2 * strlen (keyseq)));
/* Translate the ASCII representation of KEYSEQ into an array of
characters. Stuff the characters into KEYS, and the length of
/* Bind keys, making new keymaps as necessary. */
for (i = 0; i < keys_len; i++)
{
- int ic = (int) ((unsigned char)keys[i]);
+ unsigned char uc = keys[i];
+ int ic;
+
+ ic = uc;
+ if (ic < 0 || ic >= KEYMAP_SIZE)
+ return -1;
if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic))
{
{
if (map[ic].type != ISKMAP)
{
- if (map[ic].type == ISMACR)
- free ((char *)map[ic].function);
+ /* We allow subsequences of keys. If a keymap is being
+ created that will `shadow' an existing function or macro
+ key binding, we save that keybinding into the ANYOTHERKEY
+ index in the new map. The dispatch code will look there
+ to find the function to execute if the subsequence is not
+ matched. ANYOTHERKEY was chosen to be greater than
+ UCHAR_MAX. */
+ k = map[ic];
map[ic].type = ISKMAP;
map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap());
}
map = FUNCTION_TO_KEYMAP (map, ic);
+ /* The dispatch code will return this function if no matching
+ key sequence is found in the keymap. This (with a little
+ help from the dispatch code in readline.c) allows `a' to be
+ mapped to something, `abc' to be mapped to something else,
+ and the function bound to `a' to be executed when the user
+ types `abx', leaving `bx' in the input queue. */
+ if (k.function /* && k.type == ISFUNC */)
+ {
+ map[ANYOTHERKEY] = k;
+ k.function = 0;
+ }
}
else
{
if (map[ic].type == ISMACR)
free ((char *)map[ic].function);
+ else if (map[ic].type == ISKMAP)
+ {
+ map = FUNCTION_TO_KEYMAP (map, ic);
+ ic = ANYOTHERKEY;
+ }
map[ic].function = KEYMAP_TO_FUNCTION (data);
map[ic].type = type;
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;
/* Handle special case of backwards define. */
if (strncmp (&seq[i], "C-\\M-", 5) == 0)
{
- array[l++] = ESC;
+ array[l++] = ESC; /* ESC is meta-prefix */
i += 5;
array[l++] = CTRL (_rl_to_upper (seq[i]));
if (seq[i] == '\0')
else if (c == 'M')
{
i++;
- array[l++] = ESC; /* XXX */
+ array[l++] = ESC; /* ESC is meta-prefix */
}
else if (c == 'C')
{
for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)
c = (c * 8) + OCTVALUE (seq[i]);
i--; /* auto-increment in for loop */
- array[l++] = c % (largest_char + 1);
+ array[l++] = c & largest_char;
break;
case 'x':
i++;
- for (temp = 3, c = 0; isxdigit (seq[i]) && temp--; i++)
+ for (temp = 2, c = 0; ISXDIGIT ((unsigned char)seq[i]) && temp--; i++)
c = (c * 16) + HEXVALUE (seq[i]);
- if (temp == 3)
+ if (temp == 2)
c = 'x';
i--; /* auto-increment in for loop */
- array[l++] = c % (largest_char + 1);
+ array[l++] = c & largest_char;
break;
default: /* backslashes before non-special chars just add the char */
array[l++] = c;
char *ret, *r, *s;
int c;
- r = ret = xmalloc (7 * strlen (seq) + 1);
+ r = ret = (char *)xmalloc (7 * strlen (seq) + 1);
for (s = seq; *s; s++)
{
c = *s;
/* 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;
{
for (i = 0; keyseq && keyseq[i]; i++)
{
- int ic = keyseq[i];
+ unsigned char ic = keyseq[i];
if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii)
{
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;
i = read (file, buffer, file_size);
close (file);
-#if 0
- if (i < file_size)
-#else
if (i < 0)
-#endif
{
free (buffer);
return ((char *)NULL);
}
-#if 0
- buffer[file_size] = '\0';
- if (sizep)
- *sizep = file_size;
-#else
buffer[i] = '\0';
if (sizep)
*sizep = i;
-#endif
return (buffer);
}
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';
static void
_rl_init_file_error (msg)
- char *msg;
+ const char *msg;
{
if (currently_reading_init_file)
fprintf (stderr, "readline: %s: line %d: %s\n", current_readline_init_file,
/* */
/* **************************************************************** */
+typedef int _rl_parser_func_t PARAMS((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
/* Make VAR point to start of variable name. */
while (*var && whitespace (*var)) var++;
- /* Make value point to start of value string. */
+ /* Make VALUE point to start of value string. */
value = var;
while (*value && !whitespace (*value)) value++;
if (*value)
char *seq;
register int j, k, passc;
- seq = xmalloc (1 + strlen (string));
+ seq = (char *)xmalloc (1 + strlen (string));
for (j = 1, k = passc = 0; string[j]; j++)
{
/* Allow backslash to quote characters, but leave them in place.
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. */
if (*funname == '\'' || *funname == '"')
{
- unsigned char useq[2];
+ char useq[2];
int fl = strlen (funname);
useq[0] = key; useq[1] = '\0';
#define V_SPECIAL 0x1
static struct {
- char *name;
+ const char *name;
int *value;
int flags;
} boolean_varlist [] = {
{ "blink-matching-paren", &rl_blink_matching_paren, V_SPECIAL },
+ { "byte-oriented", &rl_byte_oriented, 0 },
{ "completion-ignore-case", &_rl_completion_case_fold, 0 },
{ "convert-meta", &_rl_convert_meta_chars_to_ascii, 0 },
{ "disable-completion", &rl_inhibit_completion, 0 },
{ "enable-keypad", &_rl_enable_keypad, 0 },
{ "expand-tilde", &rl_complete_with_tilde_expansion, 0 },
+ { "history-preserve-point", &_rl_history_preserve_point, 0 },
{ "horizontal-scroll-mode", &_rl_horizontal_scroll_mode, 0 },
{ "input-meta", &_rl_meta_flag, 0 },
{ "mark-directories", &_rl_complete_mark_directories, 0 },
{ "mark-modified-lines", &_rl_mark_modified_lines, 0 },
+ { "mark-symlinked-directories", &_rl_complete_mark_symlink_dirs, 0 },
+ { "match-hidden-files", &_rl_match_hidden_files, 0 },
{ "meta-flag", &_rl_meta_flag, 0 },
{ "output-meta", &_rl_output_meta_chars, 0 },
+ { "page-completions", &_rl_page_completions, 0 },
{ "prefer-visible-bell", &_rl_prefer_visible_bell, V_SPECIAL },
{ "print-completions-horizontally", &_rl_print_completions_horizontally, 0 },
{ "show-all-if-ambiguous", &_rl_complete_show_all, 0 },
static int
find_boolean_var (name)
- char *name;
+ const char *name;
{
register int i;
hack_special_boolean_var (i)
int i;
{
- char *name;
+ const char *name;
name = boolean_varlist[i].name;
}
}
+typedef int _rl_sv_func_t PARAMS((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 PARAMS((const char *));
+static int sv_combegin PARAMS((const char *));
+static int sv_compquery PARAMS((const char *));
+static int sv_editmode PARAMS((const char *));
+static int sv_isrchterm PARAMS((const char *));
+static int sv_keymap PARAMS((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 },
static int
find_string_var (name)
- char *name;
+ const char *name;
{
register int i;
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;
return 1;
}
-#define _SET_BELL(v) do { _rl_bell_preference = v; return 0; } while (0)
-
static int
sv_bell_style (value)
- char *value;
+ const char *value;
{
if (value == 0 || *value == '\0')
- _SET_BELL (AUDIBLE_BELL);
+ _rl_bell_preference = AUDIBLE_BELL;
else if (_rl_stricmp (value, "none") == 0 || _rl_stricmp (value, "off") == 0)
- _SET_BELL (NO_BELL);
+ _rl_bell_preference = NO_BELL;
else if (_rl_stricmp (value, "audible") == 0 || _rl_stricmp (value, "on") == 0)
- _SET_BELL (AUDIBLE_BELL);
+ _rl_bell_preference = AUDIBLE_BELL;
else if (_rl_stricmp (value, "visible") == 0)
- _SET_BELL (VISIBLE_BELL);
+ _rl_bell_preference = VISIBLE_BELL;
else
return 1;
+ return 0;
}
-#undef _SET_BELL
static int
sv_isrchterm (value)
- char *value;
+ const char *value;
{
int beg, end, delim;
char *v;
v[end] = '\0';
/* The value starts at v + beg. Translate it into a character string. */
- _rl_isearch_terminators = (unsigned char *)xmalloc (2 * strlen (v) + 1);
+ _rl_isearch_terminators = (char *)xmalloc (2 * strlen (v) + 1);
rl_translate_keyseq (v + beg, _rl_isearch_terminators, &end);
_rl_isearch_terminators[end] = '\0';
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 ();
pairs for possible inclusion in an inputrc file, we don't want to
do any special meta processing on KEY. */
-#if 0
+#if 1
+ /* XXX - Experimental */
/* We might want to do this, but the old version of the code did not. */
/* If this is an escape character, we don't want to do any more processing.
Just add the special ESC key sequence and return. */
if (c == ESC)
{
- keyseq[0] = '\\';
- keyseq[1] = 'e';
- keyseq[2] = '\0';
- return keyseq;
+ keyname[0] = '\\';
+ keyname[1] = 'e';
+ keyname[2] = '\0';
+ return keyname;
}
#endif
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;
if (result_index + 2 > result_size)
{
result_size += 10;
- result = (char **) xrealloc (result, result_size * sizeof (char *));
+ result = (char **)xrealloc (result, result_size * sizeof (char *));
}
result[result_index++] = keyname;
char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
if (key == ESC)
+#if 0
sprintf (keyname, "\\e");
+#else
+ /* XXX - experimental */
+ sprintf (keyname, "\\M-");
+#endif
else if (CTRL_CHAR (key))
sprintf (keyname, "\\C-%c", _rl_to_lower (UNCTRL (key)));
else if (key == RUBOUT)
if (result_index + 2 > result_size)
{
result_size += 10;
- result = (char **) xrealloc (result, result_size * sizeof (char *));
+ result = (char **)xrealloc (result, result_size * sizeof (char *));
}
result[result_index++] = keyname;
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);
{
case ISMACR:
keyname = _rl_get_keyname (key);
-#if 0
- out = (char *)map[key].function;
-#else
out = _rl_untranslate_macro_value ((char *)map[key].function);
-#endif
+
if (print_readably)
fprintf (rl_outstream, "\"%s%s\": \"%s\"\n", prefix ? prefix : "",
keyname,
keyname,
out ? out : "");
free (keyname);
-#if 1
free (out);
-#endif
break;
case ISFUNC:
break;
prefix_len = prefix ? strlen (prefix) : 0;
if (key == ESC)
{
- keyname = xmalloc (3 + prefix_len);
+ keyname = (char *)xmalloc (3 + prefix_len);
if (prefix)
strcpy (keyname, prefix);
keyname[prefix_len] = '\\';
keyname = _rl_get_keyname (key);
if (prefix)
{
- out = xmalloc (strlen (keyname) + prefix_len + 1);
+ out = (char *)xmalloc (strlen (keyname) + prefix_len + 1);
strcpy (out, prefix);
strcpy (out + prefix_len, keyname);
free (keyname);
int print_readably;
{
int i;
- char *kname;
+ const char *kname;
for (i = 0; boolean_varlist[i].name; i++)
{
if (print_readably)
fprintf (rl_outstream, "set comment-begin %s\n", _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
else
- fprintf (rl_outstream, "comment-begin is set to `%s'\n", _rl_comment_begin ? _rl_comment_begin : "");
+ fprintf (rl_outstream, "comment-begin is set to `%s'\n", _rl_comment_begin ? _rl_comment_begin : RL_COMMENT_BEGIN_DEFAULT);
/* completion-query-items */
if (print_readably)
else
fprintf (rl_outstream, "editing-mode is set to `%s'\n", (rl_editing_mode == emacs_mode) ? "emacs" : "vi");
- /* keymap */
- kname = rl_get_keymap_name (_rl_keymap);
- if (kname == 0)
- kname = rl_get_keymap_name_from_edit_mode ();
- if (print_readably)
- fprintf (rl_outstream, "set keymap %s\n", kname ? kname : "none");
- else
- fprintf (rl_outstream, "keymap is set to `%s'\n", kname ? kname : "none");
-
/* isearch-terminators */
if (_rl_isearch_terminators)
{
free (disp);
}
+
+ /* keymap */
+ kname = rl_get_keymap_name (_rl_keymap);
+ if (kname == 0)
+ kname = rl_get_keymap_name_from_edit_mode ();
+ if (print_readably)
+ fprintf (rl_outstream, "set keymap %s\n", kname ? kname : "none");
+ else
+ fprintf (rl_outstream, "keymap is set to `%s'\n", kname ? kname : "none");
}
/* Print all of the current variables and their values to
return (0);
}
-/* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. */
+/* 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. */
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)
{
func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL);
+#if defined (VI_MODE)
+ if (!func || func == rl_do_lowercase_version || func == rl_vi_movement_mode)
+#else
if (!func || func == rl_do_lowercase_version)
+#endif
rl_set_key (keyseq, default_func, _rl_keymap);
}
}
/* 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 / deliverable / binutils-gdb.git / blobdiff