/* Parser for linespec for the GNU debugger, GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "symtab.h"
#include "block.h"
#include "objc-lang.h"
#include "linespec.h"
+#include "exceptions.h"
+#include "language.h"
/* We share this one with symtab.c, but it is not exported widely. */
struct symbol *sym_class);
static int collect_methods (char *copy, struct type *t,
+ struct symbol *sym_class,
struct symbol **sym_arr);
static NORETURN void cplusplus_error (const char *name,
static int total_number_of_methods (struct type *type);
-static int find_methods (struct type *, char *, struct symbol **);
+static int find_methods (struct type *, char *,
+ enum language, struct symbol **);
static int add_matching_methods (int method_counter, struct type *t,
+ enum language language,
struct symbol **sym_arr);
static int add_constructors (int method_counter, struct type *t,
+ enum language language,
struct symbol **sym_arr);
static void build_canonical_line_spec (struct symtab_and_line *,
Note that this function is g++ specific. */
static int
-find_methods (struct type *t, char *name, struct symbol **sym_arr)
+find_methods (struct type *t, char *name, enum language language,
+ struct symbol **sym_arr)
{
int i1 = 0;
int ibase;
unless we figure out how to get the physname without the name of
the class, then the loop can't do any good. */
if (class_name
- && (lookup_symbol (class_name, (struct block *) NULL,
- STRUCT_DOMAIN, (int *) NULL,
+ && (lookup_symbol_in_language (class_name, (struct block *) NULL,
+ STRUCT_DOMAIN, language, (int *) NULL,
(struct symtab **) NULL)))
{
int method_counter;
if (strcmp_iw (name, method_name) == 0)
/* Find all the overloaded methods with that name. */
- i1 += add_matching_methods (method_counter, t,
+ i1 += add_matching_methods (method_counter, t, language,
sym_arr + i1);
else if (strncmp (class_name, name, name_len) == 0
&& (class_name[name_len] == '\0'
|| class_name[name_len] == '<'))
- i1 += add_constructors (method_counter, t,
+ i1 += add_constructors (method_counter, t, language,
sym_arr + i1);
}
}
if (i1 == 0)
for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
- i1 += find_methods (TYPE_BASECLASS (t, ibase), name, sym_arr + i1);
+ i1 += find_methods (TYPE_BASECLASS (t, ibase), name,
+ language, sym_arr + i1);
return i1;
}
static int
add_matching_methods (int method_counter, struct type *t,
- struct symbol **sym_arr)
+ enum language language, struct symbol **sym_arr)
{
int field_counter;
int i1 = 0;
}
else
phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
-
+
/* Destructor is handled by caller, don't add it to
the list. */
if (is_destructor_name (phys_name) != 0)
continue;
- sym_arr[i1] = lookup_symbol (phys_name,
+ sym_arr[i1] = lookup_symbol_in_language (phys_name,
NULL, VAR_DOMAIN,
+ language,
(int *) NULL,
(struct symtab **) NULL);
if (sym_arr[i1])
static int
add_constructors (int method_counter, struct type *t,
- struct symbol **sym_arr)
+ enum language language, struct symbol **sym_arr)
{
int field_counter;
int i1 = 0;
{
struct fn_field *f;
char *phys_name;
-
+
f = TYPE_FN_FIELDLIST1 (t, method_counter);
/* GCC 3.x will never produce stabs stub methods, so
/* If this method is actually defined, include it in the
list. */
- sym_arr[i1] = lookup_symbol (phys_name,
+ sym_arr[i1] = lookup_symbol_in_language (phys_name,
NULL, VAR_DOMAIN,
+ language,
(int *) NULL,
(struct symtab **) NULL);
if (sym_arr[i1])
}
i = 0;
- printf_unfiltered ("[0] cancel\n[1] all\n");
+ printf_unfiltered (_("[0] cancel\n[1] all\n"));
while (i < nelts)
{
init_sal (&return_values.sals[i]); /* Initialize to zeroes. */
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 ("?HERE\n");
+ printf_unfiltered (_("?HERE\n"));
i++;
}
args = command_line_input (prompt, 0, "overload-choice");
if (args == 0 || *args == 0)
- error_no_arg ("one or more choice numbers");
+ error_no_arg (_("one or more choice numbers"));
i = 0;
while (*args)
while (*arg1 >= '0' && *arg1 <= '9')
arg1++;
if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
- error ("Arguments must be choice numbers.");
+ error (_("Arguments must be choice numbers."));
num = atoi (args);
if (num == 0)
- error ("canceled");
+ error (_("canceled"));
else if (num == 1)
{
if (canonical_arr)
if (num >= nelts + 2)
{
- printf_unfiltered ("No choice number %d.\n", num);
+ printf_unfiltered (_("No choice number %d.\n"), num);
}
else
{
}
else
{
- printf_unfiltered ("duplicate request for %d ignored.\n", num);
+ printf_unfiltered (_("duplicate request for %d ignored.\n"), num);
}
}
/* Check to see if it's a multipart linespec (with colons or
periods). */
- /* Locate the end of the first half of the linespec. */
+ /* 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. */
p = locate_first_half (argptr, &is_quote_enclosed);
if (is_quoted)
*argptr = *argptr + 1;
- /* Is it a C++ or Java compound data structure? */
-
+ /* 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.
+ Note that the call to decode_compound does everything
+ for us, including the lookup on the symbol table, so we
+ can return now. */
+
if (p[0] == '.' || p[1] == ':')
return decode_compound (argptr, funfirstline, canonical,
saved_arg, p);
{
p = skip_quoted (*argptr);
if (p[-1] != '\'')
- error ("Unmatched single quote.");
+ error (_("Unmatched single quote."));
}
else if (is_objc_method)
{
/* Locate the first half of the linespec, ending in a colon, period,
or whitespace. (More or less.) Also, check to see if *ARGPTR is
enclosed in double quotes; if so, set is_quote_enclosed, advance
- ARGPTR past that and zero out the trailing double quote. */
+ ARGPTR past that and zero out the trailing double quote.
+ If ARGPTR is just a simple name like "main", p will point to ""
+ at the end. */
static char *
locate_first_half (char **argptr, int *is_quote_enclosed)
{
char *temp_end = find_template_name_end (p);
if (!temp_end)
- error ("malformed template specification in command");
+ error (_("malformed template specification in command"));
p = temp_end;
}
/* Check for a colon and a plus or minus and a [ (which
struct symbol *sym = NULL;
char *copy = NULL;
struct block *block = NULL;
- int i1 = 0;
- int i2 = 0;
+ unsigned i1 = 0;
+ unsigned i2 = 0;
values.sals = NULL;
values.nelts = 0;
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)
{
- 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;
}
}
}
/* This handles C++ and Java compound data structures. P should point
- at the first component separator, i.e. double-colon or period. */
+ at the first component separator, i.e. double-colon or period. As
+ an example, on entrance to this function we could have ARGPTR
+ pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
static struct symtabs_and_lines
decode_compound (char **argptr, int funfirstline, char ***canonical,
{
struct symtabs_and_lines values;
char *p2;
-#if 0
- char *q, *q1;
-#endif
char *saved_arg2 = *argptr;
char *temp_end;
struct symbol *sym;
struct symbol **sym_arr;
struct type *t;
- /* First check for "global" namespace specification,
- of the form "::foo". If found, skip over the colons
- and jump to normal symbol processing. */
+ /* 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). */
if (p[0] == ':'
&& ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
saved_arg2 += 2;
- /* We have what looks like a class or namespace
- scope specification (A::B), possibly with many
- levels of namespaces or classes (A::B::C::D).
-
- Some versions of the HP ANSI C++ compiler (as also possibly
- other compilers) generate class/function/member names with
- embedded double-colons if they are inside namespaces. To
- handle this, we loop a few times, considering larger and
- larger prefixes of the string as though they were single
- symbols. So, if the initially supplied string is
- A::B::C::D::foo, we have to look up "A", then "A::B",
- then "A::B::C", then "A::B::C::D", and finally
- "A::B::C::D::foo" as single, monolithic symbols, because
- A, B, C or D may be namespaces.
-
- Note that namespaces can nest only inside other
- namespaces, and not inside classes. So we need only
- consider *prefixes* of the string; there is no need to look up
- "B::C" separately as a symbol in the previous example. */
+ /* Given our example "AAA::inA::fun", we have two cases to consider:
- p2 = p; /* Save for restart. */
- while (1)
- {
- sym_class = lookup_prefix_sym (argptr, p);
+ 1) AAA::inA is the name of a class. In that case, presumably it
+ has a method called "fun"; we then look up that method using
+ find_method.
- if (sym_class &&
- (t = check_typedef (SYMBOL_TYPE (sym_class)),
- (TYPE_CODE (t) == TYPE_CODE_STRUCT
- || TYPE_CODE (t) == TYPE_CODE_UNION)))
- {
- /* Arg token is not digits => try it as a function name.
- Find the next token (everything up to end or next
- blank). */
- if (**argptr
- && strchr (get_gdb_completer_quote_characters (),
- **argptr) != NULL)
- {
- p = skip_quoted (*argptr);
- *argptr = *argptr + 1;
- }
- else
- {
- p = *argptr;
- while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':')
- p++;
- }
-/*
- q = operator_chars (*argptr, &q1);
- if (q1 - q)
- {
- char *opname;
- char *tmp = alloca (q1 - q + 1);
- memcpy (tmp, q, q1 - q);
- tmp[q1 - q] = '\0';
- opname = cplus_mangle_opname (tmp, DMGL_ANSI);
- if (opname == NULL)
- {
- cplusplus_error (saved_arg, "no mangling for \"%s\"\n", tmp);
- }
- copy = (char*) alloca (3 + strlen(opname));
- sprintf (copy, "__%s", opname);
- p = q1;
- }
- else
- */
- {
- copy = (char *) alloca (p - *argptr + 1);
- memcpy (copy, *argptr, p - *argptr);
- copy[p - *argptr] = '\0';
- if (p != *argptr
- && copy[p - *argptr - 1]
- && strchr (get_gdb_completer_quote_characters (),
- copy[p - *argptr - 1]) != NULL)
- copy[p - *argptr - 1] = '\0';
- }
+ 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.
- /* No line number may be specified. */
- while (*p == ' ' || *p == '\t')
- p++;
- *argptr = p;
+ 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
+ first loop through all of the double-colons. */
- return find_method (funfirstline, canonical, saved_arg,
- copy, t, sym_class);
- }
+ p2 = p; /* Save for restart. */
+
+ /* 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". */
+ /* In the loop below, with these strings, we'll make 2 passes, each
+ is marked in comments.*/
+
+ while (1)
+ {
/* 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. */
+ /* PASS2: p2->"::fun", p->":fun" */
+
/* Move pointer ahead to next double-colon. */
while (*p && (p[0] != ' ') && (p[0] != '\t') && (p[0] != '\''))
{
{
temp_end = find_template_name_end (p);
if (!temp_end)
- error ("malformed template specification in command");
+ error (_("malformed template specification in command"));
p = temp_end;
}
+ /* 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
+ 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. */
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++;
}
if (*p != ':')
- break; /* Out of the while (1). */
-
- p2 = p; /* Save restart for next time around. */
- *argptr = saved_arg2; /* Restore argptr. */
+ 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) */
+
+ /* We get here if p points to ' ', '\t', '\'', "::" or ""(i.e
+ string ended). */
+ /* Save restart for next time around. */
+ p2 = p;
+ /* Restore argptr as it was on entry to this function. */
+ *argptr = saved_arg2;
+ /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
+ p2->"::fun". */
+
+ /* All ready for next pass through the loop. */
} /* while (1) */
- /* Last chance attempt -- check entire name as a symbol. Use "copy"
- in preparation for jumping out of this block, to be consistent
- with usage following the jump target. */
+
+ /* 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. */
+ /* Before the call, argptr->"AAA::inA::fun",
+ p->"", p2->"::fun". After the call: argptr->"fun", p, p2
+ unchanged. */
+ sym_class = lookup_prefix_sym (argptr, p2);
+
+ /* If sym_class has been found, and if "AAA::inA" is a class, then
+ we're in case 1 above. So we look up "fun" as a method of that
+ class. */
+ if (sym_class &&
+ (t = check_typedef (SYMBOL_TYPE (sym_class)),
+ (TYPE_CODE (t) == TYPE_CODE_STRUCT
+ || TYPE_CODE (t) == TYPE_CODE_UNION)))
+ {
+ /* Arg token is not digits => try it as a function name.
+ Find the next token (everything up to end or next
+ blank). */
+ if (**argptr
+ && strchr (get_gdb_completer_quote_characters (),
+ **argptr) != NULL)
+ {
+ p = skip_quoted (*argptr);
+ *argptr = *argptr + 1;
+ }
+ else
+ {
+ /* At this point argptr->"fun". */
+ p = *argptr;
+ while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':')
+ p++;
+ /* At this point p->"". String ended. */
+ }
+
+ /* Allocate our own copy of the substring between argptr and
+ p. */
+ copy = (char *) alloca (p - *argptr + 1);
+ memcpy (copy, *argptr, p - *argptr);
+ copy[p - *argptr] = '\0';
+ if (p != *argptr
+ && copy[p - *argptr - 1]
+ && strchr (get_gdb_completer_quote_characters (),
+ copy[p - *argptr - 1]) != NULL)
+ copy[p - *argptr - 1] = '\0';
+
+ /* At this point copy->"fun", p->"" */
+
+ /* No line number may be specified. */
+ while (*p == ' ' || *p == '\t')
+ p++;
+ *argptr = p;
+ /* At this point arptr->"". */
+
+ /* 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,
+ we'll lookup the whole string in the symbol tables. */
+
+ return find_method (funfirstline, canonical, saved_arg,
+ copy, t, sym_class);
+
+ } /* 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. */
+
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
copy[p - saved_arg2] = '\000';
/* Set argptr to skip over the name. */
*argptr = (*p == '\'') ? p + 1 : p;
+
/* Look up entire name */
sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0, &sym_symtab);
if (sym)
/* Return the symbol corresponding to the substring of *ARGPTR ending
at P, allowing whitespace. Also, advance *ARGPTR past the symbol
name in question, the compound object separator ("::" or "."), and
- whitespace. */
+ whitespace. Note that *ARGPTR is changed whether or not the
+ lookup_symbol call finds anything (i.e we return NULL). As an
+ example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
static struct symbol *
lookup_prefix_sym (char **argptr, char *p)
memcpy (copy, *argptr, p - *argptr);
copy[p - *argptr] = 0;
- /* Discard the class name from the arg. */
+ /* Discard the class name from the argptr. */
p = p1 + (p1[0] == ':' ? 2 : 1);
while (*p == ' ' || *p == '\t')
p++;
*argptr = p;
+ /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
+ argptr->"inA::fun" */
+
return lookup_symbol (copy, 0, STRUCT_DOMAIN, 0,
(struct symtab **) NULL);
}
/* Find all methods with a matching name, and put them in
sym_arr. */
- i1 = collect_methods (copy, t, sym_arr);
+ i1 = collect_methods (copy, t, sym_class, sym_arr);
if (i1 == 1)
{
}
else
{
+ values.sals = NULL;
values.nelts = 0;
}
return values;
static int
collect_methods (char *copy, struct type *t,
- struct symbol **sym_arr)
+ struct symbol *sym_class, struct symbol **sym_arr)
{
int i1 = 0; /* Counter for the symbol array. */
}
}
else
- i1 = find_methods (t, copy, sym_arr);
+ i1 = find_methods (t, copy, SYMBOL_LANGUAGE (sym_class), sym_arr);
return i1;
}
if (file_symtab == 0)
{
if (!have_full_symbols () && !have_partial_symbols ())
- error ("No symbol table is loaded. Use the \"file\" command.");
+ error (_("No symbol table is loaded. Use the \"file\" command."));
if (not_found_ptr)
- {
- *not_found_ptr = 1;
- throw_exception (RETURN_ERROR);
- }
- error ("No source file named %s.", copy);
+ *not_found_ptr = 1;
+ throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
}
/* Discard the file name from the arg. */
/* We have a value history reference. */
sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
valx = access_value_history ((copy[1] == '$') ? -index : index);
- if (TYPE_CODE (VALUE_TYPE (valx)) != TYPE_CODE_INT)
- error ("History values used in line specs must have integer values.");
+ if (TYPE_CODE (value_type (valx)) != TYPE_CODE_INT)
+ error (_("History values used in line specs must have integer values."));
}
else
{
/* Not a user variable or function -- must be convenience variable. */
need_canonical = (file_symtab == 0) ? 1 : 0;
valx = value_of_internalvar (lookup_internalvar (copy + 1));
- if (TYPE_CODE (VALUE_TYPE (valx)) != TYPE_CODE_INT)
- error ("Convenience variables used in line specs must have integer values.");
+ if (TYPE_CODE (value_type (valx)) != TYPE_CODE_INT)
+ error (_("Convenience variables used in line specs must have integer values."));
}
init_sal (&val);
if (!have_full_symbols () &&
!have_partial_symbols () && !have_minimal_symbols ())
- error ("No symbol table is loaded. Use the \"file\" command.");
+ error (_("No symbol table is loaded. Use the \"file\" command."));
if (not_found_ptr)
- {
- *not_found_ptr = 1;
- throw_exception (RETURN_ERROR);
- }
-
- error ("Function \"%s\" not defined.", copy);
+ *not_found_ptr = 1;
+ throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
}
else
{
if (funfirstline)
- error ("\"%s\" is not a function", copy);
+ error (_("\"%s\" is not a function"), copy);
else if (SYMBOL_LINE (sym) != 0)
{
/* We know its line number. */
/* FIXME: Shouldn't we just set .line and .symtab to zero
and return? For example, "info line foo" could print
the address. */
- error ("Line number not known for symbol \"%s\"", copy);
+ error (_("Line number not known for symbol \"%s\""), copy);
}
}
values.sals[0].section = SYMBOL_BFD_SECTION (msymbol);
if (funfirstline)
{
- values.sals[0].pc += FUNCTION_START_OFFSET;
- values.sals[0].pc = SKIP_PROLOGUE (values.sals[0].pc);
+ values.sals[0].pc += DEPRECATED_FUNCTION_START_OFFSET;
+ values.sals[0].pc = gdbarch_skip_prologue
+ (current_gdbarch, values.sals[0].pc);
}
values.nelts = 1;
return values;