1 /* Parser for linespec for the GNU debugger, GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "completer.h"
33 #include "cp-support.h"
34 #include "parser-defs.h"
36 #include "objc-lang.h"
38 #include "exceptions.h"
41 #include "mi/mi-cmds.h"
43 #include "arch-utils.h"
45 #include "cli/cli-utils.h"
47 /* We share this one with symtab.c, but it is not exported widely. */
49 extern char *operator_chars (char *, char **);
51 /* Prototypes for local functions. */
53 static void initialize_defaults (struct symtab
**default_symtab
,
56 static struct symtabs_and_lines
decode_indirect (char **argptr
);
58 static char *locate_first_half (char **argptr
, int *is_quote_enclosed
);
60 static struct symtabs_and_lines
decode_objc (char **argptr
,
62 struct symtab
*file_symtab
,
63 struct linespec_result
*canonical
,
66 static struct symtabs_and_lines
decode_compound (char **argptr
,
68 struct linespec_result
*canonical
,
72 static struct symbol
*lookup_prefix_sym (char **argptr
, char *p
);
74 static struct symtabs_and_lines
find_method (int funfirstline
,
75 struct linespec_result
*canonical
,
79 struct symbol
*sym_class
);
81 static void cplusplus_error (const char *name
, const char *fmt
, ...)
82 ATTRIBUTE_NORETURN
ATTRIBUTE_PRINTF (2, 3);
84 static int total_number_of_methods (struct type
*type
);
86 static int find_methods (struct type
*, char *,
87 enum language
, struct symbol
**);
89 static int add_matching_methods (int method_counter
, struct type
*t
,
90 enum language language
,
91 struct symbol
**sym_arr
);
93 static int add_constructors (int method_counter
, struct type
*t
,
94 enum language language
,
95 struct symbol
**sym_arr
);
97 static void build_canonical_line_spec (struct symtab_and_line
*,
98 char *, struct linespec_result
*);
100 static char *find_toplevel_char (char *s
, char c
);
102 static int is_objc_method_format (const char *s
);
104 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
106 struct linespec_result
*);
108 static struct symtab
*symtab_from_filename (char **argptr
,
109 char *p
, int is_quote_enclosed
);
111 static struct symbol
*find_function_symbol (char **argptr
, char *p
,
112 int is_quote_enclosed
);
115 symtabs_and_lines
decode_all_digits (char **argptr
,
116 struct symtab
*default_symtab
,
118 struct linespec_result
*canonical
,
119 struct symtab
*file_symtab
,
122 static struct symtabs_and_lines
decode_dollar (char *copy
,
124 struct symtab
*default_symtab
,
125 struct linespec_result
*canonical
,
126 struct symtab
*file_symtab
);
128 static int decode_label (struct symbol
*function_symbol
,
129 char *copy
, struct linespec_result
*canonical
,
130 struct symtabs_and_lines
*result
);
132 static struct symtabs_and_lines
decode_variable (char *copy
,
134 struct linespec_result
*canonical
,
135 struct symtab
*file_symtab
);
138 symtabs_and_lines
symbol_found (int funfirstline
,
139 struct linespec_result
*canonical
,
142 struct symtab
*file_symtab
,
143 struct symbol
*function_symbol
);
146 symtabs_and_lines
minsym_found (int funfirstline
,
147 struct minimal_symbol
*msymbol
);
149 /* Helper functions. */
151 /* Issue a helpful hint on using the command completion feature on
152 single quoted demangled C++ symbols as part of the completion
156 cplusplus_error (const char *name
, const char *fmt
, ...)
158 struct ui_file
*tmp_stream
;
161 tmp_stream
= mem_fileopen ();
162 make_cleanup_ui_file_delete (tmp_stream
);
167 va_start (args
, fmt
);
168 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
172 while (*name
== '\'')
174 fprintf_unfiltered (tmp_stream
,
175 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
176 "(Note leading single quote.)"),
179 message
= ui_file_xstrdup (tmp_stream
, NULL
);
180 make_cleanup (xfree
, message
);
181 throw_error (NOT_FOUND_ERROR
, "%s", message
);
184 /* Return the number of methods described for TYPE, including the
185 methods from types it derives from. This can't be done in the symbol
186 reader because the type of the baseclass might still be stubbed
187 when the definition of the derived class is parsed. */
190 total_number_of_methods (struct type
*type
)
195 CHECK_TYPEDEF (type
);
196 if (! HAVE_CPLUS_STRUCT (type
))
198 count
= TYPE_NFN_FIELDS_TOTAL (type
);
200 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
201 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
206 /* Recursive helper function for decode_line_1.
207 Look for methods named NAME in type T.
208 Return number of matches.
209 Put matches in SYM_ARR, which should have been allocated with
210 a size of total_number_of_methods (T) * sizeof (struct symbol *).
211 Note that this function is g++ specific. */
214 find_methods (struct type
*t
, char *name
, enum language language
,
215 struct symbol
**sym_arr
)
219 char *class_name
= type_name_no_tag (t
);
220 struct cleanup
*cleanup
;
223 /* NAME is typed by the user: it needs to be canonicalized before
224 passing to lookup_symbol. */
225 canon
= cp_canonicalize_string (name
);
229 cleanup
= make_cleanup (xfree
, name
);
232 cleanup
= make_cleanup (null_cleanup
, NULL
);
234 /* Ignore this class if it doesn't have a name. This is ugly, but
235 unless we figure out how to get the physname without the name of
236 the class, then the loop can't do any good. */
238 && (lookup_symbol_in_language (class_name
, (struct block
*) NULL
,
239 STRUCT_DOMAIN
, language
, (int *) NULL
)))
242 int name_len
= strlen (name
);
246 /* Loop over each method name. At this level, all overloads of a name
247 are counted as a single name. There is an inner loop which loops over
250 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
254 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
257 if (strncmp (method_name
, "__", 2) == 0 ||
258 strncmp (method_name
, "op", 2) == 0 ||
259 strncmp (method_name
, "type", 4) == 0)
261 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
262 method_name
= dem_opname
;
263 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
264 method_name
= dem_opname
;
267 if (strcmp_iw (name
, method_name
) == 0)
268 /* Find all the overloaded methods with that name. */
269 i1
+= add_matching_methods (method_counter
, t
, language
,
271 else if (strncmp (class_name
, name
, name_len
) == 0
272 && (class_name
[name_len
] == '\0'
273 || class_name
[name_len
] == '<'))
274 i1
+= add_constructors (method_counter
, t
, language
,
279 /* Only search baseclasses if there is no match yet, since names in
280 derived classes override those in baseclasses.
282 FIXME: The above is not true; it is only true of member functions
283 if they have the same number of arguments (??? - section 13.1 of the
284 ARM says the function members are not in the same scope but doesn't
285 really spell out the rules in a way I understand. In any case, if
286 the number of arguments differ this is a case in which we can overload
287 rather than hiding without any problem, and gcc 2.4.5 does overload
288 rather than hiding in this case). */
291 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
292 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
,
293 language
, sym_arr
+ i1
);
295 do_cleanups (cleanup
);
299 /* Add the symbols associated to methods of the class whose type is T
300 and whose name matches the method indexed by METHOD_COUNTER in the
301 array SYM_ARR. Return the number of methods added. */
304 add_matching_methods (int method_counter
, struct type
*t
,
305 enum language language
, struct symbol
**sym_arr
)
310 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
315 const char *phys_name
;
317 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
319 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
321 char *tmp_name
, *tmp2
;
323 tmp_name
= gdb_mangle_name (t
,
326 tmp2
= alloca (strlen (tmp_name
) + 1);
327 strcpy (tmp2
, tmp_name
);
332 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
334 sym_arr
[i1
] = lookup_symbol_in_language (phys_name
,
342 /* This error message gets printed, but the method
343 still seems to be found.
344 fputs_filtered("(Cannot find method ", gdb_stdout);
345 fprintf_symbol_filtered (gdb_stdout, phys_name,
347 DMGL_PARAMS | DMGL_ANSI);
348 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
356 /* Add the symbols associated to constructors of the class whose type
357 is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the
358 array SYM_ARR. Return the number of methods added. */
361 add_constructors (int method_counter
, struct type
*t
,
362 enum language language
, struct symbol
**sym_arr
)
367 /* For GCC 3.x and stabs, constructors and destructors
368 have names like __base_ctor and __complete_dtor.
369 Check the physname for now if we're looking for a
372 = TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
377 const char *phys_name
;
379 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
381 /* GCC 3.x will never produce stabs stub methods, so
382 we don't need to handle this case. */
383 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
385 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
386 if (! is_constructor_name (phys_name
))
389 /* If this method is actually defined, include it in the
391 sym_arr
[i1
] = lookup_symbol_in_language (phys_name
,
402 /* Helper function for decode_line_1.
403 Build a canonical line spec in CANONICAL if it is non-NULL and if
404 the SAL has a symtab.
405 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
406 If SYMNAME is NULL the line number from SAL is used and the canonical
407 line spec is `filename:linenum'. */
410 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
411 struct linespec_result
*canonical
)
413 char **canonical_arr
;
414 char *canonical_name
;
416 struct symtab
*s
= sal
->symtab
;
418 if (s
== (struct symtab
*) NULL
419 || s
->filename
== (char *) NULL
420 || canonical
== NULL
)
423 canonical_arr
= (char **) xmalloc (sizeof (char *));
424 canonical
->canonical
= canonical_arr
;
426 filename
= s
->filename
;
429 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
430 sprintf (canonical_name
, "%s:%s", filename
, symname
);
434 canonical_name
= xmalloc (strlen (filename
) + 30);
435 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
437 canonical_arr
[0] = canonical_name
;
442 /* Find an instance of the character C in the string S that is outside
443 of all parenthesis pairs, single-quoted strings, and double-quoted
444 strings. Also, ignore the char within a template name, like a ','
445 within foo<int, int>. */
448 find_toplevel_char (char *s
, char c
)
450 int quoted
= 0; /* zero if we're not in quotes;
451 '"' if we're in a double-quoted string;
452 '\'' if we're in a single-quoted string. */
453 int depth
= 0; /* Number of unclosed parens we've seen. */
456 for (scan
= s
; *scan
; scan
++)
462 else if (*scan
== '\\' && *(scan
+ 1))
465 else if (*scan
== c
&& ! quoted
&& depth
== 0)
467 else if (*scan
== '"' || *scan
== '\'')
469 else if (*scan
== '(' || *scan
== '<')
471 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
478 /* Determines if the gives string corresponds to an Objective-C method
479 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
480 are allowed to have spaces and parentheses in them. */
483 is_objc_method_format (const char *s
)
485 if (s
== NULL
|| *s
== '\0')
487 /* Handle arguments with the format FILENAME:SYMBOL. */
488 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
489 && (s
[2] == '[') && strchr(s
, ']'))
491 /* Handle arguments that are just SYMBOL. */
492 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
497 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
498 operate on (ask user if necessary).
499 If CANONICAL is non-NULL return a corresponding array of mangled names
500 as canonical line specs there. */
502 static struct symtabs_and_lines
503 decode_line_2 (struct symbol
*sym_arr
[], int nelts
, int funfirstline
,
504 struct linespec_result
*canonical
)
506 struct symtabs_and_lines values
, return_values
;
511 struct cleanup
*old_chain
;
512 char **canonical_arr
= (char **) NULL
;
513 const char *select_mode
= multiple_symbols_select_mode ();
515 if (select_mode
== multiple_symbols_cancel
)
516 error (_("canceled because the command is ambiguous\n"
517 "See set/show multiple-symbol."));
519 values
.sals
= (struct symtab_and_line
*)
520 alloca (nelts
* sizeof (struct symtab_and_line
));
521 return_values
.sals
= (struct symtab_and_line
*)
522 xmalloc (nelts
* sizeof (struct symtab_and_line
));
523 old_chain
= make_cleanup (xfree
, return_values
.sals
);
527 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
528 make_cleanup (xfree
, canonical_arr
);
529 memset (canonical_arr
, 0, nelts
* sizeof (char *));
530 canonical
->canonical
= canonical_arr
;
536 init_sal (&return_values
.sals
[i
]); /* Initialize to zeroes. */
537 init_sal (&values
.sals
[i
]);
538 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
539 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
543 /* If select_mode is "all", then do not print the multiple-choice
544 menu and act as if the user had chosen choice "1" (all). */
545 if (select_mode
== multiple_symbols_all
546 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
551 printf_unfiltered (_("[0] cancel\n[1] all\n"));
554 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
556 if (values
.sals
[i
].symtab
)
557 printf_unfiltered ("[%d] %s at %s:%d\n",
559 SYMBOL_PRINT_NAME (sym_arr
[i
]),
560 values
.sals
[i
].symtab
->filename
,
561 values
.sals
[i
].line
);
563 printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? "
564 "Probably broken debug info...]\n"),
566 SYMBOL_PRINT_NAME (sym_arr
[i
]),
567 values
.sals
[i
].line
);
571 printf_unfiltered (_("?HERE\n"));
575 prompt
= getenv ("PS2");
580 args
= command_line_input (prompt
, 0, "overload-choice");
583 if (args
== 0 || *args
== 0)
584 error_no_arg (_("one or more choice numbers"));
592 while (*arg1
>= '0' && *arg1
<= '9')
594 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
595 error (_("Arguments must be choice numbers."));
600 error (_("canceled"));
605 for (i
= 0; i
< nelts
; i
++)
607 if (canonical_arr
[i
] == NULL
)
609 symname
= SYMBOL_LINKAGE_NAME (sym_arr
[i
]);
610 canonical_arr
[i
] = xstrdup (symname
);
614 memcpy (return_values
.sals
, values
.sals
,
615 (nelts
* sizeof (struct symtab_and_line
)));
616 return_values
.nelts
= nelts
;
617 discard_cleanups (old_chain
);
618 return return_values
;
621 if (num
>= nelts
+ 2)
623 printf_unfiltered (_("No choice number %d.\n"), num
);
628 if (values
.sals
[num
].pc
)
632 symname
= SYMBOL_LINKAGE_NAME (sym_arr
[num
]);
633 make_cleanup (xfree
, symname
);
634 canonical_arr
[i
] = xstrdup (symname
);
636 return_values
.sals
[i
++] = values
.sals
[num
];
637 values
.sals
[num
].pc
= 0;
641 printf_unfiltered (_("duplicate request for %d ignored.\n"),
647 while (*args
== ' ' || *args
== '\t')
650 return_values
.nelts
= i
;
651 discard_cleanups (old_chain
);
652 return return_values
;
655 /* A helper function for decode_line_1 and friends which skips P
656 past any method overload information at the beginning of P, e.g.,
657 "(const struct foo *)".
659 This function assumes that P has already been validated to contain
660 overload information, and it will assert if *P != '('. */
662 find_method_overload_end (char *p
)
666 gdb_assert (*p
== '(');
686 /* Does P point to a sequence of characters which implies the end
687 of a name? Terminals include "if" and "thread" clauses. */
694 if (*p
== 'i' && p
[1] == 'f'
695 && (isspace (p
[2]) || p
[2] == '\0' || p
[2] == '('))
698 if (strncmp (p
, "thread", 6) == 0
699 && (isspace (p
[6]) || p
[6] == '\0'))
705 /* Keep important information used when looking up a name. This includes
706 template parameters, overload information, and important keywords. */
709 keep_name_info (char *ptr
)
714 /* Keep any template parameters. */
716 return remove_trailing_whitespace (start
, ptr
);
721 ptr
= p
= find_template_name_end (ptr
);
724 return remove_trailing_whitespace (start
, ptr
);
726 /* Keep method overload information. */
728 ptr
= p
= find_method_overload_end (p
);
731 return remove_trailing_whitespace (start
, ptr
);
733 /* Keep important keywords. */
736 if (strncmp (p
, "const", 5) == 0
737 && (isspace (p
[5]) || p
[5] == '\0'
738 || strchr (get_gdb_completer_quote_characters (), p
[5]) != NULL
))
741 return remove_trailing_whitespace (start
, ptr
);
745 /* The parser of linespec itself. */
747 /* Parse a string that specifies a line number.
748 Pass the address of a char * variable; that variable will be
749 advanced over the characters actually parsed.
753 LINENUM -- that line number in current file. PC returned is 0.
754 FILE:LINENUM -- that line in that file. PC returned is 0.
755 FUNCTION -- line number of openbrace of that function.
756 PC returned is the start of the function.
757 LABEL -- a label in the current scope
758 VARIABLE -- line number of definition of that variable.
760 FILE:FUNCTION -- likewise, but prefer functions in that file.
761 *EXPR -- line in which address EXPR appears.
763 This may all be followed by an "if EXPR", which we ignore.
765 FUNCTION may be an undebuggable function found in minimal symbol table.
767 If the argument FUNFIRSTLINE is nonzero, we want the first line
768 of real code inside a function when a function is specified, and it is
769 not OK to specify a variable or type to get its line number.
771 DEFAULT_SYMTAB specifies the file to use if none is specified.
772 It defaults to current_source_symtab.
773 DEFAULT_LINE specifies the line number to use for relative
774 line numbers (that start with signs). Defaults to current_source_line.
775 If CANONICAL is non-NULL, store an array of strings containing the canonical
776 line specs there if necessary. Currently overloaded member functions and
777 line numbers or static functions without a filename yield a canonical
778 line spec. The array and the line spec strings are allocated on the heap,
779 it is the callers responsibility to free them.
781 Note that it is possible to return zero for the symtab
782 if no file is validly specified. Callers must check that.
783 Also, the line number returned may be invalid. */
785 /* We allow single quotes in various places. This is a hideous
786 kludge, which exists because the completer can't yet deal with the
787 lack of single quotes. FIXME: write a linespec_completer which we
788 can use as appropriate instead of make_symbol_completion_list. */
790 struct symtabs_and_lines
791 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
792 int default_line
, struct linespec_result
*canonical
)
796 /* If a file name is specified, this is its symtab. */
797 struct symtab
*file_symtab
= NULL
;
800 /* This says whether or not something in *ARGPTR is quoted with
801 completer_quotes (i.e. with single quotes). */
803 /* Is *ARGPTR is enclosed in double quotes? */
804 int is_quote_enclosed
;
805 int is_objc_method
= 0;
806 char *saved_arg
= *argptr
;
807 /* If IS_QUOTED, the end of the quoted bit. */
808 char *end_quote
= NULL
;
809 /* The "first half" of the linespec. */
812 /* If we are parsing `function:label', this holds the symbol for the
814 struct symbol
*function_symbol
= NULL
;
815 /* If FUNCTION_SYMBOL is not NULL, then this is the exception that
816 was thrown when trying to parse a filename. */
817 volatile struct gdb_exception file_exception
;
819 /* Defaults have defaults. */
821 initialize_defaults (&default_symtab
, &default_line
);
823 /* See if arg is *PC. */
826 return decode_indirect (argptr
);
828 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
832 end_quote
= skip_quoted (*argptr
);
834 /* Check to see if it's a multipart linespec (with colons or
837 /* Locate the end of the first half of the linespec.
838 After the call, for instance, if the argptr string is "foo.c:123"
839 p will point at "123". If there is only one part, like "foo", p
840 will point to "". If this is a C++ name, like "A::B::foo", p will
841 point to "::B::foo". Argptr is not changed by this call. */
843 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
845 /* Check if this is an Objective-C method (anything that starts with
846 a '+' or '-' and a '['). */
847 if (is_objc_method_format (p
))
850 /* Check if the symbol could be an Objective-C selector. */
853 struct symtabs_and_lines values
;
855 values
= decode_objc (argptr
, funfirstline
, NULL
,
856 canonical
, saved_arg
);
857 if (values
.sals
!= NULL
)
861 /* Does it look like there actually were two parts? */
863 if (p
[0] == ':' || p
[0] == '.')
865 /* Is it a C++ or Java compound data structure?
866 The check on p[1] == ':' is capturing the case of "::",
867 since p[0]==':' was checked above.
868 Note that the call to decode_compound does everything
869 for us, including the lookup on the symbol table, so we
872 if (p
[0] == '.' || p
[1] == ':')
874 struct symtabs_and_lines values
;
876 if (is_quote_enclosed
)
878 values
= decode_compound (argptr
, funfirstline
, canonical
,
880 if (is_quoted
&& **argptr
== '\'')
881 *argptr
= *argptr
+ 1;
885 /* No, the first part is a filename; set file_symtab to be that file's
886 symtab. Also, move argptr past the filename. */
888 TRY_CATCH (file_exception
, RETURN_MASK_ERROR
)
890 file_symtab
= symtab_from_filename (argptr
, p
, is_quote_enclosed
);
892 /* If that failed, maybe we have `function:label'. */
893 if (file_exception
.reason
< 0)
895 function_symbol
= find_function_symbol (argptr
, p
, is_quote_enclosed
);
896 /* If we did not find a function, re-throw the original
898 if (!function_symbol
)
899 throw_exception (file_exception
);
902 /* Check for single quotes on the non-filename part. */
905 is_quoted
= (**argptr
906 && strchr (get_gdb_completer_quote_characters (),
909 end_quote
= skip_quoted (*argptr
);
913 /* file_symtab is specified file's symtab, or 0 if no file specified.
914 If we are parsing `function:symbol', then FUNCTION_SYMBOL is the
915 function before the `:'.
916 arg no longer contains the file name. */
918 /* If the filename was quoted, we must re-check the quotation. */
920 if (end_quote
== first_half
&& *end_quote
!= '\0')
922 is_quoted
= (**argptr
923 && strchr (get_gdb_completer_quote_characters (),
926 end_quote
= skip_quoted (*argptr
);
929 /* Check whether arg is all digits (and sign). */
932 if (*q
== '-' || *q
== '+')
934 while (*q
>= '0' && *q
<= '9')
937 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ',')
938 && function_symbol
== NULL
)
939 /* We found a token consisting of all digits -- at least one digit. */
940 return decode_all_digits (argptr
, default_symtab
, default_line
,
941 canonical
, file_symtab
, q
);
943 /* Arg token is not digits => try it as a variable name
944 Find the next token (everything up to end or next whitespace). */
946 if (**argptr
== '$') /* May be a convenience variable. */
947 /* One or two $ chars possible. */
948 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
953 error (_("Unmatched single quote."));
955 else if (is_objc_method
)
957 /* allow word separators in method names for Obj-C. */
958 p
= skip_quoted_chars (*argptr
, NULL
, "");
962 p
= skip_quoted (*argptr
);
965 /* Keep any important naming information. */
966 p
= keep_name_info (p
);
968 copy
= (char *) alloca (p
- *argptr
+ 1);
969 memcpy (copy
, *argptr
, p
- *argptr
);
970 copy
[p
- *argptr
] = '\0';
973 && copy
[0] == copy
[p
- *argptr
- 1]
974 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
976 copy
[p
- *argptr
- 1] = '\0';
980 copy
[p
- *argptr
- 1] = '\0';
981 while (*p
== ' ' || *p
== '\t')
985 /* If it starts with $: may be a legitimate variable or routine name
986 (e.g. HP-UX millicode routines such as $$dyncall), or it may
987 be history value, or it may be a convenience variable. */
989 if (*copy
== '$' && function_symbol
== NULL
)
990 return decode_dollar (copy
, funfirstline
, default_symtab
,
991 canonical
, file_symtab
);
993 /* Try the token as a label, but only if no file was specified,
994 because we can only really find labels in the current scope. */
998 struct symtabs_and_lines label_result
;
999 if (decode_label (function_symbol
, copy
, canonical
, &label_result
))
1000 return label_result
;
1003 if (function_symbol
)
1004 throw_exception (file_exception
);
1006 /* Look up that token as a variable.
1007 If file specified, use that file's per-file block to start with. */
1009 return decode_variable (copy
, funfirstline
, canonical
, file_symtab
);
1014 /* Now, more helper functions for decode_line_1. Some conventions
1015 that these functions follow:
1017 Decode_line_1 typically passes along some of its arguments or local
1018 variables to the subfunctions. It passes the variables by
1019 reference if they are modified by the subfunction, and by value
1022 Some of the functions have side effects that don't arise from
1023 variables that are passed by reference. In particular, if a
1024 function is passed ARGPTR as an argument, it modifies what ARGPTR
1025 points to; typically, it advances *ARGPTR past whatever substring
1026 it has just looked at. (If it doesn't modify *ARGPTR, then the
1027 function gets passed *ARGPTR instead, which is then called ARG.)
1028 Also, functions that return a struct symtabs_and_lines may modify
1029 CANONICAL, as in the description of decode_line_1.
1031 If a function returns a struct symtabs_and_lines, then that struct
1032 will immediately make its way up the call chain to be returned by
1033 decode_line_1. In particular, all of the functions decode_XXX
1034 calculate the appropriate struct symtabs_and_lines, under the
1035 assumption that their argument is of the form XXX. */
1037 /* First, some functions to initialize stuff at the beggining of the
1041 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1043 if (*default_symtab
== 0)
1045 /* Use whatever we have for the default source line. We don't use
1046 get_current_or_default_symtab_and_line as it can recurse and call
1048 struct symtab_and_line cursal
=
1049 get_current_source_symtab_and_line ();
1051 *default_symtab
= cursal
.symtab
;
1052 *default_line
= cursal
.line
;
1058 /* Decode arg of the form *PC. */
1060 static struct symtabs_and_lines
1061 decode_indirect (char **argptr
)
1063 struct symtabs_and_lines values
;
1067 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1069 values
.sals
= (struct symtab_and_line
*)
1070 xmalloc (sizeof (struct symtab_and_line
));
1073 values
.sals
[0] = find_pc_line (pc
, 0);
1074 values
.sals
[0].pc
= pc
;
1075 values
.sals
[0].section
= find_pc_overlay (pc
);
1076 values
.sals
[0].explicit_pc
= 1;
1083 /* Locate the first half of the linespec, ending in a colon, period,
1084 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1085 enclosed in double quotes; if so, set is_quote_enclosed, advance
1086 ARGPTR past that and zero out the trailing double quote.
1087 If ARGPTR is just a simple name like "main", p will point to ""
1091 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1097 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1098 and we must isolate the first half. Outer layers will call again later
1099 for the second half.
1101 Don't count commas that appear in argument lists of overloaded
1102 functions, or in quoted strings. It's stupid to go to this much
1103 trouble when the rest of the function is such an obvious roach hotel. */
1104 ii
= find_toplevel_char (*argptr
, ',');
1105 has_comma
= (ii
!= 0);
1107 /* Temporarily zap out second half to not confuse the code below.
1108 This is undone below. Do not change ii!! */
1114 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1115 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1121 *is_quote_enclosed
= 1;
1127 *is_quote_enclosed
= 0;
1128 if (strchr (get_gdb_completer_quote_characters (), *p
))
1138 char *temp_end
= find_template_name_end (p
);
1141 error (_("malformed template specification in command"));
1146 p
= find_method_overload_end (p
);
1148 /* Check for a colon and a plus or minus and a [ (which
1149 indicates an Objective-C method). */
1150 if (is_objc_method_format (p
))
1154 /* Check for the end of the first half of the linespec. End of
1155 line, a tab, a double colon or the last single colon, or a
1156 space. But if enclosed in double quotes we do not break on
1161 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
1162 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1164 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1166 /* Java qualified method. Find the *last* '.', since the
1167 others are package qualifiers. Stop at any open parenthesis
1168 which might provide overload information. */
1169 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1177 while (p
[0] == ' ' || p
[0] == '\t')
1180 /* If the closing double quote was left at the end, remove it. */
1181 if (*is_quote_enclosed
)
1183 char *closing_quote
= strchr (p
- 1, '"');
1185 if (closing_quote
&& closing_quote
[1] == '\0')
1186 *closing_quote
= '\0';
1189 /* Now that we've safely parsed the first half, put back ',' so
1190 outer layers can see it. */
1199 /* Here's where we recognise an Objective-C Selector. An Objective C
1200 selector may be implemented by more than one class, therefore it
1201 may represent more than one method/function. This gives us a
1202 situation somewhat analogous to C++ overloading. If there's more
1203 than one method that could represent the selector, then use some of
1204 the existing C++ code to let the user choose one. */
1206 struct symtabs_and_lines
1207 decode_objc (char **argptr
, int funfirstline
, struct symtab
*file_symtab
,
1208 struct linespec_result
*canonical
, char *saved_arg
)
1210 struct symtabs_and_lines values
;
1211 struct symbol
**sym_arr
= NULL
;
1212 struct symbol
*sym
= NULL
;
1213 struct block
*block
= NULL
;
1220 if (file_symtab
!= NULL
)
1221 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
), STATIC_BLOCK
);
1224 enum language save_language
;
1226 /* get_selected_block can change the current language when there is
1227 no selected frame yet. */
1228 save_language
= current_language
->la_language
;
1229 block
= get_selected_block (0);
1230 set_language (save_language
);
1233 find_imps (file_symtab
, block
, *argptr
, NULL
, &i1
, &i2
);
1237 sym_arr
= (struct symbol
**)
1238 alloca ((i1
+ 1) * sizeof (struct symbol
*));
1241 *argptr
= find_imps (file_symtab
, block
, *argptr
, sym_arr
, &i1
, &i2
);
1244 /* i1 now represents the TOTAL number of matches found.
1245 i2 represents how many HIGH-LEVEL (struct symbol) matches,
1246 which will come first in the sym_arr array. Any low-level
1247 (minimal_symbol) matches will follow those. */
1253 /* Already a struct symbol. */
1258 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr
[0]));
1259 if ((sym
!= NULL
) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr
[0]),
1260 SYMBOL_LINKAGE_NAME (sym
)) != 0)
1262 warning (_("debugging symbol \"%s\" does "
1263 "not match selector; ignoring"),
1264 SYMBOL_LINKAGE_NAME (sym
));
1269 values
.sals
= (struct symtab_and_line
*)
1270 xmalloc (sizeof (struct symtab_and_line
));
1273 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1275 /* Canonicalize this, so it remains resolved for dylib loads. */
1276 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1277 build_canonical_line_spec (values
.sals
,
1278 SYMBOL_NATURAL_NAME (sym
), canonical
);
1282 /* The only match was a non-debuggable symbol, which might point
1283 to a function descriptor; resolve it to the actual code address
1285 struct minimal_symbol
*msymbol
= (struct minimal_symbol
*)sym_arr
[0];
1286 struct objfile
*objfile
= msymbol_objfile (msymbol
);
1287 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1288 CORE_ADDR pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
1290 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, pc
,
1293 init_sal (&values
.sals
[0]);
1294 values
.sals
[0].pc
= pc
;
1301 /* More than one match. The user must choose one or more. */
1302 return decode_line_2 (sym_arr
, i2
, funfirstline
, canonical
);
1308 /* This handles C++ and Java compound data structures. P should point
1309 at the first component separator, i.e. double-colon or period. As
1310 an example, on entrance to this function we could have ARGPTR
1311 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1313 static struct symtabs_and_lines
1314 decode_compound (char **argptr
, int funfirstline
,
1315 struct linespec_result
*canonical
,
1316 char *the_real_saved_arg
, char *p
)
1318 struct symtabs_and_lines values
;
1320 char *saved_arg2
= *argptr
;
1324 struct symbol
*sym_class
;
1326 char *saved_java_argptr
= NULL
;
1329 /* If the user specified any completer quote characters in the input,
1330 strip them. They are superfluous. */
1331 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1333 char *dst
= saved_arg
;
1334 char *src
= the_real_saved_arg
;
1335 char *quotes
= get_gdb_completer_quote_characters ();
1336 while (*src
!= '\0')
1338 if (strchr (quotes
, *src
) == NULL
)
1345 /* First check for "global" namespace specification, of the form
1346 "::foo". If found, skip over the colons and jump to normal
1347 symbol processing. I.e. the whole line specification starts with
1348 "::" (note the condition that *argptr == p). */
1350 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1353 /* Given our example "AAA::inA::fun", we have two cases to consider:
1355 1) AAA::inA is the name of a class. In that case, presumably it
1356 has a method called "fun"; we then look up that method using
1359 2) AAA::inA isn't the name of a class. In that case, either the
1360 user made a typo, AAA::inA is the name of a namespace, or it is
1361 the name of a minimal symbol.
1362 We just look up AAA::inA::fun with lookup_symbol. If that fails,
1363 try lookup_minimal_symbol.
1365 Thus, our first task is to find everything before the last set of
1366 double-colons and figure out if it's the name of a class. So we
1367 first loop through all of the double-colons. */
1369 p2
= p
; /* Save for restart. */
1371 /* This is very messy. Following the example above we have now the
1374 argptr -> "AAA::inA::fun
1375 saved_arg -> "AAA::inA::fun
1376 saved_arg2 -> "AAA::inA::fun
1377 p2 -> "::inA::fun". */
1379 /* In the loop below, with these strings, we'll make 2 passes, each
1380 is marked in comments. */
1384 static char *break_characters
= " \t(";
1386 /* Move pointer up to next possible class/namespace token. */
1388 p
= p2
+ 1; /* Restart with old value +1. */
1390 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1391 i.e. if there is a double-colon, p will now point to the
1393 /* PASS2: p2->"::fun", p->":fun" */
1395 /* Move pointer ahead to next double-colon. */
1397 && strchr (break_characters
, *p
) == NULL
1398 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1400 if (current_language
->la_language
== language_cplus
)
1401 p
+= cp_validate_operator (p
);
1405 temp_end
= find_template_name_end (p
);
1407 error (_("malformed template specification in command"));
1410 /* Note that, since, at the start of this loop, p would be
1411 pointing to the second colon in a double-colon, we only
1412 satisfy the condition below if there is another
1413 double-colon to the right (after). I.e. there is another
1414 component that can be a class or a namespace. I.e, if at
1415 the beginning of this loop (PASS1), we had
1416 p->":inA::fun", we'll trigger this when p has been
1417 advanced to point to "::fun". */
1418 /* PASS2: we will not trigger this. */
1419 else if ((p
[0] == ':') && (p
[1] == ':'))
1420 break; /* Found double-colon. */
1423 /* PASS2: We'll keep getting here, until P points to one of the
1424 break characters, at which point we exit this loop. */
1425 if (*p
&& strchr (break_characters
, *p
) == NULL
)
1431 break; /* Out of the while (1). This would happen
1432 for instance if we have looked up
1433 unsuccessfully all the components of the
1434 string, and p->""(PASS2). */
1436 /* We get here if p points to one of the break characters or "" (i.e.,
1438 /* Save restart for next time around. */
1440 /* Restore argptr as it was on entry to this function. */
1441 *argptr
= saved_arg2
;
1442 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1445 /* All ready for next pass through the loop. */
1449 /* Start of lookup in the symbol tables. */
1451 /* Lookup in the symbol table the substring between argptr and
1452 p. Note, this call changes the value of argptr. */
1453 /* Before the call, argptr->"AAA::inA::fun",
1454 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1456 sym_class
= lookup_prefix_sym (argptr
, p2
);
1458 /* If sym_class has been found, and if "AAA::inA" is a class, then
1459 we're in case 1 above. So we look up "fun" as a method of that
1462 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
1463 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
1464 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
1466 /* Arg token is not digits => try it as a function name.
1467 Find the next token (everything up to end or next
1470 && strchr (get_gdb_completer_quote_characters (),
1473 p
= skip_quoted (*argptr
);
1474 *argptr
= *argptr
+ 1;
1478 /* At this point argptr->"fun". */
1482 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1485 /* At this point p->"". String ended. */
1486 /* Nope, C++ operators could have spaces in them
1487 ("foo::operator <" or "foo::operator delete []").
1488 I apologize, this is a bit hacky... */
1489 if (current_language
->la_language
== language_cplus
1490 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1492 /* The above loop has already swallowed "operator". */
1493 p
+= cp_validate_operator (p
- 8) - 8;
1496 /* Keep any important naming information. */
1497 p
= keep_name_info (p
);
1499 /* Java may append typenames, so assume that if there is
1500 anything else left in *argptr, it must be a typename. */
1501 if (*p
&& current_language
->la_language
== language_java
)
1508 copy
= (char *) alloca (p2
- p
+ 1);
1509 memcpy (copy
, p
, p2
- p
);
1510 copy
[p2
- p
] = '\0';
1511 type
= lookup_typename (current_language
, get_current_arch (),
1515 /* Save the location of this just in case this
1516 method/type combination isn't actually defined.
1517 It will be checked later. */
1518 saved_java_argptr
= p
;
1524 /* Allocate our own copy of the substring between argptr and
1526 copy
= (char *) alloca (p
- *argptr
+ 1);
1527 memcpy (copy
, *argptr
, p
- *argptr
);
1528 copy
[p
- *argptr
] = '\0';
1530 && copy
[p
- *argptr
- 1]
1531 && strchr (get_gdb_completer_quote_characters (),
1532 copy
[p
- *argptr
- 1]) != NULL
)
1533 copy
[p
- *argptr
- 1] = '\0';
1535 /* At this point copy->"fun", p->"". */
1537 /* No line number may be specified. */
1538 while (*p
== ' ' || *p
== '\t')
1541 /* At this point arptr->"". */
1543 /* Look for copy as a method of sym_class. */
1544 /* At this point copy->"fun", sym_class is "AAA:inA",
1545 saved_arg->"AAA::inA::fun". This concludes the scanning of
1546 the string for possible components matches. If we find it
1547 here, we return. If not, and we are at the and of the string,
1548 we'll lookup the whole string in the symbol tables. */
1550 values
= find_method (funfirstline
, canonical
, saved_arg
,
1551 copy
, t
, sym_class
);
1552 if (saved_java_argptr
!= NULL
&& values
.nelts
== 1)
1554 /* The user specified a specific return type for a java method.
1555 Double-check that it really is the one the user specified.
1556 [This is a necessary evil because strcmp_iw_ordered stops
1557 comparisons too prematurely.] */
1558 sym
= find_pc_sect_function (values
.sals
[0].pc
,
1559 values
.sals
[0].section
);
1560 /* We just found a SAL, we had better be able to go backwards! */
1561 gdb_assert (sym
!= NULL
);
1562 if (strcmp_iw (SYMBOL_LINKAGE_NAME (sym
), saved_arg
) != 0)
1564 xfree (values
.sals
);
1565 error (_("the class `%s' does not have "
1566 "any method instance named %s"),
1567 SYMBOL_PRINT_NAME (sym_class
), copy
);
1571 } /* End if symbol found. */
1574 /* We couldn't find a class, so we're in case 2 above. We check the
1575 entire name as a symbol instead. */
1577 if (current_language
->la_language
== language_cplus
1578 || current_language
->la_language
== language_java
)
1579 p
= keep_name_info (p
);
1581 copy
= (char *) alloca (p
- saved_arg2
+ 1);
1582 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
1583 /* Note: if is_quoted should be true, we snuff out quote here
1585 copy
[p
- saved_arg2
] = '\000';
1586 /* Set argptr to skip over the name. */
1587 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
1589 /* Look up entire name. */
1590 sym
= lookup_symbol (copy
, get_selected_block (0), VAR_DOMAIN
, 0);
1592 return symbol_found (funfirstline
, canonical
, copy
, sym
, NULL
, NULL
);
1595 struct minimal_symbol
*msym
;
1597 /* Couldn't find any interpretation as classes/namespaces. As a last
1598 resort, try the minimal symbol tables. */
1599 msym
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1601 return minsym_found (funfirstline
, msym
);
1604 /* Couldn't find a minimal symbol, either, so give up. */
1605 cplusplus_error (the_real_saved_arg
,
1606 "Can't find member of namespace, "
1607 "class, struct, or union named \"%s\"\n",
1611 /* Next come some helper functions for decode_compound. */
1613 /* Return the symbol corresponding to the substring of *ARGPTR ending
1614 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1615 name in question, the compound object separator ("::" or "."), and
1616 whitespace. Note that *ARGPTR is changed whether or not the
1617 lookup_symbol call finds anything (i.e we return NULL). As an
1618 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1620 static struct symbol
*
1621 lookup_prefix_sym (char **argptr
, char *p
)
1627 /* Extract the class name. */
1629 while (p
!= *argptr
&& p
[-1] == ' ')
1631 copy
= (char *) alloca (p
- *argptr
+ 1);
1632 memcpy (copy
, *argptr
, p
- *argptr
);
1633 copy
[p
- *argptr
] = 0;
1635 /* Discard the class name from the argptr. */
1636 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1637 while (*p
== ' ' || *p
== '\t')
1641 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1642 argptr->"inA::fun". */
1644 sym
= lookup_symbol (copy
, get_selected_block (0), STRUCT_DOMAIN
, 0);
1647 /* Typedefs are in VAR_DOMAIN so the above symbol lookup will
1648 fail when the user attempts to lookup a method of a class
1649 via a typedef'd name (NOT via the class's name, which is already
1650 handled in symbol_matches_domain). So try the lookup again
1651 using VAR_DOMAIN (where typedefs live) and double-check that we
1652 found a struct/class type. */
1653 struct symbol
*s
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0);
1657 struct type
*t
= SYMBOL_TYPE (s
);
1660 if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1668 /* This finds the method COPY in the class whose type is T and whose
1669 symbol is SYM_CLASS. */
1671 static struct symtabs_and_lines
1672 find_method (int funfirstline
, struct linespec_result
*canonical
,
1674 char *copy
, struct type
*t
, struct symbol
*sym_class
)
1676 struct symtabs_and_lines values
;
1677 struct symbol
*sym
= NULL
;
1678 int i1
; /* Counter for the symbol array. */
1679 struct symbol
**sym_arr
= alloca (total_number_of_methods (t
)
1680 * sizeof (struct symbol
*));
1682 /* Find all methods with a matching name, and put them in
1685 i1
= find_methods (t
, copy
, SYMBOL_LANGUAGE (sym_class
), sym_arr
);
1689 /* There is exactly one field with that name. */
1692 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1694 values
.sals
= (struct symtab_and_line
*)
1695 xmalloc (sizeof (struct symtab_and_line
));
1697 values
.sals
[0] = find_function_start_sal (sym
,
1709 /* If we were given a specific overload instance, use that
1710 (or error if no matches were found). Otherwise ask the user
1711 which one to use. */
1712 if (strchr (copy
, '('))
1717 struct cleanup
*cleanup
;
1719 /* Construct the proper search name based on SYM_CLASS and COPY.
1720 SAVED_ARG may contain a valid name, but that name might not be
1721 what is actually stored in the symbol table. For example,
1722 if SAVED_ARG (and SYM_CLASS) were found via an import
1723 ("using namespace" in C++), then the physname of
1724 SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG
1726 name
= xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class
))
1727 + 2 /* "::" */ + strlen (copy
) + 1);
1728 strcpy (name
, SYMBOL_NATURAL_NAME (sym_class
));
1729 strcat (name
, "::");
1730 strcat (name
, copy
);
1731 canon
= cp_canonicalize_string (name
);
1737 cleanup
= make_cleanup (xfree
, name
);
1739 for (i
= 0; i
< i1
; ++i
)
1741 if (strcmp_iw (name
, SYMBOL_LINKAGE_NAME (sym_arr
[i
])) == 0)
1743 values
.sals
= (struct symtab_and_line
*)
1744 xmalloc (sizeof (struct symtab_and_line
));
1746 values
.sals
[0] = find_function_start_sal (sym_arr
[i
],
1748 do_cleanups (cleanup
);
1753 error (_("the class `%s' does not have "
1754 "any method instance named %s"),
1755 SYMBOL_PRINT_NAME (sym_class
), copy
);
1758 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1763 cplusplus_error (saved_arg
,
1764 "the class `%s' does not have destructor defined\n",
1765 SYMBOL_PRINT_NAME (sym_class
));
1767 cplusplus_error (saved_arg
,
1768 "the class %s does not have any method named %s\n",
1769 SYMBOL_PRINT_NAME (sym_class
), copy
);
1775 /* Return the symtab associated to the filename given by the substring
1776 of *ARGPTR ending at P, and advance ARGPTR past that filename. */
1778 static struct symtab
*
1779 symtab_from_filename (char **argptr
, char *p
, int is_quote_enclosed
)
1783 struct symtab
*file_symtab
;
1786 while (p
!= *argptr
&& p
[-1] == ' ')
1788 if ((*p
== '"') && is_quote_enclosed
)
1790 copy
= (char *) alloca (p
- *argptr
+ 1);
1791 memcpy (copy
, *argptr
, p
- *argptr
);
1792 /* It may have the ending quote right after the file name. */
1793 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
1794 || copy
[p
- *argptr
- 1] == '\'')
1795 copy
[p
- *argptr
- 1] = 0;
1797 copy
[p
- *argptr
] = 0;
1799 /* Find that file's data. */
1800 file_symtab
= lookup_symtab (copy
);
1801 if (file_symtab
== 0)
1803 if (!have_full_symbols () && !have_partial_symbols ())
1804 throw_error (NOT_FOUND_ERROR
,
1805 _("No symbol table is loaded. "
1806 "Use the \"file\" command."));
1807 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
1810 /* Discard the file name from the arg. */
1812 while (*p
== ' ' || *p
== '\t')
1819 /* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
1820 and return the symbol. If not found, return NULL. */
1822 static struct symbol
*
1823 find_function_symbol (char **argptr
, char *p
, int is_quote_enclosed
)
1827 struct symbol
*function_symbol
;
1830 while (p
!= *argptr
&& p
[-1] == ' ')
1832 if ((*p
== '"') && is_quote_enclosed
)
1834 copy
= (char *) alloca (p
- *argptr
+ 1);
1835 memcpy (copy
, *argptr
, p
- *argptr
);
1836 /* It may have the ending quote right after the file name. */
1837 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
1838 || copy
[p
- *argptr
- 1] == '\'')
1839 copy
[p
- *argptr
- 1] = 0;
1841 copy
[p
- *argptr
] = 0;
1843 function_symbol
= lookup_symbol (copy
, get_selected_block (0),
1845 if (!function_symbol
|| SYMBOL_CLASS (function_symbol
) != LOC_BLOCK
)
1848 /* Discard the file name from the arg. */
1850 while (*p
== ' ' || *p
== '\t')
1854 return function_symbol
;
1859 /* This decodes a line where the argument is all digits (possibly
1860 preceded by a sign). Q should point to the end of those digits;
1861 the other arguments are as usual. */
1863 static struct symtabs_and_lines
1864 decode_all_digits (char **argptr
, struct symtab
*default_symtab
,
1865 int default_line
, struct linespec_result
*canonical
,
1866 struct symtab
*file_symtab
, char *q
)
1869 struct symtabs_and_lines values
;
1870 struct symtab_and_line val
;
1878 /* We might need a canonical line spec if no file was specified. */
1879 int need_canonical
= (file_symtab
== NULL
) ? 1 : 0;
1883 val
.pspace
= current_program_space
;
1885 /* This is where we need to make sure that we have good defaults.
1886 We must guarantee that this section of code is never executed
1887 when we are called with just a function name, since
1888 set_default_source_symtab_and_line uses
1889 select_source_symtab that calls us with such an argument. */
1891 if (file_symtab
== 0 && default_symtab
== 0)
1893 /* Make sure we have at least a default source file. */
1894 set_default_source_symtab_and_line ();
1895 initialize_defaults (&default_symtab
, &default_line
);
1898 if (**argptr
== '+')
1899 sign
= plus
, (*argptr
)++;
1900 else if (**argptr
== '-')
1901 sign
= minus
, (*argptr
)++;
1902 val
.line
= atoi (*argptr
);
1908 if (file_symtab
== 0)
1909 val
.line
= default_line
+ val
.line
;
1914 if (file_symtab
== 0)
1915 val
.line
= default_line
- val
.line
;
1920 break; /* No need to adjust val.line. */
1923 while (*q
== ' ' || *q
== '\t')
1926 if (file_symtab
== 0)
1927 file_symtab
= default_symtab
;
1929 /* It is possible that this source file has more than one symtab,
1930 and that the new line number specification has moved us from the
1931 default (in file_symtab) to a new one. */
1932 val
.symtab
= find_line_symtab (file_symtab
, val
.line
, NULL
, NULL
);
1933 if (val
.symtab
== 0)
1934 val
.symtab
= file_symtab
;
1936 val
.pspace
= SYMTAB_PSPACE (val
.symtab
);
1938 values
.sals
= (struct symtab_and_line
*)
1939 xmalloc (sizeof (struct symtab_and_line
));
1940 values
.sals
[0] = val
;
1943 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1944 values
.sals
[0].explicit_line
= 1;
1950 /* Decode a linespec starting with a dollar sign. */
1952 static struct symtabs_and_lines
1953 decode_dollar (char *copy
, int funfirstline
, struct symtab
*default_symtab
,
1954 struct linespec_result
*canonical
, struct symtab
*file_symtab
)
1958 int need_canonical
= 0;
1959 struct symtabs_and_lines values
;
1960 struct symtab_and_line val
;
1963 struct minimal_symbol
*msymbol
;
1965 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
1966 while (*p
>= '0' && *p
<= '9')
1968 if (!*p
) /* Reached end of token without hitting non-digit. */
1970 /* We have a value history reference. */
1971 struct value
*val_history
;
1973 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
1974 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
1975 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
1976 error (_("History values used in line "
1977 "specs must have integer values."));
1978 valx
= value_as_long (val_history
);
1982 /* Not all digits -- may be user variable/function or a
1983 convenience variable. */
1985 /* Look up entire name as a symbol first. */
1986 sym
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0);
1987 file_symtab
= (struct symtab
*) NULL
;
1989 /* Symbol was found --> jump to normal symbol processing. */
1991 return symbol_found (funfirstline
, canonical
, copy
, sym
, NULL
, NULL
);
1993 /* If symbol was not found, look in minimal symbol tables. */
1994 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1995 /* Min symbol was found --> jump to minsym processing. */
1997 return minsym_found (funfirstline
, msymbol
);
1999 /* Not a user variable or function -- must be convenience variable. */
2000 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
2001 error (_("Convenience variables used in line "
2002 "specs must have integer values."));
2007 /* Either history value or convenience value from above, in valx. */
2008 val
.symtab
= file_symtab
? file_symtab
: default_symtab
;
2011 val
.pspace
= current_program_space
;
2013 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
2014 values
.sals
[0] = val
;
2018 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2025 /* A helper for decode_line_1 that tries to find a label. The label
2026 is searched for in the current block.
2027 FUNCTION_SYMBOL is the enclosing function; or NULL if none
2029 COPY is the name of the label to find.
2030 CANONICAL is the same as the "canonical" argument to decode_line_1.
2031 RESULT is a pointer to a symtabs_and_lines structure which will be
2032 filled in on success.
2033 This function returns 1 if a label was found, 0 otherwise. */
2036 decode_label (struct symbol
*function_symbol
, char *copy
,
2037 struct linespec_result
*canonical
,
2038 struct symtabs_and_lines
*result
)
2041 struct block
*block
;
2043 if (function_symbol
)
2044 block
= SYMBOL_BLOCK_VALUE (function_symbol
);
2047 block
= get_selected_block (0);
2049 block
&& !BLOCK_FUNCTION (block
);
2050 block
= BLOCK_SUPERBLOCK (block
))
2054 function_symbol
= BLOCK_FUNCTION (block
);
2057 sym
= lookup_symbol (copy
, block
, LABEL_DOMAIN
, 0);
2060 *result
= symbol_found (0, canonical
, copy
, sym
, NULL
, function_symbol
);
2065 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2066 look in that symtab's static variables first. */
2068 static struct symtabs_and_lines
2069 decode_variable (char *copy
, int funfirstline
,
2070 struct linespec_result
*canonical
,
2071 struct symtab
*file_symtab
)
2074 struct minimal_symbol
*msymbol
;
2076 sym
= lookup_symbol (copy
,
2078 ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
),
2080 : get_selected_block (0)),
2084 return symbol_found (funfirstline
, canonical
, copy
, sym
, file_symtab
, NULL
);
2086 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
2088 if (msymbol
!= NULL
)
2089 return minsym_found (funfirstline
, msymbol
);
2091 if (!have_full_symbols ()
2092 && !have_partial_symbols ()
2093 && !have_minimal_symbols ())
2094 throw_error (NOT_FOUND_ERROR
,
2095 _("No symbol table is loaded. Use the \"file\" command."));
2096 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
2102 /* Now come some functions that are called from multiple places within
2105 /* We've found a symbol SYM to associate with our linespec; build a
2106 corresponding struct symtabs_and_lines. */
2108 static struct symtabs_and_lines
2109 symbol_found (int funfirstline
, struct linespec_result
*canonical
, char *copy
,
2110 struct symbol
*sym
, struct symtab
*file_symtab
,
2111 struct symbol
*function_symbol
)
2113 struct symtabs_and_lines values
;
2115 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2117 /* Arg is the name of a function. */
2118 values
.sals
= (struct symtab_and_line
*)
2119 xmalloc (sizeof (struct symtab_and_line
));
2120 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
2123 /* Don't use the SYMBOL_LINE; if used at all it points to
2124 the line containing the parameters or thereabouts, not
2125 the first line of code. */
2127 /* We might need a canonical line spec if it is a static
2129 if (file_symtab
== 0)
2131 struct blockvector
*bv
= BLOCKVECTOR (SYMBOL_SYMTAB (sym
));
2132 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2134 if (lookup_block_symbol (b
, copy
, VAR_DOMAIN
) != NULL
)
2135 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2141 if (SYMBOL_CLASS (sym
) == LOC_LABEL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
2143 /* We know its line number. */
2144 values
.sals
= (struct symtab_and_line
*)
2145 xmalloc (sizeof (struct symtab_and_line
));
2147 init_sal (&values
.sals
[0]);
2148 values
.sals
[0].symtab
= SYMBOL_SYMTAB (sym
);
2149 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2150 values
.sals
[0].pc
= SYMBOL_VALUE_ADDRESS (sym
);
2151 values
.sals
[0].pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2152 values
.sals
[0].explicit_pc
= 1;
2156 canonical
->special_display
= 1;
2157 canonical
->canonical
= xmalloc (sizeof (char *));
2158 canonical
->canonical
[0]
2159 = xstrprintf ("%s:%s",
2160 SYMBOL_NATURAL_NAME (function_symbol
),
2161 SYMBOL_NATURAL_NAME (sym
));
2166 else if (funfirstline
)
2167 error (_("\"%s\" is not a function"), copy
);
2168 else if (SYMBOL_LINE (sym
) != 0)
2170 /* We know its line number. */
2171 values
.sals
= (struct symtab_and_line
*)
2172 xmalloc (sizeof (struct symtab_and_line
));
2174 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2175 values
.sals
[0].symtab
= SYMBOL_SYMTAB (sym
);
2176 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2177 values
.sals
[0].pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2181 /* This can happen if it is compiled with a compiler which doesn't
2182 put out line numbers for variables. */
2183 /* FIXME: Shouldn't we just set .line and .symtab to zero
2184 and return? For example, "info line foo" could print
2186 error (_("Line number not known for symbol \"%s\""), copy
);
2190 /* We've found a minimal symbol MSYMBOL to associate with our
2191 linespec; build a corresponding struct symtabs_and_lines. */
2193 static struct symtabs_and_lines
2194 minsym_found (int funfirstline
, struct minimal_symbol
*msymbol
)
2196 struct objfile
*objfile
= msymbol_objfile (msymbol
);
2197 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2198 struct symtabs_and_lines values
;
2201 values
.sals
= (struct symtab_and_line
*)
2202 xmalloc (sizeof (struct symtab_and_line
));
2203 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2204 (struct obj_section
*) 0, 0);
2205 values
.sals
[0].section
= SYMBOL_OBJ_SECTION (msymbol
);
2207 /* The minimal symbol might point to a function descriptor;
2208 resolve it to the actual code address instead. */
2209 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
2212 if (pc
!= values
.sals
[0].pc
)
2213 values
.sals
[0] = find_pc_sect_line (pc
, NULL
, 0);
2216 skip_prologue_sal (&values
.sals
[0]);
2223 init_linespec_result (struct linespec_result
*lr
)
2225 memset (lr
, 0, sizeof (*lr
));