+2017-09-11 Tom Tromey <tom@tromey.com>
+
+ * common/common-utils.h (skip_to_space): Remove macro, redeclare
+ as function.
+ (skip_to_space): Rename from skip_to_space_const.
+ * common/common-utils.c (skip_to_space): New function.
+ (skip_to_space): Rename from skip_to_space_const.
+ * cli/cli-utils.h (get_number): Rename from get_number_const.
+ (extract_arg): Rename from extract_arg_const.
+ * cli/cli-utils.c (get_number): Rename from get_number_const.
+ (extract_arg): Rename from extract_arg_const.
+ (number_or_range_parser::get_number): Use ::get_number.
+ * aarch64-linux-tdep.c, ada-lang.c, arm-linux-tdep.c, ax-gdb.c,
+ break-catch-throw.c, breakpoint.c, cli/cli-cmds.c, cli/cli-dump.c,
+ cli/cli-script.c, cli/cli-setshow.c, compile/compile.c,
+ completer.c, demangle.c, disasm.c, findcmd.c, linespec.c,
+ linux-tdep.c, linux-thread-db.c, location.c, mi/mi-parse.c,
+ minsyms.c, nat/linux-procfs.c, printcmd.c, probe.c,
+ python/py-breakpoint.c, record.c, rust-exp.y, serial.c, stack.c,
+ stap-probe.c, tid-parse.c, tracepoint.c: Update all callers.
+
2017-09-11 Tom Tromey <tom@tromey.com>
* python/python.c (do_start_initialization): Use
regname, p->saved_arg);
++tmp;
- tmp = skip_spaces_const (tmp);
+ tmp = skip_spaces (tmp);
/* Now we expect a number. It can begin with '#' or simply
a digit. */
if (*tmp == '#')
const char *end;
char *result;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
return NULL; /* No more arguments. */
/* Find the end of the current argument. */
- end = skip_to_space_const (args);
+ end = skip_to_space (args);
/* Adjust ARGSP to point to the start of the next argument. */
/* Check to see if we have a condition. */
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (startswith (args, "if")
&& (isspace (args[2]) || args[2] == '\0'))
{
args += 2;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
error (_("Condition missing after `if' keyword"));
static void
catch_ada_assert_command_split (const char *args, char **cond_string)
{
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
/* Check whether a condition was provided. */
if (startswith (args, "if")
&& (isspace (args[2]) || args[2] == '\0'))
{
args += 2;
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args[0] == '\0')
error (_("condition missing after `if' keyword"));
*cond_string = xstrdup (args);
regname, p->saved_arg);
++tmp;
- tmp = skip_spaces_const (tmp);
+ tmp = skip_spaces (tmp);
if (*tmp == '#' || *tmp == '$')
++tmp;
cmdrest = exp;
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
if (*cmdrest++ != '"')
error (_("Must start with a format string."));
if (*cmdrest++ != '"')
error (_("Bad format string, non-terminated '\"'."));
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
if (*cmdrest != ',' && *cmdrest != 0)
error (_("Invalid argument syntax"));
if (*cmdrest == ',')
cmdrest++;
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
nargs = 0;
while (*cmdrest != '\0')
const char *start;
const char *last, *last_space;
- start = skip_spaces_const (*string);
+ start = skip_spaces (*string);
last = start;
last_space = start;
/* No "if" token here. Skip to the next word start. */
last_space = skip_to_space (last);
- last = skip_spaces_const (last_space);
+ last = skip_spaces (last_space);
}
*string = last;
if (!arg)
arg = "";
- arg = skip_spaces_const (arg);
+ arg = skip_spaces (arg);
std::string except_rx = extract_exception_regexp (&arg);
{
const char *space;
- text = skip_spaces_const (text);
- space = skip_to_space_const (text);
+ text = skip_spaces (text);
+ space = skip_to_space (text);
if (*space == '\0')
{
int len;
}
/* We're completing the expression part. */
- text = skip_spaces_const (space);
+ text = skip_spaces (space);
expression_completer (cmd, tracker, text, word);
}
if (*cmdrest == ',')
++cmdrest;
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
if (*cmdrest++ != '"')
error (_("No format string following the location"));
if (*cmdrest++ != '"')
error (_("Bad format string, non-terminated '\"'."));
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
if (!(*cmdrest == ',' || *cmdrest == '\0'))
error (_("Invalid argument syntax"));
if (*cmdrest == ',')
cmdrest++;
- cmdrest = skip_spaces_const (cmdrest);
+ cmdrest = skip_spaces (cmdrest);
/* For each argument, make an expression. */
if (!arg)
arg = "";
- arg = skip_spaces_const (arg);
+ arg = skip_spaces (arg);
std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
const char *endp;
char *marker_str;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
- endp = skip_to_space_const (p);
+ endp = skip_to_space (p);
marker_str = savestring (p, endp - p);
t->static_trace_marker_id = marker_str;
const char *cond_start = NULL;
const char *cond_end = NULL;
- tok = skip_spaces_const (tok);
+ tok = skip_spaces (tok);
if ((*tok == '"' || *tok == ',') && rest)
{
return;
}
- end_tok = skip_to_space_const (tok);
+ end_tok = skip_to_space (tok);
toklen = end_tok - tok;
char *marker_str;
int i;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
- endp = skip_to_space_const (p);
+ endp = skip_to_space (p);
marker_str = savestring (p, endp - p);
old_chain = make_cleanup (xfree, marker_str);
else if (val != NULL)
release_value (val);
- tok = skip_spaces_const (arg);
- end_tok = skip_to_space_const (tok);
+ tok = skip_spaces (arg);
+ end_tok = skip_to_space (tok);
toklen = end_tok - tok;
if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
/* Skip any extra leading whitespace, and record the start of the
condition string. */
- *arg = skip_spaces_const (*arg);
+ *arg = skip_spaces (*arg);
cond_string = *arg;
/* Assume that the condition occupies the remainder of the arg
if (!arg)
arg = "";
- arg = skip_spaces_const (arg);
+ arg = skip_spaces (arg);
/* The allowed syntax is:
catch [v]fork
if (!arg)
arg = "";
- arg = skip_spaces_const (arg);
+ arg = skip_spaces (arg);
/* The allowed syntax is:
catch exec
}
}
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
}
if ((flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
/* Two arguments. */
int incl_flag = 0;
low = pc;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
if (p[0] == '+')
{
++p;
end = (*cmd) + strcspn (*cmd, " \t");
exp = savestring ((*cmd), end - (*cmd));
- (*cmd) = skip_spaces_const (end);
+ (*cmd) = skip_spaces (end);
return gdb::unique_xmalloc_ptr<char> (exp);
}
}
/* FIXME: should parse a possibly quoted string. */
const char *end;
- (*cmd) = skip_spaces_const (*cmd);
+ (*cmd) = skip_spaces (*cmd);
end = *cmd + strcspn (*cmd, " \t");
filename.reset (savestring ((*cmd), end - (*cmd)));
- (*cmd) = skip_spaces_const (end);
+ (*cmd) = skip_spaces (end);
}
gdb_assert (filename != NULL);
{
binary_flag = 1;
args += strlen (binary_string);
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
}
/* Parse offset (optional). */
if (args != NULL && *args != '\0')
{
const char *first_arg = p + find_command_name_length (p);
- return skip_spaces_const (first_arg);
+ return skip_spaces (first_arg);
}
/* Process one input line. If the command is an "end", return such an
const char *cmd_name = p;
struct cmd_list_element *cmd
= lookup_cmd_1 (&cmd_name, cmdlist, NULL, 1);
- cmd_name = skip_spaces_const (cmd_name);
+ cmd_name = skip_spaces (cmd_name);
bool inline_cmd = *cmd_name != '\0';
/* If commands are parsed, we skip initial spaces. Otherwise,
{
size_t len = sizeof ("unlimited") - 1;
- arg = skip_spaces_const (arg);
+ arg = skip_spaces (arg);
return (strncmp (arg, "unlimited", len) == 0
&& (isspace (arg[len]) || arg[len] == '\0'));
++p;
retval = 0;
}
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
*pp = p;
return retval;
}
/* See documentation in cli-utils.h. */
int
-get_number_const (const char **pp)
+get_number (const char **pp)
{
return get_number_trailer (pp, '\0');
}
and also remember the end of the final token. */
temp = &m_end_ptr;
- m_end_ptr = skip_spaces_const (m_cur_tok + 1);
- m_end_value = get_number_const (temp);
+ m_end_ptr = skip_spaces (m_cur_tok + 1);
+ m_end_value = ::get_number (temp);
if (m_end_value < m_last_retval)
{
error (_("inverted range"));
/* See documentation in cli-utils.h. */
char *
-extract_arg_const (const char **arg)
+extract_arg (const char **arg)
{
const char *result;
return NULL;
/* Find the start of the argument. */
- *arg = skip_spaces_const (*arg);
+ *arg = skip_spaces (*arg);
if (!**arg)
return NULL;
result = *arg;
/* Find the end of the argument. */
- *arg = skip_to_space_const (*arg + 1);
+ *arg = skip_to_space (*arg + 1);
if (result == *arg)
return NULL;
const char *arg_const = *arg;
char *result;
- result = extract_arg_const (&arg_const);
+ result = extract_arg (&arg_const);
*arg += arg_const - *arg;
return result;
}
/* Convenience. Like get_number_trailer, but with no TRAILER. */
-extern int get_number_const (const char **);
+extern int get_number (const char **);
-/* Like get_number_const, but takes a non-const "char **". */
+/* Like the above, but takes a non-const "char **". */
extern int get_number (char **);
extern char *extract_arg (char **arg);
-/* A const-correct version of "extract_arg".
+/* A const-correct version of the above.
Since the returned value is xmalloc'd, it eventually needs to be
xfree'ed, which prevents us from making it const as well. */
-extern char *extract_arg_const (const char **arg);
+extern char *extract_arg (const char **arg);
/* A helper function that looks for an argument at the start of a
string. The argument must also either be at the end of the string,
/* A const-correct version of the above. */
const char *
-skip_spaces_const (const char *chp)
+skip_spaces (const char *chp)
{
if (chp == NULL)
return NULL;
/* See documentation in common-utils.h. */
const char *
-skip_to_space_const (const char *chp)
+skip_to_space (const char *chp)
{
if (chp == NULL)
return NULL;
return chp;
}
+/* See documentation in common-utils.h. */
+
+char *
+skip_to_space (char *chp)
+{
+ return (char *) skip_to_space ((const char *) chp);
+}
+
/* See common/common-utils.h. */
void
/* A const-correct version of the above. */
-extern const char *skip_spaces_const (const char *inp);
+extern const char *skip_spaces (const char *inp);
/* Skip leading non-whitespace characters in INP, returning an updated
pointer. If INP is NULL, return NULL. */
-#define skip_to_space(INP) ((char *) skip_to_space_const (INP))
+extern char *skip_to_space (char *inp);
/* A const-correct version of the above. */
-extern const char *skip_to_space_const (const char *inp);
+extern const char *skip_to_space (const char *inp);
/* Assumes that V is an argv for a program, and iterates through
freeing all the elements. */
cs = symtab->producer;
while (*cs != 0 && *cs != '-')
- cs = skip_spaces_const (skip_to_space_const (cs));
+ cs = skip_spaces (skip_to_space (cs));
if (*cs != '-')
return NULL;
return cs;
keyword. */
if (keyword != word)
{
- keyword = skip_spaces_const (keyword);
+ keyword = skip_spaces (keyword);
tracker.advance_custom_word_point_by (keyword - word);
complete_on_enum (tracker, linespec_keywords, keyword, keyword);
const char * const *keywords, const char **text_p)
{
const char *text = *text_p;
- const char *after = skip_to_space_const (text);
+ const char *after = skip_to_space (text);
size_t len = after - text;
if (text[len] != ' ')
{
while (p_orig < orig_end && *p_orig == ' ')
res += *p_orig++;
- p_lcd = skip_spaces_const (p_lcd);
+ p_lcd = skip_spaces (p_lcd);
}
else
{
while (processing_args
&& *arg_start == '-')
{
- const char *p = skip_to_space_const (arg_start);
+ const char *p = skip_to_space (arg_start);
if (strncmp (arg_start, "-l", p - arg_start) == 0)
- lang_name.reset (extract_arg_const (&p));
+ lang_name.reset (extract_arg (&p));
else if (strncmp (arg_start, "--", p - arg_start) == 0)
processing_args = 0;
else
{
- gdb::unique_xmalloc_ptr<char> option (extract_arg_const (&p));
+ gdb::unique_xmalloc_ptr<char> option (extract_arg (&p));
error (_("Unrecognized option '%s' to demangle command. "
"Try \"help demangle\"."), option.get ());
}
- arg_start = skip_spaces_const (p);
+ arg_start = skip_spaces (p);
}
name = arg_start;
const char *separator = strrchr (text, ',');
if (separator != NULL)
text = separator + 1;
- text = skip_spaces_const (text);
+ text = skip_spaces (text);
complete_on_enum (tracker, opts->name, text, word);
}
}
}
}
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
}
/* Get the search range. */
if (*s == ',')
++s;
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
if (*s == '+')
{
struct type *t;
ULONGEST pattern_buf_size_need;
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
v = parse_to_comma_and_eval (&s);
t = value_type (v);
if (*s == ',')
++s;
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
}
if (pattern_buf_end == pattern_buf)
if (i != IF_KEYWORD_INDEX)
{
p += len;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
for (j = 0; linespec_keywords[j] != NULL; ++j)
{
int nextlen = strlen (linespec_keywords[j]);
{
if (isspace (*PARSER_STREAM (parser)))
{
- p = skip_spaces_const (PARSER_STREAM (parser));
+ p = skip_spaces (PARSER_STREAM (parser));
/* When we get here we know we've found something followed by
a space (we skip over parens and templates below).
So if we find a keyword now, we know it is a keyword and not,
if (parser->lexer.current.type == LSTOKEN_CONSUMED)
{
/* Skip any whitespace. */
- PARSER_STREAM (parser) = skip_spaces_const (PARSER_STREAM (parser));
+ PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser));
/* Check for a keyword, they end the linespec. */
keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
{
if (*PARSER_STREAM (parser) == ' ')
{
- parser->completion_word = skip_spaces_const (PARSER_STREAM (parser) + 1);
+ parser->completion_word = skip_spaces (PARSER_STREAM (parser) + 1);
parser->complete_what = next;
}
else
if (ptr[i] == ' ')
{
LS_TOKEN_STOKEN (token).length = i;
- PARSER_STREAM (parser) = skip_spaces_const (ptr + i + 1);
+ PARSER_STREAM (parser) = skip_spaces (ptr + i + 1);
break;
}
}
advances past a keyword automatically, so skip it
manually. */
parser->completion_word
- = skip_spaces_const (skip_to_space_const (PARSER_STREAM (parser)));
+ = skip_spaces (skip_to_space (PARSER_STREAM (parser)));
parser->complete_what = linespec_complete_what::EXPRESSION;
}
p++;
*endaddr = strtoulst (p, &p, 16);
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
*permissions = p;
while (*p && !isspace (*p))
p++;
*offset = strtoulst (p, &p, 16);
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
*device = p;
while (*p && !isspace (*p))
p++;
*inode = strtoulst (p, &p, 10);
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
*filename = p;
}
pid = current_inferior ()->pid;
}
- args = skip_spaces_const (args);
+ args = skip_spaces (args);
if (args && args[0])
error (_("Too many parameters: %s"), args);
printf_filtered (_("Process: %s\n"),
pulongest (strtoulst (p, &p, 10)));
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
if (*p == '(')
{
/* ps command also relies on no trailing fields
}
}
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
if (*p)
printf_filtered (_("State: %c\n"), *p++);
char *pids;
int i;
- cs = skip_spaces_const (cs);
+ cs = skip_spaces (cs);
if (*cs)
error (_("'info auto-load libthread-db' does not accept any parameters"));
len = strlen (opt.get ());
/* Get the argument string. */
- *argp = skip_spaces_const (*argp);
+ *argp = skip_spaces (*argp);
/* All options have a required argument. Checking for this
required argument is deferred until later. */
else if (strncmp (opt.get (), "-line", len) == 0)
{
set_oarg (explicit_location_lex_one (argp, language, NULL));
- *argp = skip_spaces_const (*argp);
+ *argp = skip_spaces (*argp);
if (have_oarg)
{
EL_EXPLICIT (location)->line_offset
return location;
}
- *argp = skip_spaces_const (*argp);
+ *argp = skip_spaces (*argp);
/* It's a little lame to error after the fact, but in this
case, it provides a much better user experience to issue
char *arg;
/* Skip leading white space. */
- chp = skip_spaces_const (chp);
+ chp = skip_spaces (chp);
/* Three possibilities: EOF, quoted string, or other text. */
switch (*chp)
{
std::unique_ptr<struct mi_parse> parse (new struct mi_parse);
/* Before starting, skip leading white space. */
- cmd = skip_spaces_const (cmd);
+ cmd = skip_spaces (cmd);
/* Find/skip any token and then extract it. */
for (chp = cmd; *chp >= '0' && *chp <= '9'; chp++)
/* This wasn't a real MI command. Return it as a CLI_COMMAND. */
if (*chp != '-')
{
- chp = skip_spaces_const (chp);
+ chp = skip_spaces (chp);
parse->command = xstrdup (chp);
parse->op = CLI_COMMAND;
_("Undefined MI command: %s"), parse->command);
/* Skip white space following the command. */
- chp = skip_spaces_const (chp);
+ chp = skip_spaces (chp);
/* Parse the --thread and --frame options, if present. At present,
some important commands, like '-break-*' are implemented by
option = "--language";
chp += ls;
- lang_name = extract_arg_const (&chp);
+ lang_name = extract_arg (&chp);
old_chain = make_cleanup (xfree, lang_name);
parse->language = language_enum (lang_name);
if (*chp != '\0' && !isspace (*chp))
error (_("Invalid value for the '%s' option"), option);
- chp = skip_spaces_const (chp);
+ chp = skip_spaces (chp);
}
/* For new argv commands, attempt to return the parsed argument
while (*string && *string != '(')
{
- string = skip_spaces_const (string);
+ string = skip_spaces (string);
if (*string && *string != '(')
{
hash = SYMBOL_HASH_NEXT (hash, *string);
static enum proc_state
parse_proc_status_state (const char *state)
{
- state = skip_spaces_const (state);
+ state = skip_spaces (state);
switch (state[0])
{
if (s == 0)
error_no_arg (_("format-control string and values to print"));
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
/* A format string should follow, enveloped in double quotes. */
if (*s++ != '"')
if (*s++ != '"')
error (_("Bad format string, non-terminated '\"'."));
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
if (*s != ',' && *s != 0)
error (_("Invalid argument syntax"));
if (*s == ',')
s++;
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
{
int nargs = 0;
{
*probe_name = *objname = NULL;
- *provider = extract_arg_const (&str);
+ *provider = extract_arg (&str);
if (*provider != NULL)
{
- *probe_name = extract_arg_const (&str);
+ *probe_name = extract_arg (&str);
if (*probe_name != NULL)
- *objname = extract_arg_const (&str);
+ *objname = extract_arg (&str);
}
}
TRY
{
gdb::unique_xmalloc_ptr<char>
- copy_holder (xstrdup (skip_spaces_const (spec)));
+ copy_holder (xstrdup (skip_spaces (spec)));
char *copy = copy_holder.get ();
switch (type)
const char *begin, *end, *pos;
begin = *arg;
- pos = skip_spaces_const (begin);
+ pos = skip_spaces (begin);
if (!isdigit (*pos))
error (_("Expected positive number, got: %s."), pos);
gdb_assert (subexps[0].rm_eo > 0);
if (lexptr[subexps[0].rm_eo - 1] == '.')
{
- const char *next = skip_spaces_const (&lexptr[subexps[0].rm_eo]);
+ const char *next = skip_spaces (&lexptr[subexps[0].rm_eo]);
if (rust_identifier_start_p (*next) || *next == '.')
{
ops = serial_interface_lookup ("pipe");
/* Discard ``|'' and any space before the command itself. */
++open_name;
- open_name = skip_spaces_const (open_name);
+ open_name = skip_spaces (open_name);
}
/* Check for a colon, suggesting an IP address/port pair.
Do this *after* checking for all the interesting prefixes. We
const char *p;
/* Skip leading white space, bail of EOL. */
- frame_exp = skip_spaces_const (frame_exp);
+ frame_exp = skip_spaces (frame_exp);
if (!*frame_exp)
break;
We handle the register displacement here, and the other cases
recursively. */
if (p->inside_paren_p)
- tmp = skip_spaces_const (tmp);
+ tmp = skip_spaces (tmp);
while (isdigit (*tmp))
{
tmp = endp;
if (p->inside_paren_p)
- tmp = skip_spaces_const (tmp);
+ tmp = skip_spaces (tmp);
/* If "stap_is_integer_prefix" returns true, it means we can
accept integers without a prefix here. But we also need to
have to parse it as it was a separate expression, without
left-side or precedence. */
++p->arg;
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
++p->inside_paren_p;
stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
++p->arg;
if (p->inside_paren_p)
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
}
else
error (_("Cannot parse expression `%s'."), p->saved_arg);
gdb_assert (p->arg != NULL);
if (p->inside_paren_p)
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
if (!has_lhs)
{
p->arg = tmp_exp_buf;
if (p->inside_paren_p)
- p->arg = skip_spaces_const (p->arg);
+ p->arg = skip_spaces (p->arg);
/* Parse the right-side of the expression. */
stap_parse_argument_conditionally (p);
reallocate_expout (&p.pstate);
- p.arg = skip_spaces_const (p.arg);
+ p.arg = skip_spaces (p.arg);
*arg = p.arg;
/* We can safely return EXPOUT here. */
arg.aexpr = expr;
/* Start it over again. */
- cur = skip_spaces_const (cur);
+ cur = skip_spaces (cur);
VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
}
{
/* Setup the number range parser to return numbers in the
whole [1,INT_MAX] range. */
- m_range_parser.setup_range (1, INT_MAX, skip_spaces_const (p + 1));
+ m_range_parser.setup_range (1, INT_MAX, skip_spaces (p + 1));
m_state = STATE_STAR_RANGE;
}
else
else
error (_("Undefined collection format \"%c\"."), *exp);
- exp = skip_spaces_const (exp);
+ exp = skip_spaces (exp);
return exp;
}
if (line == NULL)
return;
- p = skip_spaces_const (line);
+ p = skip_spaces (line);
/* Symbol lookup etc. */
if (*p == '\0') /* empty line: just prompt for another line. */
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
if (*p == '$') /* Look for special pseudo-symbols. */
{
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
tmp_p = p;
for (loc = t->loc; loc; loc = loc->next)
{
char *endp;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
t->step_count = strtol (p, &endp, 0);
if (endp == p || t->step_count == 0)
error (_("while-stepping step count `%s' is malformed."), line);
{
QUIT; /* Allow user to bail out with ^C. */
action_exp = action->line;
- action_exp = skip_spaces_const (action_exp);
+ action_exp = skip_spaces (action_exp);
cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
if (cmd == 0)
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
- action_exp = skip_spaces_const (action_exp);
+ action_exp = skip_spaces (action_exp);
if (0 == strncasecmp ("$reg", action_exp, 4))
{
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
- action_exp = skip_spaces_const (action_exp);
+ action_exp = skip_spaces (action_exp);
{
struct cleanup *old_chain1 = NULL;
QUIT; /* Allow user to bail out with ^C. */
action_exp = action->line;
- action_exp = skip_spaces_const (action_exp);
+ action_exp = skip_spaces (action_exp);
/* The collection actions to be done while stepping are
bracketed by the commands "while-stepping" and "end". */
QUIT; /* Allow user to bail out with ^C. */
if (*action_exp == ',')
action_exp++;
- action_exp = skip_spaces_const (action_exp);
+ action_exp = skip_spaces (action_exp);
next_comma = strchr (action_exp, ',');
projects / binutils-gdb.git / commitdiff