Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
- 2009, 2010 Free Software Foundation, Inc.
+ 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "mi/mi-cmds.h"
#include "target.h"
#include "arch-utils.h"
+#include <ctype.h>
+#include "cli/cli-utils.h"
-/* We share this one with symtab.c, but it is not exported widely. */
+/* We share this one with symtab.c, but it is not exported widely. */
extern char *operator_chars (char *, char **);
-/* Prototypes for local functions */
+/* Prototypes for local functions. */
static void initialize_defaults (struct symtab **default_symtab,
int *default_line);
char ***canonical,
struct symtab *file_symtab);
+static int decode_label (char *copy, char ***canonical,
+ struct symtabs_and_lines *result);
+
static struct symtabs_and_lines decode_variable (char *copy,
int funfirstline,
char ***canonical,
symtabs_and_lines minsym_found (int funfirstline,
struct minimal_symbol *msymbol);
-/* Helper functions. */
+/* Helper functions. */
/* Issue a helpful hint on using the command completion feature on
single quoted demangled C++ symbols as part of the completion
}
/* Return the number of methods described for TYPE, including the
- methods from types it derives from. This can't be done in the symbol
+ methods from types it derives from. This can't be done in the symbol
reader because the type of the baseclass might still be stubbed
when the definition of the derived class is parsed. */
int i1 = 0;
int ibase;
char *class_name = type_name_no_tag (t);
+ struct cleanup *cleanup;
+ char *canon;
+
+ /* NAME is typed by the user: it needs to be canonicalized before
+ passing to lookup_symbol. */
+ canon = cp_canonicalize_string (name);
+ if (canon != NULL)
+ {
+ name = canon;
+ cleanup = make_cleanup (xfree, name);
+ }
+ else
+ cleanup = make_cleanup (null_cleanup, NULL);
/* Ignore this class if it doesn't have a name. This is ugly, but
unless we figure out how to get the physname without the name of
i1 += find_methods (TYPE_BASECLASS (t, ibase), name,
language, sym_arr + i1);
+ do_cleanups (cleanup);
return i1;
}
else
{
/* This error message gets printed, but the method
- still seems to be found
+ still seems to be found.
fputs_filtered("(Cannot find method ", gdb_stdout);
fprintf_symbol_filtered (gdb_stdout, phys_name,
- language_cplus,
- DMGL_PARAMS | DMGL_ANSI);
+ language_cplus,
+ DMGL_PARAMS | DMGL_ANSI);
fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
*/
}
}
/* Determines if the gives string corresponds to an Objective-C method
- representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
+ representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
are allowed to have spaces and parentheses in them. */
static int
const char *select_mode = multiple_symbols_select_mode ();
if (select_mode == multiple_symbols_cancel)
- error (_("\
-canceled because the command is ambiguous\n\
-See set/show multiple-symbol."));
+ error (_("canceled because the command is ambiguous\n"
+ "See set/show multiple-symbol."));
values.sals = (struct symtab_and_line *)
alloca (nelts * sizeof (struct symtab_and_line));
values.sals[i].symtab->filename,
values.sals[i].line);
else
- printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? Probably broken debug info...]\n"),
+ printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? "
+ "Probably broken debug info...]\n"),
(i + 2),
SYMBOL_PRINT_NAME (sym_arr[i]),
values.sals[i].line);
}
else
{
- printf_unfiltered (_("duplicate request for %d ignored.\n"), num);
+ printf_unfiltered (_("duplicate request for %d ignored.\n"),
+ num);
}
}
return p;
}
+
+/* Does P point to a sequence of characters which implies the end
+ of a name? Terminals include "if" and "thread" clauses. */
+
+static int
+name_end (char *p)
+{
+ while (isspace (*p))
+ ++p;
+ if (*p == 'i' && p[1] == 'f'
+ && (isspace (p[2]) || p[2] == '\0' || p[2] == '('))
+ return 1;
+
+ if (strncmp (p, "thread", 6) == 0
+ && (isspace (p[6]) || p[6] == '\0'))
+ return 1;
+
+ return 0;
+}
+
+/* Keep important information used when looking up a name. This includes
+ template parameters, overload information, and important keywords. */
+
+static char *
+keep_name_info (char *ptr)
+{
+ char *p = ptr;
+ char *start = ptr;
+
+ /* Keep any template parameters. */
+ if (name_end (ptr))
+ return remove_trailing_whitespace (start, ptr);
+
+ while (isspace (*p))
+ ++p;
+ if (*p == '<')
+ ptr = p = find_template_name_end (ptr);
+
+ if (name_end (ptr))
+ return remove_trailing_whitespace (start, ptr);
+
+ /* Keep method overload information. */
+ if (*p == '(')
+ ptr = p = find_method_overload_end (p);
+
+ if (name_end (ptr))
+ return remove_trailing_whitespace (start, ptr);
+
+ /* Keep important keywords. */
+ while (isspace (*p))
+ ++p;
+ if (strncmp (p, "const", 5) == 0
+ && (isspace (p[5]) || p[5] == '\0'
+ || strchr (get_gdb_completer_quote_characters (), p[5]) != NULL))
+ ptr = p = p + 5;
+
+ return remove_trailing_whitespace (start, ptr);
+}
+
\f
-/* The parser of linespec itself. */
+/* The parser of linespec itself. */
/* Parse a string that specifies a line number.
Pass the address of a char * variable; that variable will be
FILE:LINENUM -- that line in that file. PC returned is 0.
FUNCTION -- line number of openbrace of that function.
PC returned is the start of the function.
+ LABEL -- a label in the current scope
VARIABLE -- line number of definition of that variable.
PC returned is 0.
FILE:FUNCTION -- likewise, but prefer functions in that file.
DEFAULT_LINE specifies the line number to use for relative
line numbers (that start with signs). Defaults to current_source_line.
If CANONICAL is non-NULL, store an array of strings containing the canonical
- line specs there if necessary. Currently overloaded member functions and
+ line specs there if necessary. Currently overloaded member functions and
line numbers or static functions without a filename yield a canonical
- line spec. The array and the line spec strings are allocated on the heap,
+ line spec. The array and the line spec strings are allocated on the heap,
it is the callers responsibility to free them.
Note that it is possible to return zero for the symtab
if no file is validly specified. Callers must check that.
Also, the line number returned may be invalid.
- If NOT_FOUND_PTR is not null, store a boolean true/false value at the location, based
- on whether or not failure occurs due to an unknown function or file. In the case
- where failure does occur due to an unknown function or file, do not issue an error
- message. */
+ If NOT_FOUND_PTR is not null, store a boolean true/false value at
+ the location, based on whether or not failure occurs due to an
+ unknown function or file. In the case where failure does occur due
+ to an unknown function or file, do not issue an error message. */
/* We allow single quotes in various places. This is a hideous
kludge, which exists because the completer can't yet deal with the
if (**argptr == '*')
return decode_indirect (argptr);
- is_quoted = (*argptr
- && strchr (get_gdb_completer_quote_characters (),
- **argptr) != NULL);
+ is_quoted = (strchr (get_gdb_completer_quote_characters (),
+ **argptr) != NULL);
+
if (is_quoted)
end_quote = skip_quoted (*argptr);
/* Locate the end of the first half of the linespec.
After the call, for instance, if the argptr string is "foo.c:123"
p will point at "123". If there is only one part, like "foo", p
- will point to "". If this is a C++ name, like "A::B::foo", p will
- point to "::B::foo". Argptr is not changed by this call. */
+ will point to "". If this is a C++ name, like "A::B::foo", p will
+ point to "::B::foo". Argptr is not changed by this call. */
first_half = p = locate_first_half (argptr, &is_quote_enclosed);
{
/* Is it a C++ or Java compound data structure?
The check on p[1] == ':' is capturing the case of "::",
- since p[0]==':' was checked above.
+ since p[0]==':' was checked above.
Note that the call to decode_compound does everything
for us, including the lookup on the symbol table, so we
- can return now. */
+ can return now. */
if (p[0] == '.' || p[1] == ':')
{
}
else if (is_objc_method)
{
- /* allow word separators in method names for Obj-C */
+ /* allow word separators in method names for Obj-C. */
p = skip_quoted_chars (*argptr, NULL, "");
}
else
p = skip_quoted (*argptr);
}
- /* Keep any template parameters */
- if (*p == '<')
- p = find_template_name_end (p);
-
- /* Keep method overload information. */
- if (*p == '(')
- p = find_method_overload_end (p);
-
- /* Make sure we keep important kewords like "const" */
- if (strncmp (p, " const", 6) == 0)
- p += 6;
+ /* Keep any important naming information. */
+ p = keep_name_info (p);
copy = (char *) alloca (p - *argptr + 1);
memcpy (copy, *argptr, p - *argptr);
return decode_dollar (copy, funfirstline, default_symtab,
canonical, file_symtab);
+ /* Try the token as a label, but only if no file was specified,
+ because we can only really find labels in the current scope. */
+
+ if (!file_symtab)
+ {
+ struct symtabs_and_lines label_result;
+ if (decode_label (copy, canonical, &label_result))
+ return label_result;
+ }
+
/* Look up that token as a variable.
If file specified, use that file's per-file block to start with. */
{
/* Use whatever we have for the default source line. We don't use
get_current_or_default_symtab_and_line as it can recurse and call
- us back! */
+ us back! */
struct symtab_and_line cursal =
get_current_source_symtab_and_line ();
CORE_ADDR pc;
(*argptr)++;
- pc = parse_and_eval_address_1 (argptr);
+ pc = value_as_address (parse_to_comma_and_eval (argptr));
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
has_comma = (ii != 0);
/* Temporarily zap out second half to not confuse the code below.
- This is undone below. Do not change ii!! */
+ This is undone below. Do not change ii!! */
if (has_comma)
{
*ii = '\0';
error (_("malformed template specification in command"));
p = temp_end;
}
+
+ if (p[0] == '(')
+ p = find_method_overload_end (p);
+
/* Check for a colon and a plus or minus and a [ (which
- indicates an Objective-C method) */
+ indicates an Objective-C method). */
if (is_objc_method_format (p))
{
break;
struct symtabs_and_lines values;
struct symbol **sym_arr = NULL;
struct symbol *sym = NULL;
- char *copy = NULL;
struct block *block = NULL;
unsigned i1 = 0;
unsigned i2 = 0;
set_language (save_language);
}
- copy = find_imps (file_symtab, block, *argptr, NULL, &i1, &i2);
+ find_imps (file_symtab, block, *argptr, NULL, &i1, &i2);
if (i1 > 0)
{
- sym_arr = (struct symbol **) alloca ((i1 + 1) * sizeof (struct symbol *));
+ sym_arr = (struct symbol **)
+ alloca ((i1 + 1) * sizeof (struct symbol *));
sym_arr[i1] = NULL;
- copy = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
- *argptr = copy;
+ *argptr = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
}
/* i1 now represents the TOTAL number of matches found.
else
{
sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
- if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]), SYMBOL_LINKAGE_NAME (sym)) != 0)
+ if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]),
+ SYMBOL_LINKAGE_NAME (sym)) != 0)
{
- warning (_("debugging symbol \"%s\" does not match selector; ignoring"), SYMBOL_LINKAGE_NAME (sym));
+ warning (_("debugging symbol \"%s\" does "
+ "not match selector; ignoring"),
+ SYMBOL_LINKAGE_NAME (sym));
sym = NULL;
}
}
- values.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
+ values.sals = (struct symtab_and_line *)
+ xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
{
/* Canonicalize this, so it remains resolved for dylib loads. */
values.sals[0] = find_function_start_sal (sym, funfirstline);
- build_canonical_line_spec (values.sals, SYMBOL_NATURAL_NAME (sym), canonical);
+ build_canonical_line_spec (values.sals,
+ SYMBOL_NATURAL_NAME (sym), canonical);
}
else
{
if (i1 > 1)
{
- /* More than one match. The user must choose one or more. */
+ /* More than one match. The user must choose one or more. */
return decode_line_2 (sym_arr, i2, funfirstline, canonical);
}
static struct symtabs_and_lines
decode_compound (char **argptr, int funfirstline, char ***canonical,
- char *saved_arg, char *p, int *not_found_ptr)
+ char *the_real_saved_arg, char *p, int *not_found_ptr)
{
struct symtabs_and_lines values;
char *p2;
struct symbol *sym_class;
struct type *t;
char *saved_java_argptr = NULL;
+ char *saved_arg;
+
+ /* If the user specified any completer quote characters in the input,
+ strip them. They are superfluous. */
+ saved_arg = alloca (strlen (the_real_saved_arg) + 1);
+ {
+ char *dst = saved_arg;
+ char *src = the_real_saved_arg;
+ char *quotes = get_gdb_completer_quote_characters ();
+ while (*src != '\0')
+ {
+ if (strchr (quotes, *src) == NULL)
+ *dst++ = *src;
+ ++src;
+ }
+ *dst = '\0';
+ }
/* First check for "global" namespace specification, of the form
"::foo". If found, skip over the colons and jump to normal
symbol processing. I.e. the whole line specification starts with
- "::" (note the condition that *argptr == p). */
+ "::" (note the condition that *argptr == p). */
if (p[0] == ':'
&& ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
saved_arg2 += 2;
find_method.
2) AAA::inA isn't the name of a class. In that case, either the
- user made a typo or AAA::inA is the name of a namespace.
- Either way, we just look up AAA::inA::fun with lookup_symbol.
+ user made a typo, AAA::inA is the name of a namespace, or it is
+ the name of a minimal symbol.
+ We just look up AAA::inA::fun with lookup_symbol. If that fails,
+ try lookup_minimal_symbol.
Thus, our first task is to find everything before the last set of
double-colons and figure out if it's the name of a class. So we
p2 = p; /* Save for restart. */
- /* This is very messy. Following the example above we have now the
+ /* This is very messy. Following the example above we have now the
following pointers:
p -> "::inA::fun"
argptr -> "AAA::inA::fun
saved_arg -> "AAA::inA::fun
saved_arg2 -> "AAA::inA::fun
- p2 -> "::inA::fun". */
+ p2 -> "::inA::fun". */
/* In the loop below, with these strings, we'll make 2 passes, each
- is marked in comments.*/
+ is marked in comments. */
while (1)
{
+ static char *break_characters = " \t(";
+
/* Move pointer up to next possible class/namespace token. */
p = p2 + 1; /* Restart with old value +1. */
/* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
i.e. if there is a double-colon, p will now point to the
- second colon. */
+ second colon. */
/* PASS2: p2->"::fun", p->":fun" */
/* Move pointer ahead to next double-colon. */
- while (*p && (p[0] != ' ') && (p[0] != '\t') && (p[0] != '\'')
- && (*p != '('))
+ while (*p
+ && strchr (break_characters, *p) == NULL
+ && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
{
if (current_language->la_language == language_cplus)
p += cp_validate_operator (p);
/* Note that, since, at the start of this loop, p would be
pointing to the second colon in a double-colon, we only
satisfy the condition below if there is another
- double-colon to the right (after). I.e. there is another
- component that can be a class or a namespace. I.e, if at
+ double-colon to the right (after). I.e. there is another
+ component that can be a class or a namespace. I.e, if at
the beginning of this loop (PASS1), we had
p->":inA::fun", we'll trigger this when p has been
advanced to point to "::fun". */
- /* PASS2: we will not trigger this. */
+ /* PASS2: we will not trigger this. */
else if ((p[0] == ':') && (p[1] == ':'))
break; /* Found double-colon. */
else
- /* PASS2: We'll keep getting here, until p->"", at which point
- we exit this loop. */
- p++;
+ {
+ /* PASS2: We'll keep getting here, until P points to one of the
+ break characters, at which point we exit this loop. */
+ if (*p && strchr (break_characters, *p) == NULL)
+ p++;
+ }
}
if (*p != ':')
break; /* Out of the while (1). This would happen
for instance if we have looked up
unsuccessfully all the components of the
- string, and p->""(PASS2) */
+ string, and p->""(PASS2). */
- /* We get here if p points to ' ', '\t', '\'', "::" or ""(i.e
- string ended). */
+ /* We get here if p points to one of the break characters or "" (i.e.,
+ string ended). */
/* Save restart for next time around. */
p2 = p;
/* Restore argptr as it was on entry to this function. */
} /* while (1) */
- /* Start of lookup in the symbol tables. */
+ /* Start of lookup in the symbol tables. */
/* Lookup in the symbol table the substring between argptr and
- p. Note, this call changes the value of argptr. */
+ p. Note, this call changes the value of argptr. */
/* Before the call, argptr->"AAA::inA::fun",
p->"", p2->"::fun". After the call: argptr->"fun", p, p2
unchanged. */
p += cp_validate_operator (p - 8) - 8;
}
- /* Keep any template parameters */
- if (*p == '<')
- p = find_template_name_end (p);
-
- /* Keep method overload information. */
- a = strchr (p, '(');
- if (a != NULL)
- p = find_method_overload_end (a);
-
- /* Make sure we keep important kewords like "const" */
- if (strncmp (p, " const", 6) == 0)
- p += 6;
+ /* Keep any important naming information. */
+ p = keep_name_info (p);
/* Java may append typenames, so assume that if there is
anything else left in *argptr, it must be a typename. */
}
/* Allocate our own copy of the substring between argptr and
- p. */
+ p. */
copy = (char *) alloca (p - *argptr + 1);
memcpy (copy, *argptr, p - *argptr);
copy[p - *argptr] = '\0';
copy[p - *argptr - 1]) != NULL)
copy[p - *argptr - 1] = '\0';
- /* At this point copy->"fun", p->"" */
+ /* At this point copy->"fun", p->"". */
/* No line number may be specified. */
while (*p == ' ' || *p == '\t')
*argptr = p;
/* At this point arptr->"". */
- /* Look for copy as a method of sym_class. */
+ /* Look for copy as a method of sym_class. */
/* At this point copy->"fun", sym_class is "AAA:inA",
saved_arg->"AAA::inA::fun". This concludes the scanning of
the string for possible components matches. If we find it
- here, we return. If not, and we are at the and of the string,
+ here, we return. If not, and we are at the and of the string,
we'll lookup the whole string in the symbol tables. */
values = find_method (funfirstline, canonical, saved_arg,
if (strcmp_iw (SYMBOL_LINKAGE_NAME (sym), saved_arg) != 0)
{
xfree (values.sals);
- error (_("the class `%s' does not have any method instance named %s\n"),
+ error (_("the class `%s' does not have "
+ "any method instance named %s"),
SYMBOL_PRINT_NAME (sym_class), copy);
}
}
return values;
- } /* End if symbol found */
+ } /* End if symbol found. */
/* We couldn't find a class, so we're in case 2 above. We check the
entire name as a symbol instead. */
+ if (current_language->la_language == language_cplus
+ || current_language->la_language == language_java)
+ p = keep_name_info (p);
+
copy = (char *) alloca (p - saved_arg2 + 1);
memcpy (copy, saved_arg2, p - saved_arg2);
/* Note: if is_quoted should be true, we snuff out quote here
/* Set argptr to skip over the name. */
*argptr = (*p == '\'') ? p + 1 : p;
- /* Look up entire name */
- sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
+ /* Look up entire name. */
+ sym = lookup_symbol (copy, get_selected_block (0), VAR_DOMAIN, 0);
if (sym)
return symbol_found (funfirstline, canonical, copy, sym, NULL);
+ else
+ {
+ struct minimal_symbol *msym;
+
+ /* Couldn't find any interpretation as classes/namespaces. As a last
+ resort, try the minimal symbol tables. */
+ msym = lookup_minimal_symbol (copy, NULL, NULL);
+ if (msym != NULL)
+ return minsym_found (funfirstline, msym);
+ }
- /* Couldn't find any interpretation as classes/namespaces, so give
- up. The quotes are important if copy is empty. */
+ /* Couldn't find a minimal symbol, either, so give up. */
if (not_found_ptr)
*not_found_ptr = 1;
- cplusplus_error (saved_arg,
- "Can't find member of namespace, class, struct, or union named \"%s\"\n",
+ cplusplus_error (the_real_saved_arg,
+ "Can't find member of namespace, "
+ "class, struct, or union named \"%s\"\n",
copy);
}
*argptr = p;
/* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
- argptr->"inA::fun" */
+ argptr->"inA::fun". */
- sym = lookup_symbol (copy, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (copy, get_selected_block (0), STRUCT_DOMAIN, 0);
if (sym == NULL)
{
/* Typedefs are in VAR_DOMAIN so the above symbol lookup will
static struct symtabs_and_lines
find_method (int funfirstline, char ***canonical, char *saved_arg,
- char *copy, struct type *t, struct symbol *sym_class, int *not_found_ptr)
+ char *copy, struct type *t, struct symbol *sym_class,
+ int *not_found_ptr)
{
struct symtabs_and_lines values;
struct symbol *sym = NULL;
/* If we were given a specific overload instance, use that
(or error if no matches were found). Otherwise ask the user
which one to use. */
- if (strchr (saved_arg, '(') != NULL)
+ if (strchr (copy, '('))
{
int i;
+ char *name;
+ char *canon;
+ struct cleanup *cleanup;
+
+ /* Construct the proper search name based on SYM_CLASS and COPY.
+ SAVED_ARG may contain a valid name, but that name might not be
+ what is actually stored in the symbol table. For example,
+ if SAVED_ARG (and SYM_CLASS) were found via an import
+ ("using namespace" in C++), then the physname of
+ SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG
+ ("myclass"). */
+ name = xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class))
+ + 2 /* "::" */ + strlen (copy) + 1);
+ strcpy (name, SYMBOL_NATURAL_NAME (sym_class));
+ strcat (name, "::");
+ strcat (name, copy);
+ canon = cp_canonicalize_string (name);
+ if (canon != NULL)
+ {
+ xfree (name);
+ name = canon;
+ }
+ cleanup = make_cleanup (xfree, name);
for (i = 0; i < i1; ++i)
{
- char *name = saved_arg;
- char *canon = cp_canonicalize_string (name);
-
- if (canon != NULL)
- name = canon;
-
if (strcmp_iw (name, SYMBOL_LINKAGE_NAME (sym_arr[i])) == 0)
{
values.sals = (struct symtab_and_line *)
values.nelts = 1;
values.sals[0] = find_function_start_sal (sym_arr[i],
funfirstline);
- if (canon)
- xfree (canon);
+ do_cleanups (cleanup);
return values;
}
-
- if (canon)
- xfree (canon);
}
- error (_("the class `%s' does not have any method instance named %s\n"),
+ error (_("the class `%s' does not have "
+ "any method instance named %s"),
SYMBOL_PRINT_NAME (sym_class), copy);
}
*not_found_ptr = 1;
if (!have_full_symbols () && !have_partial_symbols ())
throw_error (NOT_FOUND_ERROR,
- _("No symbol table is loaded. Use the \"file\" command."));
+ _("No symbol table is loaded. "
+ "Use the \"file\" command."));
throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
}
sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
val_history = access_value_history ((copy[1] == '$') ? -index : index);
if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
- error (_("History values used in line specs must have integer values."));
+ error (_("History values used in line "
+ "specs must have integer values."));
valx = value_as_long (val_history);
}
else
/* Not a user variable or function -- must be convenience variable. */
if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
- error (_("Convenience variables used in line specs must have integer values."));
+ error (_("Convenience variables used in line "
+ "specs must have integer values."));
}
init_sal (&val);
\f
+/* A helper for decode_line_1 that tries to find a label. The label
+ is searched for in the current block.
+ COPY is the name of the label to find.
+ CANONICAL is the same as the "canonical" argument to decode_line_1.
+ RESULT is a pointer to a symtabs_and_lines structure which will be
+ filled in on success.
+ This function returns 1 if a label was found, 0 otherwise. */
+
+static int
+decode_label (char *copy, char ***canonical, struct symtabs_and_lines *result)
+{
+ struct symbol *sym;
+
+ sym = lookup_symbol (copy, get_selected_block (0), LABEL_DOMAIN, 0);
+
+ if (sym != NULL)
+ *result = symbol_found (0, canonical, copy, sym, NULL);
+
+ return sym != NULL;
+}
+
/* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
- look in that symtab's static variables first. If NOT_FOUND_PTR is not NULL and
- the function cannot be found, store boolean true in the location pointed to
- and do not issue an error message. */
+ look in that symtab's static variables first. If NOT_FOUND_PTR is
+ not NULL and the function cannot be found, store boolean true in
+ the location pointed to and do not issue an error message. */
static struct symtabs_and_lines
decode_variable (char *copy, int funfirstline, char ***canonical,
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
- /* Arg is the name of a function */
+ /* Arg is the name of a function. */
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.sals[0] = find_function_start_sal (sym, funfirstline);
}
else
{
- if (funfirstline)
+ if (funfirstline && SYMBOL_CLASS (sym) != LOC_LABEL)
error (_("\"%s\" is not a function"), copy);
else if (SYMBOL_LINE (sym) != 0)
{
memset (&values.sals[0], 0, sizeof (values.sals[0]));
values.sals[0].symtab = SYMBOL_SYMTAB (sym);
values.sals[0].line = SYMBOL_LINE (sym);
+ values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
return values;
}
else
projects / deliverable / binutils-gdb.git / blobdiff