/* 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 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GDB.
#include "parser-defs.h"
#include "block.h"
#include "objc-lang.h"
+#include "linespec.h"
+#include "exceptions.h"
/* We share this one with symtab.c, but it is not exported widely. */
static char *find_toplevel_char (char *s, char c);
+static int is_objc_method_format (const char *s);
+
static struct symtabs_and_lines decode_line_2 (struct symbol *[],
int, int, char ***);
static struct symtab *symtab_from_filename (char **argptr,
- char *p, int is_quote_enclosed);
+ char *p, int is_quote_enclosed,
+ int *not_found_ptr);
static struct
symtabs_and_lines decode_all_digits (char **argptr,
static struct symtabs_and_lines decode_variable (char *copy,
int funfirstline,
char ***canonical,
- struct symtab *file_symtab);
+ struct symtab *file_symtab,
+ int *not_found_ptr);
static struct
symtabs_and_lines symbol_found (int funfirstline,
return 0;
}
+/* Determines if the gives string corresponds to an Objective-C method
+ representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
+ are allowed to have spaces and parentheses in them. */
+
+static int
+is_objc_method_format (const char *s)
+{
+ if (s == NULL || *s == '\0')
+ return 0;
+ /* Handle arguments with the format FILENAME:SYMBOL. */
+ if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
+ && (s[2] == '[') && strchr(s, ']'))
+ return 1;
+ /* Handle arguments that are just SYMBOL. */
+ else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
+ return 1;
+ return 0;
+}
+
/* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
operate on (ask user if necessary).
If CANONICAL is non-NULL return a corresponding array of mangled names
}
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. */
if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
{
values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
- printf_unfiltered ("[%d] %s at %s:%d\n",
- (i + 2),
- SYMBOL_PRINT_NAME (sym_arr[i]),
- values.sals[i].symtab->filename,
- values.sals[i].line);
+ if (values.sals[i].symtab)
+ printf_unfiltered ("[%d] %s at %s:%d\n",
+ (i + 2),
+ SYMBOL_PRINT_NAME (sym_arr[i]),
+ values.sals[i].symtab->filename,
+ values.sals[i].line);
+ else
+ 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);
}
}
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. */
+ 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. */
/* We allow single quotes in various places. This is a hideous
kludge, which exists because the completer can't yet deal with the
struct symtabs_and_lines
decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
- int default_line, char ***canonical)
+ int default_line, char ***canonical, int *not_found_ptr)
{
char *p;
char *q;
int is_objc_method = 0;
char *saved_arg = *argptr;
+ if (not_found_ptr)
+ *not_found_ptr = 0;
+
/* Defaults have defaults. */
initialize_defaults (&default_symtab, &default_line);
/* 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);
/* Check if this is an Objective-C method (anything that starts with
a '+' or '-' and a '['). */
- if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL)
- && (p[2] == '['))
+ if (is_objc_method_format (p))
{
is_objc_method = 1;
paren_pointer = NULL; /* Just a category name. Ignore it. */
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);
/* No, the first part is a filename; set s to be that file's
symtab. Also, move argptr past the filename. */
- file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed);
+ file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed,
+ not_found_ptr);
}
#if 0
/* No one really seems to know why this was added. It certainly
{
p = skip_quoted (*argptr);
if (p[-1] != '\'')
- error ("Unmatched single quote.");
+ error (_("Unmatched single quote."));
}
else if (is_objc_method)
{
/* Look up that token as a variable.
If file specified, use that file's per-file block to start with. */
- return decode_variable (copy, funfirstline, canonical, file_symtab);
+ return decode_variable (copy, funfirstline, canonical,
+ file_symtab, not_found_ptr);
}
\f
/* 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
indicates an Objective-C method) */
- if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL)
- && (p[2] == '['))
+ if (is_objc_method_format (p))
{
break;
}
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);
}
\f
/* Return the symtab associated to the filename given by the substring
- of *ARGPTR ending at P, and advance ARGPTR past that filename. */
+ of *ARGPTR ending at P, and advance ARGPTR past that filename. If
+ NOT_FOUND_PTR is not null and the source file is not found, store
+ boolean true at the location pointed to and do not issue an
+ error message. */
static struct symtab *
-symtab_from_filename (char **argptr, char *p, int is_quote_enclosed)
+symtab_from_filename (char **argptr, char *p, int is_quote_enclosed,
+ int *not_found_ptr)
{
char *p1;
char *copy;
if (file_symtab == 0)
{
if (!have_full_symbols () && !have_partial_symbols ())
- error ("No symbol table is loaded. Use the \"file\" command.");
- error ("No source file named %s.", copy);
+ error (_("No symbol table is loaded. Use the \"file\" command."));
+ if (not_found_ptr)
+ *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);
\f
/* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
- look in that symtab's static variables first. */
+ 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,
- struct symtab *file_symtab)
+ struct symtab *file_symtab, int *not_found_ptr)
{
struct symbol *sym;
/* The symtab that SYM was found in. */
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."));
- error ("Function \"%s\" not defined.", copy);
+ if (not_found_ptr)
+ *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 = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.sals[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
- (struct sec *) 0, 0);
+ (struct bfd_section *) 0, 0);
values.sals[0].section = SYMBOL_BFD_SECTION (msymbol);
if (funfirstline)
{
- values.sals[0].pc += FUNCTION_START_OFFSET;
+ values.sals[0].pc += DEPRECATED_FUNCTION_START_OFFSET;
values.sals[0].pc = SKIP_PROLOGUE (values.sals[0].pc);
}
values.nelts = 1;
projects / thirdparty / binutils-gdb.git / blobdiff